/**
 * Member access property type resolution and name extraction helpers
 *
 * ALICE'S SPEC: All member type queries go through TypeSystem.typeOfMember().
 */
import * as ts from "typescript";
import { IrType, ComputedAccessKind, ComputedAccessProtocol } from "../../../types.js";
import type { ProgramContext } from "../../../program-context.js";
export declare const hasDeclaredMemberByName: (receiverIrType: IrType | undefined, propertyName: string, ctx: ProgramContext) => boolean;
/**
 * Get the declared property type from a property access expression.
 *
 * ALICE'S SPEC: Uses explicit TypeSystem queries only.
 * Prefer exact member-handle typing when Binding resolved the property access to a
 * concrete declaration; otherwise use receiver+member TypeSystem lookup.
 *
 * @param node - Property access expression node
 * @param receiverIrType - Already-computed IR type of the receiver (object) expression
 * @param ctx - ProgramContext for type system and binding access
 * @returns The deterministically computed property type
 */
export declare const getDeclaredPropertyType: (node: ts.PropertyAccessExpression, receiverIrType: IrType | undefined, ctx: ProgramContext) => IrType | undefined;
/**
 * Normalize a receiver type for computed access classification.
 *
 * This supports common TS shapes that appear at runtime:
 * - Nullish unions (`T | undefined` / `T | null | undefined`)
 * - tsbindgen-style intersection views (`T$instance & __T$views`, and primitives like
 *   `string & String$instance & __String$views`)
 *
 * The goal is to preserve deterministic proof behavior without heuristics.
 */
export declare const normalizeForComputedAccess: (type: IrType | undefined) => IrType | undefined;
export declare const resolveComputedAccessProtocol: (objectType: IrType | undefined, ctx: ProgramContext) => ComputedAccessProtocol | undefined;
/**
 * Classify computed member access for proof pass.
 * This determines whether Int32 proof is required for the index.
 *
 * Classification is based on IR type kinds, NOT string matching.
 * CLR indexers (arrays, List<T>, etc.) require Int32 proof for indices.
 *
 * IMPORTANT: If classification cannot be determined reliably for a CLR-bound
 * reference type, we conservatively assume `clrIndexer` (requires Int32 proof).
 * This is safer than allowing arbitrary dictionary access without proof.
 *
 * @param objectType - The inferred type of the object being accessed
 * @returns The access kind classification
 */
export declare const classifyComputedAccess: (objectType: IrType | undefined, ctx: ProgramContext) => ComputedAccessKind;
/**
 * Extract the type name from an inferred type for binding lookup.
 * Handles tsbindgen's naming convention where instance types are suffixed with $instance
 * (e.g., List_1$instance → List_1 for binding lookup)
 *
 * Also handles intersection types like `TypeName$instance & __TypeName$views`
 * which are common in tsbindgen-generated types. In this case, we look for
 * the $instance member and extract the type name from it.
 */
export declare const extractTypeName: (inferredType: IrType | undefined) => string | undefined;
/**
 * Derive element type from object type for element access.
 * - Array type → element type
 * - Dictionary type → value type
 * - String → string (single character)
 * - Other → undefined
 */
export declare const deriveElementType: (objectType: IrType | undefined, ctx: ProgramContext, accessExpression?: ts.Expression) => IrType | undefined;
//# sourceMappingURL=member-resolution.d.ts.map