import { TAddress } from '../../models/TAddress';
import { TAccount } from '../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../clients/ClientEventsStream';
import { ContractBase } from '../../contracts/ContractBase';
import { TxWriter } from '../../txs/TxWriter';
import { ITxLogItem } from '../../txs/receipt/ITxLogItem';
import { Web3Client } from '../../clients/Web3Client';
import { IBlockchainExplorer } from '../../explorer/IBlockchainExplorer';
import { SubjectStream } from '../../class/SubjectStream';
import type { TAbiItem } from '../../types/TAbi';
import type { TEth } from '../../models/TEth';
import type { TOverrideReturns } from '../../utils/types';
export declare class IOutbox extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIOutboxTypes;
    $meta: {
        class: string;
    };
    OUTBOX_VERSION(): Promise<bigint>;
    bridge(): Promise<TAddress>;
    calculateItemHash(l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<TEth.Hex>;
    calculateMerkleRoot(proof: TEth.Hex[], path: bigint, item: TEth.Hex): Promise<TEth.Hex>;
    executeTransaction(sender: TSender, proof: TEth.Hex[], index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    executeTransactionSimulation(sender: TSender, index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    isSpent(index: bigint): Promise<boolean>;
    l2ToL1Block(): Promise<bigint>;
    l2ToL1EthBlock(): Promise<bigint>;
    l2ToL1OutputId(): Promise<TEth.Hex>;
    l2ToL1Sender(): Promise<TAddress>;
    l2ToL1Timestamp(): Promise<bigint>;
    rollup(): Promise<TAddress>;
    roots(input0: TEth.Hex): Promise<TEth.Hex>;
    spent(input0: bigint): Promise<TEth.Hex>;
    updateSendRoot(sender: TSender, sendRoot: TEth.Hex, l2BlockHash: TEth.Hex): Promise<TxWriter>;
    $call(): IIOutboxTxCaller;
    $signed(): TOverrideReturns<IIOutboxTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIOutboxTxData;
    $gas(): TOverrideReturns<IIOutboxTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIOutboxTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIOutboxTypes['Methods'][TMethod]['arguments'];
        };
    }>;
    onLog(event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>;
    getPastLogs<TEventName extends keyof TEvents>(events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    getPastLogs<TEventName extends keyof TEvents>(event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    onOutBoxTransactionExecuted(fn?: (event: TClientEventsStreamData<TEventArguments<'OutBoxTransactionExecuted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OutBoxTransactionExecuted'>>>;
    onSendRootUpdated(fn?: (event: TClientEventsStreamData<TEventArguments<'SendRootUpdated'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SendRootUpdated'>>>;
    extractLogsOutBoxTransactionExecuted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OutBoxTransactionExecuted'>>[];
    extractLogsSendRootUpdated(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SendRootUpdated'>>[];
    getPastLogsOutBoxTransactionExecuted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            to?: TAddress;
            l2Sender?: TAddress;
            zero?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'OutBoxTransactionExecuted'>>[]>;
    getPastLogsSendRootUpdated(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            blockHash?: TEth.Hex;
            outputRoot?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'SendRootUpdated'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIOutboxTypes = {
    Events: {
        OutBoxTransactionExecuted: {
            outputParams: {
                to: TAddress;
                l2Sender: TAddress;
                zero: bigint;
                transactionIndex: bigint;
            };
            outputArgs: [to: TAddress, l2Sender: TAddress, zero: bigint, transactionIndex: bigint];
        };
        SendRootUpdated: {
            outputParams: {
                blockHash: TEth.Hex;
                outputRoot: TEth.Hex;
            };
            outputArgs: [blockHash: TEth.Hex, outputRoot: TEth.Hex];
        };
    };
    Methods: {
        OUTBOX_VERSION: {
            method: "OUTBOX_VERSION";
            arguments: [];
        };
        bridge: {
            method: "bridge";
            arguments: [];
        };
        calculateItemHash: {
            method: "calculateItemHash";
            arguments: [l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex];
        };
        calculateMerkleRoot: {
            method: "calculateMerkleRoot";
            arguments: [proof: TEth.Hex[], path: bigint, item: TEth.Hex];
        };
        executeTransaction: {
            method: "executeTransaction";
            arguments: [proof: TEth.Hex[], index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex];
        };
        executeTransactionSimulation: {
            method: "executeTransactionSimulation";
            arguments: [index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex];
        };
        isSpent: {
            method: "isSpent";
            arguments: [index: bigint];
        };
        l2ToL1Block: {
            method: "l2ToL1Block";
            arguments: [];
        };
        l2ToL1EthBlock: {
            method: "l2ToL1EthBlock";
            arguments: [];
        };
        l2ToL1OutputId: {
            method: "l2ToL1OutputId";
            arguments: [];
        };
        l2ToL1Sender: {
            method: "l2ToL1Sender";
            arguments: [];
        };
        l2ToL1Timestamp: {
            method: "l2ToL1Timestamp";
            arguments: [];
        };
        rollup: {
            method: "rollup";
            arguments: [];
        };
        roots: {
            method: "roots";
            arguments: [input0: TEth.Hex];
        };
        spent: {
            method: "spent";
            arguments: [input0: bigint];
        };
        updateSendRoot: {
            method: "updateSendRoot";
            arguments: [sendRoot: TEth.Hex, l2BlockHash: TEth.Hex];
        };
    };
};
interface IIOutboxTxCaller {
    executeTransaction(sender: TSender, proof: TEth.Hex[], index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    executeTransactionSimulation(sender: TSender, index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    updateSendRoot(sender: TSender, sendRoot: TEth.Hex, l2BlockHash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIOutboxTxData {
    executeTransaction(sender: TSender, proof: TEth.Hex[], index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    executeTransactionSimulation(sender: TSender, index: bigint, l2Sender: TAddress, to: TAddress, l2Block: bigint, l1Block: bigint, l2Timestamp: bigint, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    updateSendRoot(sender: TSender, sendRoot: TEth.Hex, l2BlockHash: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TIOutboxTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};