@aroman22/codegraph-vba 1.3.3

package/dist/resolution/frameworks/nestjs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * NestJS Framework Resolver
+ *
+ * Handles NestJS decorator-based routing across its transport layers:
+ *   - HTTP:          @Controller(prefix) + @Get/@Post/@Put/@Patch/@Delete/@Head/@Options/@All
+ *   - GraphQL:       @Resolver + @Query/@Mutation/@Subscription
+ *   - Microservices: @MessagePattern / @EventPattern
+ *   - WebSockets:    @WebSocketGateway(namespace) + @SubscribeMessage(event)
+ *
+ * Like the other framework extractors this is regex-over-source (comment-
+ * stripped), not AST traversal. NestJS differs from Spring/ASP.NET in two ways
+ * that this resolver has to account for:
+ *
+ *   1. An HTTP route's path is split across TWO decorators — the class-level
+ *      `@Controller` prefix and the method-level `@Get`/`@Post` path — and both
+ *      are frequently empty (`@Controller()`, `@Get()`). We pair each method
+ *      decorator with its enclosing class and join the two paths.
+ *
+ *   2. `@Query()` is overloaded: it's a GraphQL *method* decorator (from
+ *      `@nestjs/graphql`) AND a REST *parameter* decorator (from
+ *      `@nestjs/common`). We only treat it as GraphQL when it sits inside an
+ *      `@Resolver` class, which is what disambiguates the two.
+ */
+import { FrameworkResolver } from '../types';
+export declare const nestjsResolver: FrameworkResolver;
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/resolution/frameworks/play.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Play Framework (Scala/Java) resolver.
+ *
+ * Play declares HTTP routes in a dedicated `conf/routes` file (and included
+ * `conf/*.routes`), Rails-style:
+ *
+ *   GET   /computers        controllers.Application.list(p: Int ?= 0)
+ *   POST  /computers        controllers.Application.save
+ *   GET   /assets/*file     controllers.Assets.versioned(path = "/public", file: Asset)
+ *
+ * The file is extensionless, so the file walk only indexes it because
+ * `isPlayRoutesFile` (grammars.ts) opts it in; it's processed through the
+ * no-grammar path and this resolver extracts the routes. Each route references
+ * its handler as `Controller.method` (the package prefix is dropped), resolved
+ * to the action method in the controller class.
+ */
+import { FrameworkResolver } from '../types';
+export declare const playResolver: FrameworkResolver;
+//# sourceMappingURL=play.d.ts.map

package/dist/resolution/frameworks/python.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Python Framework Resolver
+ *
+ * Handles Django, Flask, and FastAPI patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const djangoResolver: FrameworkResolver;
+export declare const flaskResolver: FrameworkResolver;
+export declare const fastapiResolver: FrameworkResolver;
+//# sourceMappingURL=python.d.ts.map

package/dist/resolution/frameworks/react-native.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const reactNativeBridgeResolver: FrameworkResolver;
+//# sourceMappingURL=react-native.d.ts.map

package/dist/resolution/frameworks/react.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React Framework Resolver
+ *
+ * Handles React and Next.js patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const reactResolver: FrameworkResolver;
+//# sourceMappingURL=react.d.ts.map

package/dist/resolution/frameworks/ruby.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby Framework Resolver
+ *
+ * Handles Ruby on Rails patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const railsResolver: FrameworkResolver;
+//# sourceMappingURL=ruby.d.ts.map

package/dist/resolution/frameworks/rust.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust Framework Resolver
+ *
+ * Handles Actix-web, Rocket, Axum, and common Rust patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const rustResolver: FrameworkResolver;
+//# sourceMappingURL=rust.d.ts.map

package/dist/resolution/frameworks/svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Svelte / SvelteKit Framework Resolver
+ *
+ * Handles Svelte component references, Svelte 5 runes,
+ * store auto-subscriptions, and SvelteKit route/module patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const svelteResolver: FrameworkResolver;
+//# sourceMappingURL=svelte.d.ts.map

package/dist/resolution/frameworks/swift-objc.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Swift ↔ Objective-C bridge resolver.
+ *
+ * Closes the cross-language flow gap in mixed iOS codebases. The pure
+ * bridging name math lives in `../swift-objc-bridge.ts`; this file wires
+ * it into the resolution pipeline.
+ *
+ * **Two directions to close:**
+ *
+ * 1. **Swift call → ObjC method** — A Swift caller writes
+ *    `imageDownloader.download(url:completion:)`. Tree-sitter-swift parses
+ *    this as a call_expression whose callee identifier is `download`
+ *    (parameter labels live in the argument list, not the callee). The
+ *    name-matcher tries to find any node named `download` and fails (no
+ *    Swift method by that name in this project; the ObjC implementation is
+ *    `-downloadURL:completion:`). We catch it here: from the bare Swift
+ *    name `download`, look up ObjC methods whose bridged Swift base name
+ *    would be `download` (using `swiftBaseNamesForObjcSelector`'s reverse
+ *    map, precomputed once per session).
+ *
+ * 2. **ObjC call → Swift method** — An ObjC caller writes
+ *    `[swiftThing fooWithBar:42]`. Tree-sitter-objc parses this as a
+ *    message_expression with selector `fooWithBar:` (after the multi-
+ *    keyword fix in this branch). The name-matcher tries to find a node
+ *    named `fooWithBar:` — no Swift node has colons in its name, so it
+ *    fails. We catch it: from the ObjC selector, derive candidate Swift
+ *    base names (`['fooWithBar', 'foo']`), and look up Swift methods
+ *    named those.
+ *
+ * **Provenance:** every edge produced here is recorded as a framework-
+ * resolved reference (`resolvedBy: 'framework'`) with `confidence: 0.7`
+ * (matches the django ORM dynamic-dispatch precedent — not exact, but
+ * deterministic from the bridging rule).
+ */
+import { FrameworkResolver } from '../types';
+export declare const swiftObjcBridgeResolver: FrameworkResolver;
+//# sourceMappingURL=swift-objc.d.ts.map

package/dist/resolution/frameworks/swift.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Swift Framework Resolver
+ *
+ * Handles SwiftUI, UIKit, and Vapor (server-side Swift) patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const swiftUIResolver: FrameworkResolver;
+export declare const uikitResolver: FrameworkResolver;
+export declare const vaporResolver: FrameworkResolver;
+//# sourceMappingURL=swift.d.ts.map

package/dist/resolution/frameworks/vue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vue / Nuxt Framework Resolver
+ *
+ * Handles Vue component references, compiler macros (defineProps, etc.),
+ * Nuxt auto-imports, and Nuxt file-based routing patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const vueResolver: FrameworkResolver;
+//# sourceMappingURL=vue.d.ts.map

package/dist/resolution/go-module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Go module path detection.
+ *
+ * A Go monorepo's cross-package calls (`pkga.FuncX(...)`) only resolve when
+ * the resolver knows the project's module path (the `module ...` directive
+ * in `go.mod`). Without it, `isExternalImport` treats every in-module import
+ * — `github.com/example/myproject/pkga` — as a third-party package, so
+ * resolution falls through to name-matching with path proximity and returns
+ * a tiny fraction of the real call sites. See issue #388.
+ */
+export interface GoModule {
+    /** The module path declared in `go.mod`, e.g. `github.com/example/myproject` */
+    modulePath: string;
+    /** Absolute path to the directory containing the `go.mod` file. */
+    rootDir: string;
+}
+/**
+ * Read the `go.mod` file at the project root and extract the module path.
+ * Returns `null` if no `go.mod` exists or it has no `module` directive.
+ *
+ * Limitation: only the project-root `go.mod` is read. Nested `go.mod` files
+ * (Go workspaces, monorepos with multiple modules) are not yet resolved —
+ * a follow-up if a real repro shows up.
+ */
+export declare function loadGoModule(projectRoot: string): GoModule | null;
+//# sourceMappingURL=go-module.d.ts.map

package/dist/resolution/goframe-synthesizer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GoFrame route → controller-method dispatch synthesis (#747).
+ *
+ * GoFrame binds routes reflectively (`group.Bind(user.NewV1())`), so the route
+ * declared in a request type's `g.Meta` tag has no static edge to the method
+ * that serves it. The `goframeResolver` extract pass turns each `g.Meta` into a
+ * `route` node carrying its request type in the qualifiedName; this whole-graph
+ * pass closes the loop by joining each route to its handler.
+ *
+ * The join key is the REQUEST TYPE, not the method name — GoFrame method names
+ * are free (`DeptSearchReq` is served by `List`, `DeptAddReq` by `Add`), so the
+ * only reliable link is the request type appearing in the handler's parameter
+ * signature:
+ *
+ *   func (c *sysDeptController) Add(ctx context.Context, req *system.DeptAddReq) (…)
+ *                                                              ^^^^^^^^^^^^^^^^  the join
+ *
+ * Go method nodes already carry that signature, so no source re-read is needed.
+ * Each synthesized edge is `kind:'calls'`, `provenance:'heuristic'`,
+ * `metadata.synthesizedBy:'goframe-route'` — a reflective-dispatch bridge, so
+ * `codegraph_explore` surfaces it as a dynamic hop rather than a literal call,
+ * and the handler's callers list the route that reaches it. A project with no
+ * GoFrame routes is a no-op.
+ */
+import type { Edge } from '../types';
+import type { ResolutionContext } from './types';
+export declare function goframeRouteEdges(ctx: ResolutionContext): Edge[];
+//# sourceMappingURL=goframe-synthesizer.d.ts.map

package/dist/resolution/import-resolver.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Import Resolver
+ *
+ * Resolves import paths to actual files and symbols.
+ */
+import { Language } from '../types';
+import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, ReExport } from './types';
+/**
+ * Resolve an import path to an actual file
+ */
+export declare function resolveImportPath(importPath: string, fromFile: string, language: Language, context: ResolutionContext): string | null;
+/**
+ * Clear the C/C++ include directory cache (call between indexing runs)
+ */
+export declare function clearCppIncludeDirCache(): void;
+/**
+ * Discover C/C++ include search directories for a project.
+ *
+ * Strategy:
+ * 1. Look for compile_commands.json (Clang compilation database) in the
+ *    project root and common build subdirectories. Parse -I and -isystem
+ *    flags from compiler commands.
+ * 2. If no compilation database is found, probe for common convention
+ *    directories (include/, src/, lib/, api/) and top-level directories
+ *    containing .h/.hpp files.
+ *
+ * Returns paths relative to projectRoot.
+ */
+export declare function loadCppIncludeDirs(projectRoot: string): string[];
+/**
+ * Is this reference a PHP include/require PATH (vs a namespace `use` symbol)?
+ *
+ * include/require emit a file path ("lib.php", "inc/db.php", "../x.php"),
+ * whereas namespace use is an FQN (App\Foo\Bar) or a bare class symbol
+ * (Closure). PHP identifiers contain neither '/' nor '.', so a slash or dot
+ * marks a path-shaped include. Such references resolve to files only — never
+ * to a same-named symbol — so callers must not fall back to the name-matcher.
+ */
+export declare function isPhpIncludePathRef(ref: UnresolvedRef): boolean;
+/**
+ * Extract import mappings from a file
+ */
+export declare function extractImportMappings(_filePath: string, content: string, language: Language): ImportMapping[];
+/**
+ * Clear the import mapping cache (call between indexing runs)
+ */
+export declare function clearImportMappingCache(): void;
+/**
+ * Extract JS/TS re-export declarations from `content`.
+ *
+ * Recognised forms:
+ *   export { foo } from './a';
+ *   export { foo as bar } from './a';
+ *   export * from './a';
+ *   export * as ns from './a';   (treated as wildcard for chasing)
+ *   export { default as Foo } from './a';
+ *
+ * The walker intentionally stays regex-based — the import-resolver
+ * elsewhere in this file already chooses regex over a fresh
+ * tree-sitter pass, and this function shares that trade-off. Errors
+ * fall through silently; resolution simply skips the broken file.
+ */
+export declare function extractReExports(content: string, language: Language): ReExport[];
+/**
+ * Resolve a reference using import mappings
+ */
+/**
+ * JVM (Java / Kotlin) imports use fully-qualified names (`import
+ * com.example.foo.Bar`) decoupled from filenames, so the JS/Python
+ * style filesystem path lookup misses them whenever the file isn't
+ * named after its primary symbol (Kotlin `Utils.kt` exporting `Bar`,
+ * top-level fns, extension fns). Resolve them through the
+ * `qualifiedName` index instead — populated by the package_header /
+ * package_declaration namespace wrappers in the extractor.
+ */
+export declare function resolveJvmImport(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+export declare function resolveViaImport(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+//# sourceMappingURL=import-resolver.d.ts.map

package/dist/resolution/index.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Reference Resolution Orchestrator
+ *
+ * Coordinates all reference resolution strategies.
+ */
+import { UnresolvedReference, Edge } from '../types';
+import { QueryBuilder } from '../db/queries';
+import { UnresolvedRef, ResolvedRef, ResolutionResult } from './types';
+export * from './types';
+/**
+ * Reference Resolver
+ *
+ * Orchestrates reference resolution using multiple strategies.
+ */
+export declare class ReferenceResolver {
+    private projectRoot;
+    private queries;
+    private context;
+    private frameworks;
+    private deferredChainRefs;
+    private deferredThisMemberRefs;
+    private razorUsingsCache;
+    private nodeCache;
+    private fileCache;
+    private importMappingCache;
+    private reExportCache;
+    private nameCache;
+    private lowerNameCache;
+    private qualifiedNameCache;
+    private knownNames;
+    private knownFiles;
+    private cachesWarmed;
+    private projectAliases;
+    private goModule;
+    private workspacePackages;
+    constructor(projectRoot: string, queries: QueryBuilder);
+    /**
+     * Initialize the resolver (detect frameworks, etc.)
+     */
+    initialize(): void;
+    /**
+     * Run each framework resolver's cross-file finalization pass and persist
+     * the returned node updates. Idempotent — safe to call after every indexAll
+     * and every incremental sync. Returns the number of nodes updated.
+     *
+     * Caches are cleared before/after so the post-extract pass sees fresh DB
+     * state and downstream queries see the updated names.
+     */
+    runPostExtract(): number;
+    /**
+     * Pre-build lightweight caches for resolution.
+     * Node lookups are now handled by indexed SQLite queries instead of
+     * loading all nodes into memory (which caused OOM on large codebases).
+     * We cache the set of known symbol names for fast pre-filtering.
+     */
+    warmCaches(): void;
+    /**
+     * Clear internal caches
+     */
+    clearCaches(): void;
+    /**
+     * Create the resolution context
+     */
+    private createContext;
+    /**
+     * Resolve all unresolved references
+     */
+    resolveAll(unresolvedRefs: UnresolvedReference[], onProgress?: (current: number, total: number) => void): ResolutionResult;
+    /**
+     * Check if a reference name has any possible match in the codebase.
+     * Uses the pre-built knownNames set to skip expensive resolution
+     * for names that definitely don't exist as symbols.
+     */
+    private hasAnyPossibleMatch;
+    /**
+     * Does `ref.referenceName` match an import declared in its containing
+     * file? Used as a pre-filter escape so re-export chain resolution
+     * still gets a chance when the name has no project-wide declaration.
+     */
+    private matchesAnyImport;
+    /**
+     * Resolve a single reference
+     */
+    resolveOne(ref: UnresolvedRef): ResolvedRef | null;
+    /**
+     * Create edges from resolved references
+     */
+    createEdges(resolved: ResolvedRef[]): Edge[];
+    /**
+     * Resolve and persist edges to database
+     */
+    resolveAndPersist(unresolvedRefs: UnresolvedReference[], onProgress?: (current: number, total: number) => void): ResolutionResult;
+    /**
+     * Second resolution pass for chained static-factory / fluent calls whose
+     * chained method is defined on a SUPERTYPE the receiver's type conforms to —
+     * a protocol-extension / inherited / default-interface method (#750). The
+     * first pass can't resolve these because `implements`/`extends` edges aren't
+     * built yet; this runs AFTER edges are persisted, so `context.getSupertypes`
+     * (and the conformance fallback in resolveMethodOnType) can walk them.
+     *
+     * Operates only on the leftover unresolved refs that have the `inner().method`
+     * chain shape, for the dotted-chain languages — a small set — and is idempotent
+     * (re-resolving an already-resolved ref is a no-op since it's been deleted).
+     * Returns the number of newly-created edges.
+     */
+    resolveChainedCallsViaConformance(): number;
+    /**
+     * Resolve and persist in batches to keep memory bounded.
+     * Processes unresolved references in chunks, persisting edges and cleaning
+     * up resolved refs after each batch to avoid accumulating large arrays.
+     */
+    resolveAndPersistBatched(onProgress?: (current: number, total: number) => void, batchSize?: number): Promise<ResolutionResult>;
+    /**
+     * Get detected frameworks
+     */
+    getDetectedFrameworks(): string[];
+    /**
+     * Check if reference is to a built-in or external symbol
+     */
+    private isBuiltInOrExternal;
+    /**
+     * Get file path from node ID
+     */
+    private getFilePathFromNodeId;
+    /**
+     * Get language from node ID
+     */
+    private getLanguageFromNodeId;
+    /**
+     * Drop an import/name-strategy resolution that crosses a language family.
+     * Two regimes (mirrors `applyLanguageGate`'s candidate filter):
+     *  - `references` (type usage): STRICT — a `Type.member` static read names a
+     *    same-family type, never a coincidentally same-named symbol in another
+     *    language. Drops any non-same-family target.
+     *  - `imports` (import binding / `#include`): both-known — a C++ `#include
+     *    "X.h"` must not resolve to a same-named ObjC header on another platform
+     *    (basename collision), but a singleton-family / SFC language (`vue` →
+     *    `.ts`) importing across is left alone.
+     * Applies to the import (strategy 2) + name-match (strategy 3) results.
+     */
+    /**
+     * Collect the `@using` namespaces in scope for a `.razor`/`.cshtml` file: its
+     * own `@using` directives plus every `_Imports.razor` from the file's folder up
+     * to the project root (Razor `_Imports` cascade). Cached per file.
+     */
+    private getRazorUsings;
+    /**
+     * Resolve a Razor/Blazor simple type ref through the file's `@using`
+     * namespaces: `CatalogBrand` + `@using BlazorShared.Models` → the node whose
+     * qualified name is `BlazorShared.Models::CatalogBrand`. Only resolves when the
+     * `@using` set yields exactly ONE type (otherwise it stays ambiguous and falls
+     * through to name-matching).
+     */
+    private resolveRazorUsing;
+    /**
+     * Resolve a `this.<member>` function-as-value reference (#756/#808) to the
+     * ENCLOSING CLASS's own member — never a same-named symbol elsewhere. The
+     * registration idiom (`btn.on('click', this.handleClick)`) names a member
+     * of the class being defined, so the only valid target shares the
+     * from-symbol's qualified-name scope. Function/method targets only — a
+     * property (a data field, post-#808 classification) yields no edge — same
+     * file required, no fallback of any kind.
+     */
+    private resolveThisMemberFnRef;
+    /**
+     * Second pass for `this.<member>` refs whose member wasn't on the enclosing
+     * class itself (#808): once implements/extends edges exist, walk the
+     * class's supertypes (transitively, depth-capped) and resolve the member on
+     * the nearest one that declares it — `this.handleSubmit` registered in a
+     * subclass resolves to `FormBase::handleSubmit`. Validated targets only
+     * (function/method kind, same language family); no match → no edge.
+     * Mirrors resolveChainedCallsViaConformance's lifecycle. Returns the number
+     * of newly-created edges.
+     */
+    resolveDeferredThisMemberRefs(): number;
+    private gateLanguage;
+    /**
+     * Drop a FRAMEWORK-strategy resolution that crosses two *known* language
+     * families for a type-usage (`references`) or import-binding (`imports`)
+     * edge. The framework strategy is intentionally ungated for cross-language
+     * bridges, but those legitimate bridges are either `calls` edges (RN/Expo
+     * JS → native) or config↔code edges whose config side (`yaml`/`blade`/…) is
+     * not a known programming-language family. A `references`/`imports` edge
+     * between two *known* families is always a coincidental name collision — the
+     * React/Svelte/Vue PascalCase component resolvers name-match `getNodesByName`
+     * without a language check, so a TS `<TestRunner>` ref happily matched a
+     * Kotlin `class TestRunner`. Gating only the both-known-cross-family case
+     * lets config bridges and `calls` bridges through untouched.
+     */
+    private gateFrameworkLanguage;
+}
+/**
+ * Create a reference resolver instance
+ */
+export declare function createResolver(projectRoot: string, queries: QueryBuilder): ReferenceResolver;
+//# sourceMappingURL=index.d.ts.map

package/dist/resolution/lru-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Simple LRU cache backed by JavaScript's insertion-ordered Map.
+ *
+ * Used by ReferenceResolver to bound the per-resolver caches that
+ * previously grew without limit and OOM'd on large codebases (20k+
+ * files). Each cache is sized independently — see `index.ts` for
+ * the chosen limits per cache type.
+ *
+ * Eviction is plain LRU: on `set`, if the cache is full, the
+ * least-recently-used entry (the first one in iteration order) is
+ * evicted. Touching via `get` moves the entry to the most-recently-used
+ * position so hot keys survive eviction passes.
+ */
+export declare class LRUCache<K, V> {
+    private readonly max;
+    private readonly store;
+    constructor(max: number);
+    get size(): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    clear(): void;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/dist/resolution/name-matcher.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Name Matcher
+ *
+ * Handles symbol name matching for reference resolution.
+ */
+import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types';
+/**
+ * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
+ * by matching the filename against file nodes.
+ */
+export declare function matchByFilePath(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+export declare function sameLanguageFamily(a: string, b: string): boolean;
+/**
+ * True when `lang` belongs to a known multi-language family (jvm/apple/web/c).
+ * Languages not listed (php, python, go, ruby, rust, dart, …) and config
+ * formats (yaml/xml/blade) form their own singleton families and return
+ * `false` — used to leave config↔code framework bridges (whose config side is
+ * never a known programming-language family) out of the cross-family gate.
+ */
+export declare function isKnownLanguageFamily(lang: string): boolean;
+/**
+ * True when `a` and `b` are two DIFFERENT *known* language families — the
+ * signature of a coincidental cross-language name collision (a TS `import
+ * React` matching a Swift `import React`, a C++ `#include "X.h"` matching a
+ * same-named ObjC header on another platform). The both-*known* test is
+ * deliberately weaker than {@link sameLanguageFamily}'s negation: a
+ * single-file-component language that carries its own tag (`vue`/`svelte`)
+ * importing a `.ts` module, or any singleton-family language (php/go/ruby/…),
+ * returns `false` here and is left alone.
+ */
+export declare function crossesKnownFamily(a: string, b: string): boolean;
+/**
+ * Resolve a function-as-value reference (#756) — a function name used as a
+ * callback/function-pointer value (`register(handler)`, `o->cb = handler`,
+ * `{ .cb = handler }`, `signal(SIGINT, handler)`). The ONLY strategy allowed
+ * for `function_ref` refs: exact name, function/method targets only, same
+ * language family, same-file first, and cross-file only when the match is
+ * UNIQUE. No fuzzy fallback, no qualified-name walking — a wrong callback
+ * edge is worse than none.
+ */
+export declare function matchFunctionRef(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve a reference by exact name match
+ */
+export declare function matchByExactName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve by qualified name
+ */
+export declare function matchByQualifiedName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Resolve a C++ chained call whose receiver is itself a call — encoded by the
+ * extractor as `<innerCallee>().<method>` (#645). The receiver's type is what
+ * the inner call returns; the outer method is then resolved and VALIDATED on it
+ * (resolveMethodOnType requires `cls::method` to exist), so a wrong inference
+ * produces no edge rather than a wrong one.
+ */
+export declare function matchCppCallChain(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Resolve a `::`-scoped factory chain whose receiver is a scoped/static call —
+ * PHP `Cls::for($x)->method()` (#608, the per-credential Laravel client idiom) or
+ * Rust `Foo::new().bar()` (an associated-function call) — both encoded by the
+ * extractor as `Cls::factory().method`. The receiver's type is what `Cls::factory`
+ * returns: a `self` marker (PHP `: self`/`: static`, Rust `-> Self`) resolves to
+ * the factory's own type, a concrete return type to that type. The outer method is
+ * then resolved and VALIDATED on it (resolveMethodOnType requires the method to
+ * exist on the type or a supertype it conforms to), so a wrong inference yields no
+ * edge rather than a wrong one. Shared by the `::`-receiver languages (PHP, Rust).
+ */
+export declare function matchScopedCallChain(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Resolve a dotted chained call whose receiver is a static factory / fluent call —
+ * `Foo.getInstance().bar()`, encoded by the extractor as `Foo.getInstance().bar`
+ * (#645/#608 mechanism). The receiver's type is what `Foo.getInstance` returns
+ * (its declared return type); the outer method is then resolved and VALIDATED on
+ * it (resolveMethodOnType requires `Type::method` to exist), so a wrong inference
+ * yields no edge rather than a wrong one (e.g. a same-named `bar()` on an
+ * unrelated class is never matched). Shared by the dot-notation languages
+ * (Java, Kotlin, C#, Swift) — same receiver shape, same `Class::method` qualified names.
+ */
+export declare function matchDottedCallChain(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve by method name on a class/object
+ */
+export declare function matchMethodCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Fuzzy match - last resort with lower confidence
+ */
+export declare function matchFuzzy(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Match all strategies in order of confidence
+ */
+export declare function matchReference(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+//# sourceMappingURL=name-matcher.d.ts.map