import { ASTNodeConstructor } from "./ast_node";
import { ContractDefinition } from "./implementation/declaration/contract_definition";
import { EventDefinition } from "./implementation/declaration/event_definition";
import { FunctionDefinition } from "./implementation/declaration/function_definition";
import { ModifierDefinition } from "./implementation/declaration/modifier_definition";
import { VariableDeclaration } from "./implementation/declaration/variable_declaration";
import { EmitStatement } from "./implementation/statement/emit_statement";
type FunctionLikeResolvable = FunctionDefinition | ModifierDefinition | EventDefinition;
type Resolvable = FunctionLikeResolvable | VariableDeclaration;
export declare function resolve<T extends Resolvable>(scope: ContractDefinition, target: T, onlyParents?: boolean): T | undefined;
/**
 * Resolve an inheritable contract property following the standard C3 linearization order.
 *
 * @param constructor The class constructor of the type of contract
 *   property we are resolving. One of `FunctionDefinition`,
 *   `ModifierDefinition`, `EventDefinition` or `VariableDeclaration`
 * @param name Name of the property we are attempting to resolve. Note that
 *   if we are resolving functions or events there may be multiple results as
 *   functions/events can have the same name and different arguments
 * @param onlyParents boolean flag specifing that we want to only look through the bases of the contract.
 */
export declare function resolveByName<T extends Resolvable>(scope: ContractDefinition, constructor: ASTNodeConstructor<T>, name: string, onlyParents?: boolean): T[];
export declare function resolveEvent(scope: ContractDefinition, statement: EmitStatement): EventDefinition | undefined;
export declare function resolveCallable(scope: ContractDefinition, definition: FunctionDefinition | VariableDeclaration, onlyParents?: boolean): FunctionDefinition | VariableDeclaration | undefined;
export {};
//# sourceMappingURL=dispatch.d.ts.map