import { ethers } from 'ethers';
import { Inbox, Outbox } from '@abacus-network/core';
import { ParsedMessage } from '@abacus-network/utils/dist/src/types';
import { AbacusApp } from '../app';
import { MultiProvider } from '../provider';
import { ConnectionClientConfig } from '../router';
import { ChainMap, ChainName, Remotes } from '../types';
import { CoreContracts } from './contracts';
import { environments } from './environments';
export declare type CoreEnvironment = keyof typeof environments;
export declare type CoreEnvironmentChain<E extends CoreEnvironment> = Extract<keyof typeof environments[E], ChainName>;
export declare type CoreContractsMap<Chain extends ChainName> = {
    [local in Chain]: CoreContracts<Chain, local>;
};
declare type DispatchedMessage = {
    leafIndex: number;
    message: string;
    parsed: ParsedMessage;
};
export declare class AbacusCore<Chain extends ChainName = ChainName> extends AbacusApp<CoreContracts<Chain, Chain>, Chain> {
    constructor(contractsMap: CoreContractsMap<Chain>, multiProvider: MultiProvider<Chain>);
    static fromEnvironment<Env extends CoreEnvironment>(env: Env, multiProvider: MultiProvider<CoreEnvironmentChain<Env>>): AbacusCore<CoreEnvironmentChain<Env>>;
    getContracts<Local extends Chain>(chain: Local): CoreContracts<Chain, Local>;
    getConnectionClientConfig(chain: Chain): ConnectionClientConfig;
    getConnectionClientConfigMap(): ChainMap<Chain, ConnectionClientConfig>;
    extendWithConnectionClientConfig<T>(configMap: ChainMap<Chain, T>): ChainMap<Chain, T & ConnectionClientConfig>;
    extendWithConnectionManagers<T>(config: ChainMap<Chain, T>): ChainMap<Chain, T & {
        abacusConnectionManager: string;
    }>;
    getMailboxPair<Local extends Chain>(origin: Remotes<Chain, Local>, destination: Local): {
        originOutbox: Outbox;
        destinationInbox: Inbox;
    };
    protected getDestination(message: DispatchedMessage): {
        inbox: Inbox;
        chainConnection: ChainMap<Chain, import("../provider").ChainConnection>[Chain];
    };
    protected waitForProcessReceipt(message: DispatchedMessage): Promise<ethers.ContractReceipt>;
    getDispatchedMessages(sourceTx: ethers.ContractReceipt): DispatchedMessage[];
    waitForMessageProcessing(sourceTx: ethers.ContractReceipt): Promise<ethers.ContractReceipt[]>;
}
export {};
//# sourceMappingURL=app.d.ts.map