@trapi/metadata 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/index.mjs

@@ -1,247 +1,45 @@
-import path, { normalize } from "node:path";
 import { BaseError, isBaseError } from "@ebec/core";
-import * as ts from "typescript";
-import { NodeBuilderFlags, NodeFlags, SymbolFlags, SyntaxKind, canHaveDecorators, canHaveModifiers, convertCompilerOptionsFromJson, createProgram, displayPartsToString, forEachChild, getDecorators, getModifiers, isCallExpression, isClassDeclaration, isEnumDeclaration, isEnumMember, isJSDocParameterTag, isMethodDeclaration, isModuleBlock, isModuleDeclaration, isNumericLiteral, isStringLiteral } from "typescript";
-import { buildFilePath, hasOwnProperty as hasOwnProperty$1, isObject, load, locateMany } from "locter";
-import { Container } from "validup";
-import { createValidator } from "@validup/adapter-zod";
-import { z } from "zod";
+import { NodeBuilderFlags, NodeFlags, SymbolFlags, SyntaxKind, canHaveDecorators, canHaveModifiers, convertCompilerOptionsFromJson, createProgram, displayPartsToString, factory, forEachChild, getDecorators, getModifiers, isArrayLiteralExpression, isArrayTypeNode, isCallExpression, isClassDeclaration, isConditionalTypeNode, isConstructorDeclaration, isEnumDeclaration, isEnumMember, isExpressionWithTypeArguments, isFunctionTypeNode, isIdentifier, isImportSpecifier, isIndexSignatureDeclaration, isIndexedAccessTypeNode, isInterfaceDeclaration, isIntersectionTypeNode, isJSDocParameterTag, isJSDocPropertyTag, isJSDocReturnTag, isJSDocThisTag, isJSDocTypeTag, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignature, isModuleBlock, isModuleDeclaration, isNamedTupleMember, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParameter, isParenthesizedTypeNode, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyDeclaration, isPropertySignature, isQualifiedName, isStringLiteral, isTupleTypeNode, isTypeAliasDeclaration, isTypeLiteralNode, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode } from "typescript";
+import path, { normalize } from "node:path";
+import { CollectionFormat, NumericKind, ParamKind, ParameterSource, TypeName, UtilityTypeName, ValidatorName, createRegistry, isArrayType, isDeprecatedMarker, isExtensionMarker, isNestedObjectLiteralType, isRefAliasType, isRefEnumType, isRefObjectType, isStringType, isUnionType, isVoidType, loadRegistry, loadRegistryByName, matches, matchesJsDoc, mergeRegistries, namesForMarker, newControllerDraft, newMethodDraft, newParameterDraft, numericMarkerKind, resolvePresetByName, tagsForMarker } from "@trapi/core";
+import { buildFilePath, isObject, load, locateMany } from "locter";
 import process from "node:process";
 import { parse, stringify } from "flatted";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import { tmpdir } from "node:os";
 import { minimatch } from "minimatch";
-//#region src/core/resolver/constants.ts
-let TypeName = /* @__PURE__ */ function(TypeName) {
-	TypeName["STRING"] = "string";
-	TypeName["BOOLEAN"] = "boolean";
-	TypeName["BIGINT"] = "bigint";
-	TypeName["DOUBLE"] = "double";
-	TypeName["FLOAT"] = "float";
-	TypeName["FILE"] = "file";
-	TypeName["INTEGER"] = "integer";
-	TypeName["LONG"] = "long";
-	TypeName["ENUM"] = "enum";
-	TypeName["ARRAY"] = "array";
-	TypeName["DATETIME"] = "datetime";
-	TypeName["DATE"] = "date";
-	TypeName["BINARY"] = "binary";
-	TypeName["BUFFER"] = "buffer";
-	TypeName["BYTE"] = "byte";
-	TypeName["VOID"] = "void";
-	TypeName["OBJECT"] = "object";
-	TypeName["ANY"] = "any";
-	TypeName["UNDEFINED"] = "undefined";
-	TypeName["NEVER"] = "never";
-	TypeName["REF_ENUM"] = "refEnum";
-	TypeName["REF_OBJECT"] = "refObject";
-	TypeName["REF_ALIAS"] = "refAlias";
-	TypeName["NESTED_OBJECT_LITERAL"] = "nestedObjectLiteral";
-	TypeName["UNION"] = "union";
-	TypeName["INTERSECTION"] = "intersection";
-	TypeName["TUPLE"] = "tuple";
-	return TypeName;
-}({});
-let UtilityTypeName = /* @__PURE__ */ function(UtilityTypeName) {
-	UtilityTypeName["NON_NULLABLE"] = "NonNullable";
-	UtilityTypeName["OMIT"] = "Omit";
-	UtilityTypeName["PARTIAL"] = "Partial";
-	UtilityTypeName["READONLY"] = "Readonly";
-	UtilityTypeName["RECORD"] = "Record";
-	UtilityTypeName["REQUIRED"] = "Required";
-	UtilityTypeName["PICK"] = "Pick";
-	UtilityTypeName["EXTRACT"] = "Extract";
-	UtilityTypeName["EXCLUDE"] = "Exclude";
-	UtilityTypeName["RETURN_TYPE"] = "ReturnType";
-	UtilityTypeName["PARAMETERS"] = "Parameters";
-	UtilityTypeName["AWAITED"] = "Awaited";
-	UtilityTypeName["INSTANCE_TYPE"] = "InstanceType";
-	UtilityTypeName["CONSTRUCTOR_PARAMETERS"] = "ConstructorParameters";
-	return UtilityTypeName;
-}({});
-//#endregion
-//#region src/core/resolver/type-guards.ts
-function isAnyType(param) {
-	return param.typeName === "any";
-}
-function isUndefinedType(param) {
-	return param.typeName === "undefined";
-}
-function isStringType(param) {
-	return param.typeName === "string";
-}
-function isBooleanType(param) {
-	return param.typeName === "boolean";
-}
-function isBigintType(param) {
-	return param.typeName === "bigint";
-}
-function isDoubleType(param) {
-	return param.typeName === "double";
-}
-function isFloatType(param) {
-	return param.typeName === "float";
-}
-function isIntegerType(param) {
-	return param.typeName === "integer";
-}
-function isLongType(param) {
-	return param.typeName === "long";
-}
-function isVoidType(param) {
-	return typeof param === "undefined" || param.typeName === "void";
-}
-function isNeverType(param) {
-	return param.typeName === "never";
-}
-function isDateType(param) {
-	return param.typeName === "date";
-}
-function isFileType(param) {
-	return param.typeName === "file";
-}
-function isDateTimeType(param) {
-	return param.typeName === "datetime";
-}
-function isBinaryType(param) {
-	return param.typeName === "binary";
-}
-function isBufferType(param) {
-	return param.typeName === "buffer";
-}
-function isByteType(param) {
-	return param.typeName === "byte";
-}
-function isObjectType(param) {
-	return param.typeName === "object";
-}
-function isEnumType(param) {
-	return param.typeName === "enum";
-}
-function isArrayType(param) {
-	return param.typeName === "array";
-}
-function isNestedObjectLiteralType(param) {
-	return param.typeName === "nestedObjectLiteral";
-}
-function isIntersectionType(param) {
-	return param.typeName === "intersection";
-}
-function isUnionType(param) {
-	return param.typeName === "union";
-}
-function isTupleType(param) {
-	return param.typeName === "tuple";
-}
-function isRefEnumType(param) {
-	return param.typeName === "refEnum";
-}
-function isRefObjectType(param) {
-	return param.typeName === "refObject";
-}
-function isRefAliasType(param) {
-	return param.typeName === "refAlias";
-}
-function isReferenceType(param) {
-	return param.typeName === "refAlias" || param.typeName === "refEnum" || param.typeName === "refObject";
-}
-function isPrimitiveType(type) {
-	return isAnyType(type) || isBinaryType(type) || isBooleanType(type) || isBufferType(type) || isByteType(type) || isDateType(type) || isDateTimeType(type) || isBigintType(type) || isDoubleType(type) || isFloatType(type) || isFileType(type) || isIntegerType(type) || isLongType(type) || isObjectType(type) || isStringType(type) || isUndefinedType(type);
-}
-//#endregion
 //#region src/core/error/base.ts
 var MetadataError = class extends BaseError {};
 //#endregion
-//#region src/core/resolver/error.ts
-var ResolverError = class extends MetadataError {
-	file;
-	line;
-	constructor(message, node, options) {
-		const opts = typeof options === "boolean" ? { onlyCurrent: options } : options;
-		const onlyCurrent = opts?.onlyCurrent ?? false;
-		const parts = [message];
-		let file;
-		let line;
-		if (node) {
-			const location = prettyLocationOfNode(node);
-			if (location) {
-				parts.push(location.text);
-				file = location.file;
-				line = location.line;
-			}
-			parts.push(prettyTroubleCause(node, onlyCurrent));
-		}
-		super({
-			message: parts.join("\n"),
-			cause: opts?.cause
-		});
-		this.file = file;
-		this.line = line;
-	}
+//#region src/core/error/config.ts
+var ConfigError = class extends MetadataError {};
+//#endregion
+//#region src/core/error/config-codes.ts
+const ConfigErrorCode = {
+	TSCONFIG_MALFORMED: "CONFIG_TSCONFIG_MALFORMED",
+	PRESET_NOT_FOUND: "CONFIG_PRESET_NOT_FOUND",
+	PRESET_MISSING: "CONFIG_PRESET_MISSING"
 };
-function isResolverError(input) {
+//#endregion
+//#region src/core/error/generator.ts
+var GeneratorError = class extends MetadataError {};
+function isGeneratorError(input) {
 	if (!isBaseError(input)) return false;
-	return "file" in input && "line" in input;
-}
-function prettyLocationOfNode(node) {
-	try {
-		const sourceFile = node.getSourceFile();
-		if (!sourceFile) return void 0;
-		const token = node.getFirstToken() || node.parent?.getFirstToken();
-		const start = token ? sourceFile.getLineAndCharacterOfPosition(token.getStart()).line + 1 : void 0;
-		const end = token ? sourceFile.getLineAndCharacterOfPosition(token.getEnd()).line + 1 : void 0;
-		return {
-			text: `At: ${normalize(sourceFile.fileName)}${start ? `:${start}` : ""}${end ? `:${end}` : ""}.`,
-			file: sourceFile.fileName,
-			line: start
-		};
-	} catch {
-		return;
-	}
-}
-function prettyTroubleCause(node, onlyCurrent = false) {
-	try {
-		let name;
-		if (onlyCurrent || !node.parent) name = node.pos !== -1 ? node.getText() : node.name.text;
-		else name = node.parent.pos !== -1 ? node.parent.getText() : node.parent.name.text;
-		return `This was caused by '${name}'`;
-	} catch {
-		return "This was caused by an unknown node";
-	}
+	return typeof input.code === "string";
 }
 //#endregion
-//#region src/core/method/constants.ts
-const MethodName = {
-	ALL: "ALL",
-	GET: "GET",
-	POST: "POST",
-	PUT: "PUT",
-	DELETE: "DELETE",
-	PATCH: "PATCH",
-	OPTIONS: "OPTIONS",
-	HEAD: "HEAD"
+//#region src/core/error/generator-codes.ts
+const GeneratorErrorCode = {
+	CONTROLLER_NO_SOURCE_FILE: "GENERATOR_CONTROLLER_NO_SOURCE_FILE",
+	CONTROLLER_NO_NAME: "GENERATOR_CONTROLLER_NO_NAME",
+	PARAMETER_GENERATION_FAILED: "GENERATOR_PARAMETER_GENERATION_FAILED",
+	BODY_PARAMETER_DUPLICATE: "GENERATOR_BODY_PARAMETER_DUPLICATE",
+	BODY_FORM_CONFLICT: "GENERATOR_BODY_FORM_CONFLICT",
+	STRICT_UNMATCHED_DECORATORS: "GENERATOR_STRICT_UNMATCHED_DECORATORS"
 };
 //#endregion
-//#region src/core/parameter/constants.ts
-const ParameterSource = {
-	BODY: "body",
-	BODY_PROP: "bodyProp",
-	CONTEXT: "context",
-	COOKIE: "cookie",
-	HEADER: "header",
-	FORM_DATA: "formData",
-	QUERY: "query",
-	QUERY_PROP: "queryProp",
-	PATH: "path"
-};
-const CollectionFormat = {
-	CSV: "csv",
-	SSV: "ssv",
-	TSV: "tsv",
-	PIPES: "pipes",
-	MULTI: "multi"
-};
+//#region src/core/error/parameter-codes.ts
 const ParameterErrorCode = {
 	TYPE_UNSUPPORTED: "PARAMETER_TYPE_UNSUPPORTED",
 	METHOD_UNSUPPORTED: "PARAMETER_METHOD_UNSUPPORTED",
@@ -250,7 +48,7 @@ const ParameterErrorCode = {
 	INVALID_EXAMPLE: "PARAMETER_INVALID_EXAMPLE"
 };
 //#endregion
-//#region src/core/parameter/error.ts
+//#region src/core/error/parameter.ts
 var ParameterError = class ParameterError extends MetadataError {
 	static typeUnsupported(context) {
 		const location = context.node ? ParameterError.getCurrentLocation(context.node) : void 0;
@@ -296,686 +94,74 @@ var ParameterError = class ParameterError extends MetadataError {
 	}
 };
 //#endregion
-//#region src/core/generator/error.ts
-var GeneratorError = class extends MetadataError {};
-function isGeneratorError(input) {
+//#region src/core/error/resolver.ts
+var ResolverError = class extends MetadataError {
+	file;
+	line;
+	constructor(message, node, options) {
+		const opts = typeof options === "boolean" ? { onlyCurrent: options } : options;
+		const onlyCurrent = opts?.onlyCurrent ?? false;
+		const parts = [message];
+		let file;
+		let line;
+		if (node) {
+			const location = prettyLocationOfNode(node);
+			if (location) {
+				parts.push(location.text);
+				file = location.file;
+				line = location.line;
+			}
+			parts.push(prettyTroubleCause(node, onlyCurrent));
+		}
+		super({
+			message: parts.join("\n"),
+			cause: opts?.cause
+		});
+		this.file = file;
+		this.line = line;
+	}
+};
+function isResolverError(input) {
 	if (!isBaseError(input)) return false;
-	return typeof input.code === "string";
+	return "file" in input && "line" in input;
+}
+function prettyLocationOfNode(node) {
+	try {
+		const sourceFile = node.getSourceFile();
+		if (!sourceFile) return void 0;
+		const token = node.getFirstToken() || node.parent?.getFirstToken();
+		const start = token ? sourceFile.getLineAndCharacterOfPosition(token.getStart()).line + 1 : void 0;
+		const end = token ? sourceFile.getLineAndCharacterOfPosition(token.getEnd()).line + 1 : void 0;
+		return {
+			text: `At: ${normalize(sourceFile.fileName)}${start ? `:${start}` : ""}${end ? `:${end}` : ""}.`,
+			file: sourceFile.fileName,
+			line: start
+		};
+	} catch {
+		return;
+	}
+}
+function prettyTroubleCause(node, onlyCurrent = false) {
+	try {
+		let name;
+		if (onlyCurrent || !node.parent) name = node.pos !== -1 ? node.getText() : node.name.text;
+		else name = node.parent.pos !== -1 ? node.parent.getText() : node.parent.name.text;
+		return `This was caused by '${name}'`;
+	} catch {
+		return "This was caused by an unknown node";
+	}
 }
 //#endregion
-//#region src/core/generator/constants.ts
-const GeneratorErrorCode = {
-	CONTROLLER_NO_SOURCE_FILE: "GENERATOR_CONTROLLER_NO_SOURCE_FILE",
-	CONTROLLER_NO_NAME: "GENERATOR_CONTROLLER_NO_NAME",
-	PARAMETER_GENERATION_FAILED: "GENERATOR_PARAMETER_GENERATION_FAILED",
-	BODY_PARAMETER_DUPLICATE: "GENERATOR_BODY_PARAMETER_DUPLICATE",
-	BODY_FORM_CONFLICT: "GENERATOR_BODY_FORM_CONFLICT"
-};
-//#endregion
-//#region src/core/validator/error.ts
+//#region src/core/error/validator.ts
 var ValidatorError = class extends MetadataError {};
 //#endregion
-//#region src/core/validator/constants.ts
-let ValidatorName = /* @__PURE__ */ function(ValidatorName) {
-	ValidatorName["UNIQUE_ITEMS"] = "uniqueItems";
-	ValidatorName["MINIMUM"] = "minimum";
-	ValidatorName["MAXIMUM"] = "maximum";
-	ValidatorName["MIN_ITEMS"] = "minItems";
-	ValidatorName["MAX_ITEMS"] = "maxItems";
-	ValidatorName["MIN_LENGTH"] = "minLength";
-	ValidatorName["MAX_LENGTH"] = "maxLength";
-	ValidatorName["MIN_DATE"] = "minDate";
-	ValidatorName["MAX_DATE"] = "maxDate";
-	ValidatorName["PATTERN"] = "pattern";
-	return ValidatorName;
-}({});
+//#region src/core/error/validator-codes.ts
 const ValidatorErrorCode = {
 	EXPECTED_NUMBER: "VALIDATOR_EXPECTED_NUMBER",
 	EXPECTED_DATE: "VALIDATOR_EXPECTED_DATE",
 	EXPECTED_STRING: "VALIDATOR_EXPECTED_STRING"
 };
 //#endregion
-//#region src/core/error/config.ts
-var ConfigError = class extends MetadataError {};
-//#endregion
-//#region src/core/error/config-codes.ts
-const ConfigErrorCode = {
-	TSCONFIG_MALFORMED: "CONFIG_TSCONFIG_MALFORMED",
-	PRESET_NOT_FOUND: "CONFIG_PRESET_NOT_FOUND",
-	PRESET_MISSING: "CONFIG_PRESET_MISSING"
-};
-//#endregion
-//#region src/adapters/decorator/constants.ts
-const ParamKind = {
-	Body: "body",
-	BodyProp: "bodyProp",
-	Context: "context",
-	Cookie: "cookie",
-	Header: "header",
-	FormData: "formData",
-	Query: "query",
-	QueryProp: "queryProp",
-	Path: "path"
-};
-const CollectionKind = {
-	Csv: "csv",
-	Ssv: "ssv",
-	Tsv: "tsv",
-	Pipes: "pipes",
-	Multi: "multi"
-};
-const DecoratorTargetKind = {
-	Class: "class",
-	Method: "method",
-	Parameter: "parameter",
-	Property: "property"
-};
-const DecoratorArgumentKindName = {
-	Literal: "literal",
-	Object: "object",
-	Array: "array",
-	Identifier: "identifier",
-	Unresolvable: "unresolvable"
-};
-const MarkerName = {
-	Hidden: "hidden",
-	Deprecated: "deprecated",
-	Extension: "extension"
-};
-const NumericKind = {
-	Int: "int",
-	Long: "long",
-	Float: "float",
-	Double: "double"
-};
-//#endregion
-//#region src/adapters/decorator/helpers.ts
-/**
-* Read a positional argument as a string. Accepts both literal string args
-* (`@Foo('value')`) and identifier references that resolve to a string
-* (`@Foo(SOME_CONSTANT)`). Returns `undefined` for any other argument shape.
-*/
-function readString(arg) {
-	if (!arg) return void 0;
-	if (arg.kind === "literal" && typeof arg.raw === "string") return arg.raw;
-	if (arg.kind === "identifier" && typeof arg.raw === "string") return arg.raw;
-}
-/**
-* Read a positional argument as a number. Only matches numeric literals.
-*/
-function readNumber(arg) {
-	if (!arg) return void 0;
-	if (arg.kind === "literal" && typeof arg.raw === "number") return arg.raw;
-}
-/**
-* Read a positional argument as a boolean. Only matches boolean literals.
-*/
-function readBoolean(arg) {
-	if (!arg) return void 0;
-	if (arg.kind === "literal" && typeof arg.raw === "boolean") return arg.raw;
-}
-/**
-* Read a positional argument that may be either a single string or an array
-* of strings. Returns `undefined` when the argument is missing, when any
-* array element is non-string, or otherwise unresolvable. All-or-nothing:
-* never returns a partial array with non-string items silently dropped.
-*/
-function readStringOrStringArray(arg) {
-	const single = readString(arg);
-	if (single !== void 0) return [single];
-	if (arg?.kind === "array" && Array.isArray(arg.raw)) {
-		if (arg.raw.every((item) => typeof item === "string")) return arg.raw;
-		return;
-	}
-}
-/**
-* Convenience for the common controller path assignment. Reads the first
-* argument as a string-or-string-array and writes it to `draft.paths`,
-* defaulting to `['']` when the argument is missing or unresolvable. Use this
-* inside a `controller({ match, apply })` handler to declare a class as a
-* controller.
-*/
-function setControllerPaths(draft, arg) {
-	draft.paths = readStringOrStringArray(arg) ?? [""];
-}
-/**
-* Convenience for the common method path assignment. Reads the first argument
-* as a string and writes it to `draft.path` if present; leaves the field
-* untouched otherwise (the orchestrator initialises it to `''`).
-*/
-function setMethodPath(draft, arg) {
-	const path = readString(arg);
-	if (path !== void 0) draft.path = path;
-}
-//#endregion
-//#region src/adapters/decorator/utils.ts
-function matches(match, source) {
-	if (match.name !== source.name) return false;
-	if (match.on && match.on !== source.target) return false;
-	return true;
-}
-function matchesJsDoc(match, source) {
-	if (match.tag !== source.tag) return false;
-	if (match.on && match.on !== source.target) return false;
-	return true;
-}
-function newControllerDraft(input) {
-	return {
-		name: input.name,
-		location: input.location,
-		hidden: false,
-		consumes: [],
-		produces: [],
-		tags: [],
-		responses: [],
-		security: [],
-		extensions: []
-	};
-}
-function newMethodDraft(input) {
-	return {
-		name: input.name,
-		path: "",
-		description: "",
-		hidden: false,
-		consumes: [],
-		produces: [],
-		tags: [],
-		responses: [],
-		security: [],
-		extensions: [],
-		parameters: [],
-		defaultResponseExamples: []
-	};
-}
-function newParameterDraft(input) {
-	return {
-		parameterName: input.parameterName,
-		name: input.parameterName,
-		description: "",
-		required: true,
-		examples: [],
-		exampleLabels: [],
-		extensions: [],
-		validators: {}
-	};
-}
-/**
-* Build a {@link Registry}, optionally seeded with handler arrays from `input`.
-* Any kind omitted from `input` falls back to an empty array, so callers can
-* pass just the kinds they care about (e.g. `createRegistry({ methods: [...] })`).
-*
-* The provided arrays are copied — mutating the result does not affect `input`.
-*/
-function createRegistry(input = {}) {
-	return {
-		controllers: input.controllers ? [...input.controllers] : [],
-		methods: input.methods ? [...input.methods] : [],
-		parameters: input.parameters ? [...input.parameters] : [],
-		controllerJsDoc: input.controllerJsDoc ? [...input.controllerJsDoc] : [],
-		methodJsDoc: input.methodJsDoc ? [...input.methodJsDoc] : [],
-		parameterJsDoc: input.parameterJsDoc ? [...input.parameterJsDoc] : []
-	};
-}
-/**
-* Concatenate two registries kind-by-kind. Earlier handlers run first inside
-* the orchestrator, so callers who want override-by-running-later semantics
-* should pass the dominant registry as `b`.
-*/
-function mergeRegistries(a, b) {
-	return {
-		controllers: [...a.controllers, ...b.controllers],
-		methods: [...a.methods, ...b.methods],
-		parameters: [...a.parameters, ...b.parameters],
-		controllerJsDoc: [...a.controllerJsDoc, ...b.controllerJsDoc],
-		methodJsDoc: [...a.methodJsDoc, ...b.methodJsDoc],
-		parameterJsDoc: [...a.parameterJsDoc, ...b.parameterJsDoc]
-	};
-}
-function generatePresetLookupPaths(input) {
-	if (path.isAbsolute(input) || input.startsWith("./") || input.startsWith("../")) return [input];
-	if (input.startsWith("module:")) return [input.substring(7)];
-	if (!input.startsWith("@")) return [input, `@trapi/${input}`];
-	return [input];
-}
-/**
-* Collect the unique decorator names of every handler whose `marker` matches
-* the given predicate. Lets the type resolver discover preset-renamed
-* decorators without hard-coding canonical names.
-*/
-function namesForMarker(registry, predicate) {
-	const names = /* @__PURE__ */ new Set();
-	const all = [
-		...registry.controllers,
-		...registry.methods,
-		...registry.parameters
-	];
-	for (const handler of all) if (handler.marker !== void 0 && predicate(handler.marker)) names.add(handler.match.name);
-	return names;
-}
-/**
-* Collect the unique JSDoc tag names of every JSDoc handler whose `marker`
-* matches the given predicate. JSDoc analogue of `namesForMarker`.
-*/
-function tagsForMarker(registry, predicate) {
-	const tags = /* @__PURE__ */ new Set();
-	const all = [
-		...registry.controllerJsDoc,
-		...registry.methodJsDoc,
-		...registry.parameterJsDoc
-	];
-	for (const handler of all) if (handler.marker !== void 0 && predicate(handler.marker)) tags.add(handler.match.tag);
-	return tags;
-}
-function isHiddenMarker(marker) {
-	return marker === "hidden";
-}
-function isDeprecatedMarker(marker) {
-	return marker === "deprecated";
-}
-function isExtensionMarker(marker) {
-	return marker === "extension";
-}
-function numericMarkerKind(marker) {
-	if (typeof marker === "object" && marker !== null && "numeric" in marker) return marker.numeric;
-}
-const controller = (handler) => handler;
-const method = (handler) => handler;
-const parameter = (handler) => handler;
-const controllerJsDoc = (handler) => handler;
-const methodJsDoc = (handler) => handler;
-const parameterJsDoc = (handler) => handler;
-function isLiteralLike(kind) {
-	return kind === "literal" || kind === "identifier";
-}
-function readArray(draft, key) {
-	const record = draft;
-	const existing = record[key];
-	if (Array.isArray(existing)) return existing;
-	if (typeof existing !== "undefined") throw new TypeError(`append(): cannot append to draft key "${key}": existing value is not an array (got ${typeof existing}).`);
-	const created = [];
-	record[key] = created;
-	return created;
-}
-function into(key) {
-	return {
-		positional(index) {
-			return (ctx, draft) => {
-				const arg = ctx.argument(index);
-				if (arg && isLiteralLike(arg.kind)) draft[key] = arg.raw;
-			};
-		},
-		typeArgument(index = 0) {
-			return (ctx, draft) => {
-				const ta = ctx.typeArgument(index);
-				if (ta) draft[key] = ta.resolve();
-			};
-		}
-	};
-}
-function append(key) {
-	return {
-		positional(index) {
-			return (ctx, draft) => {
-				const arg = ctx.argument(index);
-				if (!arg) return;
-				const target = readArray(draft, key);
-				if (arg.kind === "array" && Array.isArray(arg.raw)) target.push(...arg.raw);
-				else if (isLiteralLike(arg.kind)) target.push(arg.raw);
-			};
-		},
-		positionalAll() {
-			return (ctx, draft) => {
-				const target = readArray(draft, key);
-				for (const arg of ctx.arguments()) if (arg.kind === "array" && Array.isArray(arg.raw)) target.push(...arg.raw);
-				else if (isLiteralLike(arg.kind)) target.push(arg.raw);
-			};
-		}
-	};
-}
-function flag(key, value = true) {
-	return (_ctx, draft) => {
-		draft[key] = value;
-	};
-}
-//#endregion
-//#region src/adapters/decorator/validation/module.ts
-const decoratorTargetSchema = z.enum([
-	"class",
-	"method",
-	"parameter",
-	"property"
-]);
-const replacesPolicySchema = z.union([z.literal(true), z.string().min(1)]);
-function matchSchemaForKind(allowedOn) {
-	return z.object({
-		name: z.string().min(1),
-		on: decoratorTargetSchema.optional()
-	}).refine((m) => m.on === void 0 || m.on === allowedOn, {
-		message: `match.on is incompatible with the handler array it lives in — expected '${allowedOn}' or omit 'on' entirely.`,
-		path: ["on"]
-	});
-}
-function jsDocMatchSchemaForKind(allowedOn) {
-	return z.object({
-		tag: z.string().min(1),
-		on: decoratorTargetSchema.optional()
-	}).refine((m) => m.on === void 0 || m.on === allowedOn, {
-		message: `match.on is incompatible with the JSDoc handler array it lives in — expected '${allowedOn}' or omit 'on' entirely.`,
-		path: ["on"]
-	});
-}
-const matchSchema = z.object({
-	name: z.string().min(1),
-	on: decoratorTargetSchema.optional()
-});
-const jsDocMatchSchema = z.object({
-	tag: z.string().min(1),
-	on: decoratorTargetSchema.optional()
-});
-const numericMarkerSchema = z.object({ numeric: z.enum([
-	"int",
-	"long",
-	"float",
-	"double"
-]) });
-const resolverMarkerSchema = z.union([
-	z.literal("hidden"),
-	z.literal("deprecated"),
-	z.literal("extension"),
-	numericMarkerSchema
-]);
-const handlerBaseShape = {
-	replaces: replacesPolicySchema.optional(),
-	marker: resolverMarkerSchema.optional(),
-	apply: z.custom((value) => typeof value === "function", { message: "apply must be a function" })
-};
-const controllerHandlerSchema = z.object({
-	match: matchSchemaForKind("class"),
-	...handlerBaseShape
-});
-const methodHandlerSchema = z.object({
-	match: matchSchemaForKind("method"),
-	...handlerBaseShape
-});
-const parameterHandlerSchema = z.object({
-	match: matchSchemaForKind("parameter"),
-	...handlerBaseShape
-});
-const controllerJsDocHandlerSchema = z.object({
-	match: jsDocMatchSchemaForKind("class"),
-	...handlerBaseShape
-});
-const methodJsDocHandlerSchema = z.object({
-	match: jsDocMatchSchemaForKind("method"),
-	...handlerBaseShape
-});
-const parameterJsDocHandlerSchema = z.object({
-	match: jsDocMatchSchemaForKind("parameter"),
-	...handlerBaseShape
-});
-const presetSchema = z.object({
-	name: z.string().min(1),
-	extends: z.array(z.string().min(1)).optional(),
-	controllers: z.array(controllerHandlerSchema).optional(),
-	methods: z.array(methodHandlerSchema).optional(),
-	parameters: z.array(parameterHandlerSchema).optional(),
-	controllerJsDoc: z.array(controllerJsDocHandlerSchema).optional(),
-	methodJsDoc: z.array(methodJsDocHandlerSchema).optional(),
-	parameterJsDoc: z.array(parameterJsDocHandlerSchema).optional()
-});
-function createPresetContainer() {
-	const container = new Container();
-	container.mount("name", createValidator(presetSchema.shape.name));
-	container.mount("extends", { optional: true }, createValidator(presetSchema.shape.extends));
-	container.mount("controllers", { optional: true }, createValidator(presetSchema.shape.controllers));
-	container.mount("methods", { optional: true }, createValidator(presetSchema.shape.methods));
-	container.mount("parameters", { optional: true }, createValidator(presetSchema.shape.parameters));
-	container.mount("controllerJsDoc", { optional: true }, createValidator(presetSchema.shape.controllerJsDoc));
-	container.mount("methodJsDoc", { optional: true }, createValidator(presetSchema.shape.methodJsDoc));
-	container.mount("parameterJsDoc", { optional: true }, createValidator(presetSchema.shape.parameterJsDoc));
-	return container;
-}
-const sharedContainer = createPresetContainer();
-async function validatePreset(input) {
-	if (input === null || typeof input !== "object" || Array.isArray(input)) throw new TypeError("preset input must be an object");
-	return sharedContainer.run(input);
-}
-//#endregion
-//#region src/adapters/decorator/module.ts
-const decoratorKinds = [
-	"controllers",
-	"methods",
-	"parameters"
-];
-const jsDocKinds = [
-	"controllerJsDoc",
-	"methodJsDoc",
-	"parameterJsDoc"
-];
-function emptyTaggedRegistry() {
-	return {
-		controllers: [],
-		methods: [],
-		parameters: [],
-		controllerJsDoc: [],
-		methodJsDoc: [],
-		parameterJsDoc: []
-	};
-}
-async function loadRegistry(preset, options) {
-	return stripOrigins(await loadTaggedRegistry(preset, options, /* @__PURE__ */ new Set()));
-}
-async function loadTaggedRegistry(preset, options, visited) {
-	const validated = await validatePreset(preset);
-	if (visited.has(validated.name)) throw new MetadataError({ message: `Preset cycle detected: ${[...visited, validated.name].join(" -> ")}` });
-	const nextVisited = new Set(visited);
-	nextVisited.add(validated.name);
-	const merged = emptyTaggedRegistry();
-	for (const extendsName of validated.extends ?? []) appendTagged(merged, await loadTaggedRegistry(await options.resolver(extendsName), options, nextVisited));
-	applyOwnHandlers(merged, validated, !!options.strict);
-	return merged;
-}
-function applyOwnHandlers(merged, preset, strict) {
-	for (const kind of decoratorKinds) {
-		const handlers = preset[kind] ?? [];
-		for (const handler of handlers) {
-			if (handler.replaces) applyReplacesDecorator(merged, kind, handler, preset.name, strict);
-			merged[kind].push({
-				origin: preset.name,
-				handler
-			});
-		}
-	}
-	for (const kind of jsDocKinds) {
-		const handlers = preset[kind] ?? [];
-		for (const handler of handlers) {
-			if (handler.replaces) applyReplacesJsDoc(merged, kind, handler, preset.name, strict);
-			merged[kind].push({
-				origin: preset.name,
-				handler
-			});
-		}
-	}
-}
-function applyReplacesDecorator(merged, kind, handler, presetName, strict) {
-	const list = merged[kind];
-	const remaining = [];
-	let removed = 0;
-	for (const entry of list) {
-		if (entry.origin !== presetName && handlerMatches(handler, entry.handler.match.name, entry.handler.match.on) && originMatches(handler.replaces, entry.origin)) {
-			removed += 1;
-			continue;
-		}
-		remaining.push(entry);
-	}
-	if (removed === 0 && strict) throw new MetadataError({ message: `Preset '${presetName}': handler with replaces=${describeReplaces(handler.replaces)} on '${handler.match.name}' did not match any parent handler` });
-	merged[kind] = remaining;
-}
-function applyReplacesJsDoc(merged, kind, handler, presetName, strict) {
-	const list = merged[kind];
-	const remaining = [];
-	let removed = 0;
-	for (const entry of list) {
-		if (entry.origin !== presetName && handlerMatches(handler, entry.handler.match.tag, entry.handler.match.on) && originMatches(handler.replaces, entry.origin)) {
-			removed += 1;
-			continue;
-		}
-		remaining.push(entry);
-	}
-	if (removed === 0 && strict) throw new MetadataError({ message: `Preset '${presetName}': JSDoc handler with replaces=${describeReplaces(handler.replaces)} on '@${handler.match.tag}' did not match any parent handler` });
-	merged[kind] = remaining;
-}
-function handlerMatches(handler, targetName, targetOn) {
-	if (("name" in handler.match ? handler.match.name : handler.match.tag) !== targetName) return false;
-	if (handler.match.on && handler.match.on !== targetOn) return false;
-	return true;
-}
-function originMatches(replaces, origin) {
-	if (replaces === true) return true;
-	return replaces === origin;
-}
-function describeReplaces(replaces) {
-	return replaces === true ? "true" : `'${replaces}'`;
-}
-function appendTagged(target, source) {
-	for (const kind of decoratorKinds) target[kind].push(...source[kind]);
-	for (const kind of jsDocKinds) target[kind].push(...source[kind]);
-}
-function stripOrigins(tagged) {
-	const registry = createRegistry();
-	registry.controllers = tagged.controllers.map((e) => e.handler);
-	registry.methods = tagged.methods.map((e) => e.handler);
-	registry.parameters = tagged.parameters.map((e) => e.handler);
-	registry.controllerJsDoc = tagged.controllerJsDoc.map((e) => e.handler);
-	registry.methodJsDoc = tagged.methodJsDoc.map((e) => e.handler);
-	registry.parameterJsDoc = tagged.parameterJsDoc.map((e) => e.handler);
-	return registry;
-}
-/**
-* Resolve a preset by string identifier (npm package, relative path, etc.) and
-* return the v2 Preset object. Looks for a `preset` named export, then the
-* default export, then the module itself.
-*/
-async function resolvePresetByName(input) {
-	const lookupPaths = generatePresetLookupPaths(input);
-	let lastError;
-	for (const lookupPath of lookupPaths) try {
-		const moduleExport = await load(lookupPath);
-		const candidates = [
-			moduleExport.preset,
-			moduleExport.default,
-			moduleExport
-		];
-		for (const candidate of candidates) if (isV2Preset(candidate)) return candidate;
-	} catch (e) {
-		lastError = e;
-	}
-	throw new ConfigError({
-		message: `Preset '${input}' could not be resolved.`,
-		code: ConfigErrorCode.PRESET_NOT_FOUND,
-		cause: lastError
-	});
-}
-/**
-* Resolve a preset by name and immediately materialize its registry, recursively
-* loading `extends` parents through the same resolver.
-*/
-async function loadRegistryByName(input) {
-	return loadRegistry(await resolvePresetByName(input), { resolver: resolvePresetByName });
-}
-function isV2Preset(input) {
-	return typeof input === "object" && input !== null && typeof input.name === "string" && !("items" in input);
-}
-//#endregion
-//#region src/adapters/decorator/test-helpers.ts
-/**
-* Build a literal-kind {@link DecoratorArgument} from a primitive value.
-* Use this in unit tests to feed handlers a mock argument:
-*
-* ```ts
-* const ctx = createHandlerContext({ args: [literalArg('users')] });
-* controllerHandler.apply(ctx, draft);
-* ```
-*/
-function literalArg(raw) {
-	return {
-		kind: "literal",
-		raw
-	};
-}
-/**
-* Build an identifier-kind {@link DecoratorArgument} (e.g. `@Foo(SOME_CONSTANT)`).
-* `raw` is the resolved value the identifier points to — typically a string.
-*/
-function identifierArg(raw) {
-	return {
-		kind: "identifier",
-		raw
-	};
-}
-/**
-* Build an array-kind {@link DecoratorArgument} (e.g. `@Foo(['a', 'b'])`).
-*/
-function arrayArg(raw) {
-	return {
-		kind: "array",
-		raw
-	};
-}
-/**
-* Build an object-kind {@link DecoratorArgument} (e.g. `@Foo({ key: 'value' })`).
-*/
-function objectArg(raw) {
-	return {
-		kind: "object",
-		raw
-	};
-}
-/**
-* Build an unresolvable-kind {@link DecoratorArgument} — represents arguments
-* the source extractor couldn't statically evaluate (e.g. function calls,
-* unknown identifiers).
-*/
-function unresolvableArg() {
-	return {
-		kind: "unresolvable",
-		raw: void 0
-	};
-}
-/**
-* Build a {@link DecoratorTypeArgument} stub that returns the supplied type
-* when `resolve()` is called.
-*/
-function typeArg(type) {
-	return { resolve: () => type };
-}
-/**
-* Construct a {@link HandlerContext} for unit-testing handlers in isolation
-* without spinning up the full TypeScript compiler / `generateMetadata`
-* pipeline. Combine with the `*Arg(...)` builders to feed a handler a
-* controlled mock decorator source.
-*
-* ```ts
-* const ctx = createHandlerContext({ args: [literalArg('users')] });
-* const draft = newControllerDraft({ name: 'UserController', location: '/x.ts' });
-* myHandler.apply(ctx, draft);
-* expect(draft.paths).toEqual(['users']);
-* ```
-*/
-function createHandlerContext(input = {}) {
-	const args = input.args ?? [];
-	const typeArgs = input.typeArgs ?? [];
-	return {
-		host: input.host ?? { name: "TestHost" },
-		argument: (index) => args[index],
-		arguments: () => [...args],
-		typeArgument: (index) => typeArgs[index],
-		typeArguments: () => [...typeArgs],
-		parameterType: () => input.parameterType
-	};
-}
-//#endregion
 //#region src/adapters/typescript/js-doc/constants.ts
 let JSDocTagName = /* @__PURE__ */ function(JSDocTagName) {
 	JSDocTagName["ABSTRACT"] = "abstract";
@@ -1075,22 +261,22 @@ function getJSDocTagNames(node, requireTagName = false) {
 function getInitializerValue(initializer, typeChecker, type) {
 	if (!initializer) return;
 	switch (initializer.kind) {
-		case ts.SyntaxKind.ArrayLiteralExpression: return initializer.elements.map((element) => getInitializerValue(element, typeChecker));
-		case ts.SyntaxKind.StringLiteral:
-		case ts.SyntaxKind.NoSubstitutionTemplateLiteral: return initializer.text;
-		case ts.SyntaxKind.TrueKeyword: return true;
-		case ts.SyntaxKind.FalseKeyword: return false;
-		case ts.SyntaxKind.PrefixUnaryExpression: {
+		case SyntaxKind.ArrayLiteralExpression: return initializer.elements.map((element) => getInitializerValue(element, typeChecker));
+		case SyntaxKind.StringLiteral:
+		case SyntaxKind.NoSubstitutionTemplateLiteral: return initializer.text;
+		case SyntaxKind.TrueKeyword: return true;
+		case SyntaxKind.FalseKeyword: return false;
+		case SyntaxKind.PrefixUnaryExpression: {
 			const prefixUnary = initializer;
 			switch (prefixUnary.operator) {
-				case ts.SyntaxKind.PlusToken: return Number(prefixUnary.operand.text);
-				case ts.SyntaxKind.MinusToken: return Number(`-${prefixUnary.operand.text}`);
+				case SyntaxKind.PlusToken: return Number(prefixUnary.operand.text);
+				case SyntaxKind.MinusToken: return Number(`-${prefixUnary.operand.text}`);
 				default: throw new MetadataError(`Unsupported prefix operator token: ${prefixUnary.operator}`);
 			}
 		}
-		case ts.SyntaxKind.NumberKeyword:
-		case ts.SyntaxKind.FirstLiteralToken: return Number(initializer.text);
-		case ts.SyntaxKind.NewExpression: {
+		case SyntaxKind.NumberKeyword:
+		case SyntaxKind.FirstLiteralToken: return Number(initializer.text);
+		case SyntaxKind.NewExpression: {
 			const newExpression = initializer;
 			if (newExpression.expression.text === "Date") {
 				let date = /* @__PURE__ */ new Date();
@@ -1104,8 +290,8 @@ function getInitializerValue(initializer, typeChecker, type) {
 			}
 			return;
 		}
-		case ts.SyntaxKind.NullKeyword: return null;
-		case ts.SyntaxKind.ObjectLiteralExpression: {
+		case SyntaxKind.NullKeyword: return null;
+		case SyntaxKind.ObjectLiteralExpression: {
 			const objectLiteral = initializer;
 			const nestedObject = {};
 			objectLiteral.properties.forEach((p) => {
@@ -1113,7 +299,7 @@ function getInitializerValue(initializer, typeChecker, type) {
 			});
 			return nestedObject;
 		}
-		case ts.SyntaxKind.ImportSpecifier: {
+		case SyntaxKind.ImportSpecifier: {
 			if (typeof typeChecker === "undefined") return;
 			const importSpecifier = initializer;
 			const importSymbol = typeChecker.getSymbolAtLocation(importSpecifier.name);
@@ -1134,7 +320,7 @@ function getInitializerValue(initializer, typeChecker, type) {
 }
 const hasInitializer = (node) => Object.prototype.hasOwnProperty.call(node, "initializer");
 const extractInitializer = (valueDeclaration) => valueDeclaration && hasInitializer(valueDeclaration) && valueDeclaration.initializer || void 0;
-const extractImportSpecifier = (symbol) => symbol?.declarations && symbol.declarations.length > 0 && ts.isImportSpecifier(symbol.declarations[0]) && symbol.declarations[0] || void 0;
+const extractImportSpecifier = (symbol) => symbol?.declarations && symbol.declarations.length > 0 && isImportSpecifier(symbol.declarations[0]) && symbol.declarations[0] || void 0;
 //#endregion
 //#region src/adapters/decorator/typescript/utils.ts
 /**
@@ -1143,15 +329,15 @@ const extractImportSpecifier = (symbol) => symbol?.declarations && symbol.declar
 * extension extraction) that only need decorator names + argument values.
 */
 function readNodeDecorators(node, typeChecker) {
-	if (!ts.canHaveDecorators(node)) return [];
-	const decorators = ts.getDecorators(node);
+	if (!canHaveDecorators(node)) return [];
+	const decorators = getDecorators(node);
 	if (!decorators || decorators.length === 0) return [];
 	const output = [];
 	for (const decorator of decorators) {
 		const { expression } = decorator;
 		let name;
 		let argumentExpressions = [];
-		if (ts.isCallExpression(expression)) {
+		if (isCallExpression(expression)) {
 			argumentExpressions = expression.arguments;
 			name = readDecoratorName$1(expression.expression);
 		} else name = readDecoratorName$1(expression);
@@ -1173,39 +359,39 @@ function hasDecoratorNamed(node, name, typeChecker) {
 	return readNodeDecorators(node, typeChecker).some((d) => d.name === name);
 }
 function readDecoratorName$1(expression) {
-	if (ts.isIdentifier(expression)) return expression.text;
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+	if (isIdentifier(expression)) return expression.text;
+	if (isPropertyAccessExpression(expression)) return expression.name.text;
 }
 function buildDecoratorArgument(expr, typeChecker) {
-	if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return {
+	if (isStringLiteral(expr) || isNumericLiteral(expr) || isNoSubstitutionTemplateLiteral(expr)) return {
 		raw: getInitializerValue(expr, typeChecker),
 		kind: "literal"
 	};
-	if (expr.kind === ts.SyntaxKind.TrueKeyword) return {
+	if (expr.kind === SyntaxKind.TrueKeyword) return {
 		raw: true,
 		kind: "literal"
 	};
-	if (expr.kind === ts.SyntaxKind.FalseKeyword) return {
+	if (expr.kind === SyntaxKind.FalseKeyword) return {
 		raw: false,
 		kind: "literal"
 	};
-	if (expr.kind === ts.SyntaxKind.NullKeyword) return {
+	if (expr.kind === SyntaxKind.NullKeyword) return {
 		raw: null,
 		kind: "literal"
 	};
-	if (ts.isPrefixUnaryExpression(expr) && (expr.operator === ts.SyntaxKind.PlusToken || expr.operator === ts.SyntaxKind.MinusToken) && ts.isNumericLiteral(expr.operand)) return {
+	if (isPrefixUnaryExpression(expr) && (expr.operator === SyntaxKind.PlusToken || expr.operator === SyntaxKind.MinusToken) && isNumericLiteral(expr.operand)) return {
 		raw: getInitializerValue(expr, typeChecker),
 		kind: "literal"
 	};
-	if (ts.isObjectLiteralExpression(expr)) return {
+	if (isObjectLiteralExpression(expr)) return {
 		raw: getInitializerValue(expr, typeChecker),
 		kind: "object"
 	};
-	if (ts.isArrayLiteralExpression(expr)) return {
+	if (isArrayLiteralExpression(expr)) return {
 		raw: getInitializerValue(expr, typeChecker),
 		kind: "array"
 	};
-	if (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr)) {
+	if (isIdentifier(expr) || isPropertyAccessExpression(expr)) {
 		const value = getInitializerValue(expr, typeChecker);
 		if (typeof value !== "undefined") return {
 			raw: value,
@@ -1224,8 +410,8 @@ function buildDecoratorArgument(expr, typeChecker) {
 //#endregion
 //#region src/adapters/decorator/typescript/module.ts
 function buildDecoratorSources(node, options) {
-	if (!ts.canHaveDecorators(node)) return [];
-	const decorators = ts.getDecorators(node);
+	if (!canHaveDecorators(node)) return [];
+	const decorators = getDecorators(node);
 	if (!decorators || decorators.length === 0) return [];
 	const output = [];
 	for (const decorator of decorators) {
@@ -1239,7 +425,7 @@ function buildDecoratorSource(decorator, options) {
 	let name;
 	let argumentExpressions = [];
 	let typeArgumentNodes = [];
-	if (ts.isCallExpression(expression)) {
+	if (isCallExpression(expression)) {
 		argumentExpressions = expression.arguments;
 		typeArgumentNodes = expression.typeArguments ?? [];
 		name = readDecoratorName(expression.expression);
@@ -1262,8 +448,8 @@ function buildDecoratorSource(decorator, options) {
 	};
 }
 function readDecoratorName(expression) {
-	if (ts.isIdentifier(expression)) return expression.text;
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+	if (isIdentifier(expression)) return expression.text;
+	if (isPropertyAccessExpression(expression)) return expression.name.text;
 }
 function buildJsDocSources(node, options) {
 	const tags = getJSDocTags(node);
@@ -1277,10 +463,10 @@ function buildJsDocSource(tag, options) {
 	const text = transformJSDocComment(tag.comment);
 	let parameterName;
 	let typeNode;
-	if (ts.isJSDocParameterTag(tag) || ts.isJSDocPropertyTag(tag)) {
+	if (isJSDocParameterTag(tag) || isJSDocPropertyTag(tag)) {
 		if (tag.name) parameterName = readEntityName(tag.name);
 		typeNode = tag.typeExpression?.type;
-	} else if (ts.isJSDocReturnTag(tag) || ts.isJSDocTypeTag(tag) || ts.isJSDocThisTag(tag)) typeNode = tag.typeExpression?.type;
+	} else if (isJSDocReturnTag(tag) || isJSDocTypeTag(tag) || isJSDocThisTag(tag)) typeNode = tag.typeExpression?.type;
 	const source = {
 		tag: tagName,
 		target: options.target,
@@ -1295,8 +481,8 @@ function buildJsDocSource(tag, options) {
 	return source;
 }
 function readEntityName(name) {
-	if (ts.isIdentifier(name)) return name.text;
-	if (ts.isQualifiedName(name)) {
+	if (isIdentifier(name)) return name.text;
+	if (isQualifiedName(name)) {
 		const left = readEntityName(name.left);
 		return left ? `${left}.${name.right.text}` : name.right.text;
 	}
@@ -1358,16 +544,6 @@ function applyJsDocHandlers(node, handlers, draft, options) {
 	for (const source of sources) for (const handler of handlers) if (matchesJsDoc(handler.match, source)) handler.apply(buildJsDocHandlerContext(source, options), draft);
 }
 //#endregion
-//#region src/core/error/validator.ts
-var ValidatorError$1 = class extends MetadataError {};
-//#endregion
-//#region src/core/error/validator-codes.ts
-const ValidatorErrorCode$1 = {
-	EXPECTED_NUMBER: "VALIDATOR_EXPECTED_NUMBER",
-	EXPECTED_DATE: "VALIDATOR_EXPECTED_DATE",
-	EXPECTED_STRING: "VALIDATOR_EXPECTED_STRING"
-};
-//#endregion
 //#region src/adapters/typescript/validator/module.ts
 function getDeclarationValidators(declaration, name) {
 	if (!declaration.parent) return {};
@@ -1400,23 +576,23 @@ function getDeclarationValidators(declaration, name) {
 		comment = comment.substring(comment.indexOf(" ") + 1).trim();
 		const value = getCommentValue(comment);
 		switch (name) {
-			case "uniqueItems":
+			case ValidatorName.UNIQUE_ITEMS:
 				validators[name] = {
 					message: getErrorMsg(comment, false),
 					value: void 0
 				};
 				break;
-			case "minimum":
-			case "maximum":
-			case "minItems":
-			case "maxItems":
-			case "minLength":
-			case "maxLength":
+			case ValidatorName.MINIMUM:
+			case ValidatorName.MAXIMUM:
+			case ValidatorName.MIN_ITEMS:
+			case ValidatorName.MAX_ITEMS:
+			case ValidatorName.MIN_LENGTH:
+			case ValidatorName.MAX_LENGTH:
 				{
 					const parsed = Number(value);
-					if (!Number.isFinite(parsed)) throw new ValidatorError$1({
+					if (!Number.isFinite(parsed)) throw new ValidatorError({
 						message: `@${name} validator expects a numeric value, got '${value}'.`,
-						code: ValidatorErrorCode$1.EXPECTED_NUMBER
+						code: ValidatorErrorCode.EXPECTED_NUMBER
 					});
 					validators[name] = {
 						message: getErrorMsg(comment),
@@ -1424,21 +600,21 @@ function getDeclarationValidators(declaration, name) {
 					};
 				}
 				break;
-			case "minDate":
-			case "maxDate":
-				if (typeof value !== "string") throw new ValidatorError$1({
+			case ValidatorName.MIN_DATE:
+			case ValidatorName.MAX_DATE:
+				if (typeof value !== "string") throw new ValidatorError({
 					message: `@${name} validator expects a date string, got '${typeof value}'.`,
-					code: ValidatorErrorCode$1.EXPECTED_DATE
+					code: ValidatorErrorCode.EXPECTED_DATE
 				});
 				validators[name] = {
 					message: getErrorMsg(comment),
 					value
 				};
 				break;
-			case "pattern":
-				if (typeof value !== "string") throw new ValidatorError$1({
+			case ValidatorName.PATTERN:
+				if (typeof value !== "string") throw new ValidatorError({
 					message: `@${name} validator expects a string pattern, got '${value}'.`,
-					code: ValidatorErrorCode$1.EXPECTED_STRING
+					code: ValidatorErrorCode.EXPECTED_STRING
 				});
 				validators[name] = {
 					message: getErrorMsg(comment),
@@ -1486,64 +662,6 @@ function removeSurroundingQuotes(str) {
 	return str;
 }
 //#endregion
-//#region src/core/error/resolver.ts
-var ResolverError$1 = class extends MetadataError {
-	file;
-	line;
-	constructor(message, node, options) {
-		const opts = typeof options === "boolean" ? { onlyCurrent: options } : options;
-		const onlyCurrent = opts?.onlyCurrent ?? false;
-		const parts = [message];
-		let file;
-		let line;
-		if (node) {
-			const location = prettyLocationOfNode$1(node);
-			if (location) {
-				parts.push(location.text);
-				file = location.file;
-				line = location.line;
-			}
-			parts.push(prettyTroubleCause$1(node, onlyCurrent));
-		}
-		super({
-			message: parts.join("\n"),
-			cause: opts?.cause
-		});
-		this.file = file;
-		this.line = line;
-	}
-};
-function isResolverError$1(input) {
-	if (!isBaseError(input)) return false;
-	return "file" in input && "line" in input;
-}
-function prettyLocationOfNode$1(node) {
-	try {
-		const sourceFile = node.getSourceFile();
-		if (!sourceFile) return void 0;
-		const token = node.getFirstToken() || node.parent?.getFirstToken();
-		const start = token ? sourceFile.getLineAndCharacterOfPosition(token.getStart()).line + 1 : void 0;
-		const end = token ? sourceFile.getLineAndCharacterOfPosition(token.getEnd()).line + 1 : void 0;
-		return {
-			text: `At: ${normalize(sourceFile.fileName)}${start ? `:${start}` : ""}${end ? `:${end}` : ""}.`,
-			file: sourceFile.fileName,
-			line: start
-		};
-	} catch {
-		return;
-	}
-}
-function prettyTroubleCause$1(node, onlyCurrent = false) {
-	try {
-		let name;
-		if (onlyCurrent || !node.parent) name = node.pos !== -1 ? node.getText() : node.name.text;
-		else name = node.parent.pos !== -1 ? node.parent.getText() : node.parent.name.text;
-		return `This was caused by '${name}'`;
-	} catch {
-		return "This was caused by an unknown node";
-	}
-}
-//#endregion
 //#region src/adapters/typescript/resolver/extension/module.ts
 function getNodeExtensions(node, registry) {
 	const names = namesForMarker(registry, isExtensionMarker);
@@ -1567,9 +685,9 @@ function getNodeExtensions(node, registry) {
 //#endregion
 //#region src/adapters/typescript/resolver/sub/array.ts
 function resolveArrayType(typeNode, ctx) {
-	if (!ts.isArrayTypeNode(typeNode)) return;
+	if (!isArrayTypeNode(typeNode)) return;
 	return {
-		typeName: "array",
+		typeName: TypeName.ARRAY,
 		elementType: ctx.resolveType(typeNode.elementType, ctx.parentNode, ctx.context)
 	};
 }
@@ -1613,92 +731,93 @@ function getNodeDescription(node, typeChecker) {
 }
 function toTypeNodeOrFail(typeChecker, ...args) {
 	const output = typeChecker.typeToTypeNode(...args);
-	if (typeof output === "undefined") throw new ResolverError$1("Type could not be transformed to TypeNode.");
+	if (typeof output === "undefined") throw new ResolverError("Type could not be transformed to TypeNode.");
 	return output;
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/indexed-access.ts
 function resolveIndexedAccessType(typeNode, ctx) {
-	if (!ts.isIndexedAccessTypeNode(typeNode)) return;
-	if (typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword || typeNode.indexType.kind === ts.SyntaxKind.StringKeyword) {
-		const numberIndexType = typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword;
+	if (!isIndexedAccessTypeNode(typeNode)) return;
+	if (typeNode.indexType.kind === SyntaxKind.NumberKeyword || typeNode.indexType.kind === SyntaxKind.StringKeyword) {
+		const numberIndexType = typeNode.indexType.kind === SyntaxKind.NumberKeyword;
 		const objectType = ctx.typeChecker.getTypeFromTypeNode(typeNode.objectType);
 		const type = numberIndexType ? objectType.getNumberIndexType() : objectType.getStringIndexType();
-		if (type === void 0) throw new ResolverError$1(`Could not determine ${numberIndexType ? "number" : "string"} index on ${ctx.typeChecker.typeToString(objectType)}`, typeNode);
+		if (type === void 0) throw new ResolverError(`Could not determine ${numberIndexType ? "number" : "string"} index on ${ctx.typeChecker.typeToString(objectType)}`, typeNode);
 		return ctx.resolveType(toTypeNodeOrFail(ctx.typeChecker, type, void 0, void 0), typeNode, ctx.context, ctx.referencer);
 	}
-	if (ts.isLiteralTypeNode(typeNode.indexType) && (ts.isStringLiteral(typeNode.indexType.literal) || ts.isNumericLiteral(typeNode.indexType.literal))) {
+	if (isLiteralTypeNode(typeNode.indexType) && (isStringLiteral(typeNode.indexType.literal) || isNumericLiteral(typeNode.indexType.literal))) {
 		const hasType = (node) => node !== void 0 && Object.prototype.hasOwnProperty.call(node, "type");
 		const symbol = ctx.typeChecker.getPropertyOfType(ctx.typeChecker.getTypeFromTypeNode(typeNode.objectType), typeNode.indexType.literal.text);
-		if (symbol === void 0) throw new ResolverError$1(`Could not determine the keys on ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode.objectType))}`, typeNode);
+		if (symbol === void 0) throw new ResolverError(`Could not determine the keys on ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode.objectType))}`, typeNode);
 		if (hasType(symbol.valueDeclaration) && symbol.valueDeclaration.type) return ctx.resolveType(symbol.valueDeclaration.type, typeNode, ctx.context, ctx.referencer);
 		const declaration = ctx.typeChecker.getTypeOfSymbolAtLocation(symbol, typeNode.objectType);
 		try {
 			return ctx.resolveType(toTypeNodeOrFail(ctx.typeChecker, declaration, void 0, void 0), typeNode, ctx.context, ctx.referencer);
 		} catch (err) {
-			throw new ResolverError$1(`Could not determine the keys on ${ctx.typeChecker.typeToString(declaration)}`, typeNode, { cause: err });
+			throw new ResolverError(`Could not determine the keys on ${ctx.typeChecker.typeToString(declaration)}`, typeNode, { cause: err });
 		}
 	}
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/intersection.ts
 function resolveIntersectionType(typeNode, ctx) {
-	if (!ts.isIntersectionTypeNode(typeNode)) return;
+	if (!isIntersectionTypeNode(typeNode)) return;
+	const members = typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context));
 	return {
-		typeName: "intersection",
-		members: typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context))
+		typeName: TypeName.INTERSECTION,
+		members
 	};
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/literal.ts
 function resolveLiteralType(typeNode, ctx) {
-	if (typeNode.kind === ts.SyntaxKind.NullKeyword) return {
-		typeName: "enum",
+	if (typeNode.kind === SyntaxKind.NullKeyword) return {
+		typeName: TypeName.ENUM,
 		members: [null]
 	};
-	if (typeNode.kind === ts.SyntaxKind.AnyKeyword || typeNode.kind === ts.SyntaxKind.UnknownKeyword) return { typeName: "any" };
-	if (ts.isLiteralTypeNode(typeNode)) return {
-		typeName: "enum",
+	if (typeNode.kind === SyntaxKind.AnyKeyword || typeNode.kind === SyntaxKind.UnknownKeyword) return { typeName: TypeName.ANY };
+	if (isLiteralTypeNode(typeNode)) return {
+		typeName: TypeName.ENUM,
 		members: [getLiteralValue(typeNode)]
 	};
-	if (typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
+	if (typeNode.kind === SyntaxKind.TemplateLiteralType) {
 		const type = ctx.typeChecker.getTypeFromTypeNode(ctx.referencer || typeNode);
 		if (type.isUnion() && type.types.every((t) => t.isStringLiteral())) return {
-			typeName: "enum",
+			typeName: TypeName.ENUM,
 			members: type.types.map((t) => t.value)
 		};
-		throw new ResolverError$1(`Could not resolve type: ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode), typeNode)}`, typeNode);
+		throw new ResolverError(`Could not resolve type: ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode), typeNode)}`, typeNode);
 	}
-	if (ts.isParenthesizedTypeNode(typeNode)) return ctx.resolveType(typeNode.type, typeNode, ctx.context, ctx.referencer);
-	if (typeNode.kind === ts.SyntaxKind.ObjectKeyword || ts.isFunctionTypeNode(typeNode)) return { typeName: "object" };
+	if (isParenthesizedTypeNode(typeNode)) return ctx.resolveType(typeNode.type, typeNode, ctx.context, ctx.referencer);
+	if (typeNode.kind === SyntaxKind.ObjectKeyword || isFunctionTypeNode(typeNode)) return { typeName: TypeName.OBJECT };
 }
 function getLiteralValue(typeNode) {
 	let value;
 	switch (typeNode.literal.kind) {
-		case ts.SyntaxKind.TrueKeyword:
+		case SyntaxKind.TrueKeyword:
 			value = true;
 			break;
-		case ts.SyntaxKind.FalseKeyword:
+		case SyntaxKind.FalseKeyword:
 			value = false;
 			break;
-		case ts.SyntaxKind.StringLiteral:
+		case SyntaxKind.StringLiteral:
 			value = typeNode.literal.text;
 			break;
-		case ts.SyntaxKind.NumericLiteral:
+		case SyntaxKind.NumericLiteral:
 			value = Number.parseFloat(typeNode.literal.text);
 			break;
-		case ts.SyntaxKind.NullKeyword:
+		case SyntaxKind.NullKeyword:
 			value = null;
 			break;
 		default: if (Object.prototype.hasOwnProperty.call(typeNode.literal, "text")) value = typeNode.literal.text;
-		else throw new ResolverError$1(`Couldn't resolve literal node: ${typeNode.literal.getText()}`, typeNode.literal);
+		else throw new ResolverError(`Couldn't resolve literal node: ${typeNode.literal.getText()}`, typeNode.literal);
 	}
 	return value;
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/mapped.ts
 function resolveMappedType(typeNode, ctx) {
-	if (!ts.isMappedTypeNode(typeNode) || !ctx.referencer) return;
+	if (!isMappedTypeNode(typeNode) || !ctx.referencer) return;
 	const type = ctx.typeChecker.getTypeFromTypeNode(ctx.referencer);
 	const mappedTypeNode = typeNode;
 	const { typeChecker } = ctx;
@@ -1706,41 +825,42 @@ function resolveMappedType(typeNode, ctx) {
 	const isIgnored = (prop) => {
 		const declaration = getDeclaration(prop);
 		if (prop.getJsDocTags().findIndex((tag) => tag.name === "ignore") >= 0) return true;
-		return !!declaration && !ts.isPropertyDeclaration(declaration) && !ts.isPropertySignature(declaration) && !ts.isParameter(declaration);
+		return !!declaration && !isPropertyDeclaration(declaration) && !isPropertySignature(declaration) && !isParameter(declaration);
 	};
+	const properties = type.getProperties().filter((property) => !isIgnored(property)).map((property) => {
+		const declaration = getDeclaration(property);
+		const overrideToken = mappedTypeNode.questionToken?.kind === SyntaxKind.PlusToken ? factory.createToken(SyntaxKind.QuestionToken) : mappedTypeNode.questionToken;
+		if (declaration && isPropertySignature(declaration)) return {
+			...ctx.propertyFromSignature(declaration, overrideToken),
+			name: property.getName()
+		};
+		if (declaration && (isPropertyDeclaration(declaration) || isParameter(declaration))) return {
+			...ctx.propertyFromDeclaration(declaration, overrideToken),
+			name: property.getName()
+		};
+		let required = (property.flags & SymbolFlags.Optional) === 0;
+		const typeNode2 = toTypeNodeOrFail(typeChecker, typeChecker.getTypeOfSymbolAtLocation(property, typeNode), void 0, NodeBuilderFlags.NoTruncation);
+		if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === SyntaxKind.MinusToken) required = true;
+		else if (mappedTypeNode.questionToken && (mappedTypeNode.questionToken.kind === SyntaxKind.QuestionToken || mappedTypeNode.questionToken.kind === SyntaxKind.PlusToken)) required = false;
+		return {
+			name: property.getName(),
+			required,
+			deprecated: false,
+			type: ctx.resolveType(typeNode2, typeNode, ctx.context, ctx.referencer),
+			validators: {}
+		};
+	});
 	return {
-		typeName: "nestedObjectLiteral",
-		properties: type.getProperties().filter((property) => !isIgnored(property)).map((property) => {
-			const declaration = getDeclaration(property);
-			const overrideToken = mappedTypeNode.questionToken?.kind === ts.SyntaxKind.PlusToken ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : mappedTypeNode.questionToken;
-			if (declaration && ts.isPropertySignature(declaration)) return {
-				...ctx.propertyFromSignature(declaration, overrideToken),
-				name: property.getName()
-			};
-			if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) return {
-				...ctx.propertyFromDeclaration(declaration, overrideToken),
-				name: property.getName()
-			};
-			let required = (property.flags & ts.SymbolFlags.Optional) === 0;
-			const typeNode2 = toTypeNodeOrFail(typeChecker, typeChecker.getTypeOfSymbolAtLocation(property, typeNode), void 0, ts.NodeBuilderFlags.NoTruncation);
-			if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.MinusToken) required = true;
-			else if (mappedTypeNode.questionToken && (mappedTypeNode.questionToken.kind === ts.SyntaxKind.QuestionToken || mappedTypeNode.questionToken.kind === ts.SyntaxKind.PlusToken)) required = false;
-			return {
-				name: property.getName(),
-				required,
-				deprecated: false,
-				type: ctx.resolveType(typeNode2, typeNode, ctx.context, ctx.referencer),
-				validators: {}
-			};
-		})
+		typeName: TypeName.NESTED_OBJECT_LITERAL,
+		properties
 	};
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/object-literal.ts
 function resolveObjectLiteralType(typeNode, ctx) {
-	if (!ts.isTypeLiteralNode(typeNode)) return;
-	const properties = typeNode.members.filter((member) => ts.isPropertySignature(member)).reduce((res, propertySignature) => {
-		if (!propertySignature.type) throw new ResolverError$1("No valid type found for property declaration.", propertySignature);
+	if (!isTypeLiteralNode(typeNode)) return;
+	const properties = typeNode.members.filter((member) => isPropertySignature(member)).reduce((res, propertySignature) => {
+		if (!propertySignature.type) throw new ResolverError("No valid type found for property declaration.", propertySignature);
 		const type = ctx.resolveType(propertySignature.type, propertySignature, ctx.context);
 		return [{
 			deprecated: hasJSDocTag(propertySignature, "deprecated"),
@@ -1755,16 +875,16 @@ function resolveObjectLiteralType(typeNode, ctx) {
 			validators: getDeclarationValidators(propertySignature) || {}
 		}, ...res];
 	}, []);
-	const indexMember = typeNode.members.find((member) => ts.isIndexSignatureDeclaration(member));
+	const indexMember = typeNode.members.find((member) => isIndexSignatureDeclaration(member));
 	let additionalType;
 	if (indexMember) {
 		const indexSignatureDeclaration = indexMember;
-		if (!isStringType(ctx.resolveType(indexSignatureDeclaration.parameters[0].type, ctx.parentNode, ctx.context))) throw new ResolverError$1("Only string indexes are supported.", typeNode);
+		if (!isStringType(ctx.resolveType(indexSignatureDeclaration.parameters[0].type, ctx.parentNode, ctx.context))) throw new ResolverError("Only string indexes are supported.", typeNode);
 		additionalType = ctx.resolveType(indexSignatureDeclaration.type, ctx.parentNode, ctx.context);
 	}
 	return {
 		additionalProperties: indexMember && additionalType,
-		typeName: "nestedObjectLiteral",
+		typeName: TypeName.NESTED_OBJECT_LITERAL,
 		properties
 	};
 }
@@ -1772,17 +892,17 @@ function getNodeFormat(node) {
 	return getJSDocTagComment(node, "format");
 }
 function getPropertyName(node) {
-	if (ts.isIdentifier(node.name)) return node.name.text;
-	if (ts.isStringLiteral(node.name) || ts.isNumericLiteral(node.name)) return node.name.text;
+	if (isIdentifier(node.name)) return node.name.text;
+	if (isStringLiteral(node.name) || isNumericLiteral(node.name)) return node.name.text;
 	return node.name.getText();
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/primitive.ts
 const NUMERIC_KIND_TO_TYPE_NAME = {
-	[NumericKind.Int]: "integer",
-	[NumericKind.Long]: "long",
-	[NumericKind.Float]: "float",
-	[NumericKind.Double]: "double"
+	[NumericKind.Int]: TypeName.INTEGER,
+	[NumericKind.Long]: TypeName.LONG,
+	[NumericKind.Float]: TypeName.FLOAT,
+	[NumericKind.Double]: TypeName.DOUBLE
 };
 var PrimitiveResolver = class {
 	registry;
@@ -1792,15 +912,15 @@ var PrimitiveResolver = class {
 	resolve(node, parentNode) {
 		const resolved = this.resolveSyntaxKind(node.kind);
 		if (resolved) {
-			if (resolved === "string") return { typeName: "string" };
-			if (resolved === "void") return { typeName: "void" };
-			if (resolved === "boolean") return { typeName: "boolean" };
-			if (resolved === "undefined") return { typeName: "undefined" };
+			if (resolved === "string") return { typeName: TypeName.STRING };
+			if (resolved === "void") return { typeName: TypeName.VOID };
+			if (resolved === "boolean") return { typeName: TypeName.BOOLEAN };
+			if (resolved === "undefined") return { typeName: TypeName.UNDEFINED };
 			if (resolved === "null") return;
-			if (resolved === "never") return { typeName: "never" };
-			if (resolved === "bigint") return { typeName: "bigint" };
+			if (resolved === "never") return { typeName: TypeName.NEVER };
+			if (resolved === "bigint") return { typeName: TypeName.BIGINT };
 			if (resolved === "number") {
-				if (!parentNode) return { typeName: "double" };
+				if (!parentNode) return { typeName: TypeName.DOUBLE };
 				const presentJsDocTags = new Set(getJSDocTagNames(parentNode).map((tag) => tag.toLowerCase()));
 				for (const kind of [
 					NumericKind.Int,
@@ -1814,7 +934,7 @@ var PrimitiveResolver = class {
 					const jsDocTags = tagsForMarker(this.registry, matchKind);
 					for (const tag of jsDocTags) if (presentJsDocTags.has(tag.toLowerCase())) return { typeName: NUMERIC_KIND_TO_TYPE_NAME[kind] };
 				}
-				return { typeName: "double" };
+				return { typeName: TypeName.DOUBLE };
 			}
 		}
 	}
@@ -1842,9 +962,9 @@ var ReferenceResolver = class extends ResolverBase {
 	}
 	merge(referenceTypes) {
 		if (referenceTypes.length === 1) return referenceTypes[0];
-		if (referenceTypes.every((refType) => refType.refName === "refEnum")) return this.mergeManyRefEnums(referenceTypes);
-		if (referenceTypes.every((refType) => refType.refName === "refObject")) return this.mergeManyRefObjects(referenceTypes);
-		throw new ResolverError$1(`These resolved type merge rules are not defined: ${JSON.stringify(referenceTypes)}`);
+		if (referenceTypes.every((refType) => refType.refName === TypeName.REF_ENUM)) return this.mergeManyRefEnums(referenceTypes);
+		if (referenceTypes.every((refType) => refType.refName === TypeName.REF_OBJECT)) return this.mergeManyRefObjects(referenceTypes);
+		throw new ResolverError(`These resolved type merge rules are not defined: ${JSON.stringify(referenceTypes)}`);
 	}
 	mergeManyRefEnums(many) {
 		let merged = this.mergeRefEnums(many[0], many[1]);
@@ -1857,7 +977,7 @@ var ReferenceResolver = class extends ResolverBase {
 		else if (!second.description) description = first.description;
 		else description = `${first.description}\n${second.description}`;
 		return {
-			typeName: "refEnum",
+			typeName: TypeName.REF_ENUM,
 			example: first.example || second.example,
 			description,
 			members: [...first.members || [], ...second.members || []],
@@ -1881,11 +1001,11 @@ var ReferenceResolver = class extends ResolverBase {
 		if (first.additionalProperties || second.additionalProperties) if (!first.additionalProperties) additionalProperties = second.additionalProperties;
 		else if (!second.additionalProperties) additionalProperties = first.additionalProperties;
 		else additionalProperties = {
-			typeName: "union",
+			typeName: TypeName.UNION,
 			members: [first.additionalProperties, second.additionalProperties]
 		};
 		return {
-			typeName: "refObject",
+			typeName: TypeName.REF_OBJECT,
 			description,
 			properties,
 			additionalProperties,
@@ -1899,7 +1019,7 @@ var ReferenceResolver = class extends ResolverBase {
 		const enums = declaration.members.map(this.typeChecker.getConstantValue.bind(this.typeChecker)).filter(isNotUndefined);
 		const enumNames = declaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
 		return {
-			typeName: "refEnum",
+			typeName: TypeName.REF_ENUM,
 			description: getNodeDescription(declaration, this.typeChecker),
 			members: enums,
 			memberNames: enumNames,
@@ -1909,7 +1029,7 @@ var ReferenceResolver = class extends ResolverBase {
 	}
 	transformEnumMember(declaration, enumName) {
 		return {
-			typeName: "refEnum",
+			typeName: TypeName.REF_ENUM,
 			refName: enumName,
 			members: [this.typeChecker.getConstantValue(declaration)],
 			memberNames: [declaration.name.getText()],
@@ -1920,40 +1040,42 @@ var ReferenceResolver = class extends ResolverBase {
 //#endregion
 //#region src/adapters/typescript/resolver/sub/tuple.ts
 function resolveTupleType(typeNode, ctx) {
-	if (!ts.isTupleTypeNode(typeNode)) return;
+	if (!isTupleTypeNode(typeNode)) return;
+	const elements = typeNode.elements.map((element) => {
+		const isNamed = isNamedTupleMember(element);
+		const actualType = isNamed ? element.type : element;
+		return {
+			type: ctx.resolveType(actualType, ctx.parentNode, ctx.context),
+			...isNamed && { name: element.name.text }
+		};
+	});
 	return {
-		typeName: "tuple",
-		elements: typeNode.elements.map((element) => {
-			const isNamed = ts.isNamedTupleMember(element);
-			const actualType = isNamed ? element.type : element;
-			return {
-				type: ctx.resolveType(actualType, ctx.parentNode, ctx.context),
-				...isNamed && { name: element.name.text }
-			};
-		})
+		typeName: TypeName.TUPLE,
+		elements
 	};
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/type-operator.ts
 function resolveTypeOperatorType(typeNode, ctx) {
-	if (!ts.isTypeOperatorNode(typeNode)) return;
-	if (typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
+	if (!isTypeOperatorNode(typeNode)) return;
+	if (typeNode.operator === SyntaxKind.KeyOfKeyword) {
 		const type = ctx.typeChecker.getTypeFromTypeNode(typeNode);
 		try {
-			return ctx.resolveType(toTypeNodeOrFail(ctx.typeChecker, type, void 0, ts.NodeBuilderFlags.NoTruncation), typeNode, ctx.context, ctx.referencer);
+			return ctx.resolveType(toTypeNodeOrFail(ctx.typeChecker, type, void 0, NodeBuilderFlags.NoTruncation), typeNode, ctx.context, ctx.referencer);
 		} catch (err) {
-			throw new ResolverError$1(`Could not determine the keys on ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode.type))}`, typeNode, { cause: err });
+			throw new ResolverError(`Could not determine the keys on ${ctx.typeChecker.typeToString(ctx.typeChecker.getTypeFromTypeNode(typeNode.type))}`, typeNode, { cause: err });
 		}
 	}
-	if (typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) return ctx.resolveType(typeNode.type, typeNode, ctx.context, ctx.referencer);
+	if (typeNode.operator === SyntaxKind.ReadonlyKeyword) return ctx.resolveType(typeNode.type, typeNode, ctx.context, ctx.referencer);
 }
 //#endregion
 //#region src/adapters/typescript/resolver/sub/union.ts
 function resolveUnionType(typeNode, ctx) {
-	if (!ts.isUnionTypeNode(typeNode)) return;
+	if (!isUnionTypeNode(typeNode)) return;
+	const members = typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context));
 	return {
-		typeName: "union",
-		members: typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context))
+		typeName: TypeName.UNION,
+		members
 	};
 }
 //#endregion
@@ -1985,7 +1107,7 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	*/
 	static clearCache() {}
 	resolve() {
-		if (this.depth > TypeNodeResolver.MAX_DEPTH) throw new ResolverError$1(`Type resolution exceeded maximum depth of ${TypeNodeResolver.MAX_DEPTH}. This usually indicates deeply nested or circular generics.`, this.typeNode);
+		if (this.depth > TypeNodeResolver.MAX_DEPTH) throw new ResolverError(`Type resolution exceeded maximum depth of ${TypeNodeResolver.MAX_DEPTH}. This usually indicates deeply nested or circular generics.`, this.typeNode);
 		const ctx = this.createSubResolverContext();
 		const result = this.primitiveResolver.resolve(this.typeNode, this.parentNode) ?? resolveLiteralType(this.typeNode, ctx) ?? resolveArrayType(this.typeNode, ctx) ?? resolveUnionType(this.typeNode, ctx) ?? resolveIntersectionType(this.typeNode, ctx) ?? resolveObjectLiteralType(this.typeNode, ctx) ?? resolveTupleType(this.typeNode, ctx) ?? resolveMappedType(this.typeNode, ctx) ?? this.resolveConditionalType() ?? resolveTypeOperatorType(this.typeNode, ctx) ?? resolveIndexedAccessType(this.typeNode, ctx) ?? this.resolveTypeReference();
 		if (!result) this.throwUnknownType();
@@ -2010,32 +1132,32 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		return new TypeNodeResolver(typeNode, this.current, parentNode, context, referencer, this.depth + 1).resolve();
 	}
 	throwUnknownType() {
-		throw new ResolverError$1(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode);
+		throw new ResolverError(`Unknown type: ${SyntaxKind[this.typeNode.kind]}`, this.typeNode);
 	}
 	resolveConditionalType() {
-		if (!ts.isConditionalTypeNode(this.typeNode)) return;
+		if (!isConditionalTypeNode(this.typeNode)) return;
 		if (Object.keys(this.context).length > 0 && this.referencer) return this.resolveTypeViaChecker(this.referencer);
 		return this.resolveTypeViaChecker(this.typeNode);
 	}
 	resolveTypeReference() {
-		if (this.typeNode.kind !== ts.SyntaxKind.TypeReference) return;
+		if (this.typeNode.kind !== SyntaxKind.TypeReference) return;
 		const typeReference = this.typeNode;
-		if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
+		if (typeReference.typeName.kind === SyntaxKind.Identifier) {
 			if (typeReference.typeName.text === "Record" && typeReference.typeArguments) return {
 				additionalProperties: this.resolveNestedType(typeReference.typeArguments[1], this.parentNode, this.context),
-				typeName: "nestedObjectLiteral",
+				typeName: TypeName.NESTED_OBJECT_LITERAL,
 				properties: []
 			};
 			const specialReference = TypeNodeResolver.resolveSpecialReference(typeReference.typeName);
 			if (typeof specialReference !== "undefined") return specialReference;
 			if (typeReference.typeName.text === "Date") return this.getDateType(this.parentNode);
-			if (typeReference.typeName.text === "Buffer" || typeReference.typeName.text === "Readable") return { typeName: "buffer" };
+			if (typeReference.typeName.text === "Buffer" || typeReference.typeName.text === "Readable") return { typeName: TypeName.BUFFER };
 			if (typeReference.typeName.text === "Array" && typeReference.typeArguments && typeReference.typeArguments.length >= 1) return {
-				typeName: "array",
+				typeName: TypeName.ARRAY,
 				elementType: this.resolveNestedType(typeReference.typeArguments[0], this.parentNode, this.context)
 			};
 			if (typeReference.typeName.text === "Promise" && typeReference.typeArguments && typeReference.typeArguments.length === 1) return this.resolveNestedType(typeReference.typeArguments[0], this.parentNode, this.context);
-			if (typeReference.typeName.text === "String") return { typeName: "string" };
+			if (typeReference.typeName.text === "String") return { typeName: TypeName.STRING };
 			if (this.context[typeReference.typeName.text]) return this.resolveNestedType(this.context[typeReference.typeName.text], this.parentNode, this.context);
 			if (TypeNodeResolver.isCheckerResolvableUtilityType(typeReference.typeName.text)) return this.resolveUtilityTypeViaChecker(typeReference);
 		}
@@ -2052,19 +1174,19 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		}
 	}
 	static CHECKER_RESOLVABLE_UTILITY_TYPES = new Set([
-		"NonNullable",
-		"Omit",
-		"Partial",
-		"Readonly",
-		"Required",
-		"Pick",
-		"Extract",
-		"Exclude",
-		"ReturnType",
-		"Parameters",
-		"Awaited",
-		"InstanceType",
-		"ConstructorParameters"
+		UtilityTypeName.NON_NULLABLE,
+		UtilityTypeName.OMIT,
+		UtilityTypeName.PARTIAL,
+		UtilityTypeName.READONLY,
+		UtilityTypeName.REQUIRED,
+		UtilityTypeName.PICK,
+		UtilityTypeName.EXTRACT,
+		UtilityTypeName.EXCLUDE,
+		UtilityTypeName.RETURN_TYPE,
+		UtilityTypeName.PARAMETERS,
+		UtilityTypeName.AWAITED,
+		UtilityTypeName.INSTANCE_TYPE,
+		UtilityTypeName.CONSTRUCTOR_PARAMETERS
 	]);
 	static isCheckerResolvableUtilityType(name) {
 		return TypeNodeResolver.CHECKER_RESOLVABLE_UTILITY_TYPES.has(name);
@@ -2080,9 +1202,9 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	*/
 	resolveTypeViaChecker(typeNode) {
 		const type = this.current.typeChecker.getTypeFromTypeNode(typeNode);
-		const resolvedTypeNode = this.current.typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.InTypeAlias);
+		const resolvedTypeNode = this.current.typeChecker.typeToTypeNode(type, void 0, NodeBuilderFlags.NoTruncation | NodeBuilderFlags.InTypeAlias);
 		if (!resolvedTypeNode) return {
-			typeName: "tuple",
+			typeName: TypeName.TUPLE,
 			elements: []
 		};
 		return this.resolveNestedType(resolvedTypeNode, this.parentNode, this.context);
@@ -2094,23 +1216,23 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	*/
 	hasUnboundContextArgs(typeReference) {
 		if (!typeReference.typeArguments || Object.keys(this.context).length === 0) return false;
-		return typeReference.typeArguments.some((arg) => ts.isTypeReferenceNode(arg) && ts.isIdentifier(arg.typeName) && arg.typeName.text in this.context);
+		return typeReference.typeArguments.some((arg) => isTypeReferenceNode(arg) && isIdentifier(arg.typeName) && arg.typeName.text in this.context);
 	}
 	static resolveSpecialReference(node) {
 		switch (node.text) {
 			case "Buffer":
 			case "DownloadBinaryData":
-			case "DownloadResource": return { typeName: "buffer" };
+			case "DownloadResource": return { typeName: TypeName.BUFFER };
 			default: return;
 		}
 	}
 	getDateType(parentNode) {
-		if (!parentNode) return { typeName: "datetime" };
+		if (!parentNode) return { typeName: TypeName.DATETIME };
 		const tags = getJSDocTagNames(parentNode).filter((name) => ["isDate", "isDateTime"].includes(name));
-		if (tags.length === 0) return { typeName: "datetime" };
+		if (tags.length === 0) return { typeName: TypeName.DATETIME };
 		switch (tags[0]) {
-			case "isDate": return { typeName: "date" };
-			default: return { typeName: "datetime" };
+			case "isDate": return { typeName: TypeName.DATE };
+			default: return { typeName: TypeName.DATETIME };
 		}
 	}
 	static getDesignatedModels(nodes, _typeName) {
@@ -2118,16 +1240,16 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	}
 	getEnumerateType(typeName) {
 		const enumName = typeName.text;
-		let enumNodes = this.current.nodes.filter((node) => node.kind === ts.SyntaxKind.EnumDeclaration && node.name.text === enumName);
+		let enumNodes = this.current.nodes.filter((node) => node.kind === SyntaxKind.EnumDeclaration && node.name.text === enumName);
 		if (!enumNodes.length) return;
 		enumNodes = TypeNodeResolver.getDesignatedModels(enumNodes, enumName);
-		if (enumNodes.length > 1) throw new ResolverError$1(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
+		if (enumNodes.length > 1) throw new ResolverError(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
 		const enumDeclaration = enumNodes[0];
 		const isNotUndefined = (item) => item !== void 0;
 		const enums = enumDeclaration.members.map(this.current.typeChecker.getConstantValue.bind(this.current.typeChecker)).filter(isNotUndefined);
 		const enumNames = enumDeclaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
 		return {
-			typeName: "refEnum",
+			typeName: TypeName.REF_ENUM,
 			description: this.getNodeDescription(enumDeclaration),
 			members: enums,
 			memberNames: enumNames,
@@ -2137,13 +1259,13 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	}
 	getReferenceType(node) {
 		let type;
-		if (ts.isTypeReferenceNode(node)) type = node.typeName;
-		else if (ts.isExpressionWithTypeArguments(node)) type = node.expression;
-		else throw new ResolverError$1("Can't resolve reference type.");
+		if (isTypeReferenceNode(node)) type = node.typeName;
+		else if (isExpressionWithTypeArguments(node)) type = node.expression;
+		else throw new ResolverError("Can't resolve reference type.");
 		let resolvableName = node.pos !== -1 ? node.getText() : type.text;
 		if (node.pos === -1 && "typeArguments" in node && Array.isArray(node.typeArguments)) {
 			const argumentsString = node.typeArguments.map((arg) => {
-				if (ts.isLiteralTypeNode(arg)) return `'${String(getLiteralValue(arg))}'`;
+				if (isLiteralTypeNode(arg)) return `'${String(getLiteralValue(arg))}'`;
 				const resolvedType = this.primitiveResolver.resolveSyntaxKind(arg.kind);
 				if (typeof resolvedType === "undefined") return "any";
 				return resolvedType;
@@ -2161,7 +1283,7 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 				const refName = TypeNodeResolver.getRefTypeName(name);
 				const declarations = this.getModelTypeDeclarations(type);
 				const referenceTypes = [];
-				for (const declaration of declarations) if (ts.isTypeAliasDeclaration(declaration)) referenceTypes.push(this.getTypeAliasReference(declaration, name, node));
+				for (const declaration of declarations) if (isTypeAliasDeclaration(declaration)) referenceTypes.push(this.getTypeAliasReference(declaration, name, node));
 				else if (isEnumDeclaration(declaration)) referenceTypes.push(this.referenceResolver.transformEnum(declaration, refName));
 				else if (isEnumMember(declaration)) referenceTypes.push(this.referenceResolver.transformEnumMember(declaration, refName));
 				else referenceTypes.push(this.getModelReference(declaration, name));
@@ -2172,15 +1294,15 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 				this.current.resolverCache.clearInProgress(name);
 			}
 		} catch (err) {
-			throw new ResolverError$1(`There was a problem resolving type of '${name}'.`, node, { cause: err });
+			throw new ResolverError(`There was a problem resolving type of '${name}'.`, node, { cause: err });
 		}
 	}
 	getTypeAliasReference(declaration, name, referencer) {
 		const refName = TypeNodeResolver.getRefTypeName(name);
-		if (declaration.type.kind === ts.SyntaxKind.TypeReference) {
+		if (declaration.type.kind === SyntaxKind.TypeReference) {
 			const innerRef = declaration.type;
-			const innerName = ts.isIdentifier(innerRef.typeName) ? innerRef.typeName.text : void 0;
-			if (!(innerName === "Record" || innerName !== void 0 && TypeNodeResolver.isCheckerResolvableUtilityType(innerName))) {
+			const innerName = isIdentifier(innerRef.typeName) ? innerRef.typeName.text : void 0;
+			if (!(innerName === UtilityTypeName.RECORD || innerName !== void 0 && TypeNodeResolver.isCheckerResolvableUtilityType(innerName))) {
 				const referenceType = this.getReferenceType(innerRef);
 				if (referenceType.refName === refName) return referenceType;
 			}
@@ -2188,7 +1310,7 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		const type = this.resolveNestedType(declaration.type, declaration, this.context, this.referencer || referencer);
 		const example = this.getNodeExample(declaration);
 		return {
-			typeName: "refAlias",
+			typeName: TypeName.REF_ALIAS,
 			default: getJSDocTagComment(declaration, "default"),
 			description: this.getNodeDescription(declaration),
 			refName,
@@ -2204,21 +1326,21 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		const description = this.getNodeDescription(modelType);
 		const deprecatedDecoratorNames = namesForMarker(this.current.registry, isDeprecatedMarker);
 		const deprecated = [...tagsForMarker(this.current.registry, isDeprecatedMarker)].some((tag) => hasJSDocTag(modelType, tag)) || [...deprecatedDecoratorNames].some((name) => hasDecoratorNamed(modelType, name));
-		if (!modelType.name) throw new ResolverError$1("Can't get Symbol from anonymous class", modelType);
+		if (!modelType.name) throw new ResolverError("Can't get Symbol from anonymous class", modelType);
 		const type = this.current.typeChecker.getTypeAtLocation(modelType.name);
 		const toJSON = this.current.typeChecker.getPropertyOfType(type, "toJSON");
-		if (toJSON && toJSON.valueDeclaration && (ts.isMethodDeclaration(toJSON.valueDeclaration) || ts.isMethodSignature(toJSON.valueDeclaration))) {
+		if (toJSON && toJSON.valueDeclaration && (isMethodDeclaration(toJSON.valueDeclaration) || isMethodSignature(toJSON.valueDeclaration))) {
 			let nodeType = toJSON.valueDeclaration.type;
 			if (!nodeType) {
 				const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
 				if (signature) {
 					const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
-					nodeType = this.current.typeChecker.typeToTypeNode(implicitType, void 0, ts.NodeBuilderFlags.NoTruncation);
-				} else throw new ResolverError$1("Can't get signature from toJson value declaration", modelType);
+					nodeType = this.current.typeChecker.typeToTypeNode(implicitType, void 0, NodeBuilderFlags.NoTruncation);
+				} else throw new ResolverError("Can't get signature from toJson value declaration", modelType);
 			}
 			return {
 				refName: `${TypeNodeResolver.getRefTypeName(name)}Alias`,
-				typeName: "refAlias",
+				typeName: TypeName.REF_ALIAS,
 				description,
 				type: this.resolveNestedType(nodeType),
 				deprecated,
@@ -2227,11 +1349,13 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 			};
 		}
 		const properties = this.getModelProperties(modelType);
+		const additionalProperties = this.getModelAdditionalProperties(modelType);
+		const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
 		const referenceType = {
-			additionalProperties: this.getModelAdditionalProperties(modelType),
-			typeName: "refObject",
+			additionalProperties,
+			typeName: TypeName.REF_OBJECT,
 			description,
-			properties: this.getModelInheritedProperties(modelType) || [],
+			properties: inheritedProperties,
 			refName: TypeNodeResolver.getRefTypeName(name),
 			deprecated,
 			...example && { example }
@@ -2261,14 +1385,14 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 				this.current.resolverCache.clearInProgress(name);
 			}
 		} catch (err) {
-			throw new ResolverError$1(`There was a problem resolving type of '${name}'.`, this.typeNode, { cause: err });
+			throw new ResolverError(`There was a problem resolving type of '${name}'.`, this.typeNode, { cause: err });
 		}
 	}
 	createCircularDependencyResolver(refName) {
 		const referenceType = {
 			deprecated: false,
 			properties: [],
-			typeName: "refObject",
+			typeName: TypeName.REF_OBJECT,
 			refName
 		};
 		this.current.registerDependencyResolver((referenceTypes) => {
@@ -2283,27 +1407,27 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	}
 	static nodeIsUsable(node) {
 		switch (node.kind) {
-			case ts.SyntaxKind.InterfaceDeclaration:
-			case ts.SyntaxKind.ClassDeclaration:
-			case ts.SyntaxKind.TypeAliasDeclaration:
-			case ts.SyntaxKind.EnumDeclaration:
-			case ts.SyntaxKind.EnumMember: return true;
+			case SyntaxKind.InterfaceDeclaration:
+			case SyntaxKind.ClassDeclaration:
+			case SyntaxKind.TypeAliasDeclaration:
+			case SyntaxKind.EnumDeclaration:
+			case SyntaxKind.EnumMember: return true;
 			default: return false;
 		}
 	}
 	getModelTypeDeclarations(type) {
-		let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
+		let typeName = type.kind === SyntaxKind.Identifier ? type.text : type.right.text;
 		let symbol = this.getSymbolAtLocation(type);
-		if (!symbol && type.kind === ts.SyntaxKind.QualifiedName) symbol = this.getSymbolAtLocation(type.left).exports?.get(typeName);
-		if (!symbol) throw new ResolverError$1(`No symbol found for referenced type ${typeName}.`);
+		if (!symbol && type.kind === SyntaxKind.QualifiedName) symbol = this.getSymbolAtLocation(type.left).exports?.get(typeName);
+		if (!symbol) throw new ResolverError(`No symbol found for referenced type ${typeName}.`);
 		const declarations = symbol.getDeclarations();
-		if (!declarations || declarations.length === 0) throw new ResolverError$1(`No declarations found for referenced type ${typeName}.`);
+		if (!declarations || declarations.length === 0) throw new ResolverError(`No declarations found for referenced type ${typeName}.`);
 		if (symbol.escapedName !== typeName && symbol.escapedName !== "default") typeName = symbol.escapedName;
 		let modelTypes = declarations.filter((node) => {
 			if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) return false;
 			return node.name?.text === typeName;
 		});
-		if (!modelTypes.length) throw new ResolverError$1(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
+		if (!modelTypes.length) throw new ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
 		if (modelTypes.length > 1) {
 			modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile().fileName.replace(/\\/g, "/").toLowerCase().indexOf("node_modules/typescript") <= -1);
 			modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
@@ -2311,23 +1435,23 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		return modelTypes;
 	}
 	getModelTypeDeclaration(type) {
-		let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
+		let typeName = type.kind === SyntaxKind.Identifier ? type.text : type.right.text;
 		const symbol = this.getSymbolAtLocation(type);
 		const declarations = symbol.getDeclarations();
-		if (!declarations || declarations.length === 0) throw new ResolverError$1(`No models found for referenced type ${typeName}.`);
+		if (!declarations || declarations.length === 0) throw new ResolverError(`No models found for referenced type ${typeName}.`);
 		if (symbol.escapedName !== typeName && symbol.escapedName !== "default") typeName = symbol.escapedName;
 		let modelTypes = declarations.filter((node) => {
 			if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) return false;
 			return node.name?.text === typeName;
 		});
-		if (!modelTypes.length) throw new ResolverError$1(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
+		if (!modelTypes.length) throw new ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
 		if (modelTypes.length > 1) {
 			modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile().fileName.replace(/\\/g, "/").toLowerCase().indexOf("node_modules/typescript") <= -1);
 			modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
 		}
 		if (modelTypes.length > 1) {
 			const conflicts = modelTypes.map((modelType) => modelType.getSourceFile().fileName).join("\"; \"");
-			throw new ResolverError$1(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
+			throw new ResolverError(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
 		}
 		return modelTypes[0];
 	}
@@ -2336,13 +1460,13 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	}
 	getSymbolAtLocation(type) {
 		const symbol = this.current.typeChecker.getSymbolAtLocation(type) || type.symbol;
-		return symbol && this.hasFlag(symbol, ts.SymbolFlags.Alias) && this.current.typeChecker.getAliasedSymbol(symbol) || symbol;
+		return symbol && this.hasFlag(symbol, SymbolFlags.Alias) && this.current.typeChecker.getAliasedSymbol(symbol) || symbol;
 	}
 	getModelProperties(node, overrideToken) {
 		const isIgnored = (e) => hasJSDocTag(e, "ignore");
-		if (ts.isInterfaceDeclaration(node)) return node.members.filter((member) => !isIgnored(member) && ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
-		const properties = node.members.filter((member) => !isIgnored(member) && member.kind === ts.SyntaxKind.PropertyDeclaration && !this.hasStaticModifier(member) && this.hasPublicModifier(member));
-		const classConstructor = node.members.find((member) => ts.isConstructorDeclaration(member));
+		if (isInterfaceDeclaration(node)) return node.members.filter((member) => !isIgnored(member) && isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
+		const properties = node.members.filter((member) => !isIgnored(member) && member.kind === SyntaxKind.PropertyDeclaration && !this.hasStaticModifier(member) && this.hasPublicModifier(member));
+		const classConstructor = node.members.find((member) => isConstructorDeclaration(member));
 		if (classConstructor && classConstructor.parameters) {
 			const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
 			properties.push(...constructorProperties);
@@ -2351,10 +1475,10 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 	}
 	propertyFromSignature(propertySignature, overrideToken) {
 		const identifier = propertySignature.name;
-		if (!propertySignature.type) throw new ResolverError$1("No valid type found for property declaration.");
+		if (!propertySignature.type) throw new ResolverError("No valid type found for property declaration.");
 		let required = !propertySignature.questionToken;
-		if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) required = true;
-		else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) required = false;
+		if (overrideToken && overrideToken.kind === SyntaxKind.MinusToken) required = true;
+		else if (overrideToken && overrideToken.kind === SyntaxKind.QuestionToken) required = false;
 		return {
 			deprecated: hasJSDocTag(propertySignature, "deprecated"),
 			default: getJSDocTagComment(propertySignature, "default"),
@@ -2373,13 +1497,13 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		let typeNode = propertyDeclaration.type;
 		if (!typeNode) {
 			const tsType = this.current.typeChecker.getTypeAtLocation(propertyDeclaration);
-			typeNode = this.current.typeChecker.typeToTypeNode(tsType, void 0, ts.NodeBuilderFlags.NoTruncation);
+			typeNode = this.current.typeChecker.typeToTypeNode(tsType, void 0, NodeBuilderFlags.NoTruncation);
 		}
-		if (!typeNode) throw new ResolverError$1("No valid type found for property declaration.");
+		if (!typeNode) throw new ResolverError("No valid type found for property declaration.");
 		const type = this.resolveNestedType(typeNode, propertyDeclaration, this.context, typeNode);
 		let required = !propertyDeclaration.questionToken && !propertyDeclaration.initializer;
-		if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) required = true;
-		else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) required = false;
+		if (overrideToken && overrideToken.kind === SyntaxKind.MinusToken) required = true;
+		else if (overrideToken && overrideToken.kind === SyntaxKind.QuestionToken) required = false;
 		return {
 			deprecated: hasJSDocTag(propertyDeclaration, "deprecated"),
 			default: getInitializerValue(propertyDeclaration.initializer, this.current.typeChecker),
@@ -2394,11 +1518,11 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		};
 	}
 	getModelAdditionalProperties(node) {
-		if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
-			const indexMember = node.members.find((member) => member.kind === ts.SyntaxKind.IndexSignature);
+		if (node.kind === SyntaxKind.InterfaceDeclaration) {
+			const indexMember = node.members.find((member) => member.kind === SyntaxKind.IndexSignature);
 			if (!indexMember) return;
 			const indexSignatureDeclaration = indexMember;
-			if (this.resolveNestedType(indexSignatureDeclaration.parameters[0].type, this.parentNode, this.context).typeName !== "string") throw new ResolverError$1("Only string indexers are supported.", this.typeNode);
+			if (this.resolveNestedType(indexSignatureDeclaration.parameters[0].type, this.parentNode, this.context).typeName !== "string") throw new ResolverError("Only string indexers are supported.", this.typeNode);
 			return this.resolveNestedType(indexSignatureDeclaration.type, this.parentNode, this.context);
 		}
 	}
@@ -2409,10 +1533,10 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 		if (typeParameters) for (const [index, typeParameter] of typeParameters.entries()) {
 			const typeArg = type.typeArguments && type.typeArguments[index];
 			let resolvedType;
-			if (typeArg && ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && context[typeArg.typeName.text]) resolvedType = context[typeArg.typeName.text];
+			if (typeArg && isTypeReferenceNode(typeArg) && isIdentifier(typeArg.typeName) && context[typeArg.typeName.text]) resolvedType = context[typeArg.typeName.text];
 			else if (typeArg) resolvedType = typeArg;
 			else if (typeParameter.default) resolvedType = typeParameter.default;
-			else throw new ResolverError$1(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
+			else throw new ResolverError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
 			this.context = {
 				...this.context,
 				[typeParameter.name.text]: resolvedType
@@ -2434,8 +1558,8 @@ var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
 					if (isRefAliasType(referenceType)) {
 						let type = referenceType;
 						while (isRefAliasType(type)) type = type.type;
-						if (type.typeName === "refObject") properties = [...properties, ...type.properties];
-						else if (type.typeName === "nestedObjectLiteral") properties = [...properties, ...type.properties];
+						if (type.typeName === TypeName.REF_OBJECT) properties = [...properties, ...type.properties];
+						else if (type.typeName === TypeName.NESTED_OBJECT_LITERAL) properties = [...properties, ...type.properties];
 					}
 					if (isRefObjectType(referenceType)) referenceType.properties.forEach((property) => properties.push(property));
 				}
@@ -2748,69 +1872,6 @@ var CacheClient = class {
 };
 const CACHE_KEY_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 //#endregion
-//#region src/core/error/generator.ts
-var GeneratorError$1 = class extends MetadataError {};
-function isGeneratorError$1(input) {
-	if (!isBaseError(input)) return false;
-	return typeof input.code === "string";
-}
-//#endregion
-//#region src/core/error/generator-codes.ts
-const GeneratorErrorCode$1 = {
-	CONTROLLER_NO_SOURCE_FILE: "GENERATOR_CONTROLLER_NO_SOURCE_FILE",
-	CONTROLLER_NO_NAME: "GENERATOR_CONTROLLER_NO_NAME",
-	PARAMETER_GENERATION_FAILED: "GENERATOR_PARAMETER_GENERATION_FAILED",
-	BODY_PARAMETER_DUPLICATE: "GENERATOR_BODY_PARAMETER_DUPLICATE",
-	BODY_FORM_CONFLICT: "GENERATOR_BODY_FORM_CONFLICT",
-	STRICT_UNMATCHED_DECORATORS: "GENERATOR_STRICT_UNMATCHED_DECORATORS"
-};
-//#endregion
-//#region src/core/error/parameter.ts
-var ParameterError$1 = class ParameterError$1 extends MetadataError {
-	static typeUnsupported(context) {
-		const location = context.node ? ParameterError$1.getCurrentLocation(context.node) : void 0;
-		return new ParameterError$1({
-			message: `@${context.decoratorName}('${context.propertyName}') does not support '${context.type.typeName}' type${location ? ` at ${location}` : ""}.`,
-			code: ParameterErrorCode.TYPE_UNSUPPORTED
-		});
-	}
-	static methodUnsupported(context) {
-		const location = context.node ? ParameterError$1.getCurrentLocation(context.node) : void 0;
-		return new ParameterError$1({
-			message: `@${context.decoratorName}('${context.propertyName}') does not support method '${context.method}'${location ? ` at ${location}` : ""}.`,
-			code: ParameterErrorCode.METHOD_UNSUPPORTED
-		});
-	}
-	static invalidPathMatch(context) {
-		const location = context.node ? ParameterError$1.getCurrentLocation(context.node) : void 0;
-		return new ParameterError$1({
-			message: `@${context.decoratorName}('${context.propertyName}') does not exist in path '${context.path}'${location ? ` at ${location}` : ""}.`,
-			code: ParameterErrorCode.PATH_MISMATCH
-		});
-	}
-	static scopeRequired(context) {
-		const location = context.node ? ParameterError$1.getCurrentLocation(context.node) : void 0;
-		return new ParameterError$1({
-			message: `@${context.decoratorName}() requires a scope argument${location ? ` at ${location}` : ""}.`,
-			code: ParameterErrorCode.SCOPE_REQUIRED
-		});
-	}
-	static invalidExampleSchema() {
-		return new ParameterError$1({
-			message: "The @example JSDoc tag contains invalid JSON.",
-			code: ParameterErrorCode.INVALID_EXAMPLE
-		});
-	}
-	static getCurrentLocation(node) {
-		const parts = [];
-		if (isMethodDeclaration(node.parent)) {
-			parts.push(node.parent.name.getText());
-			if (isClassDeclaration(node.parent.parent)) parts.unshift(node.parent.parent.name.text);
-		}
-		return parts.join(".");
-	}
-};
-//#endregion
 //#region src/app/generator/parameter/module.ts
 const BODY_SUPPORTED_METHODS = new Set([
 	"delete",
@@ -2820,16 +1881,16 @@ const BODY_SUPPORTED_METHODS = new Set([
 	"get"
 ]);
 const SUPPORTED_LEAF_TYPES = new Set([
-	"string",
-	"integer",
-	"long",
-	"float",
-	"double",
-	"date",
-	"datetime",
-	"buffer",
-	"boolean",
-	"enum"
+	TypeName.STRING,
+	TypeName.INTEGER,
+	TypeName.LONG,
+	TypeName.FLOAT,
+	TypeName.DOUBLE,
+	TypeName.DATE,
+	TypeName.DATETIME,
+	TypeName.BUFFER,
+	TypeName.BOOLEAN,
+	TypeName.ENUM
 ]);
 var ParameterGenerator = class {
 	parameter;
@@ -2863,7 +1924,7 @@ var ParameterGenerator = class {
 		}
 		Object.assign(draft.validators, getDeclarationValidators(this.parameter, parameterName));
 		if (!draft.in) {
-			if (!BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError$1.methodUnsupported({
+			if (!BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError.methodUnsupported({
 				decoratorName: "Body",
 				propertyName: parameterName,
 				method: this.method,
@@ -2871,7 +1932,7 @@ var ParameterGenerator = class {
 			});
 			draft.in = ParamKind.Body;
 		}
-		if ((draft.in === ParamKind.Body || draft.in === ParamKind.BodyProp) && !BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError$1.methodUnsupported({
+		if ((draft.in === ParamKind.Body || draft.in === ParamKind.BodyProp) && !BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError.methodUnsupported({
 			decoratorName: "Body",
 			propertyName: draft.name,
 			method: this.method,
@@ -2894,7 +1955,7 @@ var ParameterGenerator = class {
 			return decomposed;
 		}
 		if ((kind === ParameterSource.QUERY || kind === ParameterSource.QUERY_PROP) && isArrayType(type)) {
-			if (!this.isLeafTypeSupported(type.elementType)) throw ParameterError$1.typeUnsupported({
+			if (!this.isLeafTypeSupported(type.elementType)) throw ParameterError.typeUnsupported({
 				decoratorName: kind === ParameterSource.QUERY ? "Query" : "QueryProp",
 				propertyName: draft.name,
 				type: type.elementType,
@@ -2906,7 +1967,7 @@ var ParameterGenerator = class {
 				type
 			}];
 		}
-		if ((kind === ParameterSource.QUERY || kind === ParameterSource.QUERY_PROP) && !this.isLeafOrEnumOrUnion(type)) throw ParameterError$1.typeUnsupported({
+		if ((kind === ParameterSource.QUERY || kind === ParameterSource.QUERY_PROP) && !this.isLeafOrEnumOrUnion(type)) throw ParameterError.typeUnsupported({
 			decoratorName: kind === ParameterSource.QUERY ? "Query" : "QueryProp",
 			propertyName: draft.name,
 			type,
@@ -2972,7 +2033,7 @@ var ParameterGenerator = class {
 		return false;
 	}
 	validatePathDecomposition(decomposed) {
-		for (const element of decomposed) if (!this.pathContainsParam(element.name)) throw ParameterError$1.invalidPathMatch({
+		for (const element of decomposed) if (!this.pathContainsParam(element.name)) throw ParameterError.invalidPathMatch({
 			decoratorName: "Path",
 			propertyName: element.name,
 			path: this.paths.join(" | "),
@@ -2981,7 +2042,7 @@ var ParameterGenerator = class {
 	}
 	validatePathName(name, parameterName) {
 		const candidate = name || parameterName;
-		if (!this.pathContainsParam(candidate)) throw ParameterError$1.invalidPathMatch({
+		if (!this.pathContainsParam(candidate)) throw ParameterError.invalidPathMatch({
 			decoratorName: "Path",
 			propertyName: candidate,
 			path: this.paths.join(" | "),
@@ -2998,20 +2059,20 @@ var ParameterGenerator = class {
 		let typeNode = this.parameter.type;
 		if (!typeNode) {
 			const t = this.current.typeChecker.getTypeAtLocation(this.parameter);
-			typeNode = this.current.typeChecker.typeToTypeNode(t, void 0, ts.NodeBuilderFlags.NoTruncation);
+			typeNode = this.current.typeChecker.typeToTypeNode(t, void 0, NodeBuilderFlags.NoTruncation);
 		}
-		if (!typeNode) throw new ParameterError$1({ message: `Could not resolve type for parameter '${this.getParameterName()}'.` });
+		if (!typeNode) throw new ParameterError({ message: `Could not resolve type for parameter '${this.getParameterName()}'.` });
 		return new TypeNodeResolver(typeNode, this.current, this.parameter).resolve();
 	}
 	getParameterName() {
-		if (!ts.isIdentifier(this.parameter.name)) throw new ParameterError$1({ message: "Destructured parameters are not supported. Use a simple identifier name." });
+		if (!isIdentifier(this.parameter.name)) throw new ParameterError({ message: "Destructured parameters are not supported. Use a simple identifier name." });
 		return this.parameter.name.text;
 	}
 	getDescription() {
 		const symbol = this.current.typeChecker.getSymbolAtLocation(this.parameter.name);
 		if (symbol) {
 			const comments = symbol.getDocumentationComment(this.current.typeChecker);
-			if (comments.length > 0) return ts.displayPartsToString(comments);
+			if (comments.length > 0) return displayPartsToString(comments);
 		}
 		return "";
 	}
@@ -3036,7 +2097,7 @@ var ParameterGenerator = class {
 				exampleLabels
 			};
 		} catch {
-			throw ParameterError$1.invalidExampleSchema();
+			throw ParameterError.invalidExampleSchema();
 		}
 	}
 	applyOptions(parameterName) {
@@ -3136,19 +2197,19 @@ var MethodGenerator = class {
 			}
 		} catch (e) {
 			const causeMsg = e instanceof Error ? `: ${e.message}` : "";
-			throw new GeneratorError$1({
+			throw new GeneratorError({
 				message: `Parameter generation failed for '${controllerId.text}.${methodId.text}' argument index ${i}${causeMsg}`,
-				code: GeneratorErrorCode$1.PARAMETER_GENERATION_FAILED,
+				code: GeneratorErrorCode.PARAMETER_GENERATION_FAILED,
 				cause: e
 			});
 		}
-		if (bodyParameterCount > 1) throw new GeneratorError$1({
+		if (bodyParameterCount > 1) throw new GeneratorError({
 			message: `Only one body parameter allowed in '${controllerId.text}.${methodId.text}' method.`,
-			code: GeneratorErrorCode$1.BODY_PARAMETER_DUPLICATE
+			code: GeneratorErrorCode.BODY_PARAMETER_DUPLICATE
 		});
-		if (bodyParameterCount > 0 && formParameterCount > 0) throw new GeneratorError$1({
+		if (bodyParameterCount > 0 && formParameterCount > 0) throw new GeneratorError({
 			message: `Cannot mix body and form parameters in '${controllerId.text}.${methodId.text}' method.`,
-			code: GeneratorErrorCode$1.BODY_FORM_CONFLICT
+			code: GeneratorErrorCode.BODY_FORM_CONFLICT
 		});
 		return output;
 	}
@@ -3186,13 +2247,13 @@ var ControllerGenerator = class {
 		return !!this.node.name;
 	}
 	generate() {
-		if (!this.node.parent) throw new GeneratorError$1({
+		if (!this.node.parent) throw new GeneratorError({
 			message: "Controller node doesn't have a valid parent source file.",
-			code: GeneratorErrorCode$1.CONTROLLER_NO_SOURCE_FILE
+			code: GeneratorErrorCode.CONTROLLER_NO_SOURCE_FILE
 		});
-		if (!this.node.name) throw new GeneratorError$1({
+		if (!this.node.name) throw new GeneratorError({
 			message: "Controller node doesn't have a valid name.",
-			code: GeneratorErrorCode$1.CONTROLLER_NO_NAME
+			code: GeneratorErrorCode.CONTROLLER_NO_NAME
 		});
 		const sourceFile = this.node.parent.getSourceFile();
 		const draft = newControllerDraft({
@@ -3254,7 +2315,7 @@ var ControllerGenerator = class {
 				set.add(methodName);
 				output.push(method);
 			} catch (error) {
-				if (isResolverError$1(error) || isGeneratorError$1(error) && error.code === GeneratorErrorCode$1.PARAMETER_GENERATION_FAILED) continue;
+				if (isResolverError(error) || isGeneratorError(error) && error.code === GeneratorErrorCode.PARAMETER_GENERATION_FAILED) continue;
 				throw error;
 			}
 		}
@@ -3374,9 +2435,9 @@ var MetadataGenerator = class {
 			return;
 		}
 		const summary = this.formatUnmatchedSummary();
-		if (this.config.strict === "throw") throw new GeneratorError$1({
+		if (this.config.strict === "throw") throw new GeneratorError({
 			message: summary,
-			code: GeneratorErrorCode$1.STRICT_UNMATCHED_DECORATORS
+			code: GeneratorErrorCode.STRICT_UNMATCHED_DECORATORS
 		});
 		console.warn(summary);
 	}
@@ -3464,11 +2525,6 @@ var MetadataGenerator = class {
 	}
 };
 //#endregion
-//#region src/app/generator/metadata/utils.ts
-function isMetadata(input) {
-	return isObject(input) && hasOwnProperty$1(input, "controllers") && Array.isArray(input.controllers) && hasOwnProperty$1(input, "referenceTypes") && isObject(input.referenceTypes);
-}
-//#endregion
 //#region src/app/generate.ts
 async function generateMetadata(options) {
 	let compilerOptions;
@@ -3486,6 +2542,6 @@ async function generateMetadata(options) {
 	}).generate();
 }
 //#endregion
-export { CACHE_DEFAULT_MAX_AGE_MS, CACHE_FILE_PREFIX, CACHE_FILE_SUFFIX, CACHE_SCHEMA_VERSION, CacheClient, CollectionFormat, CollectionKind, ConfigError, ConfigErrorCode, ControllerGenerator, DecoratorArgumentKindName, DecoratorTargetKind, GeneratorError, GeneratorErrorCode, JSDocTagName, MarkerName, MetadataError, MetadataGenerator, MethodGenerator, MethodName, NumericKind, ParamKind, ParameterError, ParameterErrorCode, ParameterGenerator, ParameterSource, PrimitiveResolver, ReferenceResolver, ResolverBase, ResolverCache, ResolverError, TypeName, TypeNodeResolver, UtilityTypeName, ValidatorError, ValidatorErrorCode, ValidatorName, append, applyDecoratorHandlers, applyJsDocHandlers, arrayArg, buildCacheOptions, buildDecoratorArgument, buildDecoratorSources, buildHandlerContext, buildJsDocHandlerContext, buildJsDocSources, composeCacheKey, controller, controllerHandlerSchema, controllerJsDoc, controllerJsDocHandlerSchema, createHandlerContext, createPresetContainer, createRegistry, findDecoratorByName, findDecoratorsByName, flag, generateMetadata, generatePresetLookupPaths, getDeclarationValidators, getInitializerValue, getJSDoc, getJSDocDescription, getJSDocTagComment, getJSDocTagNames, getJSDocTags, getLiteralValue, getNodeDecorators, getNodeDescription, getNodeExtensions, hasDecoratorNamed, hasInitializer, hasJSDocTag, hasOwnProperty, hashCompilerOptions, hashRegistry, identifierArg, into, isAnyType, isArrayType, isBigintType, isBinaryType, isBooleanType, isBufferType, isByteType, isDateTimeType, isDateType, isDeprecatedMarker, isDoubleType, isEnumType, isExtensionMarker, isFileType, isFloatType, isGeneratorError, isHiddenMarker, isIntegerType, isIntersectionType, isLongType, isMetadata, isNestedObjectLiteralType, isNeverType, isObjectType, isPrimitiveType, isRefAliasType, isRefEnumType, isRefObjectType, isReferenceType, isResolverError, isStringArray, isStringType, isTupleType, isUndefinedType, isUnionType, isVoidType, jsDocMatchSchema, literalArg, loadRegistry, loadRegistryByName, loadTSConfig, matchSchema, matches, matchesJsDoc, mergeRegistries, method, methodHandlerSchema, methodJsDoc, methodJsDocHandlerSchema, namesForMarker, newControllerDraft, newMethodDraft, newParameterDraft, normalizePath, numericMarkerKind, objectArg, parameter, parameterHandlerSchema, parameterJsDoc, parameterJsDocHandlerSchema, presetSchema, prettyLocationOfNode, prettyTroubleCause, readBoolean, readNodeDecorators, readNumber, readString, readStringOrStringArray, resolveArrayType, resolveIndexedAccessType, resolveIntersectionType, resolveLiteralType, resolveMappedType, resolveObjectLiteralType, resolvePresetByName, resolveTupleType, resolveTypeOperatorType, resolveUnionType, scanSourceFiles, setControllerPaths, setMethodPath, softLoadTsconfig, tagsForMarker, toTypeNodeOrFail, transformJSDocComment, typeArg, unresolvableArg, validatePreset };
+export { CACHE_DEFAULT_MAX_AGE_MS, CACHE_FILE_PREFIX, CACHE_FILE_SUFFIX, CACHE_SCHEMA_VERSION, CacheClient, ConfigError, ConfigErrorCode, ControllerGenerator, GeneratorError, GeneratorErrorCode, JSDocTagName, MetadataError, MetadataGenerator, MethodGenerator, ParameterError, ParameterErrorCode, ParameterGenerator, PrimitiveResolver, ReferenceResolver, ResolverBase, ResolverCache, ResolverError, TypeNodeResolver, ValidatorError, ValidatorErrorCode, applyDecoratorHandlers, applyJsDocHandlers, buildCacheOptions, buildDecoratorArgument, buildDecoratorSources, buildHandlerContext, buildJsDocHandlerContext, buildJsDocSources, composeCacheKey, findDecoratorByName, findDecoratorsByName, generateMetadata, getDeclarationValidators, getInitializerValue, getJSDoc, getJSDocDescription, getJSDocTagComment, getJSDocTagNames, getJSDocTags, getLiteralValue, getNodeDecorators, getNodeDescription, getNodeExtensions, hasDecoratorNamed, hasInitializer, hasJSDocTag, hasOwnProperty, hashCompilerOptions, hashRegistry, isGeneratorError, isResolverError, isStringArray, loadTSConfig, normalizePath, prettyLocationOfNode, prettyTroubleCause, readNodeDecorators, resolveArrayType, resolveIndexedAccessType, resolveIntersectionType, resolveLiteralType, resolveMappedType, resolveObjectLiteralType, resolveTupleType, resolveTypeOperatorType, resolveUnionType, scanSourceFiles, softLoadTsconfig, toTypeNodeOrFail, transformJSDocComment };
 
 //# sourceMappingURL=index.mjs.map