@trapi/metadata 1.3.0 → 2.0.0-beta.1

package/dist/index.d.mts

@@ -0,0 +1,1819 @@
+import { BaseError } from "@ebec/core";
+import * as ts from "typescript";
+import { ClassDeclaration, CompilerOptions, EnumDeclaration, EnumMember, Expression, JSDoc, JSDocComment, JSDocTag, MethodDeclaration, Node, NodeArray, ParameterDeclaration, PropertyDeclaration, PropertySignature, SyntaxKind, TypeAliasDeclaration, TypeChecker, TypeNode } from "typescript";
+import { Container } from "validup";
+import { z } from "zod";
+
+//#region src/core/validator/types.d.ts
+interface ValidatorMeta {}
+type Validator = {
+  value?: unknown;
+  message?: string;
+  meta?: ValidatorMeta;
+};
+type Validators = Record<string, Validator>;
+//#endregion
+//#region src/core/resolver/constants.d.ts
+declare enum TypeName {
+  STRING = "string",
+  BOOLEAN = "boolean",
+  BIGINT = "bigint",
+  DOUBLE = "double",
+  FLOAT = "float",
+  FILE = "file",
+  INTEGER = "integer",
+  LONG = "long",
+  ENUM = "enum",
+  ARRAY = "array",
+  DATETIME = "datetime",
+  DATE = "date",
+  BINARY = "binary",
+  BUFFER = "buffer",
+  BYTE = "byte",
+  VOID = "void",
+  OBJECT = "object",
+  ANY = "any",
+  UNDEFINED = "undefined",
+  NEVER = "never",
+  REF_ENUM = "refEnum",
+  REF_OBJECT = "refObject",
+  REF_ALIAS = "refAlias",
+  NESTED_OBJECT_LITERAL = "nestedObjectLiteral",
+  UNION = "union",
+  INTERSECTION = "intersection",
+  TUPLE = "tuple"
+}
+declare enum UtilityTypeName {
+  NON_NULLABLE = "NonNullable",
+  OMIT = "Omit",
+  PARTIAL = "Partial",
+  READONLY = "Readonly",
+  RECORD = "Record",
+  REQUIRED = "Required",
+  PICK = "Pick",
+  EXTRACT = "Extract",
+  EXCLUDE = "Exclude",
+  RETURN_TYPE = "ReturnType",
+  PARAMETERS = "Parameters",
+  AWAITED = "Awaited",
+  INSTANCE_TYPE = "InstanceType",
+  CONSTRUCTOR_PARAMETERS = "ConstructorParameters"
+}
+//#endregion
+//#region src/core/resolver/extension.d.ts
+type Extension = {
+  key: string;
+  value: ExtensionType | ExtensionType[];
+};
+type ExtensionType = string | number | boolean | null | ExtensionType[] | {
+  [name: string]: ExtensionType | ExtensionType[];
+};
+//#endregion
+//#region src/core/resolver/types.d.ts
+type Type = PrimitiveType | ObjectType | EnumType | ArrayType | FileType | DateTimeType | DateType | BinaryType | BufferType | ByteType | AnyType | UndefinedType | NeverType | RefEnumType | RefObjectType | RefAliasType | NestedObjectLiteralType | UnionType | IntersectionType | TupleType | VoidType;
+type BaseType = {
+  typeName: `${TypeName}`;
+};
+type AnyType = BaseType & {
+  typeName: `${TypeName.ANY}`;
+};
+type UndefinedType = BaseType & {
+  typeName: `${TypeName.UNDEFINED}`;
+};
+type StringType = BaseType & {
+  typeName: `${TypeName.STRING}`;
+};
+type BooleanType = BaseType & {
+  typeName: `${TypeName.BOOLEAN}`;
+};
+type BigintType = BaseType & {
+  typeName: `${TypeName.BIGINT}`;
+};
+type DoubleType = BaseType & {
+  typeName: `${TypeName.DOUBLE}`;
+};
+type FloatType = BaseType & {
+  typeName: `${TypeName.FLOAT}`;
+};
+type IntegerType = BaseType & {
+  typeName: `${TypeName.INTEGER}`;
+};
+type LongType = BaseType & {
+  typeName: `${TypeName.LONG}`;
+};
+type VoidType = BaseType & {
+  typeName: `${TypeName.VOID}`;
+};
+type NeverType = BaseType & {
+  typeName: `${TypeName.NEVER}`;
+};
+type DateType = BaseType & {
+  typeName: `${TypeName.DATE}`;
+};
+type FileType = BaseType & {
+  typeName: `${TypeName.FILE}`;
+};
+type DateTimeType = BaseType & {
+  typeName: `${TypeName.DATETIME}`;
+};
+type BinaryType = BaseType & {
+  typeName: `${TypeName.BINARY}`;
+};
+type BufferType = BaseType & {
+  typeName: `${TypeName.BUFFER}`;
+};
+type ByteType = BaseType & {
+  typeName: `${TypeName.BYTE}`;
+};
+type ObjectType = BaseType & {
+  typeName: `${TypeName.OBJECT}`;
+};
+type EnumType = BaseType & {
+  members: Array<string | number | boolean | null>;
+  typeName: `${TypeName.ENUM}`;
+};
+type ArrayType = BaseType & {
+  elementType: Type;
+  typeName: `${TypeName.ARRAY}`;
+};
+type NestedObjectLiteralType = BaseType & {
+  typeName: `${TypeName.NESTED_OBJECT_LITERAL}`;
+  properties: ResolverProperty[];
+  additionalProperties?: Type;
+};
+type IntersectionType = BaseType & {
+  typeName: `${TypeName.INTERSECTION}`;
+  members: Type[];
+};
+type UnionType = BaseType & {
+  typeName: `${TypeName.UNION}`;
+  members: Type[];
+};
+type TupleElement = {
+  type: Type;
+  name?: string;
+};
+type TupleType = BaseType & {
+  typeName: `${TypeName.TUPLE}`;
+  elements: TupleElement[];
+};
+type ReferenceType = RefEnumType | RefObjectType | RefAliasType;
+type ReferenceTypes = Record<string, ReferenceType>;
+type DependencyResolver = (referenceTypes: ReferenceTypes) => void;
+type ReferenceTypeBase = BaseType & {
+  description?: string;
+  typeName: `${TypeName.REF_ALIAS}` | `${TypeName.REF_ENUM}` | `${TypeName.REF_OBJECT}`;
+  refName: string;
+  example?: unknown;
+  deprecated: boolean;
+};
+type RefEnumType = ReferenceTypeBase & {
+  typeName: `${TypeName.REF_ENUM}`;
+  members: Array<string | number | boolean>;
+  memberNames?: string[];
+};
+type RefObjectType = ReferenceTypeBase & {
+  typeName: `${TypeName.REF_OBJECT}`;
+  properties: ResolverProperty[];
+  additionalProperties?: Type;
+};
+type RefAliasType = Omit<ResolverProperty, 'name' | 'required'> & ReferenceTypeBase & {
+  typeName: `${TypeName.REF_ALIAS}`;
+};
+type PrimitiveType = AnyType | BinaryType | BooleanType | BufferType | ByteType | DateType | DateTimeType | DoubleType | FloatType | FileType | BigintType | IntegerType | LongType | ObjectType | StringType | UndefinedType;
+type ResolverProperty = {
+  default?: any;
+  format?: string;
+  example?: unknown;
+  validators?: Record<string, Validator>;
+  description?: string;
+  name: string;
+  type: Type;
+  required: boolean;
+  deprecated: boolean;
+  extensions?: Extension[];
+};
+/**
+ * Cache interface for the resolver's type cache.
+ */
+interface IResolverCache {
+  getCachedType(name: string): ReferenceType | undefined;
+  setCachedType(name: string, type: ReferenceType): void;
+  isInProgress(name: string): boolean;
+  markInProgress(name: string): void;
+  clearInProgress(name: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/core/resolver/type-guards.d.ts
+declare function isAnyType(param: BaseType): param is AnyType;
+declare function isUndefinedType(param: BaseType): param is UndefinedType;
+declare function isStringType(param: BaseType): param is StringType;
+declare function isBooleanType(param: BaseType): param is BooleanType;
+declare function isBigintType(param: BaseType): param is BigintType;
+declare function isDoubleType(param: BaseType): param is DoubleType;
+declare function isFloatType(param: BaseType): param is FloatType;
+declare function isIntegerType(param: BaseType): param is IntegerType;
+declare function isLongType(param: BaseType): param is LongType;
+declare function isVoidType(param: BaseType | undefined): param is VoidType;
+declare function isNeverType(param: BaseType): param is NeverType;
+declare function isDateType(param: BaseType): param is DateType;
+declare function isFileType(param: BaseType): param is FileType;
+declare function isDateTimeType(param: BaseType): param is DateTimeType;
+declare function isBinaryType(param: BaseType): param is BinaryType;
+declare function isBufferType(param: BaseType): param is BufferType;
+declare function isByteType(param: BaseType): param is ByteType;
+declare function isObjectType(param: BaseType): param is ObjectType;
+declare function isEnumType(param: BaseType): param is EnumType;
+declare function isArrayType(param: BaseType): param is ArrayType;
+declare function isNestedObjectLiteralType(param: BaseType): param is NestedObjectLiteralType;
+declare function isIntersectionType(param: BaseType): param is IntersectionType;
+declare function isUnionType(param: BaseType): param is UnionType;
+declare function isTupleType(param: BaseType): param is TupleType;
+declare function isRefEnumType(param: BaseType): param is RefEnumType;
+declare function isRefObjectType(param: BaseType): param is RefObjectType;
+declare function isRefAliasType(param: BaseType): param is RefAliasType;
+declare function isReferenceType(param: BaseType): param is ReferenceType;
+declare function isPrimitiveType(type: BaseType): type is PrimitiveType;
+//#endregion
+//#region src/core/error/base.d.ts
+declare class MetadataError extends BaseError {}
+//#endregion
+//#region src/core/resolver/error.d.ts
+declare class ResolverError extends MetadataError {
+  readonly file?: string;
+  readonly line?: number;
+  constructor(message: string, node?: Node | TypeNode, options?: boolean | {
+    onlyCurrent?: boolean;
+    cause?: unknown;
+  });
+}
+declare function isResolverError(input: unknown): input is ResolverError;
+declare function prettyLocationOfNode(node: Node | TypeNode): {
+  text: string;
+  file: string;
+  line?: number;
+} | undefined;
+declare function prettyTroubleCause(node: Node | TypeNode, onlyCurrent?: boolean): string;
+//#endregion
+//#region src/core/generator/types.d.ts
+type Security = Record<string, string[]>;
+type Example = {
+  value: unknown | unknown[];
+  summary?: string;
+  description?: string;
+  label?: string;
+};
+type Response = {
+  description: string;
+  examples?: Example[];
+  headers?: NestedObjectLiteralType | RefObjectType;
+  name: string;
+  produces?: string[];
+  status: string;
+  schema?: BaseType;
+};
+//#endregion
+//#region src/core/parameter/constants.d.ts
+declare const ParameterSource: {
+  readonly BODY: "body";
+  readonly BODY_PROP: "bodyProp";
+  readonly CONTEXT: "context";
+  readonly COOKIE: "cookie";
+  readonly HEADER: "header";
+  readonly FORM_DATA: "formData";
+  readonly QUERY: "query";
+  readonly QUERY_PROP: "queryProp";
+  readonly PATH: "path";
+};
+type ParameterSource = typeof ParameterSource[keyof typeof ParameterSource];
+declare const CollectionFormat: {
+  readonly CSV: "csv";
+  readonly SSV: "ssv";
+  readonly TSV: "tsv";
+  readonly PIPES: "pipes";
+  readonly MULTI: "multi";
+};
+type CollectionFormat = typeof CollectionFormat[keyof typeof CollectionFormat];
+declare const ParameterErrorCode: {
+  readonly TYPE_UNSUPPORTED: "PARAMETER_TYPE_UNSUPPORTED";
+  readonly METHOD_UNSUPPORTED: "PARAMETER_METHOD_UNSUPPORTED";
+  readonly PATH_MISMATCH: "PARAMETER_PATH_MISMATCH";
+  readonly SCOPE_REQUIRED: "PARAMETER_SCOPE_REQUIRED";
+  readonly INVALID_EXAMPLE: "PARAMETER_INVALID_EXAMPLE";
+};
+//#endregion
+//#region src/core/parameter/types.d.ts
+type Parameter = {
+  parameterName: string;
+  description: string;
+  in: `${ParameterSource}`;
+  name: string;
+  required: boolean;
+  type: Type;
+  collectionFormat?: `${CollectionFormat}`;
+  allowEmptyValue?: boolean;
+  default?: any;
+  maxItems?: number;
+  minItems?: number;
+  deprecated?: boolean;
+  examples?: Example[];
+  exampleLabels?: string[];
+  extensions: Extension[];
+  validators?: Record<string, Validator>;
+};
+type ArrayParameter = Parameter & {
+  type: ArrayType;
+};
+interface IParameterGenerator {
+  generate(): Parameter[];
+}
+//#endregion
+//#region src/core/method/types.d.ts
+type Method = {
+  operationId?: string;
+  deprecated?: boolean;
+  description: string;
+  method: MethodType;
+  extensions: Extension[];
+  name: string;
+  parameters: Parameter[];
+  path: string;
+  type: BaseType;
+  tags: string[];
+  responses: Response[];
+  security?: Security[];
+  summary?: string;
+  consumes: string[];
+  produces: string[];
+  hidden: boolean;
+};
+type MethodType = 'get' | 'post' | 'put' | 'delete' | 'options' | 'head' | 'patch';
+//#endregion
+//#region src/core/controller/types.d.ts
+type Controller = {
+  /**
+   * Allowed Content-Types to pass
+   * data according the definition.
+   *
+   * i.e. ['application/json']
+   */
+  consumes: string[];
+  /**
+   * Whether every operation under this controller should be considered
+   * deprecated. OpenAPI has no controller-level `deprecated` field — emitters
+   * should cascade this flag to each emitted operation (combined with the
+   * method's own `deprecated`).
+   */
+  deprecated?: boolean;
+  /**
+   * Vendor extensions (x-* keys) declared on the controller class.
+   */
+  extensions: Extension[];
+  /**
+   * Is controller hidden, and should
+   * not be used/displayed in some scenarios.
+   */
+  hidden: boolean;
+  /**
+   * File Location of the Controller.
+   */
+  location: string;
+  /**
+   * Array of found method ( class functions )
+   * for a specific controller (class)
+   */
+  methods: Method[];
+  name: string;
+  /**
+   * Relative URL paths the controller mounts at, e.g. ['/users'] or
+   * ['/roles', '/realms/:id/roles'] for multi-mounting.
+   *
+   * Always non-empty; a controller declared with no path argument has
+   * `paths: ['']`.
+   */
+  paths: string[];
+  /**
+   * Possible Content-Types to receive
+   * data according the definition.
+   *
+   * i.e. ['application/json']
+   */
+  produces: string[];
+  responses: Response[];
+  /**
+   * Tags can be used to group controllers
+   * by a name together.
+   *
+   * i.e. ['auth']
+   */
+  tags: string[];
+  security?: Security[];
+};
+interface IControllerGenerator {
+  isValid(): boolean;
+  generate(): Controller | null;
+}
+//#endregion
+//#region src/core/method/constants.d.ts
+declare const MethodName: {
+  readonly ALL: "ALL";
+  readonly GET: "GET";
+  readonly POST: "POST";
+  readonly PUT: "PUT";
+  readonly DELETE: "DELETE";
+  readonly PATCH: "PATCH";
+  readonly OPTIONS: "OPTIONS";
+  readonly HEAD: "HEAD";
+};
+type MethodName = typeof MethodName[keyof typeof MethodName];
+//#endregion
+//#region src/core/parameter/error.d.ts
+type UnsupportedTypeContext = {
+  decoratorName: string;
+  propertyName: string;
+  type: BaseType;
+  node?: Node;
+};
+type UnsupportedMethodContext = {
+  decoratorName: string;
+  propertyName: string;
+  method: string;
+  node?: Node;
+};
+type PathMatchInvalidContext = {
+  decoratorName: string;
+  propertyName: string;
+  path: string;
+  node?: Node;
+};
+type ScopeRequiredContext = {
+  decoratorName: string;
+  node?: Node;
+};
+declare class ParameterError extends MetadataError {
+  static typeUnsupported(context: UnsupportedTypeContext): ParameterError;
+  static methodUnsupported(context: UnsupportedMethodContext): ParameterError;
+  static invalidPathMatch(context: PathMatchInvalidContext): ParameterError;
+  static scopeRequired(context: ScopeRequiredContext): ParameterError;
+  static invalidExampleSchema(): ParameterError;
+  static getCurrentLocation(node: Node): string;
+}
+//#endregion
+//#region src/core/generator/error.d.ts
+declare class GeneratorError extends MetadataError {}
+declare function isGeneratorError(input: unknown): input is GeneratorError & {
+  code: string;
+};
+//#endregion
+//#region src/core/generator/constants.d.ts
+declare const GeneratorErrorCode: {
+  readonly CONTROLLER_NO_SOURCE_FILE: "GENERATOR_CONTROLLER_NO_SOURCE_FILE";
+  readonly CONTROLLER_NO_NAME: "GENERATOR_CONTROLLER_NO_NAME";
+  readonly PARAMETER_GENERATION_FAILED: "GENERATOR_PARAMETER_GENERATION_FAILED";
+  readonly BODY_PARAMETER_DUPLICATE: "GENERATOR_BODY_PARAMETER_DUPLICATE";
+  readonly BODY_FORM_CONFLICT: "GENERATOR_BODY_FORM_CONFLICT";
+};
+//#endregion
+//#region src/adapters/cache/types.d.ts
+interface CacheOptions {
+  /**
+   * Specify if the cache driver should be enabled.
+   *
+   * Default: false
+   * */
+  enabled: boolean;
+  /**
+   * Directory relative or absolute path. Auto-created on first save.
+   *
+   * Default: tmpDir()
+   */
+  directoryPath: string;
+  /**
+   * Specify the cache file name. When set, the cache becomes a single-slot
+   * store at this exact name (instead of one file per cache key). The
+   * in-file `cacheKey` check still rejects mismatches; you just lose
+   * multi-key caching.
+   *
+   * Default: .trapi-metadata-{cacheKey}.json
+   */
+  fileName?: string;
+  /**
+   * Files older than this many milliseconds are pruned opportunistically
+   * after each successful save. Set to `0` to disable eviction.
+   *
+   * Default: 7 days
+   */
+  maxAgeMs: number;
+}
+type CacheOptionsInput = Partial<CacheOptions>;
+type CacheData = {
+  /**
+   * Opaque composite key — sha256 over (schema version, source files content,
+   * compiler options, resolved registry shape, preset name). The reader
+   * cross-checks this against the expected key to defend against collisions
+   * or schema drift.
+   */
+  cacheKey: string; /** Stamped at write time; rejected on read if not equal to the current value. */
+  schemaVersion: string;
+} & Metadata;
+interface ICacheClient {
+  save(data: CacheData): Promise<string | undefined>;
+  get(cacheKey: string): Promise<CacheData | undefined>;
+  /** Prune cache files older than `maxAgeMs`. Safe to call concurrently. */
+  evict(): Promise<void>;
+}
+//#endregion
+//#region src/adapters/cache/client.d.ts
+declare class CacheClient implements ICacheClient {
+  private readonly options;
+  constructor(input?: string | boolean | CacheOptionsInput);
+  save(data: CacheData): Promise<string | undefined>;
+  get(cacheKey: string): Promise<CacheData | undefined>;
+  /**
+   * 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.
+   */
+  evict(): Promise<void>;
+  private resolveFilePath;
+  private ensureDirectory;
+}
+//#endregion
+//#region src/adapters/cache/constants.d.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.
+ */
+declare const CACHE_SCHEMA_VERSION = "3";
+declare const CACHE_FILE_PREFIX = ".trapi-metadata-";
+declare const CACHE_FILE_SUFFIX = ".json";
+/** 7 days. */
+declare const CACHE_DEFAULT_MAX_AGE_MS: number;
+//#endregion
+//#region src/adapters/decorator/constants.d.ts
+declare const ParamKind: {
+  readonly Body: "body";
+  readonly BodyProp: "bodyProp";
+  readonly Context: "context";
+  readonly Cookie: "cookie";
+  readonly Header: "header";
+  readonly FormData: "formData";
+  readonly Query: "query";
+  readonly QueryProp: "queryProp";
+  readonly Path: "path";
+};
+type ParamKind = typeof ParamKind[keyof typeof ParamKind];
+declare const CollectionKind: {
+  readonly Csv: "csv";
+  readonly Ssv: "ssv";
+  readonly Tsv: "tsv";
+  readonly Pipes: "pipes";
+  readonly Multi: "multi";
+};
+type CollectionKind = typeof CollectionKind[keyof typeof CollectionKind];
+declare const DecoratorTargetKind: {
+  readonly Class: "class";
+  readonly Method: "method";
+  readonly Parameter: "parameter";
+  readonly Property: "property";
+};
+type DecoratorTargetKind = typeof DecoratorTargetKind[keyof typeof DecoratorTargetKind];
+declare const DecoratorArgumentKindName: {
+  readonly Literal: "literal";
+  readonly Object: "object";
+  readonly Array: "array";
+  readonly Identifier: "identifier";
+  readonly Unresolvable: "unresolvable";
+};
+type DecoratorArgumentKindName = typeof DecoratorArgumentKindName[keyof typeof DecoratorArgumentKindName];
+declare const MarkerName: {
+  readonly Hidden: "hidden";
+  readonly Deprecated: "deprecated";
+  readonly Extension: "extension";
+};
+type MarkerName = typeof MarkerName[keyof typeof MarkerName];
+declare const NumericKind: {
+  readonly Int: "int";
+  readonly Long: "long";
+  readonly Float: "float";
+  readonly Double: "double";
+};
+type NumericKind = typeof NumericKind[keyof typeof NumericKind];
+//#endregion
+//#region src/adapters/decorator/types.d.ts
+type DecoratorTarget = `${DecoratorTargetKind}`;
+type DecoratorArgumentKind = `${DecoratorArgumentKindName}`;
+type DecoratorArgument = {
+  raw: unknown;
+  kind: DecoratorArgumentKind;
+};
+type DecoratorTypeArgument = {
+  resolve: () => Type;
+};
+type DecoratorHost = {
+  name: string;
+  parentName?: string;
+};
+type DecoratorSource = {
+  name: string;
+  arguments: DecoratorArgument[];
+  typeArguments: DecoratorTypeArgument[];
+  target: DecoratorTarget;
+  host: DecoratorHost;
+  /**
+   * Source-file location of the decorator AST node itself (1-based line).
+   * Optional because decorator sources can be synthesised in tests without
+   * a real source file. Populated by {@link buildDecoratorSources} when the
+   * decorator's containing source file is available.
+   */
+  location?: {
+    file: string;
+    line: number;
+  };
+};
+type JsDocSource = {
+  tag: string;
+  text?: string;
+  typeExpression?: {
+    resolve: () => Type;
+  };
+  parameterName?: string;
+  target: DecoratorTarget;
+  host: DecoratorHost;
+};
+type ControllerDraft = {
+  name: string;
+  location: string;
+  paths?: string[];
+  hidden: boolean;
+  deprecated?: boolean;
+  consumes: string[];
+  produces: string[];
+  tags: string[];
+  responses: Response[];
+  security: Security[];
+  extensions: Extension[];
+};
+type MethodDraft = {
+  name: string;
+  verb?: MethodType;
+  path: string;
+  operationId?: string;
+  description: string;
+  summary?: string;
+  deprecated?: boolean;
+  hidden: boolean;
+  consumes: string[];
+  produces: string[];
+  tags: string[];
+  responses: Response[];
+  security: Security[];
+  extensions: Extension[];
+  parameters: ParameterDraft[];
+  type?: BaseType;
+  /**
+   * Examples that handlers (e.g. `@Example`) want attached to the implicitly
+   * generated default response. The orchestrator merges these into the
+   * default 200/204 response when finalising the method.
+   */
+  defaultResponseExamples: Example[];
+};
+type ParameterDraft = {
+  parameterName: string;
+  name: string;
+  in?: `${ParamKind}`;
+  description: string;
+  required: boolean;
+  type?: Type;
+  collectionFormat?: `${CollectionKind}`;
+  allowEmptyValue?: boolean;
+  default?: unknown;
+  maxItems?: number;
+  minItems?: number;
+  deprecated?: boolean;
+  examples: Example[];
+  exampleLabels: string[];
+  extensions: Extension[];
+  validators: Record<string, Validator>;
+};
+type HandlerContext = {
+  host: DecoratorHost;
+  argument: (index: number) => DecoratorArgument | undefined;
+  arguments: () => DecoratorArgument[];
+  typeArgument: (index: number) => DecoratorTypeArgument | undefined;
+  typeArguments: () => DecoratorTypeArgument[];
+  parameterType: () => Type | undefined;
+};
+type JsDocHandlerContext = {
+  host: DecoratorHost;
+  source: JsDocSource;
+  parameterType: () => Type | undefined;
+};
+type Match = {
+  name: string;
+  on?: DecoratorTarget;
+};
+type JsDocMatch = {
+  tag: string;
+  on?: DecoratorTarget;
+};
+type ReplacesPolicy = true | string;
+/**
+ * Tags a handler with a semantic concept that the type resolver consults.
+ *
+ * Allows preset authors to rename a decorator (via `match.name`) without
+ * breaking type-resolver behaviour: the resolver looks up handlers by marker
+ * and reads the canonical decorator name from each handler's `match.name`.
+ */
+type ResolverMarker = `${MarkerName}` | {
+  numeric: `${NumericKind}`;
+};
+type HandlerBase = {
+  match: Match;
+  replaces?: ReplacesPolicy;
+  marker?: ResolverMarker;
+};
+type ControllerHandler = HandlerBase & {
+  apply: (ctx: HandlerContext, draft: ControllerDraft) => void;
+};
+type MethodHandler = HandlerBase & {
+  apply: (ctx: HandlerContext, draft: MethodDraft) => void;
+};
+type ParameterHandler = HandlerBase & {
+  apply: (ctx: HandlerContext, draft: ParameterDraft) => void;
+};
+type JsDocHandlerBase = {
+  match: JsDocMatch;
+  replaces?: ReplacesPolicy;
+  marker?: ResolverMarker;
+};
+type ControllerJsDocHandler = JsDocHandlerBase & {
+  apply: (ctx: JsDocHandlerContext, draft: ControllerDraft) => void;
+};
+type MethodJsDocHandler = JsDocHandlerBase & {
+  apply: (ctx: JsDocHandlerContext, draft: MethodDraft) => void;
+};
+type ParameterJsDocHandler = JsDocHandlerBase & {
+  apply: (ctx: JsDocHandlerContext, draft: ParameterDraft) => void;
+};
+type AnyDecoratorHandler = ControllerHandler | MethodHandler | ParameterHandler;
+type AnyJsDocHandler = ControllerJsDocHandler | MethodJsDocHandler | ParameterJsDocHandler;
+type Preset = {
+  name: string;
+  extends?: string[];
+  controllers?: ControllerHandler[];
+  methods?: MethodHandler[];
+  parameters?: ParameterHandler[];
+  controllerJsDoc?: ControllerJsDocHandler[];
+  methodJsDoc?: MethodJsDocHandler[];
+  parameterJsDoc?: ParameterJsDocHandler[];
+};
+type Registry = {
+  controllers: ControllerHandler[];
+  methods: MethodHandler[];
+  parameters: ParameterHandler[];
+  controllerJsDoc: ControllerJsDocHandler[];
+  methodJsDoc: MethodJsDocHandler[];
+  parameterJsDoc: ParameterJsDocHandler[];
+};
+type PresetResolver = (name: string) => Promise<Preset> | Preset;
+type LoadRegistryOptions = {
+  resolver: PresetResolver;
+  strict?: boolean;
+};
+//#endregion
+//#region src/adapters/cache/utils.d.ts
+declare function buildCacheOptions(input?: string | boolean | CacheOptionsInput): CacheOptions;
+type CacheKeyParts = {
+  schemaVersion: string;
+  sourceFilesHash: string;
+  compilerOptionsHash: string;
+  registryHash: string;
+  presetName?: string;
+};
+/**
+ * Combines all key contributors into a single sha256 hex string. The order is
+ * stable; each part is null-separated to avoid concatenation ambiguity.
+ */
+declare function composeCacheKey(parts: CacheKeyParts): string;
+/**
+ * Hash a stable JSON projection of `compilerOptions`. Sorting keys keeps the
+ * output deterministic regardless of declaration order in tsconfig.json.
+ */
+declare function hashCompilerOptions(options?: CompilerOptions): string;
+/**
+ * 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.
+ */
+declare function hashRegistry(registry: Registry): string;
+//#endregion
+//#region src/adapters/decorator/helpers.d.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.
+ */
+declare function readString(arg: DecoratorArgument | undefined): string | undefined;
+/**
+ * Read a positional argument as a number. Only matches numeric literals.
+ */
+declare function readNumber(arg: DecoratorArgument | undefined): number | undefined;
+/**
+ * Read a positional argument as a boolean. Only matches boolean literals.
+ */
+declare function readBoolean(arg: DecoratorArgument | undefined): boolean | undefined;
+/**
+ * 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.
+ */
+declare function readStringOrStringArray(arg: DecoratorArgument | undefined): string[] | undefined;
+/**
+ * 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.
+ */
+declare function setControllerPaths(draft: ControllerDraft, arg: DecoratorArgument | undefined): void;
+/**
+ * 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 `''`).
+ */
+declare function setMethodPath(draft: MethodDraft, arg: DecoratorArgument | undefined): void;
+//#endregion
+//#region src/adapters/decorator/module.d.ts
+declare function loadRegistry(preset: Preset, options: LoadRegistryOptions): Promise<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.
+ */
+declare function resolvePresetByName(input: string): Promise<Preset>;
+/**
+ * Resolve a preset by name and immediately materialize its registry, recursively
+ * loading `extends` parents through the same resolver.
+ */
+declare function loadRegistryByName(input: string): Promise<Registry>;
+//#endregion
+//#region src/adapters/decorator/test-helpers.d.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);
+ * ```
+ */
+declare function literalArg(raw: string | number | boolean | null): DecoratorArgument;
+/**
+ * Build an identifier-kind {@link DecoratorArgument} (e.g. `@Foo(SOME_CONSTANT)`).
+ * `raw` is the resolved value the identifier points to — typically a string.
+ */
+declare function identifierArg(raw: unknown): DecoratorArgument;
+/**
+ * Build an array-kind {@link DecoratorArgument} (e.g. `@Foo(['a', 'b'])`).
+ */
+declare function arrayArg(raw: unknown[]): DecoratorArgument;
+/**
+ * Build an object-kind {@link DecoratorArgument} (e.g. `@Foo({ key: 'value' })`).
+ */
+declare function objectArg(raw: Record<string, unknown>): DecoratorArgument;
+/**
+ * Build an unresolvable-kind {@link DecoratorArgument} — represents arguments
+ * the source extractor couldn't statically evaluate (e.g. function calls,
+ * unknown identifiers).
+ */
+declare function unresolvableArg(): DecoratorArgument;
+/**
+ * Build a {@link DecoratorTypeArgument} stub that returns the supplied type
+ * when `resolve()` is called.
+ */
+declare function typeArg(type: Type): DecoratorTypeArgument;
+type CreateHandlerContextInput = {
+  args?: DecoratorArgument[];
+  typeArgs?: DecoratorTypeArgument[];
+  host?: DecoratorHost;
+  parameterType?: 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']);
+ * ```
+ */
+declare function createHandlerContext(input?: CreateHandlerContextInput): HandlerContext;
+//#endregion
+//#region src/adapters/decorator/orchestrator/types.d.ts
+/**
+ * Reported when a decorator on a node has no matching handler in the
+ * supplied registry. The orchestrator computes file/line from the host node
+ * (1-based line number).
+ */
+type UnmatchedDecoratorReport = {
+  name: string;
+  target: DecoratorTarget;
+  host: DecoratorHost;
+  file: string;
+  line: number;
+};
+type ApplyHandlersOptions = {
+  target: DecoratorTarget;
+  host: DecoratorHost;
+  resolveTypeNode: (node: TypeNode) => Type;
+  parameterType?: () => Type | undefined;
+  typeChecker?: TypeChecker;
+  /**
+   * Optional reporter for decorator sources that no handler matched.
+   * The orchestrator builds a {@link DecoratorSource} for every decorator
+   * on the node; if iteration finishes without any handler claiming a
+   * source, this callback fires once for that source.
+   */
+  onUnmatchedDecorator?: (report: UnmatchedDecoratorReport, source: DecoratorSource) => void;
+};
+//#endregion
+//#region src/adapters/decorator/orchestrator/module.d.ts
+type DecoratorHandlerLike<D> = {
+  match: Match;
+  apply: (ctx: HandlerContext, draft: D) => void;
+};
+type JsDocHandlerLike<D> = {
+  match: JsDocMatch;
+  apply: (ctx: JsDocHandlerContext, draft: D) => void;
+};
+declare function buildHandlerContext(source: DecoratorSource, options: ApplyHandlersOptions): HandlerContext;
+declare function buildJsDocHandlerContext(source: JsDocSource, options: ApplyHandlersOptions): JsDocHandlerContext;
+declare function applyDecoratorHandlers<D>(node: Node, handlers: DecoratorHandlerLike<D>[], draft: D, options: ApplyHandlersOptions): void;
+declare function applyJsDocHandlers<D>(node: Node, handlers: JsDocHandlerLike<D>[], draft: D, options: ApplyHandlersOptions): void;
+//#endregion
+//#region src/adapters/decorator/typescript/types.d.ts
+type DecoratorSourceBuilderOptions = {
+  target: DecoratorTarget;
+  host: DecoratorHost;
+  resolveTypeNode: (node: TypeNode) => Type;
+  typeChecker?: TypeChecker;
+};
+type JsDocSourceBuilderOptions = {
+  target: DecoratorTarget;
+  host: DecoratorHost;
+  resolveTypeNode: (node: TypeNode) => Type;
+};
+//#endregion
+//#region src/adapters/decorator/typescript/module.d.ts
+declare function buildDecoratorSources(node: Node, options: DecoratorSourceBuilderOptions): DecoratorSource[];
+declare function buildJsDocSources(node: Node, options: JsDocSourceBuilderOptions): JsDocSource[];
+//#endregion
+//#region src/adapters/decorator/typescript/utils.d.ts
+type RawDecorator = {
+  name: string;
+  arguments: DecoratorArgument[];
+};
+/**
+ * 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.
+ */
+declare function readNodeDecorators(node: Node, typeChecker?: TypeChecker): RawDecorator[];
+declare function findDecoratorByName(node: Node, name: string, typeChecker?: TypeChecker): RawDecorator | undefined;
+declare function findDecoratorsByName(node: Node, name: string, typeChecker?: TypeChecker): RawDecorator[];
+declare function hasDecoratorNamed(node: Node, name: string, typeChecker?: TypeChecker): boolean;
+declare function buildDecoratorArgument(expr: Expression, typeChecker?: TypeChecker): DecoratorArgument;
+//#endregion
+//#region src/adapters/decorator/utils.d.ts
+declare function matches(match: Match, source: Pick<DecoratorSource, 'name' | 'target'>): boolean;
+declare function matchesJsDoc(match: JsDocMatch, source: Pick<JsDocSource, 'tag' | 'target'>): boolean;
+declare function newControllerDraft(input: Pick<ControllerDraft, 'name' | 'location'>): ControllerDraft;
+declare function newMethodDraft(input: Pick<MethodDraft, 'name'>): MethodDraft;
+declare function newParameterDraft(input: Pick<ParameterDraft, 'parameterName'>): ParameterDraft;
+declare function createRegistry(): Registry;
+declare function generatePresetLookupPaths(input: string): string[];
+/**
+ * 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.
+ */
+declare function namesForMarker(registry: Registry, predicate: (marker: ResolverMarker) => boolean): Set<string>;
+/**
+ * Collect the unique JSDoc tag names of every JSDoc handler whose `marker`
+ * matches the given predicate. JSDoc analogue of `namesForMarker`.
+ */
+declare function tagsForMarker(registry: Registry, predicate: (marker: ResolverMarker) => boolean): Set<string>;
+declare function isHiddenMarker(marker: ResolverMarker): boolean;
+declare function isDeprecatedMarker(marker: ResolverMarker): boolean;
+declare function isExtensionMarker(marker: ResolverMarker): boolean;
+declare function numericMarkerKind(marker: ResolverMarker): 'int' | 'long' | 'float' | 'double' | undefined;
+declare const controller: (handler: ControllerHandler) => ControllerHandler;
+declare const method: (handler: MethodHandler) => MethodHandler;
+declare const parameter: (handler: ParameterHandler) => ParameterHandler;
+declare const controllerJsDoc: (handler: ControllerJsDocHandler) => ControllerJsDocHandler;
+declare const methodJsDoc: (handler: MethodJsDocHandler) => MethodJsDocHandler;
+declare const parameterJsDoc: (handler: ParameterJsDocHandler) => ParameterJsDocHandler;
+type AnyDraft = ControllerDraft | MethodDraft | ParameterDraft;
+type DraftApply = (ctx: HandlerContext, draft: AnyDraft) => void;
+declare function into(key: string): {
+  positional(index: number): DraftApply;
+  typeArgument(index?: number): DraftApply;
+};
+declare function append(key: string): {
+  positional(index: number): DraftApply;
+  positionalAll(): DraftApply;
+};
+declare function flag(key: string, value?: unknown): DraftApply;
+//#endregion
+//#region src/adapters/decorator/validation/module.d.ts
+declare const matchSchema: z.ZodObject<{
+  name: z.ZodString;
+  on: z.ZodOptional<z.ZodEnum<{
+    class: "class";
+    method: "method";
+    parameter: "parameter";
+    property: "property";
+  }>>;
+}, z.core.$strip>;
+declare const jsDocMatchSchema: z.ZodObject<{
+  tag: z.ZodString;
+  on: z.ZodOptional<z.ZodEnum<{
+    class: "class";
+    method: "method";
+    parameter: "parameter";
+    property: "property";
+  }>>;
+}, z.core.$strip>;
+declare const controllerHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    name: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const methodHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    name: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const parameterHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    name: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const controllerJsDocHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    tag: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const methodJsDocHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    tag: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const parameterJsDocHandlerSchema: z.ZodObject<{
+  replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+    numeric: z.ZodEnum<{
+      double: "double";
+      float: "float";
+      long: "long";
+      int: "int";
+    }>;
+  }, z.core.$strip>]>>;
+  apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+  match: z.ZodObject<{
+    tag: z.ZodString;
+    on: z.ZodOptional<z.ZodEnum<{
+      class: "class";
+      method: "method";
+      parameter: "parameter";
+      property: "property";
+    }>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const presetSchema: z.ZodObject<{
+  name: z.ZodString;
+  extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  controllers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      name: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      name: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      name: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  controllerJsDoc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      tag: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  methodJsDoc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      tag: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  parameterJsDoc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    replaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"hidden">, z.ZodLiteral<"deprecated">, z.ZodLiteral<"extension">, z.ZodObject<{
+      numeric: z.ZodEnum<{
+        double: "double";
+        float: "float";
+        long: "long";
+        int: "int";
+      }>;
+    }, z.core.$strip>]>>;
+    apply: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    match: z.ZodObject<{
+      tag: z.ZodString;
+      on: z.ZodOptional<z.ZodEnum<{
+        class: "class";
+        method: "method";
+        parameter: "parameter";
+        property: "property";
+      }>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare function createPresetContainer(): Container<Preset>;
+declare function validatePreset(input: unknown): Promise<Preset>;
+//#endregion
+//#region src/adapters/filesystem/tsconfig/types.d.ts
+type TsconfigLoadContext = {
+  cwd?: string;
+  name?: string;
+};
+type TsCompilerOptions = CompilerOptions;
+type TsConfig = {
+  compilerOptions?: TsCompilerOptions;
+  [key: string]: any;
+};
+//#endregion
+//#region src/adapters/filesystem/tsconfig/module.d.ts
+declare function loadTSConfig(context?: TsconfigLoadContext): Promise<TsConfig>;
+declare function softLoadTsconfig(context?: TsconfigLoadContext): Promise<TsConfig>;
+//#endregion
+//#region src/core/config/types.d.ts
+type EntryPointOptions = {
+  cwd: string;
+  pattern: string;
+};
+type EntryPoint = string | string[] | EntryPointOptions | EntryPointOptions[];
+type MetadataGeneratorOptions = {
+  /**
+   * The entry point to your API.
+   */
+  entryPoint: EntryPoint;
+  /**
+   * Directory to ignore during TypeScript files scan.
+   * Default: []
+   */
+  ignore?: string[];
+  /**
+   * Directory to allow during TypeScript files scan.
+   * Default: []
+   */
+  allow?: string[];
+  /**
+   * Directory to store and cache metadata cache files.
+   * Default: false
+   */
+  cache?: string | boolean | Partial<CacheOptions>;
+  /**
+   * Load a specific preset configuration.
+   */
+  preset?: string;
+  /**
+   * Controls how unmatched decorators (decorators with no matching handler
+   * in the resolved registry) are surfaced.
+   *
+   * - `false` / unset (default): silent.
+   * - `true`: emit a single `console.warn` listing every unmatched decorator
+   *   at the end of generation. Useful for catching typos (e.g. `@Hiden`
+   *   instead of `@Hidden`) and unwired decorators in custom presets.
+   * - `'throw'`: throw a `GeneratorError` instead of warning. Useful as a
+   *   CI gate.
+   *
+   * If `onUnmatchedDecorator` is also set, the callback is invoked instead
+   * of warning/throwing — collection still happens, but reporting is yours.
+   *
+   * Note: JSDoc tags are not currently included in strict-mode reporting
+   * because standard documentation tags (`@param`, `@returns`, ...) would
+   * generate excessive noise.
+   */
+  strict?: boolean | 'throw';
+  /**
+   * Optional callback invoked at the end of generation with all unmatched-
+   * decorator reports collected during the run. Replaces the default
+   * `console.warn` / `throw` behaviour of `strict` — when set, the callback
+   * is the terminal step (no warn, no throw).
+   *
+   * Setting this implicitly enables collection — you don't also need to set
+   * `strict`.
+   */
+  onUnmatchedDecorator?: (reports: UnmatchedDecoratorReport[]) => void;
+};
+type MetadataGenerateOptions = MetadataGeneratorOptions & {
+  /**
+   * Path to tsconfig.json or a TsConfig object.
+   */
+  tsconfig?: string | TsConfig;
+};
+//#endregion
+//#region src/core/metadata/types.d.ts
+type MetadataGeneratorContext = {
+  options: MetadataGeneratorOptions;
+  sourceFiles: string[];
+  compilerOptions?: CompilerOptions;
+};
+interface IMetadataGenerator {
+  generate(): Promise<Metadata>;
+}
+/**
+ * The output specification for metadata generation.
+ */
+type Metadata = {
+  /**
+   * A Controller is a collection of grouped methods (GET, POST, ...)
+   * for a common URL path (i.e /users) or an more explicit URL path (i.e. /users/:id).
+   */
+  controllers: Controller[];
+  /**
+   * ReferenceTypes is an object of found types (interfaces, type, ...),
+   * and classes which were detected during code analysis.
+   */
+  referenceTypes: ReferenceTypes;
+};
+/**
+ * Narrow context interface for the type resolver.
+ * Contains only what TypeNodeResolver needs — no generator methods.
+ */
+interface IResolverContext {
+  readonly typeChecker: TypeChecker;
+  readonly nodes: Node[];
+  readonly registry: Registry;
+  readonly resolverCache: IResolverCache;
+  isExportedNode(node: Node): boolean;
+}
+/**
+ * Callback interface for resolver → generator communication.
+ * Allows the resolver to register discovered reference types
+ * without importing the MetadataGenerator class.
+ */
+interface IReferenceTypeRegistry {
+  addReferenceType(type: ReferenceType): void;
+  getReferenceType(refName: string): ReferenceType | undefined;
+  registerDependencyResolver(callback: DependencyResolver): void;
+}
+/**
+ * Context interface for generators.
+ * Extends IResolverContext and IReferenceTypeRegistry so generators
+ * can pass `this.current` directly to TypeNodeResolver.
+ */
+interface IGeneratorContext extends IResolverContext, IReferenceTypeRegistry {
+  readonly config: MetadataGeneratorOptions;
+  readonly registry: Registry;
+  /**
+   * Optional sink for unmatched-decorator reports. Generators forward to
+   * this when `config.strict` is enabled. The metadata generator drains the
+   * sink after the controller walk and emits a single warning summary.
+   */
+  reportUnmatchedDecorator?(report: UnmatchedDecoratorReport): void;
+}
+//#endregion
+//#region src/core/metadata/variable.d.ts
+type VariableType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+//#endregion
+//#region src/core/validator/error.d.ts
+declare class ValidatorError extends MetadataError {}
+//#endregion
+//#region src/core/validator/constants.d.ts
+declare enum ValidatorName {
+  UNIQUE_ITEMS = "uniqueItems",
+  MINIMUM = "minimum",
+  MAXIMUM = "maximum",
+  MIN_ITEMS = "minItems",
+  MAX_ITEMS = "maxItems",
+  MIN_LENGTH = "minLength",
+  MAX_LENGTH = "maxLength",
+  MIN_DATE = "minDate",
+  MAX_DATE = "maxDate",
+  PATTERN = "pattern"
+}
+declare const ValidatorErrorCode: {
+  readonly EXPECTED_NUMBER: "VALIDATOR_EXPECTED_NUMBER";
+  readonly EXPECTED_DATE: "VALIDATOR_EXPECTED_DATE";
+  readonly EXPECTED_STRING: "VALIDATOR_EXPECTED_STRING";
+};
+//#endregion
+//#region src/core/error/config.d.ts
+declare class ConfigError extends MetadataError {}
+//#endregion
+//#region src/core/error/config-codes.d.ts
+declare const ConfigErrorCode: {
+  readonly TSCONFIG_MALFORMED: "CONFIG_TSCONFIG_MALFORMED";
+  readonly PRESET_NOT_FOUND: "CONFIG_PRESET_NOT_FOUND";
+  readonly PRESET_MISSING: "CONFIG_PRESET_MISSING";
+};
+type ConfigErrorCode = typeof ConfigErrorCode[keyof typeof ConfigErrorCode];
+//#endregion
+//#region src/adapters/typescript/resolver/types.d.ts
+type OverrideToken = ts.Token<ts.SyntaxKind.QuestionToken> | ts.Token<ts.SyntaxKind.PlusToken> | ts.Token<ts.SyntaxKind.MinusToken>;
+type UsableDeclaration = ts.InterfaceDeclaration | ts.ClassDeclaration | ts.PropertySignature | ts.TypeAliasDeclaration | ts.EnumMember;
+type TypeNodeResolverContext = {
+  [name: string]: ts.TypeReferenceNode | ts.TypeNode;
+};
+type SubResolverContext = {
+  readonly typeChecker: ts.TypeChecker;
+  readonly current: IResolverContext & IReferenceTypeRegistry;
+  readonly parentNode?: ts.Node;
+  readonly context: TypeNodeResolverContext;
+  readonly referencer?: ts.TypeNode;
+  resolveType(typeNode: ts.TypeNode, parentNode?: ts.Node, context?: TypeNodeResolverContext, referencer?: ts.TypeNode): Type;
+  propertyFromSignature(sig: ts.PropertySignature, overrideToken?: OverrideToken): ResolverProperty;
+  propertyFromDeclaration(decl: ts.PropertyDeclaration | ts.ParameterDeclaration, overrideToken?: OverrideToken): ResolverProperty;
+  getNodeDescription(node: UsableDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.EnumDeclaration): string;
+  getNodeExample(node: UsableDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.EnumDeclaration): unknown;
+  getNodeExtensions(node: UsableDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.EnumDeclaration): Extension[];
+};
+//#endregion
+//#region src/adapters/typescript/resolver/sub/array.d.ts
+declare function resolveArrayType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/base.d.ts
+declare class ResolverBase {
+  protected hasPublicModifier(node: Node): boolean;
+  protected hasStaticModifier(node: Node): boolean;
+  protected isAccessibleParameter(node: Node): boolean;
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/indexed-access.d.ts
+declare function resolveIndexedAccessType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/intersection.d.ts
+declare function resolveIntersectionType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/literal.d.ts
+declare function resolveLiteralType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+declare function getLiteralValue(typeNode: ts.LiteralTypeNode): string | number | boolean | null;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/mapped.d.ts
+declare function resolveMappedType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/object-literal.d.ts
+declare function resolveObjectLiteralType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/primitive.d.ts
+declare class PrimitiveResolver {
+  protected registry: Registry;
+  constructor(registry: Registry);
+  resolve(node: TypeNode, parentNode?: Node): PrimitiveType | NeverType | VoidType | undefined;
+  resolveSyntaxKind(syntaxKind: SyntaxKind): "string" | "number" | "boolean" | "bigint" | "null" | "undefined" | "void" | "never";
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/reference.d.ts
+declare class ReferenceResolver extends ResolverBase {
+  protected typeChecker: TypeChecker;
+  constructor(typeChecker: TypeChecker);
+  merge(referenceTypes: ReferenceType[]): ReferenceType;
+  mergeManyRefEnums(many: RefEnumType[]): RefEnumType;
+  mergeRefEnums(first: RefEnumType, second: RefEnumType): RefEnumType;
+  mergeManyRefObjects(many: RefObjectType[]): RefObjectType;
+  mergeRefObject(first: RefObjectType, second: RefObjectType): RefObjectType;
+  transformEnum(declaration: EnumDeclaration, enumName: string): RefEnumType;
+  transformEnumMember(declaration: EnumMember, enumName: string): RefEnumType;
+}
+//#endregion
+//#region src/adapters/typescript/resolver/sub/tuple.d.ts
+declare function resolveTupleType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/type-operator.d.ts
+declare function resolveTypeOperatorType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/sub/union.d.ts
+declare function resolveUnionType(typeNode: ts.TypeNode, ctx: SubResolverContext): Type | undefined;
+//#endregion
+//#region src/adapters/typescript/resolver/module.d.ts
+declare class TypeNodeResolver extends ResolverBase {
+  private static readonly MAX_DEPTH;
+  private readonly typeNode;
+  private readonly current;
+  private readonly parentNode?;
+  private context;
+  private readonly referencer;
+  private readonly depth;
+  private readonly primitiveResolver;
+  private readonly referenceResolver;
+  constructor(typeNode: ts.TypeNode, current: IResolverContext & IReferenceTypeRegistry, parentNode?: ts.Node, context?: TypeNodeResolverContext, referencer?: ts.TypeNode, depth?: number);
+  /**
+   * @deprecated Use resolverCache.clear() on the context instead.
+   * Kept for backward compatibility — no-ops since cache is now instance-scoped.
+   */
+  static clearCache(): void;
+  resolve(): Type;
+  private createSubResolverContext;
+  private resolveNestedType;
+  private throwUnknownType;
+  private resolveConditionalType;
+  private resolveTypeReference;
+  private static readonly CHECKER_RESOLVABLE_UTILITY_TYPES;
+  private static isCheckerResolvableUtilityType;
+  private resolveUtilityTypeViaChecker;
+  /**
+   * 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.
+   */
+  private resolveTypeViaChecker;
+  /**
+   * 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).
+   */
+  private hasUnboundContextArgs;
+  private static resolveSpecialReference;
+  private getDateType;
+  private static getDesignatedModels;
+  private getEnumerateType;
+  private getReferenceType;
+  private getTypeAliasReference;
+  private getModelReference;
+  private static getRefTypeName;
+  private contextualizedName;
+  private handleCachingAndCircularReferences;
+  private createCircularDependencyResolver;
+  private static nodeIsUsable;
+  private getModelTypeDeclarations;
+  private getModelTypeDeclaration;
+  private hasFlag;
+  private getSymbolAtLocation;
+  private getModelProperties;
+  private propertyFromSignature;
+  private propertyFromDeclaration;
+  private getModelAdditionalProperties;
+  private typeArgumentsToContext;
+  private getModelInheritedProperties;
+  private getNodeDescription;
+  private static getNodeFormat;
+  private getNodeExample;
+  protected getNodeExtensions(node: UsableDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.EnumDeclaration): Extension[];
+}
+//#endregion
+//#region src/adapters/typescript/resolver/cache.d.ts
+declare class ResolverCache implements IResolverCache {
+  private referenceTypes;
+  private inProgressTypes;
+  getCachedType(name: string): ReferenceType | undefined;
+  setCachedType(name: string, type: ReferenceType): void;
+  isInProgress(name: string): boolean;
+  markInProgress(name: string): void;
+  clearInProgress(name: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/adapters/typescript/resolver/utils.d.ts
+declare function getNodeDescription(node: Node, typeChecker: TypeChecker): string;
+declare function toTypeNodeOrFail(typeChecker: TypeChecker, ...args: Parameters<TypeChecker['typeToTypeNode']>): TypeNode;
+//#endregion
+//#region src/adapters/typescript/resolver/extension/module.d.ts
+declare function getNodeExtensions(node: Node, registry: Registry): Extension[];
+//#endregion
+//#region src/adapters/typescript/node-utils/types.d.ts
+interface NodeDecorator {
+  text: string;
+  arguments: any[];
+  typeArguments: any[];
+}
+//#endregion
+//#region src/adapters/typescript/node-utils/module.d.ts
+/**
+ * Get Decorators for a specific node.
+ *
+ * @param node
+ * @param isMatching
+ */
+declare function getNodeDecorators(node: Node, isMatching?: (data: NodeDecorator) => boolean): NodeDecorator[];
+//#endregion
+//#region src/adapters/typescript/initializer.d.ts
+declare function getInitializerValue(initializer?: ts.Expression, typeChecker?: ts.TypeChecker, type?: Type): unknown;
+declare const hasInitializer: (node: ts.Node) => node is ts.HasInitializer;
+//#endregion
+//#region src/adapters/typescript/js-doc/constants.d.ts
+declare enum JSDocTagName {
+  ABSTRACT = "abstract",
+  ACCESS = "access",
+  ALIAS = "alias",
+  ASYNC = "async",
+  /**
+   * Alias for @extends
+   */
+  AUGMENTS = "augments",
+  AUTHOR = "author",
+  DEFAULT = "default",
+  DEPRECATED = "deprecated",
+  DESCRIPTION = "description",
+  EXAMPLE = "example",
+  FORMAT = "format",
+  IGNORE = "ignore",
+  SUMMARY = "summary"
+}
+//#endregion
+//#region src/adapters/typescript/js-doc/module.d.ts
+declare function getJSDocDescription(node: Node, index?: number): string | undefined;
+declare function getJSDoc(node: Node, index?: number): undefined | JSDoc;
+declare function getJSDocTags(node: Node, isMatching?: `${JSDocTagName}` | `${JSDocTagName}`[] | (string & {}) | (string & {})[] | ((tag: JSDocTag) => boolean)): JSDocTag[];
+declare function hasJSDocTag(node: Node, tagName: ((tag: JSDocTag) => boolean) | `${JSDocTagName}` | (string & {})): boolean;
+declare function getJSDocTagComment(node: Node, tagName: ((tag: JSDocTag) => boolean) | `${JSDocTagName}`): undefined | string;
+declare function getJSDocTagNames(node: Node, requireTagName?: boolean): string[];
+//#endregion
+//#region src/adapters/typescript/js-doc/utils.d.ts
+declare function transformJSDocComment(input?: string | NodeArray<JSDocComment>): string | undefined;
+//#endregion
+//#region src/adapters/typescript/validator/module.d.ts
+declare function getDeclarationValidators(declaration: PropertyDeclaration | TypeAliasDeclaration | PropertySignature | ParameterDeclaration, name?: string): Record<string, Validator>;
+//#endregion
+//#region src/adapters/filesystem/source-files.d.ts
+declare function scanSourceFiles(input: EntryPoint): Promise<string[]>;
+//#endregion
+//#region src/app/generate.d.ts
+declare function generateMetadata(options: MetadataGenerateOptions): Promise<Metadata>;
+//#endregion
+//#region src/app/generator/metadata/module.d.ts
+declare class MetadataGenerator implements IGeneratorContext, IMetadataGenerator {
+  readonly nodes: Node[];
+  readonly typeChecker: TypeChecker;
+  registry: Registry;
+  readonly resolverCache: ResolverCache;
+  readonly config: MetadataGeneratorOptions;
+  private readonly program;
+  private cache;
+  private controllers;
+  private referenceTypes;
+  private circularDependencyResolvers;
+  private unmatchedDecorators;
+  constructor(context: MetadataGeneratorContext);
+  generate(): Promise<Metadata>;
+  private assertPresetProducedControllers;
+  reportUnmatchedDecorator(report: UnmatchedDecoratorReport): void;
+  private dispatchUnmatchedDecoratorReports;
+  private formatUnmatchedSummary;
+  protected buildNodesFromSourceFiles(): string;
+  /**
+   * Check if the source file path is in the ignored path list.
+   *
+   * @param filePath
+   * @protected
+   */
+  protected isIgnoredPath(filePath: string): boolean;
+  /**
+   * Check if the source file path is in the ignored path list.
+   *
+   * @param filePath
+   * @protected
+   */
+  protected isAllowedPath(filePath: string): boolean;
+  isExportedNode(_node: Node): boolean;
+  addReferenceType(referenceType: ReferenceType): void;
+  getReferenceType(refName: string): ReferenceType;
+  registerDependencyResolver(callback: DependencyResolver): void;
+  private buildControllers;
+}
+//#endregion
+//#region src/app/generator/metadata/utils.d.ts
+declare function isMetadata(input: unknown): input is Metadata;
+//#endregion
+//#region src/app/generator/controller/module.d.ts
+declare class ControllerGenerator implements IControllerGenerator {
+  protected readonly node: ClassDeclaration;
+  protected readonly current: IGeneratorContext;
+  constructor(node: ClassDeclaration, current: IGeneratorContext);
+  isValid(): boolean;
+  generate(): Controller | null;
+  private applyOptions;
+  protected buildMethods(controllerPaths: string[]): Method[];
+  private collectInheritedMethodDeclarations;
+  private resolveBaseClassDeclaration;
+}
+//#endregion
+//#region src/app/generator/method/module.d.ts
+declare class MethodGenerator {
+  protected readonly node: MethodDeclaration;
+  protected readonly current: IGeneratorContext;
+  constructor(node: MethodDeclaration, current: IGeneratorContext);
+  getMethodName(): string;
+  generate(controllerPaths: string[]): Method | null;
+  private applyOptions;
+  private resolveReturnType;
+  private buildParameters;
+}
+//#endregion
+//#region src/app/generator/parameter/module.d.ts
+declare class ParameterGenerator implements IParameterGenerator {
+  private readonly parameter;
+  private readonly method;
+  private readonly paths;
+  private readonly current;
+  constructor(parameter: ts.ParameterDeclaration, method: string, paths: string[], current: IGeneratorContext);
+  generate(): Parameter[];
+  private finalize;
+  private draftToParameter;
+  private decomposeObject;
+  private pathContainsParam;
+  private validatePathDecomposition;
+  private validatePathName;
+  private isLeafTypeSupported;
+  private isLeafOrEnumOrUnion;
+  private resolveType;
+  private getParameterName;
+  private getDescription;
+  private getJsDocExamples;
+  private applyOptions;
+}
+//#endregion
+//#region src/core/utils/array.d.ts
+declare function isStringArray(input: unknown): input is string[];
+//#endregion
+//#region src/core/utils/object.d.ts
+declare function hasOwnProperty<Y extends PropertyKey>(obj: unknown, prop: Y): obj is Record<Y, unknown>;
+//#endregion
+//#region src/core/utils/path-normalize.d.ts
+declare function normalizePath(str: string): string;
+//#endregion
+export { AnyDecoratorHandler, AnyJsDocHandler, AnyType, ApplyHandlersOptions, ArrayParameter, ArrayType, BaseType, BigintType, BinaryType, BooleanType, BufferType, ByteType, CACHE_DEFAULT_MAX_AGE_MS, CACHE_FILE_PREFIX, CACHE_FILE_SUFFIX, CACHE_SCHEMA_VERSION, CacheClient, CacheData, CacheKeyParts, CacheOptions, CacheOptionsInput, CollectionFormat, CollectionKind, ConfigError, ConfigErrorCode, Controller, ControllerDraft, ControllerGenerator, ControllerHandler, ControllerJsDocHandler, CreateHandlerContextInput, DateTimeType, DateType, DecoratorArgument, DecoratorArgumentKind, DecoratorArgumentKindName, DecoratorHost, DecoratorSource, DecoratorSourceBuilderOptions, DecoratorTarget, DecoratorTargetKind, DecoratorTypeArgument, DependencyResolver, DoubleType, EntryPoint, EntryPointOptions, EnumType, Example, Extension, ExtensionType, FileType, FloatType, GeneratorError, GeneratorErrorCode, HandlerContext, ICacheClient, IControllerGenerator, IGeneratorContext, IMetadataGenerator, IParameterGenerator, IReferenceTypeRegistry, IResolverCache, IResolverContext, IntegerType, IntersectionType, JSDocTagName, JsDocHandlerContext, JsDocMatch, JsDocSource, JsDocSourceBuilderOptions, LoadRegistryOptions, LongType, MarkerName, Match, Metadata, MetadataError, MetadataGenerateOptions, MetadataGenerator, MetadataGeneratorContext, MetadataGeneratorOptions, Method, MethodDraft, MethodGenerator, MethodHandler, MethodJsDocHandler, MethodName, MethodType, NestedObjectLiteralType, NeverType, NodeDecorator, NumericKind, ObjectType, OverrideToken, ParamKind, Parameter, ParameterDraft, ParameterError, ParameterErrorCode, ParameterGenerator, ParameterHandler, ParameterJsDocHandler, ParameterSource, Preset, PresetResolver, PrimitiveResolver, PrimitiveType, RawDecorator, RefAliasType, RefEnumType, RefObjectType, ReferenceResolver, ReferenceType, ReferenceTypeBase, ReferenceTypes, Registry, ReplacesPolicy, ResolverBase, ResolverCache, ResolverError, ResolverMarker, ResolverProperty, Response, Security, StringType, SubResolverContext, TsCompilerOptions, TsConfig, TsconfigLoadContext, TupleElement, TupleType, Type, TypeName, TypeNodeResolver, TypeNodeResolverContext, UndefinedType, UnionType, UnmatchedDecoratorReport, UsableDeclaration, UtilityTypeName, Validator, ValidatorError, ValidatorErrorCode, ValidatorMeta, ValidatorName, Validators, VariableType, VoidType, 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.d.mts.map