@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/type-extractors/shared.js

@@ -0,0 +1,322 @@
+// code-mapper/src/core/ingestion/type-extractors/shared.ts
+/** @file shared.ts
+ *  @description Shared utilities for type extraction across all languages */
+// Nullable wrapper types that unwrap to their inner type for receiver resolution
+// e.g. Optional<User> -> "User", Option<User> -> "User"
+// Only nullable wrappers -- NOT containers (List, Vec) or async wrappers (Promise, Future)
+// See call-processor.ts WRAPPER_GENERICS for the full set used in return-type inference
+const NULLABLE_WRAPPER_TYPES = new Set([
+    'Optional', // Java
+    'Option', // Rust, Scala
+    'Maybe', // Haskell-style, Kotlin Arrow
+]);
+/**
+ * Extract the simple type name from a type AST node
+ *
+ * Handles generic types (List<User> -> List), qualified names (models.User -> User),
+ * and nullable types (User? -> User). Returns undefined for complex types
+ */
+export const extractSimpleTypeName = (typeNode) => {
+    // Direct type identifier (includes Ruby 'constant' for class names)
+    if (typeNode.type === 'type_identifier' || typeNode.type === 'identifier'
+        || typeNode.type === 'simple_identifier' || typeNode.type === 'constant') {
+        return typeNode.text;
+    }
+    // Qualified/scoped names: take the last segment (e.g. models.User -> User, Models::User -> User)
+    if (typeNode.type === 'scoped_identifier' || typeNode.type === 'qualified_identifier'
+        || typeNode.type === 'scoped_type_identifier' || typeNode.type === 'qualified_name'
+        || typeNode.type === 'qualified_type'
+        || typeNode.type === 'member_expression' || typeNode.type === 'member_access_expression'
+        || typeNode.type === 'attribute'
+        || typeNode.type === 'scope_resolution'
+        || typeNode.type === 'selector_expression') {
+        const last = typeNode.lastNamedChild;
+        if (last && (last.type === 'type_identifier' || last.type === 'identifier'
+            || last.type === 'simple_identifier' || last.type === 'name'
+            || last.type === 'constant' || last.type === 'property_identifier'
+            || last.type === 'field_identifier')) {
+            return last.text;
+        }
+    }
+    // Generic types: extract the base type (e.g. List<User> -> List)
+    // For nullable wrappers (Optional<User>, Option<User>), unwrap to inner type
+    if (typeNode.type === 'generic_type' || typeNode.type === 'parameterized_type') {
+        const base = typeNode.childForFieldName('name')
+            ?? typeNode.childForFieldName('type')
+            ?? typeNode.firstNamedChild;
+        if (!base)
+            return undefined;
+        const baseName = extractSimpleTypeName(base);
+        // Unwrap known nullable wrappers: Optional<User> -> User, Option<User> -> User
+        if (baseName && NULLABLE_WRAPPER_TYPES.has(baseName)) {
+            const args = extractGenericTypeArgs(typeNode);
+            if (args.length >= 1)
+                return args[0];
+        }
+        return baseName;
+    }
+    // Nullable types (Kotlin User?, C# User?)
+    if (typeNode.type === 'nullable_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Nullable union types (TS/JS: User | null, User | undefined, User | null | undefined)
+    // Extract the single non-null/undefined type from the union
+    if (typeNode.type === 'union_type') {
+        const nonNullTypes = [];
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const child = typeNode.namedChild(i);
+            if (!child)
+                continue;
+            // Skip null/undefined/void literal types
+            const text = child.text;
+            if (text === 'null' || text === 'undefined' || text === 'void')
+                continue;
+            nonNullTypes.push(child);
+        }
+        // Only unwrap if exactly one meaningful type remains
+        if (nonNullTypes.length === 1) {
+            return extractSimpleTypeName(nonNullTypes[0]);
+        }
+    }
+    // Type annotations that wrap the actual type (TS/Python: `: Foo`, Kotlin: user_type)
+    if (typeNode.type === 'type_annotation' || typeNode.type === 'type'
+        || typeNode.type === 'user_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Pointer/reference types (C++, Rust): User*, &User, &mut User
+    if (typeNode.type === 'pointer_type' || typeNode.type === 'reference_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // PHP primitive_type (string, int, float, bool)
+    if (typeNode.type === 'primitive_type') {
+        return typeNode.text;
+    }
+    // PHP named_type / optional_type
+    if (typeNode.type === 'named_type' || typeNode.type === 'optional_type') {
+        const inner = typeNode.childForFieldName('name') ?? typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Name node (PHP)
+    if (typeNode.type === 'name') {
+        return typeNode.text;
+    }
+    return undefined;
+};
+/**
+ * Extract variable name from a declarator or pattern node
+ *
+ * Returns the simple identifier text, or undefined for destructuring/complex patterns
+ */
+export const extractVarName = (node) => {
+    if (node.type === 'identifier' || node.type === 'simple_identifier'
+        || node.type === 'variable_name' || node.type === 'name'
+        || node.type === 'constant') {
+        return node.text;
+    }
+    // variable_declarator (Java/C#): has a 'name' field
+    if (node.type === 'variable_declarator') {
+        const nameChild = node.childForFieldName('name');
+        if (nameChild)
+            return extractVarName(nameChild);
+    }
+    // Rust: let mut x = ... -- mut_pattern wraps an identifier
+    if (node.type === 'mut_pattern') {
+        const inner = node.firstNamedChild;
+        if (inner)
+            return extractVarName(inner);
+    }
+    return undefined;
+};
+/** Node types for function/method parameters with type annotations */
+export const TYPED_PARAMETER_TYPES = new Set([
+    'required_parameter', // TS: (x: Foo)
+    'optional_parameter', // TS: (x?: Foo)
+    'formal_parameter', // Java/Kotlin
+    'parameter', // C#/Rust/Go/Python/Swift
+    'parameter_declaration', // C/C++ void f(Type name)
+    'simple_parameter', // PHP function(Foo $x)
+    'property_promotion_parameter', // PHP 8.0+ constructor promotion: __construct(private Foo $x)
+]);
+/**
+ * Extract type arguments from a generic type node
+ *
+ * e.g. List<User, String> -> ['User', 'String'], Vec<User> -> ['User']
+ * Used by extractSimpleTypeName to unwrap nullable wrappers (Optional<User> -> User)
+ *
+ * Handles language-specific AST structures:
+ * - TS/Java/Rust/Go: generic_type > type_arguments > type nodes
+ * - C#: generic_type > type_argument_list > type nodes
+ * - Kotlin: generic_type > type_arguments > type_projection > type nodes
+ *
+ * Note: Go slices/maps use slice_type/map_type, not generic_type -- those are
+ * NOT handled here; use language-specific extractors for Go container types
+ *
+ * @param typeNode A generic_type or parameterized_type AST node (returns [] for non-generic types)
+ * @returns Array of resolved type argument names (unresolvable arguments are omitted)
+ */
+export const extractGenericTypeArgs = (typeNode) => {
+    // Unwrap wrapper nodes that may sit above the generic_type
+    if (typeNode.type === 'type_annotation' || typeNode.type === 'type'
+        || typeNode.type === 'user_type' || typeNode.type === 'nullable_type'
+        || typeNode.type === 'optional_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractGenericTypeArgs(inner);
+        return [];
+    }
+    // Only process generic/parameterized type nodes
+    if (typeNode.type !== 'generic_type' && typeNode.type !== 'parameterized_type') {
+        return [];
+    }
+    // Find the type_arguments / type_argument_list child
+    let argsNode = null;
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child && (child.type === 'type_arguments' || child.type === 'type_argument_list')) {
+            argsNode = child;
+            break;
+        }
+    }
+    if (!argsNode)
+        return [];
+    const result = [];
+    for (let i = 0; i < argsNode.namedChildCount; i++) {
+        let argNode = argsNode.namedChild(i);
+        if (!argNode)
+            continue;
+        // Kotlin: type_arguments > type_projection > user_type > type_identifier
+        if (argNode.type === 'type_projection') {
+            argNode = argNode.firstNamedChild;
+            if (!argNode)
+                continue;
+        }
+        const name = extractSimpleTypeName(argNode);
+        if (name)
+            result.push(name);
+    }
+    return result;
+};
+/**
+ * Match Ruby constructor assignment: `user = User.new` or `service = Models::User.new`
+ *
+ * Handles both simple constants and scope_resolution (namespaced) receivers
+ * @returns `{ varName, calleeName }` or undefined if not a Ruby constructor assignment
+ */
+export const extractRubyConstructorAssignment = (node) => {
+    if (node.type !== 'assignment')
+        return undefined;
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (!left || !right)
+        return undefined;
+    if (left.type !== 'identifier' && left.type !== 'constant')
+        return undefined;
+    if (right.type !== 'call')
+        return undefined;
+    const method = right.childForFieldName('method');
+    if (!method || method.text !== 'new')
+        return undefined;
+    const receiver = right.childForFieldName('receiver');
+    if (!receiver)
+        return undefined;
+    let calleeName;
+    if (receiver.type === 'constant') {
+        calleeName = receiver.text;
+    }
+    else if (receiver.type === 'scope_resolution') {
+        // Models::User -> extract last segment "User"
+        const last = receiver.lastNamedChild;
+        if (!last || last.type !== 'constant')
+            return undefined;
+        calleeName = last.text;
+    }
+    else {
+        return undefined;
+    }
+    return { varName: left.text, calleeName };
+};
+/**
+ * Check if an AST node has an explicit type annotation
+ *
+ * Checks both named fields ('type') and child nodes ('type_annotation')
+ * Used by constructor binding scanners to skip annotated declarations
+ */
+export const hasTypeAnnotation = (node) => {
+    if (node.childForFieldName('type'))
+        return true;
+    for (let i = 0; i < node.childCount; i++) {
+        if (node.child(i)?.type === 'type_annotation')
+            return true;
+    }
+    return false;
+};
+// Bare nullable keywords that should not produce a receiver binding
+const NULLABLE_KEYWORDS = new Set(['null', 'undefined', 'void', 'None', 'nil']);
+/**
+ * Strip nullable wrappers from a type name string
+ *
+ * Used by both lookupInEnv (TypeEnv annotations) and extractReturnTypeName
+ * (return-type text) to normalize types before receiver lookup
+ *
+ *   "User | null"              -> "User"
+ *   "User | undefined"         -> "User"
+ *   "User | null | undefined"  -> "User"
+ *   "User?"                    -> "User"
+ *   "User | Repo"              -> undefined  (genuine union -- refuse)
+ *   "null"                     -> undefined
+ */
+export const stripNullable = (typeName) => {
+    let text = typeName.trim();
+    if (!text)
+        return undefined;
+    if (NULLABLE_KEYWORDS.has(text))
+        return undefined;
+    // Strip nullable suffix: User? -> User
+    if (text.endsWith('?'))
+        text = text.slice(0, -1).trim();
+    // Strip union with null/undefined/None/nil/void
+    if (text.includes('|')) {
+        const parts = text.split('|').map(p => p.trim()).filter(p => p !== '' && !NULLABLE_KEYWORDS.has(p));
+        if (parts.length === 1)
+            return parts[0];
+        return undefined; // genuine union or all-nullable -- refuse
+    }
+    return text || undefined;
+};
+/**
+ * Unwrap an await_expression to get the inner value
+ *
+ * Returns the node itself if not an await_expression, or null if input is null
+ */
+export const unwrapAwait = (node) => {
+    if (!node)
+        return null;
+    return node.type === 'await_expression' ? node.firstNamedChild : node;
+};
+/**
+ * Extract the callee name from a call_expression node
+ *
+ * Navigates to the 'function' field (or first named child) and extracts a simple type name
+ */
+export const extractCalleeName = (callNode) => {
+    const func = callNode.childForFieldName('function') ?? callNode.firstNamedChild;
+    if (!func)
+        return undefined;
+    return extractSimpleTypeName(func);
+};
+/** Find the first named child with the given node type */
+export const findChildByType = (node, type) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+};

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

@@ -0,0 +1,4 @@
+/** @file swift.ts
+ *  @description Type extraction for Swift (property declarations, initializer inference) */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;

package/dist/core/ingestion/type-extractors/swift.js

@@ -0,0 +1,140 @@
+// code-mapper/src/core/ingestion/type-extractors/swift.ts
+/** @file swift.ts
+ *  @description Type extraction for Swift (property declarations, initializer inference) */
+import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'property_declaration',
+]);
+// Swift: let x: Foo = ...
+const extractDeclaration = (node, env) => {
+    // Swift property_declaration has pattern and type_annotation
+    const pattern = node.childForFieldName('pattern')
+        ?? findChildByType(node, 'pattern');
+    const typeAnnotation = node.childForFieldName('type')
+        ?? findChildByType(node, 'type_annotation');
+    if (!pattern || !typeAnnotation)
+        return;
+    const varName = extractVarName(pattern) ?? pattern.text;
+    const typeName = extractSimpleTypeName(typeAnnotation);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// Swift: parameter -> name: type
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('name')
+            ?? node.childForFieldName('internal_name');
+        typeNode = node.childForFieldName('type');
+    }
+    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);
+};
+// Swift: let user = User(name: "alice") -- infer type from call when callee is a known class
+// Swift initializers are syntactically identical to function calls, so we verify
+// against classNames (which may include cross-file SymbolTable lookups)
+const extractInitializer = (node, env, classNames) => {
+    if (node.type !== 'property_declaration')
+        return;
+    // Skip if has type annotation -- extractDeclaration handled it
+    if (node.childForFieldName('type') || findChildByType(node, 'type_annotation'))
+        return;
+    // Find pattern (variable name)
+    const pattern = node.childForFieldName('pattern') ?? findChildByType(node, 'pattern');
+    if (!pattern)
+        return;
+    const varName = extractVarName(pattern) ?? pattern.text;
+    if (!varName || env.has(varName))
+        return;
+    // Find call_expression in the value
+    const callExpr = findChildByType(node, 'call_expression');
+    if (!callExpr)
+        return;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return;
+    // Direct call: User(name: "alice")
+    if (callee.type === 'simple_identifier') {
+        const calleeName = callee.text;
+        if (calleeName && classNames.has(calleeName)) {
+            env.set(varName, calleeName);
+        }
+        return;
+    }
+    // Explicit init: User.init(name: "alice") -- navigation_expression with .init suffix
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            const calleeName = receiver.text;
+            if (calleeName && classNames.has(calleeName)) {
+                env.set(varName, calleeName);
+            }
+        }
+    }
+};
+// Swift: let user = User(name: "alice") -- scan property_declaration for constructor binding
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'property_declaration')
+        return undefined;
+    if (hasTypeAnnotation(node))
+        return undefined;
+    const pattern = node.childForFieldName('pattern');
+    if (!pattern)
+        return undefined;
+    const varName = pattern.text;
+    if (!varName)
+        return undefined;
+    let callExpr = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'call_expression') {
+            callExpr = child;
+            break;
+        }
+    }
+    if (!callExpr)
+        return undefined;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return undefined;
+    if (callee.type === 'simple_identifier') {
+        return { varName, calleeName: callee.text };
+    }
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            return { varName, calleeName: receiver.text };
+        }
+        // General qualified call: service.getUser() -> extract method name
+        // tree-sitter-swift may wrap the identifier in navigation_suffix, so
+        // check both direct simple_identifier and navigation_suffix > simple_identifier
+        if (suffix?.type === 'simple_identifier') {
+            return { varName, calleeName: suffix.text };
+        }
+        if (suffix?.type === 'navigation_suffix') {
+            const inner = suffix.lastNamedChild;
+            if (inner?.type === 'simple_identifier') {
+                return { varName, calleeName: inner.text };
+            }
+        }
+    }
+    return undefined;
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
+};

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

@@ -0,0 +1,111 @@
+/** @file types.ts
+ *  @description Type definitions for per-language type extraction used by TypeEnv */
+import type { SyntaxNode } from '../utils.js';
+/** Extracts type bindings from a declaration node into the env map */
+export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Extracts type bindings from a parameter node into the env map */
+export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Minimal interface for checking whether a name is a known class/struct -- only `.has()` is needed */
+export type ClassNameLookup = {
+    has(name: string): boolean;
+};
+/** Extracts type bindings from a constructor-call initializer, with access to known class names */
+export type InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup) => void;
+/**
+ * Scans an AST node for untyped `var = callee()` patterns for return-type inference
+ * @returns `{ varName, calleeName }` if matched, undefined otherwise
+ *   `receiverClassName` is an optional hint for method calls on known receivers
+ *   (e.g. `$this->getUser()` in PHP provides the enclosing class name)
+ */
+export type ConstructorBindingScanner = (node: SyntaxNode) => {
+    varName: string;
+    calleeName: string;
+    receiverClassName?: string;
+} | undefined;
+/**
+ * Extracts a return type string from a method/function definition node
+ *
+ * Used for languages where return types live in comments (e.g. YARD `@return [Type]`)
+ * rather than AST fields. Returns undefined if no return type can be determined
+ */
+export type ReturnTypeExtractor = (node: SyntaxNode) => string | undefined;
+/** Extracts loop variable type binding from a for-each statement */
+export type ForLoopExtractor = (node: SyntaxNode, scopeEnv: Map<string, string>) => void;
+/**
+ * Extracts a plain-identifier assignment for Tier 2 propagation
+ *
+ * For `const b = a`, returns `{ lhs: 'b', rhs: 'a' }` when the LHS has no resolved type
+ * Returns undefined if the node is not a plain identifier assignment
+ */
+export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => {
+    lhs: string;
+    rhs: string;
+} | undefined;
+/**
+ * Extracts a typed variable binding from a pattern-matching construct
+ *
+ * Returns `{ varName, typeName }` for patterns that introduce new variables
+ * Examples: `if let Some(user) = opt` (Rust), `x instanceof User user` (Java)
+ * Conservative: returns undefined when the source variable's type is unknown
+ *
+ * @param scopeEnv Read-only view of already-resolved type bindings in the current scope
+ * @param declarationTypeNodes Maps `scope\0varName` to the original declaration's type
+ *   annotation AST node, allowing generic type argument extraction (e.g. T from Result<T,E>)
+ *   that is stripped during normal TypeEnv extraction
+ * @param scope Current scope key (e.g. `"process@42"`) for declarationTypeNodes lookups
+ */
+export type PatternBindingExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>, declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, scope: string) => {
+    varName: string;
+    typeName: string;
+} | undefined;
+/** Per-language type extraction configuration */
+export interface LanguageTypeConfig {
+    /** Node types that represent typed declarations for this language */
+    declarationNodeTypes: ReadonlySet<string>;
+    /** AST node types for for-each/for-in statements with explicit element types */
+    forLoopNodeTypes?: ReadonlySet<string>;
+    /** Extract a (varName -> typeName) binding from a declaration node */
+    extractDeclaration: TypeBindingExtractor;
+    /** Extract a (varName -> typeName) binding from a parameter node */
+    extractParameter: ParameterExtractor;
+    /**
+     * Extract a (varName -> typeName) binding from a constructor-call initializer
+     *
+     * Called as fallback when extractDeclaration produces no binding for a declaration node
+     * Only for languages with syntactic constructor markers (new, composite_literal, ::new)
+     * Receives classNames -- the set of class/struct names visible in the current file's AST
+     */
+    extractInitializer?: InitializerExtractor;
+    /**
+     * Scan for untyped `var = callee()` assignments for return-type inference
+     *
+     * Called on every AST node during buildTypeEnv walk; returns undefined for non-matches
+     * The callee binding is unverified -- the caller must confirm against the SymbolTable
+     */
+    scanConstructorBinding?: ConstructorBindingScanner;
+    /**
+     * Extract return type from comment-based annotations (e.g. YARD `@return [Type]`)
+     *
+     * Called as fallback when extractMethodSignature finds no AST-based return type
+     */
+    extractReturnType?: ReturnTypeExtractor;
+    /** Extract loop variable -> type binding from a for-each AST node */
+    extractForLoopBinding?: ForLoopExtractor;
+    /**
+     * Extract plain-identifier assignment (e.g. `const b = a`) for Tier 2 chain propagation
+     *
+     * Called on declaration/assignment nodes; returns {lhs, rhs} when the RHS is a bare
+     * identifier and the LHS has no resolved type yet. Language-specific because AST shapes
+     * differ widely
+     */
+    extractPendingAssignment?: PendingAssignmentExtractor;
+    /**
+     * Extract a typed variable binding from a pattern-matching construct
+     *
+     * Called on every AST node; returns { varName, typeName } when the node introduces a new
+     * typed variable via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`)
+     * Receives the current scope's resolved bindings (read-only) to look up the source
+     * variable's type. Returns undefined for non-matching nodes or unknown source types
+     */
+    extractPatternBinding?: PatternBindingExtractor;
+}

package/dist/core/ingestion/type-extractors/types.js

@@ -0,0 +1,4 @@
+// code-mapper/src/core/ingestion/type-extractors/types.ts
+/** @file types.ts
+ *  @description Type definitions for per-language type extraction used by TypeEnv */
+export {};

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

@@ -0,0 +1,4 @@
+/** @file typescript.ts
+ *  @description Type extraction for TypeScript and JavaScript (including JSDoc annotations) */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;