@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/type-env.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @file Per-file scoped type environment for receiver-type resolution
+ * @description Maps (scope, variableName) -> typeName using a three-tier strategy:
+ *   Tier 0: explicit type annotations, Tier 1: constructor inference,
+ *   Tier 2: single-pass assignment chain propagation
+ */
+import type { SyntaxNode } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import type { SymbolTable } from './symbol-table.js';
+/**
+ * Per-file scoped type environment: maps (scope, variableName) -> typeName
+ *
+ * Scope-aware: function-local variables are keyed by function name,
+ * file-level variables use the '' (empty string) scope.
+ * Built once per file, used for receiver resolution, then discarded
+ */
+export type TypeEnv = Map<string, Map<string, string>>;
+/**
+ * Per-file type environment with receiver resolution
+ *
+ * Built once per file via `buildTypeEnv`, used for receiver-type filtering,
+ * then discarded. Encapsulates scope-aware type lookup and self/this/super
+ * AST resolution behind a single `.lookup()` method
+ */
+export interface TypeEnvironment {
+    /** Look up a variable's resolved type, with self/this/super AST resolution */
+    lookup(varName: string, callNode: SyntaxNode): string | undefined;
+    /** Unverified cross-file constructor bindings for SymbolTable verification */
+    readonly constructorBindings: readonly ConstructorBinding[];
+    /** Raw per-scope type bindings (for testing and debugging) */
+    readonly env: TypeEnv;
+}
+/**
+ * Build a TypeEnvironment from a tree-sitter AST in a single pass
+ *
+ * Collects class/struct names, type bindings, and constructor bindings that
+ * couldn't be resolved locally. When a symbolTable is provided, cross-project
+ * class names are available for constructor inference
+ */
+export declare const buildTypeEnv: (tree: {
+    rootNode: SyntaxNode;
+}, language: SupportedLanguages, symbolTable?: SymbolTable) => TypeEnvironment;
+/**
+ * Unverified constructor binding: a `val x = Callee()` pattern where
+ * the callee class is in another file. Caller must verify against SymbolTable
+ */
+export interface ConstructorBinding {
+    scope: string;
+    varName: string;
+    calleeName: string;
+    receiverClassName?: string;
+}

package/dist/core/ingestion/type-env.js

@@ -0,0 +1,349 @@
+// code-mapper/src/core/ingestion/type-env.ts
+/**
+ * @file Per-file scoped type environment for receiver-type resolution
+ * @description Maps (scope, variableName) -> typeName using a three-tier strategy:
+ *   Tier 0: explicit type annotations, Tier 1: constructor inference,
+ *   Tier 2: single-pass assignment chain propagation
+ */
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
+import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
+import { extractSimpleTypeName, stripNullable } from './type-extractors/shared.js';
+// File-level scope key
+const FILE_SCOPE = '';
+// Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier)
+const findTypeIdentifierChild = (node) => {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === 'type_identifier')
+            return child;
+    }
+    return null;
+};
+// Shared lookup implementation
+const lookupInEnv = (env, varName, callNode) => {
+    // self/this receiver: resolve to enclosing class name via AST walk
+    if (varName === 'self' || varName === 'this' || varName === '$this') {
+        return findEnclosingClassName(callNode);
+    }
+    // super/base/parent receiver: walk up to enclosing class, extract superclass from heritage
+    if (varName === 'super' || varName === 'base' || varName === 'parent') {
+        return findEnclosingParentClassName(callNode);
+    }
+    // Determine enclosing function scope
+    const scopeKey = findEnclosingScopeKey(callNode);
+    // Try function-local scope first
+    if (scopeKey) {
+        const scopeEnv = env.get(scopeKey);
+        if (scopeEnv) {
+            const result = scopeEnv.get(varName);
+            if (result)
+                return stripNullable(result);
+        }
+    }
+    // Fall back to file-level scope
+    const fileEnv = env.get(FILE_SCOPE);
+    const raw = fileEnv?.get(varName);
+    return raw ? stripNullable(raw) : undefined;
+};
+/** Walk up AST to find the enclosing class/module name for self/this resolution */
+const findEnclosingClassName = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            const nameNode = current.childForFieldName('name')
+                ?? findTypeIdentifierChild(current);
+            if (nameNode)
+                return nameNode.text;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/** Walk up AST to find enclosing class and extract its parent class name for super/base/parent */
+const findEnclosingParentClassName = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            return extractParentClassFromNode(current);
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/** Extract the parent/superclass name from a class declaration AST node */
+const extractParentClassFromNode = (classNode) => {
+    // 1. Named fields: Java (superclass), Ruby (superclass), Python (superclasses)
+    const superclassNode = classNode.childForFieldName('superclass');
+    if (superclassNode) {
+        // Java: superclass > type_identifier or generic_type, Ruby: superclass > constant
+        const inner = superclassNode.childForFieldName('type')
+            ?? superclassNode.firstNamedChild
+            ?? superclassNode;
+        return extractSimpleTypeName(inner) ?? inner.text;
+    }
+    const superclassesNode = classNode.childForFieldName('superclasses');
+    if (superclassesNode) {
+        // Python: argument_list with identifiers or attribute nodes (e.g. models.Model)
+        const first = superclassesNode.firstNamedChild;
+        if (first)
+            return extractSimpleTypeName(first) ?? first.text;
+    }
+    // 2. Unnamed children: walk class node's children looking for heritage nodes
+    for (let i = 0; i < classNode.childCount; i++) {
+        const child = classNode.child(i);
+        if (!child)
+            continue;
+        switch (child.type) {
+            // TypeScript: class_heritage > extends_clause > type_identifier
+            // JavaScript: class_heritage > identifier (no extends_clause wrapper)
+            case 'class_heritage': {
+                for (let j = 0; j < child.childCount; j++) {
+                    const clause = child.child(j);
+                    if (clause?.type === 'extends_clause') {
+                        const typeNode = clause.firstNamedChild;
+                        if (typeNode)
+                            return extractSimpleTypeName(typeNode) ?? typeNode.text;
+                    }
+                    // JS: direct identifier child (no extends_clause wrapper)
+                    if (clause?.type === 'identifier' || clause?.type === 'type_identifier') {
+                        return clause.text;
+                    }
+                }
+                break;
+            }
+            // C#: base_list > identifier or generic_name > identifier
+            case 'base_list': {
+                const first = child.firstNamedChild;
+                if (first) {
+                    // generic_name wraps the identifier: BaseClass<T>
+                    if (first.type === 'generic_name') {
+                        const inner = first.childForFieldName('name') ?? first.firstNamedChild;
+                        if (inner)
+                            return inner.text;
+                    }
+                    return first.text;
+                }
+                break;
+            }
+            // PHP: base_clause > name
+            case 'base_clause': {
+                const name = child.firstNamedChild;
+                if (name)
+                    return name.text;
+                break;
+            }
+            // C++: base_class_clause > type_identifier (with optional access_specifier before it)
+            case 'base_class_clause': {
+                for (let j = 0; j < child.childCount; j++) {
+                    const inner = child.child(j);
+                    if (inner?.type === 'type_identifier')
+                        return inner.text;
+                }
+                break;
+            }
+            // Kotlin: delegation_specifier > constructor_invocation > user_type > type_identifier
+            case 'delegation_specifier': {
+                const delegate = child.firstNamedChild;
+                if (delegate?.type === 'constructor_invocation') {
+                    const userType = delegate.firstNamedChild;
+                    if (userType?.type === 'user_type') {
+                        const typeId = userType.firstNamedChild;
+                        if (typeId)
+                            return typeId.text;
+                    }
+                }
+                // Also handle plain user_type (interface conformance without parentheses)
+                if (delegate?.type === 'user_type') {
+                    const typeId = delegate.firstNamedChild;
+                    if (typeId)
+                        return typeId.text;
+                }
+                break;
+            }
+            // Swift: inheritance_specifier > user_type > type_identifier
+            case 'inheritance_specifier': {
+                const userType = child.childForFieldName('inherits_from') ?? child.firstNamedChild;
+                if (userType?.type === 'user_type') {
+                    const typeId = userType.firstNamedChild;
+                    if (typeId)
+                        return typeId.text;
+                }
+                break;
+            }
+        }
+    }
+    return undefined;
+};
+/** Find the enclosing function name for scope lookup */
+const findEnclosingScopeKey = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (FUNCTION_NODE_TYPES.has(current.type)) {
+            const { funcName } = extractFunctionName(current);
+            if (funcName)
+                return `${funcName}@${current.startIndex}`;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * Create a class name lookup backed by local AST names + SymbolTable global index
+ *
+ * Distinguishes constructor calls from function calls (e.g. Kotlin `User()` vs `getUser()`)
+ * using cross-file type information. Results are memoized
+ */
+const createClassNameLookup = (localNames, symbolTable) => {
+    if (!symbolTable)
+        return localNames;
+    const memo = new Map();
+    return {
+        has(name) {
+            if (localNames.has(name))
+                return true;
+            const cached = memo.get(name);
+            if (cached !== undefined)
+                return cached;
+            const result = symbolTable.lookupFuzzy(name).some(def => def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct');
+            memo.set(name, result);
+            return result;
+        },
+    };
+};
+/**
+ * Build a TypeEnvironment from a tree-sitter AST in a single pass
+ *
+ * Collects class/struct names, type bindings, and constructor bindings that
+ * couldn't be resolved locally. When a symbolTable is provided, cross-project
+ * class names are available for constructor inference
+ */
+export const buildTypeEnv = (tree, language, symbolTable) => {
+    const env = new Map();
+    const localClassNames = new Set();
+    const classNames = createClassNameLookup(localClassNames, symbolTable);
+    const config = typeConfigs[language];
+    const bindings = [];
+    const pendingAssignments = [];
+    // Maps `scope\0varName` -> type annotation AST node from the original declaration
+    // Allows pattern extractors to navigate back to generic type arguments
+    const declarationTypeNodes = new Map();
+    /**
+     * Extract a (variableName -> typeName) binding from a single AST node
+     *
+     * Tier 0: explicit type annotations, Tier 1: constructor-call inference
+     * Also populates declarationTypeNodes for pattern extractor access to generic args
+     */
+    const extractTypeBinding = (node, scopeEnv, scope) => {
+        // Fast path: eliminates 90%+ of calls before language dispatch
+        if (TYPED_PARAMETER_TYPES.has(node.type)) {
+            const keysBefore = new Set(scopeEnv.keys());
+            config.extractParameter(node, scopeEnv);
+            // Capture the type node for newly introduced parameter bindings
+            const typeNode = node.childForFieldName('type');
+            if (typeNode) {
+                for (const varName of scopeEnv.keys()) {
+                    if (!keysBefore.has(varName)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, typeNode);
+                    }
+                }
+            }
+            return;
+        }
+        // For-each loop variable bindings (Java/C#/Kotlin)
+        // Checked before declarationNodeTypes — loop variables are not declarations
+        if (config.forLoopNodeTypes?.has(node.type)) {
+            config.extractForLoopBinding?.(node, scopeEnv);
+            return;
+        }
+        if (config.declarationNodeTypes.has(node.type)) {
+            const keysBefore = new Set(scopeEnv.keys());
+            config.extractDeclaration(node, scopeEnv);
+            // Capture type annotation AST node for newly introduced bindings
+            // Only declarations with an explicit 'type' field are recorded
+            const typeNode = node.childForFieldName('type');
+            if (typeNode) {
+                for (const varName of scopeEnv.keys()) {
+                    if (!keysBefore.has(varName)) {
+                        declarationTypeNodes.set(`${scope}\0${varName}`, typeNode);
+                    }
+                }
+            }
+            // Tier 1: constructor-call inference as fallback
+            // Each language's extractInitializer skips declarators with explicit annotations
+            if (config.extractInitializer) {
+                config.extractInitializer(node, scopeEnv, classNames);
+            }
+        }
+    };
+    const walk = (node, currentScope) => {
+        // Collect class/struct names for constructor vs function call disambiguation
+        // Currently only C++ uses local names; other languages rely on the SymbolTable
+        if (CLASS_CONTAINER_TYPES.has(node.type)) {
+            // Most languages use 'name' field; Kotlin uses a type_identifier child instead
+            const nameNode = node.childForFieldName('name')
+                ?? findTypeIdentifierChild(node);
+            if (nameNode)
+                localClassNames.add(nameNode.text);
+        }
+        // Detect scope boundaries (function/method definitions)
+        let scope = currentScope;
+        if (FUNCTION_NODE_TYPES.has(node.type)) {
+            const { funcName } = extractFunctionName(node);
+            if (funcName)
+                scope = `${funcName}@${node.startIndex}`;
+        }
+        // Get or create the sub-map for this scope
+        if (!env.has(scope))
+            env.set(scope, new Map());
+        const scopeEnv = env.get(scope);
+        extractTypeBinding(node, scopeEnv, scope);
+        // Pattern binding extraction: introduces new typed variables via pattern matching
+        // (e.g. `if let Some(x) = opt`, `x instanceof T t`)
+        // Runs after Tier 0/1 so scopeEnv already has the source variable's type
+        if (config.extractPatternBinding) {
+            const patternBinding = config.extractPatternBinding(node, scopeEnv, declarationTypeNodes, scope);
+            if (patternBinding && !scopeEnv.has(patternBinding.varName)) {
+                scopeEnv.set(patternBinding.varName, patternBinding.typeName);
+            }
+        }
+        // Tier 2: collect plain-identifier RHS assignments for post-walk propagation
+        // Delegates to per-language extractPendingAssignment (AST shapes vary by language)
+        if (config.extractPendingAssignment && config.declarationNodeTypes.has(node.type)) {
+            const pending = config.extractPendingAssignment(node, scopeEnv);
+            if (pending) {
+                pendingAssignments.push({ scope, ...pending });
+            }
+        }
+        // Scan for constructor bindings that couldn't be resolved locally
+        if (config.scanConstructorBinding) {
+            const result = config.scanConstructorBinding(node);
+            if (result && !scopeEnv.has(result.varName)) {
+                bindings.push({ scope, ...result });
+            }
+        }
+        // Recurse into children
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                walk(child, scope);
+        }
+    };
+    walk(tree.rootNode, FILE_SCOPE);
+    // Tier 2: single-pass assignment chain propagation in source order
+    // Resolves `const b = a` where `a` has a known type from Tier 0/1
+    // No fixpoint iteration — covers 95%+ of real-world patterns
+    for (const { scope, lhs, rhs } of pendingAssignments) {
+        const scopeEnv = env.get(scope);
+        if (!scopeEnv || scopeEnv.has(lhs))
+            continue;
+        const rhsType = scopeEnv.get(rhs) ?? env.get(FILE_SCOPE)?.get(rhs);
+        if (rhsType) {
+            scopeEnv.set(lhs, rhsType);
+        }
+    }
+    return {
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode),
+        constructorBindings: bindings,
+        env,
+    };
+};

package/dist/core/ingestion/type-extractors/c-cpp.d.ts

@@ -0,0 +1,4 @@
+/** @file c-cpp.ts
+ *  @description Type extraction for C and C++ (typed declarations, auto inference, brace initialization) */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -0,0 +1,214 @@
+// code-mapper/src/core/ingestion/type-extractors/c-cpp.ts
+/** @file c-cpp.ts
+ *  @description Type extraction for C and C++ (typed declarations, auto inference, brace initialization) */
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'declaration',
+    'for_range_loop',
+]);
+// C++: Type x = ...; Type* x; Type& x;
+const extractDeclaration = (node, env) => {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return;
+    const typeName = extractSimpleTypeName(typeNode);
+    if (!typeName)
+        return;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator)
+        return;
+    // init_declarator: Type x = value
+    const nameNode = declarator.type === 'init_declarator'
+        ? declarator.childForFieldName('declarator')
+        : declarator;
+    if (!nameNode)
+        return;
+    // Handle pointer/reference declarators
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild
+        : nameNode;
+    if (!finalName)
+        return;
+    const varName = extractVarName(finalName);
+    if (varName)
+        env.set(varName, typeName);
+};
+// C++: auto x = new User(); auto x = User()
+const extractInitializer = (node, env, classNames) => {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return;
+    // Only handle auto/placeholder -- typed declarations are handled by extractDeclaration
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' &&
+        typeText !== 'decltype(auto)' &&
+        typeNode.type !== 'placeholder_type_specifier')
+        return;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator)
+        return;
+    // Must be an init_declarator (i.e., has an initializer value)
+    if (declarator.type !== 'init_declarator')
+        return;
+    const value = declarator.childForFieldName('value');
+    if (!value)
+        return;
+    // Resolve the variable name, unwrapping pointer/reference declarators
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild
+        : nameNode;
+    if (!finalName)
+        return;
+    const varName = extractVarName(finalName);
+    if (!varName)
+        return;
+    // auto x = new User() -- new_expression
+    if (value.type === 'new_expression') {
+        const ctorType = value.childForFieldName('type');
+        if (ctorType) {
+            const typeName = extractSimpleTypeName(ctorType);
+            if (typeName)
+                env.set(varName, typeName);
+        }
+        return;
+    }
+    // auto x = User() -- call_expression where function is a type name
+    // tree-sitter-cpp may parse the constructor name as type_identifier or identifier
+    // For plain identifiers, verify against known class names from the file's AST
+    // to distinguish constructor calls (User()) from function calls (getUser())
+    if (value.type === 'call_expression') {
+        const func = value.childForFieldName('function');
+        if (!func)
+            return;
+        if (func.type === 'type_identifier') {
+            const typeName = func.text;
+            if (typeName)
+                env.set(varName, typeName);
+        }
+        else if (func.type === 'identifier') {
+            const text = func.text;
+            if (text && classNames.has(text))
+                env.set(varName, text);
+        }
+        return;
+    }
+    // auto x = User{} -- compound_literal_expression (brace initialization)
+    // AST: compound_literal_expression > type_identifier + initializer_list
+    if (value.type === 'compound_literal_expression') {
+        const typeId = value.firstNamedChild;
+        const typeName = typeId ? extractSimpleTypeName(typeId) : undefined;
+        if (typeName)
+            env.set(varName, typeName);
+    }
+};
+// C/C++: parameter_declaration -> type declarator
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter_declaration') {
+        typeNode = node.childForFieldName('type');
+        const declarator = node.childForFieldName('declarator');
+        if (declarator) {
+            nameNode = declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator'
+                ? declarator.firstNamedChild
+                : declarator;
+        }
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// C/C++: auto x = User() where function is an identifier (not type_identifier)
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'declaration')
+        return undefined;
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' && typeText !== 'decltype(auto)' && typeNode.type !== 'placeholder_type_specifier')
+        return undefined;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator || declarator.type !== 'init_declarator')
+        return undefined;
+    const value = declarator.childForFieldName('value');
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    const func = value.childForFieldName('function');
+    if (!func)
+        return undefined;
+    if (func.type === 'qualified_identifier' || func.type === 'scoped_identifier') {
+        const last = func.lastNamedChild;
+        if (!last)
+            return undefined;
+        const nameNode = declarator.childForFieldName('declarator');
+        if (!nameNode)
+            return undefined;
+        const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+            ? nameNode.firstNamedChild : nameNode;
+        if (!finalName)
+            return undefined;
+        return { varName: finalName.text, calleeName: last.text };
+    }
+    if (func.type !== 'identifier')
+        return undefined;
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return undefined;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild : nameNode;
+    if (!finalName)
+        return undefined;
+    const varName = finalName.text;
+    if (!varName)
+        return undefined;
+    return { varName, calleeName: func.text };
+};
+// C++: auto alias = user -> declaration with auto type + init_declarator where value is identifier
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type !== 'declaration')
+        return undefined;
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    // Only handle auto -- typed declarations already resolved by extractDeclaration
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' && typeText !== 'decltype(auto)'
+        && typeNode.type !== 'placeholder_type_specifier')
+        return undefined;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator || declarator.type !== 'init_declarator')
+        return undefined;
+    const value = declarator.childForFieldName('value');
+    if (!value || value.type !== 'identifier')
+        return undefined;
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return undefined;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild : nameNode;
+    if (!finalName)
+        return undefined;
+    const lhs = extractVarName(finalName);
+    if (!lhs || scopeEnv.has(lhs))
+        return undefined;
+    return { lhs, rhs: value.text };
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
+    extractPendingAssignment,
+};

package/dist/core/ingestion/type-extractors/csharp.d.ts

@@ -0,0 +1,4 @@
+/** @file csharp.ts
+ *  @description Type extraction for C# (typed declarations, var inference, pattern matching) */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;