@trapi/metadata 1.3.0 → 2.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,3458 @@
+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 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;
+	}
+};
+function isResolverError(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";
+	}
+}
+//#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"
+};
+//#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"
+};
+const ParameterErrorCode = {
+	TYPE_UNSUPPORTED: "PARAMETER_TYPE_UNSUPPORTED",
+	METHOD_UNSUPPORTED: "PARAMETER_METHOD_UNSUPPORTED",
+	PATH_MISMATCH: "PARAMETER_PATH_MISMATCH",
+	SCOPE_REQUIRED: "PARAMETER_SCOPE_REQUIRED",
+	INVALID_EXAMPLE: "PARAMETER_INVALID_EXAMPLE"
+};
+//#endregion
+//#region src/core/parameter/error.ts
+var ParameterError = class ParameterError extends MetadataError {
+	static typeUnsupported(context) {
+		const location = context.node ? ParameterError.getCurrentLocation(context.node) : void 0;
+		return new ParameterError({
+			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.getCurrentLocation(context.node) : void 0;
+		return new ParameterError({
+			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.getCurrentLocation(context.node) : void 0;
+		return new ParameterError({
+			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.getCurrentLocation(context.node) : void 0;
+		return new ParameterError({
+			message: `@${context.decoratorName}() requires a scope argument${location ? ` at ${location}` : ""}.`,
+			code: ParameterErrorCode.SCOPE_REQUIRED
+		});
+	}
+	static invalidExampleSchema() {
+		return new ParameterError({
+			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/core/generator/error.ts
+var GeneratorError = class extends MetadataError {};
+function isGeneratorError(input) {
+	if (!isBaseError(input)) return false;
+	return typeof input.code === "string";
+}
+//#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
+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;
+}({});
+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: {}
+	};
+}
+function createRegistry() {
+	return {
+		controllers: [],
+		methods: [],
+		parameters: [],
+		controllerJsDoc: [],
+		methodJsDoc: [],
+		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";
+	JSDocTagName["ACCESS"] = "access";
+	JSDocTagName["ALIAS"] = "alias";
+	JSDocTagName["ASYNC"] = "async";
+	/**
+	* Alias for @extends
+	*/
+	JSDocTagName["AUGMENTS"] = "augments";
+	JSDocTagName["AUTHOR"] = "author";
+	JSDocTagName["DEFAULT"] = "default";
+	JSDocTagName["DEPRECATED"] = "deprecated";
+	JSDocTagName["DESCRIPTION"] = "description";
+	JSDocTagName["EXAMPLE"] = "example";
+	JSDocTagName["FORMAT"] = "format";
+	JSDocTagName["IGNORE"] = "ignore";
+	JSDocTagName["SUMMARY"] = "summary";
+	return JSDocTagName;
+}({});
+//#endregion
+//#region src/core/utils/array.ts
+function isStringArray(input) {
+	if (!Array.isArray(input)) return false;
+	for (const element of input) if (typeof element !== "string") return false;
+	return true;
+}
+//#endregion
+//#region src/core/utils/object.ts
+function hasOwnProperty(obj, prop) {
+	return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+//#endregion
+//#region src/core/utils/path-normalize.ts
+function normalizePath(str) {
+	str = str.replace(/^[/\\\s]+|[/\\\s]+$/g, "");
+	str = str.replace(/([^:]\/)\/+/g, "$1");
+	return str;
+}
+//#endregion
+//#region src/adapters/typescript/js-doc/utils.ts
+function transformJSDocComment(input) {
+	if (typeof input === "string") return input;
+	if (!input || input.length === 0) return;
+	const comment = input[0];
+	if (typeof comment === "string") return comment;
+	if (isObject(comment) && typeof comment.text === "string") return comment.text;
+}
+//#endregion
+//#region src/adapters/typescript/js-doc/module.ts
+function getJSDocDescription(node, index) {
+	const jsDoc = getJSDoc(node, index);
+	if (!jsDoc) return;
+	return transformJSDocComment(jsDoc.comment);
+}
+function getJSDoc(node, index) {
+	if (!hasOwnProperty(node, "jsDoc")) return;
+	const jsDoc = node.jsDoc;
+	if (!jsDoc || !Array.isArray(jsDoc) || !jsDoc.length) return;
+	index = index ?? 0;
+	return jsDoc.length > index && index >= 0 ? jsDoc[index] : void 0;
+}
+function getJSDocTags(node, isMatching) {
+	const jsDoc = getJSDoc(node);
+	if (typeof jsDoc === "undefined") return [];
+	const jsDocTags = jsDoc.tags;
+	if (typeof jsDocTags === "undefined") return [];
+	if (typeof isMatching === "undefined") return jsDocTags;
+	if (typeof isMatching === "function") return jsDocTags.filter(isMatching);
+	const tagNames = Array.isArray(isMatching) ? isMatching : [isMatching];
+	return jsDocTags.filter((tag) => tagNames.includes(tag.tagName.text));
+}
+function hasJSDocTag(node, tagName) {
+	const tags = getJSDocTags(node, tagName);
+	return !(!tags || !tags.length);
+}
+function getJSDocTagComment(node, tagName) {
+	const tags = getJSDocTags(node, tagName);
+	if (!tags || !tags.length || typeof tags[0].comment !== "string") return;
+	return tags[0].comment;
+}
+function getJSDocTagNames(node, requireTagName = false) {
+	let tags;
+	/* istanbul ignore next */
+	if (node.kind === SyntaxKind.Parameter) {
+		const parameterName = node.name.text;
+		tags = getJSDocTags(node.parent, (tag) => {
+			if (isJSDocParameterTag(tag)) return false;
+			if (tag.comment === void 0) throw new MetadataError(`Orphan tag: @${String(tag.tagName.text || tag.tagName.escapedText)} must be followed by a parameter name.`);
+			return typeof tag.comment === "string" ? tag.comment.startsWith(parameterName) : false;
+		});
+	} else tags = getJSDocTags(node, (tag) => requireTagName ? tag.comment !== void 0 : true);
+	return tags.map((tag) => tag.tagName.text);
+}
+//#endregion
+//#region src/adapters/typescript/initializer.ts
+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: {
+			const prefixUnary = initializer;
+			switch (prefixUnary.operator) {
+				case ts.SyntaxKind.PlusToken: return Number(prefixUnary.operand.text);
+				case ts.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: {
+			const newExpression = initializer;
+			if (newExpression.expression.text === "Date") {
+				let date = /* @__PURE__ */ new Date();
+				if (newExpression.arguments) {
+					const argsValue = newExpression.arguments.filter((args) => args.kind !== void 0).map((args) => getInitializerValue(args, typeChecker));
+					if (argsValue.length > 0) date = new Date(argsValue);
+				}
+				const dateString = date.toISOString();
+				if (type && type.typeName === "date") return dateString.split("T")[0];
+				return dateString;
+			}
+			return;
+		}
+		case ts.SyntaxKind.NullKeyword: return null;
+		case ts.SyntaxKind.ObjectLiteralExpression: {
+			const objectLiteral = initializer;
+			const nestedObject = {};
+			objectLiteral.properties.forEach((p) => {
+				nestedObject[p.name.text] = getInitializerValue(p.initializer, typeChecker);
+			});
+			return nestedObject;
+		}
+		case ts.SyntaxKind.ImportSpecifier: {
+			if (typeof typeChecker === "undefined") return;
+			const importSpecifier = initializer;
+			const importSymbol = typeChecker.getSymbolAtLocation(importSpecifier.name);
+			if (!importSymbol) return;
+			const declarations = typeChecker.getAliasedSymbol(importSymbol).getDeclarations();
+			return getInitializerValue(extractInitializer(declarations && declarations.length > 0 ? declarations[0] : void 0), typeChecker);
+		}
+		default: {
+			if (typeof initializer === "undefined") return;
+			if (typeof initializer.parent === "undefined" || typeof typeChecker === "undefined") {
+				if (hasOwnProperty(initializer, "text")) return initializer.text;
+				return;
+			}
+			const symbol = typeChecker.getSymbolAtLocation(initializer);
+			return getInitializerValue(extractInitializer(symbol.valueDeclaration) || extractInitializer(extractImportSpecifier(symbol)), typeChecker);
+		}
+	}
+}
+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;
+//#endregion
+//#region src/adapters/decorator/typescript/utils.ts
+/**
+* Enumerate decorators on a TS node and classify their argument values without
+* going through the registry. Used by read-side consumers (type resolver,
+* extension extraction) that only need decorator names + argument values.
+*/
+function readNodeDecorators(node, typeChecker) {
+	if (!ts.canHaveDecorators(node)) return [];
+	const decorators = ts.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)) {
+			argumentExpressions = expression.arguments;
+			name = readDecoratorName$1(expression.expression);
+		} else name = readDecoratorName$1(expression);
+		if (!name) continue;
+		output.push({
+			name,
+			arguments: argumentExpressions.map((a) => buildDecoratorArgument(a, typeChecker))
+		});
+	}
+	return output;
+}
+function findDecoratorByName(node, name, typeChecker) {
+	return readNodeDecorators(node, typeChecker).find((d) => d.name === name);
+}
+function findDecoratorsByName(node, name, typeChecker) {
+	return readNodeDecorators(node, typeChecker).filter((d) => d.name === name);
+}
+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;
+}
+function buildDecoratorArgument(expr, typeChecker) {
+	if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return {
+		raw: getInitializerValue(expr, typeChecker),
+		kind: "literal"
+	};
+	if (expr.kind === ts.SyntaxKind.TrueKeyword) return {
+		raw: true,
+		kind: "literal"
+	};
+	if (expr.kind === ts.SyntaxKind.FalseKeyword) return {
+		raw: false,
+		kind: "literal"
+	};
+	if (expr.kind === ts.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 {
+		raw: getInitializerValue(expr, typeChecker),
+		kind: "literal"
+	};
+	if (ts.isObjectLiteralExpression(expr)) return {
+		raw: getInitializerValue(expr, typeChecker),
+		kind: "object"
+	};
+	if (ts.isArrayLiteralExpression(expr)) return {
+		raw: getInitializerValue(expr, typeChecker),
+		kind: "array"
+	};
+	if (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr)) {
+		const value = getInitializerValue(expr, typeChecker);
+		if (typeof value !== "undefined") return {
+			raw: value,
+			kind: "identifier"
+		};
+		return {
+			raw: void 0,
+			kind: "unresolvable"
+		};
+	}
+	return {
+		raw: void 0,
+		kind: "unresolvable"
+	};
+}
+//#endregion
+//#region src/adapters/decorator/typescript/module.ts
+function buildDecoratorSources(node, options) {
+	if (!ts.canHaveDecorators(node)) return [];
+	const decorators = ts.getDecorators(node);
+	if (!decorators || decorators.length === 0) return [];
+	const output = [];
+	for (const decorator of decorators) {
+		const source = buildDecoratorSource(decorator, options);
+		if (source) output.push(source);
+	}
+	return output;
+}
+function buildDecoratorSource(decorator, options) {
+	const { expression } = decorator;
+	let name;
+	let argumentExpressions = [];
+	let typeArgumentNodes = [];
+	if (ts.isCallExpression(expression)) {
+		argumentExpressions = expression.arguments;
+		typeArgumentNodes = expression.typeArguments ?? [];
+		name = readDecoratorName(expression.expression);
+	} else name = readDecoratorName(expression);
+	if (!name) return;
+	const decoratorArguments = argumentExpressions.map((arg) => buildDecoratorArgument(arg, options.typeChecker));
+	const decoratorTypeArguments = typeArgumentNodes.map((typeNode) => ({ resolve: () => options.resolveTypeNode(typeNode) }));
+	const sourceFile = decorator.getSourceFile();
+	const location = sourceFile ? {
+		file: sourceFile.fileName,
+		line: sourceFile.getLineAndCharacterOfPosition(decorator.getStart()).line + 1
+	} : void 0;
+	return {
+		name,
+		arguments: decoratorArguments,
+		typeArguments: decoratorTypeArguments,
+		target: options.target,
+		host: options.host,
+		location
+	};
+}
+function readDecoratorName(expression) {
+	if (ts.isIdentifier(expression)) return expression.text;
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+}
+function buildJsDocSources(node, options) {
+	const tags = getJSDocTags(node);
+	if (tags.length === 0) return [];
+	const output = [];
+	for (const tag of tags) output.push(buildJsDocSource(tag, options));
+	return output;
+}
+function buildJsDocSource(tag, options) {
+	const tagName = tag.tagName.text;
+	const text = transformJSDocComment(tag.comment);
+	let parameterName;
+	let typeNode;
+	if (ts.isJSDocParameterTag(tag) || ts.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;
+	const source = {
+		tag: tagName,
+		target: options.target,
+		host: options.host
+	};
+	if (typeof text !== "undefined") source.text = text;
+	if (typeof parameterName !== "undefined") source.parameterName = parameterName;
+	if (typeNode) {
+		const capturedTypeNode = typeNode;
+		source.typeExpression = { resolve: () => options.resolveTypeNode(capturedTypeNode) };
+	}
+	return source;
+}
+function readEntityName(name) {
+	if (ts.isIdentifier(name)) return name.text;
+	if (ts.isQualifiedName(name)) {
+		const left = readEntityName(name.left);
+		return left ? `${left}.${name.right.text}` : name.right.text;
+	}
+}
+//#endregion
+//#region src/adapters/decorator/orchestrator/module.ts
+function buildHandlerContext(source, options) {
+	return {
+		host: source.host,
+		argument: (i) => source.arguments[i],
+		arguments: () => source.arguments,
+		typeArgument: (i) => source.typeArguments[i],
+		typeArguments: () => source.typeArguments,
+		parameterType: options.parameterType ?? (() => void 0)
+	};
+}
+function buildJsDocHandlerContext(source, options) {
+	return {
+		host: source.host,
+		source,
+		parameterType: options.parameterType ?? (() => void 0)
+	};
+}
+function applyDecoratorHandlers(node, handlers, draft, options) {
+	if (handlers.length === 0 && !options.onUnmatchedDecorator) return;
+	const sources = buildDecoratorSources(node, options);
+	if (sources.length === 0) return;
+	for (const source of sources) {
+		let matched = 0;
+		for (const handler of handlers) if (matches(handler.match, source)) {
+			handler.apply(buildHandlerContext(source, options), draft);
+			matched += 1;
+		}
+		if (matched === 0 && options.onUnmatchedDecorator) {
+			let file;
+			let line;
+			if (source.location) {
+				file = source.location.file;
+				line = source.location.line;
+			} else {
+				const sourceFile = node.getSourceFile();
+				file = sourceFile.fileName;
+				line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+			}
+			options.onUnmatchedDecorator({
+				name: source.name,
+				target: source.target,
+				host: source.host,
+				file,
+				line
+			}, source);
+		}
+	}
+}
+function applyJsDocHandlers(node, handlers, draft, options) {
+	if (handlers.length === 0) return;
+	const sources = buildJsDocSources(node, options);
+	if (sources.length === 0) return;
+	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 {};
+	const getCommentValue = (comment) => comment && comment.split(" ")[0];
+	const parameterTags = getSupportedParameterTags();
+	const tags = getJSDocTags(declaration.parent, (tag) => {
+		const { comment } = tag;
+		const text = transformJSDocComment(comment);
+		if (!comment) return false;
+		const commentValue = getCommentValue(text);
+		return parameterTags.some((value) => {
+			if (value !== tag.tagName.text) return false;
+			return !(name && name !== commentValue);
+		});
+	});
+	function getErrorMsg(comment, isValue = true) {
+		if (!comment) return;
+		if (isValue) {
+			const indexOf = comment.indexOf(" ");
+			if (indexOf > 0) return comment.substring(indexOf + 1);
+			return;
+		}
+		return comment;
+	}
+	const validators = {};
+	for (const tag of tags) {
+		if (!tag.comment) continue;
+		const name = tag.tagName.text;
+		let comment = transformJSDocComment(tag.comment);
+		comment = comment.substring(comment.indexOf(" ") + 1).trim();
+		const value = getCommentValue(comment);
+		switch (name) {
+			case "uniqueItems":
+				validators[name] = {
+					message: getErrorMsg(comment, false),
+					value: void 0
+				};
+				break;
+			case "minimum":
+			case "maximum":
+			case "minItems":
+			case "maxItems":
+			case "minLength":
+			case "maxLength":
+				{
+					const parsed = Number(value);
+					if (!Number.isFinite(parsed)) throw new ValidatorError$1({
+						message: `@${name} validator expects a numeric value, got '${value}'.`,
+						code: ValidatorErrorCode$1.EXPECTED_NUMBER
+					});
+					validators[name] = {
+						message: getErrorMsg(comment),
+						value: parsed
+					};
+				}
+				break;
+			case "minDate":
+			case "maxDate":
+				if (typeof value !== "string") throw new ValidatorError$1({
+					message: `@${name} validator expects a date string, got '${typeof value}'.`,
+					code: ValidatorErrorCode$1.EXPECTED_DATE
+				});
+				validators[name] = {
+					message: getErrorMsg(comment),
+					value
+				};
+				break;
+			case "pattern":
+				if (typeof value !== "string") throw new ValidatorError$1({
+					message: `@${name} validator expects a string pattern, got '${value}'.`,
+					code: ValidatorErrorCode$1.EXPECTED_STRING
+				});
+				validators[name] = {
+					message: getErrorMsg(comment),
+					value: removeSurroundingQuotes(value)
+				};
+				break;
+			default:
+				if (name.toLowerCase().startsWith("is")) {
+					const errorMsg = getErrorMsg(comment, false);
+					if (errorMsg) validators[name] = {
+						message: errorMsg,
+						value: void 0
+					};
+				}
+				break;
+		}
+	}
+	return validators;
+}
+function getSupportedParameterTags() {
+	return [
+		"isString",
+		"isBoolean",
+		"isInt",
+		"isLong",
+		"isFloat",
+		"isDouble",
+		"isDate",
+		"isDateTime",
+		"minItems",
+		"maxItems",
+		"uniqueItems",
+		"minLength",
+		"maxLength",
+		"pattern",
+		"minimum",
+		"maximum",
+		"minDate",
+		"maxDate"
+	];
+}
+function removeSurroundingQuotes(str) {
+	if (str.startsWith("`") && str.endsWith("`")) return str.substring(1, str.length - 1);
+	if (str.startsWith("```") && str.endsWith("```")) return str.substring(3, str.length - 3);
+	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);
+	if (names.size === 0) return [];
+	const output = [];
+	for (const name of names) {
+		const decorators = findDecoratorsByName(node, name);
+		for (const decorator of decorators) {
+			const keyArg = decorator.arguments[0];
+			const valueArg = decorator.arguments[1];
+			if (!keyArg || keyArg.kind !== "literal" || typeof keyArg.raw !== "string") continue;
+			if (!valueArg || valueArg.kind === "unresolvable" || typeof valueArg.raw === "undefined") continue;
+			output.push({
+				key: keyArg.raw,
+				value: valueArg.raw
+			});
+		}
+	}
+	return output;
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/array.ts
+function resolveArrayType(typeNode, ctx) {
+	if (!ts.isArrayTypeNode(typeNode)) return;
+	return {
+		typeName: "array",
+		elementType: ctx.resolveType(typeNode.elementType, ctx.parentNode, ctx.context)
+	};
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/base.ts
+var ResolverBase = class {
+	hasPublicModifier(node) {
+		if (!canHaveModifiers(node)) return true;
+		const modifiers = getModifiers(node);
+		if (!modifiers) return true;
+		return modifiers.every((modifier) => modifier.kind !== SyntaxKind.ProtectedKeyword && modifier.kind !== SyntaxKind.PrivateKeyword);
+	}
+	hasStaticModifier(node) {
+		if (!canHaveModifiers(node)) return false;
+		const modifiers = getModifiers(node);
+		return modifiers && modifiers.some((modifier) => modifier.kind === SyntaxKind.StaticKeyword);
+	}
+	isAccessibleParameter(node) {
+		if (!canHaveModifiers(node)) return false;
+		const modifiers = getModifiers(node);
+		if (!modifiers) return false;
+		if (modifiers.some((modifier) => modifier.kind === SyntaxKind.PublicKeyword)) return true;
+		const isReadonly = modifiers.some((modifier) => modifier.kind === SyntaxKind.ReadonlyKeyword);
+		const isProtectedOrPrivate = modifiers.some((modifier) => modifier.kind === SyntaxKind.ProtectedKeyword || modifier.kind === SyntaxKind.PrivateKeyword);
+		return isReadonly && !isProtectedOrPrivate;
+	}
+};
+//#endregion
+//#region src/adapters/typescript/resolver/utils.ts
+function getNodeDescription(node, typeChecker) {
+	if (!hasOwnProperty(node, "name")) return;
+	const symbol = typeChecker.getSymbolAtLocation(node.name);
+	if (!symbol) return;
+	/**
+	* TODO: Workaround for what seems like a bug in the compiler
+	* Warrants more investigation and possibly a PR against typescript
+	*/
+	if (node.kind === SyntaxKind.Parameter) symbol.flags = 0;
+	const comments = symbol.getDocumentationComment(typeChecker);
+	if (comments.length) return displayPartsToString(comments);
+}
+function toTypeNodeOrFail(typeChecker, ...args) {
+	const output = typeChecker.typeToTypeNode(...args);
+	if (typeof output === "undefined") throw new ResolverError$1("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;
+		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);
+		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))) {
+		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 (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 });
+		}
+	}
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/intersection.ts
+function resolveIntersectionType(typeNode, ctx) {
+	if (!ts.isIntersectionTypeNode(typeNode)) return;
+	return {
+		typeName: "intersection",
+		members: typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context))
+	};
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/literal.ts
+function resolveLiteralType(typeNode, ctx) {
+	if (typeNode.kind === ts.SyntaxKind.NullKeyword) return {
+		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",
+		members: [getLiteralValue(typeNode)]
+	};
+	if (typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
+		const type = ctx.typeChecker.getTypeFromTypeNode(ctx.referencer || typeNode);
+		if (type.isUnion() && type.types.every((t) => t.isStringLiteral())) return {
+			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);
+	}
+	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" };
+}
+function getLiteralValue(typeNode) {
+	let value;
+	switch (typeNode.literal.kind) {
+		case ts.SyntaxKind.TrueKeyword:
+			value = true;
+			break;
+		case ts.SyntaxKind.FalseKeyword:
+			value = false;
+			break;
+		case ts.SyntaxKind.StringLiteral:
+			value = typeNode.literal.text;
+			break;
+		case ts.SyntaxKind.NumericLiteral:
+			value = Number.parseFloat(typeNode.literal.text);
+			break;
+		case ts.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);
+	}
+	return value;
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/mapped.ts
+function resolveMappedType(typeNode, ctx) {
+	if (!ts.isMappedTypeNode(typeNode) || !ctx.referencer) return;
+	const type = ctx.typeChecker.getTypeFromTypeNode(ctx.referencer);
+	const mappedTypeNode = typeNode;
+	const { typeChecker } = ctx;
+	const getDeclaration = (prop) => prop.declarations && prop.declarations[0];
+	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 {
+		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: {}
+			};
+		})
+	};
+}
+//#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);
+		const type = ctx.resolveType(propertySignature.type, propertySignature, ctx.context);
+		return [{
+			deprecated: hasJSDocTag(propertySignature, "deprecated"),
+			example: ctx.getNodeExample(propertySignature),
+			extensions: ctx.getNodeExtensions(propertySignature),
+			default: getJSDocTagComment(propertySignature, "default"),
+			description: ctx.getNodeDescription(propertySignature),
+			format: getNodeFormat(propertySignature),
+			name: getPropertyName(propertySignature),
+			required: !propertySignature.questionToken,
+			type,
+			validators: getDeclarationValidators(propertySignature) || {}
+		}, ...res];
+	}, []);
+	const indexMember = typeNode.members.find((member) => ts.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);
+		additionalType = ctx.resolveType(indexSignatureDeclaration.type, ctx.parentNode, ctx.context);
+	}
+	return {
+		additionalProperties: indexMember && additionalType,
+		typeName: "nestedObjectLiteral",
+		properties
+	};
+}
+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;
+	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"
+};
+var PrimitiveResolver = class {
+	registry;
+	constructor(registry) {
+		this.registry = registry;
+	}
+	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 === "null") return;
+			if (resolved === "never") return { typeName: "never" };
+			if (resolved === "bigint") return { typeName: "bigint" };
+			if (resolved === "number") {
+				if (!parentNode) return { typeName: "double" };
+				const presentJsDocTags = new Set(getJSDocTagNames(parentNode).map((tag) => tag.toLowerCase()));
+				for (const kind of [
+					NumericKind.Int,
+					NumericKind.Long,
+					NumericKind.Float,
+					NumericKind.Double
+				]) {
+					const matchKind = (m) => numericMarkerKind(m) === kind;
+					const decoratorNames = namesForMarker(this.registry, matchKind);
+					for (const name of decoratorNames) if (hasDecoratorNamed(parentNode, name)) return { typeName: NUMERIC_KIND_TO_TYPE_NAME[kind] };
+					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" };
+			}
+		}
+	}
+	resolveSyntaxKind(syntaxKind) {
+		switch (syntaxKind) {
+			case SyntaxKind.StringKeyword: return "string";
+			case SyntaxKind.BooleanKeyword: return "boolean";
+			case SyntaxKind.VoidKeyword: return "void";
+			case SyntaxKind.UndefinedKeyword: return "undefined";
+			case SyntaxKind.NullKeyword: return "null";
+			case SyntaxKind.NumberKeyword: return "number";
+			case SyntaxKind.BigIntKeyword: return "bigint";
+			case SyntaxKind.NeverKeyword: return "never";
+			default: return;
+		}
+	}
+};
+//#endregion
+//#region src/adapters/typescript/resolver/sub/reference.ts
+var ReferenceResolver = class extends ResolverBase {
+	typeChecker;
+	constructor(typeChecker) {
+		super();
+		this.typeChecker = typeChecker;
+	}
+	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)}`);
+	}
+	mergeManyRefEnums(many) {
+		let merged = this.mergeRefEnums(many[0], many[1]);
+		for (let i = 2; i < many.length; ++i) merged = this.mergeRefEnums(merged, many[i]);
+		return merged;
+	}
+	mergeRefEnums(first, second) {
+		let description;
+		if (first.description || second.description) if (!first.description) description = second.description;
+		else if (!second.description) description = first.description;
+		else description = `${first.description}\n${second.description}`;
+		return {
+			typeName: "refEnum",
+			example: first.example || second.example,
+			description,
+			members: [...first.members || [], ...second.members || []],
+			memberNames: [...first.memberNames || [], ...second.memberNames || []],
+			refName: first.refName,
+			deprecated: first.deprecated || second.deprecated
+		};
+	}
+	mergeManyRefObjects(many) {
+		let merged = this.mergeRefObject(many[0], many[1]);
+		for (let i = 2; i < many.length; ++i) merged = this.mergeRefObject(merged, many[i]);
+		return merged;
+	}
+	mergeRefObject(first, second) {
+		let description;
+		if (first.description || second.description) if (!first.description) description = second.description;
+		else if (!second.description) description = first.description;
+		else description = `${first.description}\n${second.description}`;
+		const properties = [...first.properties, ...second.properties.filter((prop) => first.properties.every((firstProp) => firstProp.name !== prop.name))];
+		let additionalProperties;
+		if (first.additionalProperties || second.additionalProperties) if (!first.additionalProperties) additionalProperties = second.additionalProperties;
+		else if (!second.additionalProperties) additionalProperties = first.additionalProperties;
+		else additionalProperties = {
+			typeName: "union",
+			members: [first.additionalProperties, second.additionalProperties]
+		};
+		return {
+			typeName: "refObject",
+			description,
+			properties,
+			additionalProperties,
+			refName: first.refName,
+			deprecated: first.deprecated || second.deprecated,
+			example: first.example || second.example
+		};
+	}
+	transformEnum(declaration, enumName) {
+		const isNotUndefined = (item) => item !== void 0;
+		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",
+			description: getNodeDescription(declaration, this.typeChecker),
+			members: enums,
+			memberNames: enumNames,
+			refName: enumName,
+			deprecated: hasJSDocTag(declaration, "deprecated")
+		};
+	}
+	transformEnumMember(declaration, enumName) {
+		return {
+			typeName: "refEnum",
+			refName: enumName,
+			members: [this.typeChecker.getConstantValue(declaration)],
+			memberNames: [declaration.name.getText()],
+			deprecated: hasJSDocTag(declaration, "deprecated")
+		};
+	}
+};
+//#endregion
+//#region src/adapters/typescript/resolver/sub/tuple.ts
+function resolveTupleType(typeNode, ctx) {
+	if (!ts.isTupleTypeNode(typeNode)) return;
+	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 }
+			};
+		})
+	};
+}
+//#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) {
+		const type = ctx.typeChecker.getTypeFromTypeNode(typeNode);
+		try {
+			return ctx.resolveType(toTypeNodeOrFail(ctx.typeChecker, type, void 0, ts.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 });
+		}
+	}
+	if (typeNode.operator === ts.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;
+	return {
+		typeName: "union",
+		members: typeNode.types.map((type) => ctx.resolveType(type, ctx.parentNode, ctx.context))
+	};
+}
+//#endregion
+//#region src/adapters/typescript/resolver/module.ts
+var TypeNodeResolver = class TypeNodeResolver extends ResolverBase {
+	static MAX_DEPTH = 50;
+	typeNode;
+	current;
+	parentNode;
+	context;
+	referencer;
+	depth;
+	primitiveResolver;
+	referenceResolver;
+	constructor(typeNode, current, parentNode, context, referencer, depth) {
+		super();
+		this.typeNode = typeNode;
+		this.current = current;
+		this.parentNode = parentNode;
+		this.context = context || {};
+		this.referencer = referencer;
+		this.depth = depth ?? 0;
+		this.primitiveResolver = new PrimitiveResolver(current.registry);
+		this.referenceResolver = new ReferenceResolver(current.typeChecker);
+	}
+	/**
+	* @deprecated Use resolverCache.clear() on the context instead.
+	* Kept for backward compatibility — no-ops since cache is now instance-scoped.
+	*/
+	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);
+		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();
+		return result;
+	}
+	createSubResolverContext() {
+		return {
+			typeChecker: this.current.typeChecker,
+			current: this.current,
+			parentNode: this.parentNode,
+			context: this.context,
+			referencer: this.referencer,
+			resolveType: (typeNode, parentNode, context, referencer) => this.resolveNestedType(typeNode, parentNode, context, referencer),
+			propertyFromSignature: (sig, overrideToken) => this.propertyFromSignature(sig, overrideToken),
+			propertyFromDeclaration: (decl, overrideToken) => this.propertyFromDeclaration(decl, overrideToken),
+			getNodeDescription: (node) => this.getNodeDescription(node),
+			getNodeExample: (node) => this.getNodeExample(node),
+			getNodeExtensions: (node) => this.getNodeExtensions(node)
+		};
+	}
+	resolveNestedType(typeNode, parentNode, context, referencer) {
+		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);
+	}
+	resolveConditionalType() {
+		if (!ts.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;
+		const typeReference = this.typeNode;
+		if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
+			if (typeReference.typeName.text === "Record" && typeReference.typeArguments) return {
+				additionalProperties: this.resolveNestedType(typeReference.typeArguments[1], this.parentNode, this.context),
+				typeName: "nestedObjectLiteral",
+				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 === "Array" && typeReference.typeArguments && typeReference.typeArguments.length >= 1) return {
+				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 (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);
+		}
+		try {
+			const referenceType = this.getReferenceType(typeReference);
+			this.current.addReferenceType(referenceType);
+			return referenceType;
+		} catch (err) {
+			try {
+				return this.resolveTypeViaChecker(typeReference);
+			} catch {
+				throw err;
+			}
+		}
+	}
+	static CHECKER_RESOLVABLE_UTILITY_TYPES = new Set([
+		"NonNullable",
+		"Omit",
+		"Partial",
+		"Readonly",
+		"Required",
+		"Pick",
+		"Extract",
+		"Exclude",
+		"ReturnType",
+		"Parameters",
+		"Awaited",
+		"InstanceType",
+		"ConstructorParameters"
+	]);
+	static isCheckerResolvableUtilityType(name) {
+		return TypeNodeResolver.CHECKER_RESOLVABLE_UTILITY_TYPES.has(name);
+	}
+	resolveUtilityTypeViaChecker(typeReference) {
+		if (this.hasUnboundContextArgs(typeReference) && this.referencer) return this.resolveTypeViaChecker(this.referencer);
+		return this.resolveTypeViaChecker(typeReference);
+	}
+	/**
+	* Shared checker delegation: resolves a type node by letting the TS
+	* type checker evaluate it, converting back to a TypeNode, and
+	* recursively resolving the result.
+	*/
+	resolveTypeViaChecker(typeNode) {
+		const type = this.current.typeChecker.getTypeFromTypeNode(typeNode);
+		const resolvedTypeNode = this.current.typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.InTypeAlias);
+		if (!resolvedTypeNode) return {
+			typeName: "tuple",
+			elements: []
+		};
+		return this.resolveNestedType(resolvedTypeNode, this.parentNode, this.context);
+	}
+	/**
+	* Check if a type reference has type arguments that reference unbound
+	* type parameters from this.context (e.g. `Awaited<T>` where T is a
+	* generic parameter mapped in context).
+	*/
+	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);
+	}
+	static resolveSpecialReference(node) {
+		switch (node.text) {
+			case "Buffer":
+			case "DownloadBinaryData":
+			case "DownloadResource": return { typeName: "buffer" };
+			default: return;
+		}
+	}
+	getDateType(parentNode) {
+		if (!parentNode) return { typeName: "datetime" };
+		const tags = getJSDocTagNames(parentNode).filter((name) => ["isDate", "isDateTime"].includes(name));
+		if (tags.length === 0) return { typeName: "datetime" };
+		switch (tags[0]) {
+			case "isDate": return { typeName: "date" };
+			default: return { typeName: "datetime" };
+		}
+	}
+	static getDesignatedModels(nodes, _typeName) {
+		return nodes;
+	}
+	getEnumerateType(typeName) {
+		const enumName = typeName.text;
+		let enumNodes = this.current.nodes.filter((node) => node.kind === ts.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.`);
+		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",
+			description: this.getNodeDescription(enumDeclaration),
+			members: enums,
+			memberNames: enumNames,
+			refName: enumName,
+			deprecated: hasJSDocTag(enumDeclaration, "deprecated")
+		};
+	}
+	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.");
+		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))}'`;
+				const resolvedType = this.primitiveResolver.resolveSyntaxKind(arg.kind);
+				if (typeof resolvedType === "undefined") return "any";
+				return resolvedType;
+			});
+			resolvableName += `<${argumentsString.join(", ")}>`;
+		}
+		const name = this.contextualizedName(resolvableName);
+		this.typeArgumentsToContext(node, type, this.context);
+		try {
+			const existingType = this.current.resolverCache.getCachedType(name);
+			if (existingType) return existingType;
+			if (this.current.resolverCache.isInProgress(name)) return this.createCircularDependencyResolver(name);
+			this.current.resolverCache.markInProgress(name);
+			try {
+				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));
+				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));
+				const referenceType = this.referenceResolver.merge(referenceTypes);
+				this.current.resolverCache.setCachedType(name, referenceType);
+				return referenceType;
+			} finally {
+				this.current.resolverCache.clearInProgress(name);
+			}
+		} catch (err) {
+			throw new ResolverError$1(`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) {
+			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 referenceType = this.getReferenceType(innerRef);
+				if (referenceType.refName === refName) return referenceType;
+			}
+		}
+		const type = this.resolveNestedType(declaration.type, declaration, this.context, this.referencer || referencer);
+		const example = this.getNodeExample(declaration);
+		return {
+			typeName: "refAlias",
+			default: getJSDocTagComment(declaration, "default"),
+			description: this.getNodeDescription(declaration),
+			refName,
+			format: TypeNodeResolver.getNodeFormat(declaration),
+			type,
+			validators: getDeclarationValidators(declaration) || {},
+			deprecated: hasJSDocTag(declaration, "deprecated"),
+			...example && { example }
+		};
+	}
+	getModelReference(modelType, name) {
+		const example = this.getNodeExample(modelType);
+		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);
+		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))) {
+			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);
+			}
+			return {
+				refName: `${TypeNodeResolver.getRefTypeName(name)}Alias`,
+				typeName: "refAlias",
+				description,
+				type: this.resolveNestedType(nodeType),
+				deprecated,
+				validators: {},
+				...example && { example }
+			};
+		}
+		const properties = this.getModelProperties(modelType);
+		const referenceType = {
+			additionalProperties: this.getModelAdditionalProperties(modelType),
+			typeName: "refObject",
+			description,
+			properties: this.getModelInheritedProperties(modelType) || [],
+			refName: TypeNodeResolver.getRefTypeName(name),
+			deprecated,
+			...example && { example }
+		};
+		referenceType.properties = referenceType.properties.concat(properties);
+		return referenceType;
+	}
+	static getRefTypeName(name) {
+		const sanitized = name.replace(/[<>]/g, "_").replace(/[{}]/g, "_").replace(/\s+/g, "").replace(/,/g, ".").replace(/'([^']*)'/g, "$1").replace(/"([^"]*)"/g, "$1").replace(/&/g, "-and-").replace(/\|/g, "-or-").replace(/\[\]/g, "-array").replace(/([a-z]+):([a-z]+)/gi, "$1-$2").replace(/;/g, "--").replace(/([a-z]+)\[([a-z]+)]/gi, "$1-at-$2").replace(/_/g, "");
+		return encodeURIComponent(sanitized);
+	}
+	contextualizedName(name) {
+		return Object.entries(this.context).reduce((acc, [key, entry]) => acc.replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, "g"), `<$1${entry.getText()}$3>`).replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, "g"), `<$1${entry.getText()}$3,`).replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, "g"), `,$1${entry.getText()}$3>`).replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, "g"), `<$1${entry.getText()}$3<`), name);
+	}
+	handleCachingAndCircularReferences(name, declarationResolver) {
+		try {
+			const existingType = this.current.resolverCache.getCachedType(name);
+			if (existingType) return existingType;
+			if (this.current.resolverCache.isInProgress(name)) return this.createCircularDependencyResolver(name);
+			this.current.resolverCache.markInProgress(name);
+			try {
+				const reference = declarationResolver();
+				this.current.resolverCache.setCachedType(name, reference);
+				this.current.addReferenceType(reference);
+				return reference;
+			} finally {
+				this.current.resolverCache.clearInProgress(name);
+			}
+		} catch (err) {
+			throw new ResolverError$1(`There was a problem resolving type of '${name}'.`, this.typeNode, { cause: err });
+		}
+	}
+	createCircularDependencyResolver(refName) {
+		const referenceType = {
+			deprecated: false,
+			properties: [],
+			typeName: "refObject",
+			refName
+		};
+		this.current.registerDependencyResolver((referenceTypes) => {
+			const realReferenceType = referenceTypes[refName];
+			if (!realReferenceType) return;
+			referenceType.description = realReferenceType.description;
+			if (realReferenceType.typeName === "refObject" && referenceType.typeName === "refObject") referenceType.properties = realReferenceType.properties;
+			referenceType.typeName = realReferenceType.typeName;
+			referenceType.refName = realReferenceType.refName;
+		});
+		return referenceType;
+	}
+	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;
+			default: return false;
+		}
+	}
+	getModelTypeDeclarations(type) {
+		let typeName = type.kind === ts.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}.`);
+		const declarations = symbol.getDeclarations();
+		if (!declarations || declarations.length === 0) throw new ResolverError$1(`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 > 1) {
+			modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile().fileName.replace(/\\/g, "/").toLowerCase().indexOf("node_modules/typescript") <= -1);
+			modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
+		}
+		return modelTypes;
+	}
+	getModelTypeDeclaration(type) {
+		let typeName = type.kind === ts.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 (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 > 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}".`);
+		}
+		return modelTypes[0];
+	}
+	hasFlag(type, flag) {
+		return (type.flags & flag) === flag;
+	}
+	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;
+	}
+	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 (classConstructor && classConstructor.parameters) {
+			const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
+			properties.push(...constructorProperties);
+		}
+		return properties.map((property) => this.propertyFromDeclaration(property, overrideToken));
+	}
+	propertyFromSignature(propertySignature, overrideToken) {
+		const identifier = propertySignature.name;
+		if (!propertySignature.type) throw new ResolverError$1("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;
+		return {
+			deprecated: hasJSDocTag(propertySignature, "deprecated"),
+			default: getJSDocTagComment(propertySignature, "default"),
+			description: this.getNodeDescription(propertySignature),
+			example: this.getNodeExample(propertySignature),
+			extensions: this.getNodeExtensions(propertySignature),
+			format: TypeNodeResolver.getNodeFormat(propertySignature),
+			name: identifier.text,
+			required,
+			type: this.resolveNestedType(propertySignature.type, propertySignature.type.parent, this.context, propertySignature.type),
+			validators: getDeclarationValidators(propertySignature) || {}
+		};
+	}
+	propertyFromDeclaration(propertyDeclaration, overrideToken) {
+		const identifier = propertyDeclaration.name;
+		let typeNode = propertyDeclaration.type;
+		if (!typeNode) {
+			const tsType = this.current.typeChecker.getTypeAtLocation(propertyDeclaration);
+			typeNode = this.current.typeChecker.typeToTypeNode(tsType, void 0, ts.NodeBuilderFlags.NoTruncation);
+		}
+		if (!typeNode) throw new ResolverError$1("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;
+		return {
+			deprecated: hasJSDocTag(propertyDeclaration, "deprecated"),
+			default: getInitializerValue(propertyDeclaration.initializer, this.current.typeChecker),
+			description: this.getNodeDescription(propertyDeclaration),
+			example: this.getNodeExample(propertyDeclaration),
+			extensions: this.getNodeExtensions(propertyDeclaration),
+			format: TypeNodeResolver.getNodeFormat(propertyDeclaration),
+			name: identifier.text,
+			required,
+			type,
+			validators: getDeclarationValidators(propertyDeclaration) || {}
+		};
+	}
+	getModelAdditionalProperties(node) {
+		if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
+			const indexMember = node.members.find((member) => member.kind === ts.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);
+			return this.resolveNestedType(indexSignatureDeclaration.type, this.parentNode, this.context);
+		}
+	}
+	typeArgumentsToContext(type, targetEntity, context) {
+		const declaration = this.getModelTypeDeclaration(targetEntity);
+		if (typeof declaration === "undefined" || !("typeParameters" in declaration)) return context;
+		const { typeParameters } = declaration;
+		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];
+			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);
+			this.context = {
+				...this.context,
+				[typeParameter.name.text]: resolvedType
+			};
+		}
+		return context;
+	}
+	getModelInheritedProperties(modelTypeDeclaration) {
+		let properties = [];
+		const { heritageClauses } = modelTypeDeclaration;
+		if (!heritageClauses) return properties;
+		heritageClauses.forEach((clause) => {
+			if (!clause.types) return;
+			clause.types.forEach((t) => {
+				const baseEntityName = t.expression;
+				const resetCtx = this.typeArgumentsToContext(t, baseEntityName, this.context);
+				const referenceType = this.getReferenceType(t);
+				if (referenceType) {
+					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 (isRefObjectType(referenceType)) referenceType.properties.forEach((property) => properties.push(property));
+				}
+				this.context = resetCtx;
+			});
+		});
+		return properties;
+	}
+	getNodeDescription(node) {
+		return getNodeDescription(node, this.current.typeChecker);
+	}
+	static getNodeFormat(node) {
+		return getJSDocTagComment(node, "format");
+	}
+	getNodeExample(node) {
+		const example = getJSDocTagComment(node, "example");
+		if (example) try {
+			return JSON.parse(example);
+		} catch {
+			return example;
+		}
+	}
+	getNodeExtensions(node) {
+		return getNodeExtensions(node, this.current.registry);
+	}
+};
+//#endregion
+//#region src/adapters/typescript/resolver/cache.ts
+var ResolverCache = class {
+	referenceTypes = /* @__PURE__ */ new Map();
+	inProgressTypes = /* @__PURE__ */ new Set();
+	getCachedType(name) {
+		return this.referenceTypes.get(name);
+	}
+	setCachedType(name, type) {
+		this.referenceTypes.set(name, type);
+	}
+	isInProgress(name) {
+		return this.inProgressTypes.has(name);
+	}
+	markInProgress(name) {
+		this.inProgressTypes.add(name);
+	}
+	clearInProgress(name) {
+		this.inProgressTypes.delete(name);
+	}
+	clear() {
+		this.referenceTypes.clear();
+		this.inProgressTypes.clear();
+	}
+};
+//#endregion
+//#region src/adapters/typescript/node-utils/module.ts
+/**
+* Get Decorators for a specific node.
+*
+* @param node
+* @param isMatching
+*/
+function getNodeDecorators(node, isMatching) {
+	if (!canHaveDecorators(node)) return [];
+	const decorators = getDecorators(node);
+	if (typeof decorators === "undefined") return [];
+	const items = decorators.map((d) => {
+		const result = {
+			arguments: [],
+			typeArguments: []
+		};
+		let x = d.expression;
+		if (isCallExpression(x)) {
+			if (x.arguments) result.arguments = x.arguments.map((argument) => {
+				if (isStringLiteral(argument) || isNumericLiteral(argument)) return argument.text;
+				return argument;
+			});
+			if (x.typeArguments) result.typeArguments = x.typeArguments;
+			x = x.expression;
+		}
+		result.text = x.text || x.name.text;
+		return result;
+	});
+	return typeof isMatching === "undefined" ? items : items.filter(isMatching);
+}
+//#endregion
+//#region src/adapters/filesystem/source-files.ts
+async function scanSourceFiles(input) {
+	const sources = Array.isArray(input) ? input : [input];
+	const result = /* @__PURE__ */ new Set();
+	const promises = [];
+	for (const source of sources) if (typeof source === "string") promises.push(locateMany(source));
+	else promises.push(locateMany(source.pattern, { path: source.cwd }));
+	const matches = (await Promise.all(promises)).flat();
+	for (const match of matches) result.add(buildFilePath(match));
+	return Array.from(result);
+}
+//#endregion
+//#region src/adapters/filesystem/tsconfig/module.ts
+async function loadTSConfig(context = {}) {
+	let fileName;
+	let filePath;
+	const cwd = context.cwd || process.cwd();
+	if (typeof context.name === "string") {
+		if (path.isAbsolute(context.name)) filePath = context.name;
+		else filePath = path.resolve(cwd, context.name);
+		fileName = path.basename(filePath);
+	} else {
+		fileName = "tsconfig.json";
+		filePath = path.join(cwd, fileName);
+	}
+	const content = await load(filePath);
+	if (!isObject(content)) throw new ConfigError({
+		message: `The tsconfig file '${filePath}' is malformed.`,
+		code: ConfigErrorCode.TSCONFIG_MALFORMED
+	});
+	if (typeof content.compilerOptions !== "undefined") {
+		const { options: compilerOptions } = convertCompilerOptionsFromJson(content.compilerOptions, cwd, fileName);
+		content.compilerOptions = compilerOptions;
+	}
+	return content;
+}
+async function softLoadTsconfig(context = {}) {
+	try {
+		return await loadTSConfig(context);
+	} catch {
+		return {};
+	}
+}
+//#endregion
+//#region src/adapters/cache/constants.ts
+/**
+* Bump whenever the on-disk cache shape changes incompatibly
+* (Metadata, Controller, Method, Parameter, resolver type nodes,
+* or the cache wrapper itself). Old cache files with a different
+* version are rejected on read.
+*/
+const CACHE_SCHEMA_VERSION = "3";
+const CACHE_FILE_PREFIX = ".trapi-metadata-";
+const CACHE_FILE_SUFFIX = ".json";
+/** 7 days. */
+const CACHE_DEFAULT_MAX_AGE_MS = 10080 * 60 * 1e3;
+//#endregion
+//#region src/adapters/cache/utils.ts
+function buildCacheOptions(input) {
+	if (typeof input === "string") input = {
+		enabled: true,
+		directoryPath: input
+	};
+	if (typeof input === "boolean") input = { enabled: input };
+	input = input || {};
+	let directoryPath = tmpdir();
+	if (typeof input.directoryPath === "string") directoryPath = path.isAbsolute(input.directoryPath) ? input.directoryPath : path.join(process.cwd(), input.directoryPath);
+	return {
+		fileName: input.fileName,
+		directoryPath,
+		enabled: input.enabled ?? true,
+		maxAgeMs: normalizeMaxAgeMs(input.maxAgeMs)
+	};
+}
+function normalizeMaxAgeMs(input) {
+	if (typeof input !== "number" || !Number.isFinite(input) || input < 0) return CACHE_DEFAULT_MAX_AGE_MS;
+	return input;
+}
+/**
+* Combines all key contributors into a single sha256 hex string. The order is
+* stable; each part is null-separated to avoid concatenation ambiguity.
+*/
+function composeCacheKey(parts) {
+	const hash = crypto.createHash("sha256");
+	hash.update(parts.schemaVersion);
+	hash.update("\0");
+	hash.update(parts.sourceFilesHash);
+	hash.update("\0");
+	hash.update(parts.compilerOptionsHash);
+	hash.update("\0");
+	hash.update(parts.registryHash);
+	hash.update("\0");
+	hash.update(parts.presetName ?? "");
+	return hash.digest("hex");
+}
+/**
+* Hash a stable JSON projection of `compilerOptions`. Sorting keys keeps the
+* output deterministic regardless of declaration order in tsconfig.json.
+*/
+function hashCompilerOptions(options) {
+	const hash = crypto.createHash("sha256");
+	hash.update(stableStringify(options ?? {}));
+	return hash.digest("hex");
+}
+/**
+* Hash the resolved registry's structural shape. Catches structural changes
+* (handler added/removed/renamed, marker changed, replaces policy changed)
+* AND most logic changes via `apply.toString()`. Misses changes that are
+* purely captured-variable shifts in factory-built handlers — acceptable
+* trade-off for catching local preset edits.
+*/
+function hashRegistry(registry) {
+	const hash = crypto.createHash("sha256");
+	for (const kind of [
+		"controllers",
+		"methods",
+		"parameters",
+		"controllerJsDoc",
+		"methodJsDoc",
+		"parameterJsDoc"
+	]) {
+		hash.update(kind);
+		hash.update("\0");
+		const handlers = registry[kind] ?? [];
+		for (const handler of handlers) {
+			hash.update(stableStringify(handler.match));
+			hash.update("\0");
+			hash.update(stableStringify(handler.marker ?? null));
+			hash.update("\0");
+			hash.update(String(handler.replaces ?? ""));
+			hash.update("\0");
+			hash.update(handler.apply.toString());
+			hash.update("\0");
+		}
+		hash.update("
");
+	}
+	return hash.digest("hex");
+}
+/**
+* JSON.stringify with sorted object keys at every level. Functions and
+* undefined are omitted as usual; that's fine for the inputs we hash here.
+*/
+function stableStringify(value) {
+	return JSON.stringify(value, (_key, val) => {
+		if (val && typeof val === "object" && !Array.isArray(val)) {
+			const sorted = {};
+			for (const k of Object.keys(val).sort()) sorted[k] = val[k];
+			return sorted;
+		}
+		return val;
+	});
+}
+//#endregion
+//#region src/adapters/cache/client.ts
+var CacheClient = class {
+	options;
+	constructor(input) {
+		this.options = buildCacheOptions(input);
+	}
+	async save(data) {
+		if (!this.options.enabled) return;
+		await this.ensureDirectory();
+		const filePath = this.resolveFilePath(data.cacheKey);
+		const payload = stringify(data);
+		const tmpPath = `${filePath}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+		try {
+			await fs.promises.writeFile(tmpPath, payload);
+			await fs.promises.rename(tmpPath, filePath);
+		} catch (err) {
+			try {
+				await fs.promises.unlink(tmpPath);
+			} catch {}
+			throw err;
+		}
+		this.evict().catch(() => void 0);
+		return filePath;
+	}
+	async get(cacheKey) {
+		if (!this.options.enabled) return;
+		const filePath = this.resolveFilePath(cacheKey);
+		let content;
+		try {
+			content = await fs.promises.readFile(filePath, { encoding: "utf-8" });
+		} catch {
+			return;
+		}
+		let cache;
+		try {
+			cache = parse(content);
+		} catch {
+			await fs.promises.unlink(filePath).catch(() => void 0);
+			return;
+		}
+		if (!cache || cache.cacheKey !== cacheKey || cache.schemaVersion !== "3") return;
+		return cache;
+	}
+	/**
+	* Prune cache files older than `maxAgeMs`. No-op when disabled or when
+	* `maxAgeMs <= 0`. Each unlink is best-effort — a concurrent generator
+	* may have already removed the file.
+	*/
+	async evict() {
+		if (!this.options.enabled || this.options.maxAgeMs <= 0) return;
+		const pattern = this.options.fileName ?? `.trapi-metadata-*.json`;
+		let entries;
+		try {
+			entries = await locateMany(pattern, { path: this.options.directoryPath });
+		} catch {
+			return;
+		}
+		const cutoff = Date.now() - this.options.maxAgeMs;
+		await Promise.all(entries.map(async (entry) => {
+			const filePath = buildFilePath(entry);
+			try {
+				if ((await fs.promises.stat(filePath)).mtimeMs < cutoff) await fs.promises.unlink(filePath);
+			} catch {}
+		}));
+	}
+	resolveFilePath(cacheKey) {
+		if (!CACHE_KEY_PATTERN.test(cacheKey)) throw new Error(`Invalid cacheKey: must match ${CACHE_KEY_PATTERN}`);
+		const fileName = this.options.fileName ?? `.trapi-metadata-${cacheKey}.json`;
+		return path.join(this.options.directoryPath, fileName);
+	}
+	async ensureDirectory() {
+		await fs.promises.mkdir(this.options.directoryPath, { recursive: true });
+	}
+};
+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",
+	"post",
+	"put",
+	"patch",
+	"get"
+]);
+const SUPPORTED_LEAF_TYPES = new Set([
+	"string",
+	"integer",
+	"long",
+	"float",
+	"double",
+	"date",
+	"datetime",
+	"buffer",
+	"boolean",
+	"enum"
+]);
+var ParameterGenerator = class {
+	parameter;
+	method;
+	paths;
+	current;
+	constructor(parameter, method, paths, current) {
+		this.parameter = parameter;
+		this.method = method;
+		this.paths = paths.length === 0 ? [""] : paths;
+		this.current = current;
+	}
+	generate() {
+		const parameterName = this.getParameterName();
+		const draft = newParameterDraft({ parameterName });
+		const options = this.applyOptions(parameterName);
+		applyDecoratorHandlers(this.parameter, this.current.registry.parameters, draft, options);
+		applyJsDocHandlers(this.parameter, this.current.registry.parameterJsDoc, draft, options);
+		const type = this.resolveType();
+		draft.type = type;
+		const description = this.getDescription();
+		if (description) draft.description = description;
+		if (draft.deprecated === void 0 && hasJSDocTag(this.parameter, "deprecated")) draft.deprecated = true;
+		const defaultValue = getInitializerValue(this.parameter.initializer, this.current.typeChecker, type);
+		if (defaultValue !== void 0) draft.default = defaultValue;
+		draft.required = !this.parameter.questionToken && !this.parameter.initializer;
+		const { examples, exampleLabels } = this.getJsDocExamples(parameterName);
+		if (examples) {
+			draft.examples = examples.map((value) => ({ value }));
+			draft.exampleLabels = (exampleLabels ?? []).filter((l) => l !== void 0);
+		}
+		Object.assign(draft.validators, getDeclarationValidators(this.parameter, parameterName));
+		if (!draft.in) {
+			if (!BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError$1.methodUnsupported({
+				decoratorName: "Body",
+				propertyName: parameterName,
+				method: this.method,
+				node: this.parameter
+			});
+			draft.in = ParamKind.Body;
+		}
+		if ((draft.in === ParamKind.Body || draft.in === ParamKind.BodyProp) && !BODY_SUPPORTED_METHODS.has(this.method)) throw ParameterError$1.methodUnsupported({
+			decoratorName: "Body",
+			propertyName: draft.name,
+			method: this.method,
+			node: this.parameter
+		});
+		return this.finalize(draft, type, parameterName, examples, exampleLabels);
+	}
+	finalize(draft, type, parameterName, examples, exampleLabels) {
+		const kind = draft.in;
+		const wrappedExamples = examples ? examples.map((value) => ({ value })) : void 0;
+		const filteredLabels = exampleLabels?.filter((l) => l !== void 0);
+		if ((kind === ParameterSource.QUERY || kind === ParameterSource.PATH) && (isNestedObjectLiteralType(type) || isRefObjectType(type))) {
+			const decomposed = this.decomposeObject(type, {
+				in: kind === ParameterSource.QUERY ? ParameterSource.QUERY_PROP : ParameterSource.PATH,
+				examples: wrappedExamples,
+				exampleLabels: filteredLabels,
+				extensions: draft.extensions
+			});
+			if (kind === ParameterSource.PATH) this.validatePathDecomposition(decomposed);
+			return decomposed;
+		}
+		if ((kind === ParameterSource.QUERY || kind === ParameterSource.QUERY_PROP) && isArrayType(type)) {
+			if (!this.isLeafTypeSupported(type.elementType)) throw ParameterError$1.typeUnsupported({
+				decoratorName: kind === ParameterSource.QUERY ? "Query" : "QueryProp",
+				propertyName: draft.name,
+				type: type.elementType,
+				node: this.parameter
+			});
+			return [{
+				...this.draftToParameter(draft),
+				collectionFormat: draft.collectionFormat ?? CollectionFormat.MULTI,
+				type
+			}];
+		}
+		if ((kind === ParameterSource.QUERY || kind === ParameterSource.QUERY_PROP) && !this.isLeafOrEnumOrUnion(type)) throw ParameterError$1.typeUnsupported({
+			decoratorName: kind === ParameterSource.QUERY ? "Query" : "QueryProp",
+			propertyName: draft.name,
+			type,
+			node: this.parameter
+		});
+		if (kind === ParameterSource.PATH) this.validatePathName(draft.name, parameterName);
+		return [this.draftToParameter(draft)];
+	}
+	draftToParameter(draft) {
+		return {
+			allowEmptyValue: draft.allowEmptyValue,
+			collectionFormat: draft.collectionFormat,
+			default: draft.default,
+			description: draft.description,
+			examples: draft.examples.length > 0 ? draft.examples : void 0,
+			exampleLabels: draft.exampleLabels.length > 0 ? draft.exampleLabels : void 0,
+			extensions: draft.extensions,
+			in: draft.in,
+			maxItems: draft.maxItems,
+			minItems: draft.minItems,
+			name: draft.name,
+			parameterName: draft.parameterName,
+			required: draft.required,
+			type: draft.type,
+			deprecated: draft.deprecated,
+			validators: draft.validators
+		};
+	}
+	decomposeObject(type, details) {
+		if (type.properties.length === 0) return [];
+		const parameterName = this.getParameterName();
+		const initializerValue = getInitializerValue(this.parameter.initializer, this.current.typeChecker, type);
+		const description = this.getDescription();
+		const isParamOptional = !!this.parameter.questionToken;
+		const isParamDeprecated = hasJSDocTag(this.parameter, "deprecated");
+		const output = [];
+		for (const property of type.properties) {
+			let propertyDefaultValue = property.default;
+			if (typeof propertyDefaultValue === "undefined" && isObject(initializerValue)) propertyDefaultValue = initializerValue[property.name];
+			const required = isParamOptional ? false : property.required;
+			output.push({
+				extensions: [...details.extensions],
+				in: details.in,
+				examples: details.examples,
+				exampleLabels: details.exampleLabels,
+				default: propertyDefaultValue,
+				description: property.description || description,
+				name: property.name,
+				parameterName,
+				required,
+				type: property.type,
+				deprecated: property.deprecated || isParamDeprecated,
+				validators: {}
+			});
+		}
+		return output;
+	}
+	pathContainsParam(name) {
+		const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const colonPattern = new RegExp(`:${escaped}\\b`);
+		const bracePattern = `{${name}}`;
+		for (const p of this.paths) if (p.includes(bracePattern) || colonPattern.test(p)) return true;
+		return false;
+	}
+	validatePathDecomposition(decomposed) {
+		for (const element of decomposed) if (!this.pathContainsParam(element.name)) throw ParameterError$1.invalidPathMatch({
+			decoratorName: "Path",
+			propertyName: element.name,
+			path: this.paths.join(" | "),
+			node: this.parameter
+		});
+	}
+	validatePathName(name, parameterName) {
+		const candidate = name || parameterName;
+		if (!this.pathContainsParam(candidate)) throw ParameterError$1.invalidPathMatch({
+			decoratorName: "Path",
+			propertyName: candidate,
+			path: this.paths.join(" | "),
+			node: this.parameter
+		});
+	}
+	isLeafTypeSupported(type) {
+		return SUPPORTED_LEAF_TYPES.has(type.typeName);
+	}
+	isLeafOrEnumOrUnion(type) {
+		return SUPPORTED_LEAF_TYPES.has(type.typeName) || isRefEnumType(type) || isUnionType(type);
+	}
+	resolveType() {
+		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);
+		}
+		if (!typeNode) throw new ParameterError$1({ 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." });
+		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);
+		}
+		return "";
+	}
+	getJsDocExamples(parameterName) {
+		const exampleLabels = [];
+		const examples = getJSDocTags(this.parameter.parent, (tag) => {
+			const comment = transformJSDocComment(tag.comment);
+			const isExample = (tag.tagName.text === "example" || tag.tagName.escapedText === "example") && !!comment && comment.startsWith(parameterName);
+			if (isExample && comment) {
+				const hasExampleLabel = (comment.split(" ")[0].indexOf(".") || -1) > 0;
+				exampleLabels.push(hasExampleLabel ? comment.split(" ")[0].split(".").slice(1).join(".") : void 0);
+			}
+			return isExample ?? false;
+		}).map((tag) => (transformJSDocComment(tag.comment) || "").replace(`${transformJSDocComment(tag.comment)?.split(" ")[0] || ""}`, "").replace(/\r/g, ""));
+		if (examples.length === 0) return {
+			examples: void 0,
+			exampleLabels: void 0
+		};
+		try {
+			return {
+				examples: examples.map((example) => JSON.parse(example)),
+				exampleLabels
+			};
+		} catch {
+			throw ParameterError$1.invalidExampleSchema();
+		}
+	}
+	applyOptions(parameterName) {
+		return {
+			target: "parameter",
+			host: {
+				name: parameterName,
+				parentName: this.method
+			},
+			resolveTypeNode: (n) => new TypeNodeResolver(n, this.current).resolve(),
+			typeChecker: this.current.typeChecker,
+			parameterType: () => this.parameter.type ? new TypeNodeResolver(this.parameter.type, this.current).resolve() : void 0,
+			onUnmatchedDecorator: this.current.config.strict || this.current.config.onUnmatchedDecorator ? (report) => this.current.reportUnmatchedDecorator?.(report) : void 0
+		};
+	}
+};
+//#endregion
+//#region src/app/generator/method/module.ts
+var MethodGenerator = class {
+	node;
+	current;
+	constructor(node, current) {
+		this.node = node;
+		this.current = current;
+	}
+	getMethodName() {
+		return this.node.name.text;
+	}
+	generate(controllerPaths) {
+		const name = this.getMethodName();
+		const draft = newMethodDraft({ name });
+		const options = this.applyOptions();
+		applyDecoratorHandlers(this.node, this.current.registry.methods, draft, options);
+		applyJsDocHandlers(this.node, this.current.registry.methodJsDoc, draft, options);
+		if (!draft.verb) return null;
+		if (draft.hidden) return null;
+		const returnType = this.resolveReturnType();
+		const defaultResponse = buildDefaultResponse(returnType, draft.defaultResponseExamples);
+		const responses = mergeDefaultResponse(draft.responses, defaultResponse);
+		const parameters = this.buildParameters(controllerPaths, draft.path, draft.verb);
+		const description = getJSDocDescription(this.node) ?? draft.description;
+		const summary = draft.summary ?? getJSDocTagComment(this.node, "summary");
+		return {
+			consumes: draft.consumes,
+			deprecated: draft.deprecated ?? false,
+			description: description ?? "",
+			extensions: draft.extensions,
+			hidden: draft.hidden,
+			method: draft.verb,
+			name,
+			path: normalizePath(draft.path),
+			produces: draft.produces,
+			responses,
+			security: draft.security,
+			summary,
+			tags: draft.tags,
+			type: returnType,
+			parameters
+		};
+	}
+	applyOptions() {
+		const parentName = this.node.parent.name?.text;
+		return {
+			target: "method",
+			host: {
+				name: this.getMethodName(),
+				parentName
+			},
+			resolveTypeNode: (n) => new TypeNodeResolver(n, this.current).resolve(),
+			typeChecker: this.current.typeChecker,
+			onUnmatchedDecorator: this.current.config.strict || this.current.config.onUnmatchedDecorator ? (report) => this.current.reportUnmatchedDecorator?.(report) : void 0
+		};
+	}
+	resolveReturnType() {
+		let nodeType = this.node.type;
+		if (!nodeType) {
+			const { typeChecker } = this.current;
+			const signature = typeChecker.getSignatureFromDeclaration(this.node);
+			const implicitType = typeChecker.getReturnTypeOfSignature(signature);
+			nodeType = typeChecker.typeToTypeNode(implicitType, void 0, NodeBuilderFlags.NoTruncation);
+		}
+		return new TypeNodeResolver(nodeType, this.current).resolve();
+	}
+	buildParameters(controllerPaths, methodPath, verb) {
+		const controllerId = this.node.parent.name;
+		const methodId = this.node.name;
+		const fullPaths = (controllerPaths.length === 0 ? [""] : controllerPaths).map((cp) => path.posix.join("/", cp, methodPath));
+		const output = [];
+		let bodyParameterCount = 0;
+		let formParameterCount = 0;
+		for (let i = 0; i < this.node.parameters.length; i++) try {
+			const parameters = new ParameterGenerator(this.node.parameters[i], verb, fullPaths, this.current).generate();
+			for (const parameter of parameters) {
+				if (parameter.in === ParameterSource.BODY) bodyParameterCount += 1;
+				if (parameter.in === ParameterSource.FORM_DATA) formParameterCount += 1;
+				if (parameter.in !== ParameterSource.CONTEXT) output.push(parameter);
+			}
+		} catch (e) {
+			const causeMsg = e instanceof Error ? `: ${e.message}` : "";
+			throw new GeneratorError$1({
+				message: `Parameter generation failed for '${controllerId.text}.${methodId.text}' argument index ${i}${causeMsg}`,
+				code: GeneratorErrorCode$1.PARAMETER_GENERATION_FAILED,
+				cause: e
+			});
+		}
+		if (bodyParameterCount > 1) throw new GeneratorError$1({
+			message: `Only one body parameter allowed in '${controllerId.text}.${methodId.text}' method.`,
+			code: GeneratorErrorCode$1.BODY_PARAMETER_DUPLICATE
+		});
+		if (bodyParameterCount > 0 && formParameterCount > 0) throw new GeneratorError$1({
+			message: `Cannot mix body and form parameters in '${controllerId.text}.${methodId.text}' method.`,
+			code: GeneratorErrorCode$1.BODY_FORM_CONFLICT
+		});
+		return output;
+	}
+};
+function buildDefaultResponse(returnType, examples) {
+	const isVoid = isVoidType(returnType);
+	return {
+		description: isVoid ? "No content" : "Ok",
+		examples,
+		schema: returnType,
+		status: isVoid ? "204" : "200",
+		name: isVoid ? "204" : "200"
+	};
+}
+function mergeDefaultResponse(handlerResponses, defaultResponse) {
+	if (handlerResponses.length === 0) return [defaultResponse];
+	const existing = handlerResponses.findIndex((r) => r.status === defaultResponse.status);
+	if (existing >= 0) {
+		const target = handlerResponses[existing];
+		if (defaultResponse.examples && defaultResponse.examples.length > 0 && (!target.examples || target.examples.length === 0)) target.examples = defaultResponse.examples;
+		return handlerResponses;
+	}
+	return [...handlerResponses, defaultResponse];
+}
+//#endregion
+//#region src/app/generator/controller/module.ts
+var ControllerGenerator = class {
+	node;
+	current;
+	constructor(node, current) {
+		this.node = node;
+		this.current = current;
+	}
+	isValid() {
+		return !!this.node.name;
+	}
+	generate() {
+		if (!this.node.parent) throw new GeneratorError$1({
+			message: "Controller node doesn't have a valid parent source file.",
+			code: GeneratorErrorCode$1.CONTROLLER_NO_SOURCE_FILE
+		});
+		if (!this.node.name) throw new GeneratorError$1({
+			message: "Controller node doesn't have a valid name.",
+			code: GeneratorErrorCode$1.CONTROLLER_NO_NAME
+		});
+		const sourceFile = this.node.parent.getSourceFile();
+		const draft = newControllerDraft({
+			name: this.node.name.text,
+			location: sourceFile.fileName
+		});
+		const options = this.applyOptions();
+		applyDecoratorHandlers(this.node, this.current.registry.controllers, draft, options);
+		applyJsDocHandlers(this.node, this.current.registry.controllerJsDoc, draft, options);
+		if (draft.paths === void 0) return null;
+		const normalized = (draft.paths.length === 0 ? [""] : draft.paths).map(normalizePath);
+		const paths = [...new Set(normalized)];
+		const methods = this.buildMethods(paths);
+		return {
+			consumes: draft.consumes,
+			deprecated: draft.deprecated,
+			extensions: draft.extensions,
+			hidden: draft.hidden,
+			location: draft.location,
+			name: draft.name,
+			paths,
+			produces: draft.produces,
+			responses: draft.responses,
+			security: draft.security,
+			tags: draft.tags,
+			methods
+		};
+	}
+	applyOptions() {
+		return {
+			target: "class",
+			host: { name: this.node.name.text },
+			resolveTypeNode: (n) => new TypeNodeResolver(n, this.current).resolve(),
+			typeChecker: this.current.typeChecker,
+			onUnmatchedDecorator: this.current.config.strict || this.current.config.onUnmatchedDecorator ? (report) => this.current.reportUnmatchedDecorator?.(report) : void 0
+		};
+	}
+	buildMethods(controllerPaths) {
+		const set = /* @__PURE__ */ new Set();
+		const output = [];
+		for (const member of this.node.members) {
+			if (!isMethodDeclaration(member)) continue;
+			const generator = new MethodGenerator(member, this.current);
+			const methodName = generator.getMethodName();
+			if (set.has(methodName)) continue;
+			const method = generator.generate(controllerPaths);
+			if (!method) continue;
+			set.add(methodName);
+			output.push(method);
+		}
+		const inheritedMethods = this.collectInheritedMethodDeclarations(this.node);
+		for (const node of inheritedMethods) {
+			const generator = new MethodGenerator(node, this.current);
+			const methodName = generator.getMethodName();
+			if (set.has(methodName)) continue;
+			try {
+				const method = generator.generate(controllerPaths);
+				if (!method) continue;
+				set.add(methodName);
+				output.push(method);
+			} catch (error) {
+				if (isResolverError$1(error) || isGeneratorError$1(error) && error.code === GeneratorErrorCode$1.PARAMETER_GENERATION_FAILED) continue;
+				throw error;
+			}
+		}
+		return output;
+	}
+	collectInheritedMethodDeclarations(node) {
+		const methods = [];
+		if (!node.heritageClauses) return methods;
+		for (const clause of node.heritageClauses) {
+			if (clause.token !== SyntaxKind.ExtendsKeyword) continue;
+			for (const type of clause.types) {
+				const baseDeclaration = this.resolveBaseClassDeclaration(type.expression);
+				if (!baseDeclaration) continue;
+				for (const member of baseDeclaration.members) if (isMethodDeclaration(member)) methods.push(member);
+				methods.push(...this.collectInheritedMethodDeclarations(baseDeclaration));
+			}
+		}
+		return methods;
+	}
+	resolveBaseClassDeclaration(expression) {
+		let symbol = this.current.typeChecker.getSymbolAtLocation(expression);
+		if (!symbol) return;
+		if (symbol.flags & SymbolFlags.Alias) symbol = this.current.typeChecker.getAliasedSymbol(symbol);
+		const declarations = symbol.getDeclarations();
+		if (!declarations || declarations.length === 0) return;
+		const declaration = declarations[0];
+		if (isClassDeclaration(declaration)) return declaration;
+	}
+};
+//#endregion
+//#region src/app/generator/metadata/module.ts
+var MetadataGenerator = class {
+	nodes;
+	typeChecker;
+	registry;
+	resolverCache;
+	config;
+	program;
+	cache;
+	controllers;
+	referenceTypes = {};
+	circularDependencyResolvers = new Array();
+	unmatchedDecorators = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.nodes = [];
+		this.config = context.options;
+		this.cache = new CacheClient(context.options.cache);
+		this.registry = createRegistry();
+		this.resolverCache = new ResolverCache();
+		this.program = createProgram(context.sourceFiles, context.compilerOptions || {});
+		this.typeChecker = this.program.getTypeChecker();
+	}
+	async generate() {
+		const sourceFilesHash = this.buildNodesFromSourceFiles();
+		if (this.config.preset) this.registry = await loadRegistryByName(this.config.preset);
+		const cacheKey = composeCacheKey({
+			schemaVersion: "3",
+			sourceFilesHash,
+			compilerOptionsHash: hashCompilerOptions(this.program.getCompilerOptions()),
+			registryHash: hashRegistry(this.registry),
+			presetName: this.config.preset
+		});
+		const bypassCache = !!(this.config.strict || this.config.onUnmatchedDecorator);
+		let cache = bypassCache ? void 0 : await this.cache.get(cacheKey);
+		if (!cache) {
+			this.buildControllers();
+			this.assertPresetProducedControllers();
+			this.circularDependencyResolvers.forEach((resolve) => resolve(this.referenceTypes));
+			cache = {
+				controllers: this.controllers,
+				referenceTypes: this.referenceTypes,
+				cacheKey,
+				schemaVersion: "3"
+			};
+			if (!bypassCache) await this.cache.save(cache);
+		}
+		if (this.config.strict || this.config.onUnmatchedDecorator) this.dispatchUnmatchedDecoratorReports();
+		return {
+			controllers: cache.controllers,
+			referenceTypes: cache.referenceTypes
+		};
+	}
+	assertPresetProducedControllers() {
+		if (this.config.preset || this.controllers.length > 0) return;
+		if (this.nodes.length === 0) return;
+		throw new ConfigError({
+			message: "No preset configured and no controllers detected. Provide `preset: '@trapi/preset-decorators-express'` (or another preset) so handlers can match your decorators.",
+			code: ConfigErrorCode.PRESET_MISSING
+		});
+	}
+	reportUnmatchedDecorator(report) {
+		const key = `${report.target}:${report.name}`;
+		const existing = this.unmatchedDecorators.get(key);
+		if (existing) {
+			existing.push(report);
+			return;
+		}
+		this.unmatchedDecorators.set(key, [report]);
+	}
+	dispatchUnmatchedDecoratorReports() {
+		if (this.unmatchedDecorators.size === 0) return;
+		const flat = [];
+		for (const reports of this.unmatchedDecorators.values()) flat.push(...reports);
+		if (this.config.onUnmatchedDecorator) {
+			this.config.onUnmatchedDecorator(flat);
+			return;
+		}
+		const summary = this.formatUnmatchedSummary();
+		if (this.config.strict === "throw") throw new GeneratorError$1({
+			message: summary,
+			code: GeneratorErrorCode$1.STRICT_UNMATCHED_DECORATORS
+		});
+		console.warn(summary);
+	}
+	formatUnmatchedSummary() {
+		const lines = ["[trapi] strict mode: decorators with no matching handler:"];
+		for (const reports of this.unmatchedDecorators.values()) {
+			const first = reports[0];
+			const occurrences = reports.length;
+			const location = `${first.file}:${first.line}`;
+			const suffix = occurrences > 1 ? ` (${occurrences} occurrences; first at ${location})` : ` (${location})`;
+			lines.push(`  - @${first.name} on ${first.target} '${first.host.name}'${suffix}`);
+		}
+		return lines.join("\n");
+	}
+	buildNodesFromSourceFiles() {
+		const hash = crypto.createHash("sha256");
+		this.program.getSourceFiles().forEach((sf) => {
+			if (this.isIgnoredPath(sf.fileName) && !this.isAllowedPath(sf.fileName)) return;
+			hash.update(sf.fileName);
+			hash.update("\0");
+			hash.update(sf.text);
+			hash.update("\0");
+			forEachChild(sf, (node) => {
+				if (isModuleDeclaration(node)) {
+					/**
+					* For some reason unknown to me, TS resolves both `declare module` and `namespace` to
+					* the same kind (`ModuleDeclaration`). In order to figure out whether it's one or the other,
+					* we check the node flags. They tell us whether it is a namespace or not.
+					*/
+					if ((node.flags & NodeFlags.Namespace) === 0 && node.body && isModuleBlock(node.body)) {
+						node.body.statements.forEach((statement) => {
+							this.nodes.push(statement);
+						});
+						return;
+					}
+				}
+				this.nodes.push(node);
+			});
+		});
+		return hash.digest("hex");
+	}
+	/**
+	* Check if the source file path is in the ignored path list.
+	*
+	* @param filePath
+	* @protected
+	*/
+	isIgnoredPath(filePath) {
+		if (typeof this.config.ignore === "undefined") return false;
+		return this.config.ignore.some((item) => minimatch(filePath, item));
+	}
+	/**
+	* Check if the source file path is in the ignored path list.
+	*
+	* @param filePath
+	* @protected
+	*/
+	isAllowedPath(filePath) {
+		if (typeof this.config.allow === "undefined") return false;
+		return this.config.allow.some((item) => minimatch(filePath, item));
+	}
+	isExportedNode(_node) {
+		return true;
+	}
+	addReferenceType(referenceType) {
+		if (!referenceType.refName) return;
+		this.referenceTypes[referenceType.refName] = referenceType;
+	}
+	getReferenceType(refName) {
+		return this.referenceTypes[refName];
+	}
+	registerDependencyResolver(callback) {
+		this.circularDependencyResolvers.push(callback);
+	}
+	buildControllers() {
+		this.controllers = [];
+		for (let i = 0; i < this.nodes.length; i++) {
+			const node = this.nodes[i];
+			if (!isClassDeclaration(node)) continue;
+			const generator = new ControllerGenerator(node, this);
+			if (!generator.isValid()) continue;
+			const controller = generator.generate();
+			if (controller) this.controllers.push(controller);
+		}
+	}
+};
+//#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;
+	if (options.tsconfig) {
+		let { tsconfig } = options;
+		if (typeof tsconfig === "string") {
+			tsconfig = await softLoadTsconfig({ name: tsconfig });
+			compilerOptions = tsconfig.compilerOptions;
+		} else compilerOptions = tsconfig.compilerOptions || {};
+	}
+	return new MetadataGenerator({
+		sourceFiles: await scanSourceFiles(options.entryPoint),
+		compilerOptions,
+		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, 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 };
+
+//# sourceMappingURL=index.mjs.map