/**
 * Contextual Type Checks & Identifier Analysis
 *
 * AST-based contextual type detection helpers for lambdas, object literals,
 * and array literals. Also includes generic function value identifier
 * analysis and symbol resolution utilities.
 */
import * as ts from "typescript";
/**
 * DETERMINISTIC IR TYPING (INV-0 compliant):
 * Check if a lambda is in a position where expected types provide parameter types.
 *
 * This replaces the old getContextualType-based inference with AST analysis.
 * Expected types are propagated from:
 * 1. Call arguments - the callee's parameter type provides the expected type
 * 2. Variable initializers - the variable's type annotation provides the expected type
 * 3. New expression arguments - the constructor's parameter type provides the expected type
 * 4. Return statements - the function's return type provides the expected type
 * 5. Property assignments - the object's contextual type provides the expected type
 * 6. Nested arrow functions - body of another arrow that has expected context
 */
export declare const lambdaHasExpectedTypeContext: (lambda: ts.ArrowFunction | ts.FunctionExpression) => boolean;
export declare const arrayLiteralHasContextualType: (node: ts.ArrayLiteralExpression) => boolean;
/**
 * Find the containing function declaration/expression for a node.
 */
export declare const findContainingFunction: (node: ts.Node) => ts.FunctionLikeDeclaration | undefined;
/**
 * DETERMINISTIC IR TYPING (INV-0 compliant):
 * Check if an object literal is in a position where expected types are available.
 */
export declare const objectLiteralHasContextualType: (node: ts.ObjectLiteralExpression) => boolean;
export declare const isAllowedGenericFunctionValueIdentifierUse: (node: ts.Identifier, checker: ts.TypeChecker) => boolean;
export declare const getReferencedIdentifierSymbol: (checker: ts.TypeChecker, node: ts.Identifier) => ts.Symbol | undefined;
//# sourceMappingURL=contextual-type-checks.d.ts.map