import type { VariableType } from "../types.js";
/**
 * Eager evaluation for the type operators `keyof T` and `T["key"]`.
 * Both run during type resolution and produce ordinary types, so nothing
 * downstream knows the operator nodes exist.
 *
 * Argument validation is SHARED with the builtin generics
 * (resolveObjectArg / resolveKeysArg) so the error wording stays one
 * family across Partial, Pick, keyof, and indexed access.
 *
 * CYCLE RULE: this module must not import assignability.ts. The resolver
 * arrives as the `resolve` callback, carrying the caller's in-progress
 * guard, so recursive alias operands degrade the same way they do
 * everywhere else.
 */
type Resolve = (t: VariableType) => VariableType;
export declare function evalKeyof(operand: VariableType, resolve: Resolve): VariableType;
export declare function evalIndexedAccess(objectType: VariableType, index: VariableType, resolve: Resolve): VariableType;
/** Injected structural-identity comparator — see the CYCLE RULE above:
 *  typeKey lives behind assignability, so the caller provides equality
 *  the same way it provides `resolve`. */
export type TypeEquals = (a: VariableType, b: VariableType) => boolean;
/**
 * `A & B & ...` — merge object types. Four steps:
 *
 *   RESOLVE  every operand to an object type
 *   GROUP    all properties across all operands by key,
 *            in first-seen key order
 *   COMBINE  each key group into one property (the shared-key
 *            rules live in intersectPropertyValues)
 *   BUILD    an ordinary object type
 *
 * Grouping ALL operands at once (rather than folding pairwise) is what
 * makes the merge n-ary and associative by construction.
 */
export declare function evalIntersection(members: VariableType[], resolve: Resolve, typesEqual: TypeEquals): VariableType;
export {};