import { AgencyNode, FunctionParameter, VariableType } from "../types.js";
import type { BlockType } from "../types/typeHints.js";
import { TypeCheckerContext } from "./types.js";
import { Scope } from "./scope.js";
/**
 * Look up the parameter list for a callable name across local defs, graph
 * nodes, and imported functions — the resolution order used at every call
 * site that needs to inspect a callee's signature.
 */
export declare function getParamsForNodeOrFunc(name: string, ctx: TypeCheckerContext): FunctionParameter[] | undefined;
/**
 * If the named callable's last parameter is `blockType`, return that signature
 * — the slot a trailing/inline block fills. Returns undefined for callables
 * whose block param is untyped, `any`, or absent (block bodies in those cases
 * keep their literal annotations and aren't checked against a contract).
 */
export declare function getBlockSlot(name: string, ctx: TypeCheckerContext): BlockType | undefined;
export declare function isAnyType(t: VariableType): boolean;
/**
 * Check mode (top-down): verify that an expression is compatible with expectedType.
 * Shared by scopes.ts (assignment checking) and checker.ts (return type checking).
 */
export declare function checkType(expr: AgencyNode, expectedType: VariableType, scope: Scope, context: string, ctx: TypeCheckerContext): void;
/**
 * When an object literal meets an object-typed target, every key must
 * correspond to a declared property. Mirrors TypeScript's excess-property
 * check; without it, typos like `modle:` slip through structural
 * assignability. Splat entries are dynamic and skipped.
 */
export declare function checkExcessObjectProperties(literal: AgencyNode & {
    type: "agencyObject";
}, expectedType: VariableType, context: string, ctx: TypeCheckerContext): void;
