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 IBridge extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIBridgeTypes;
    $meta: {
        class: string;
    };
    activeOutbox(): Promise<TAddress>;
    allowedDelayedInboxList(sender: TSender, input0: bigint): Promise<TxWriter>;
    allowedDelayedInboxes(inbox: TAddress): Promise<boolean>;
    allowedOutboxList(sender: TSender, input0: bigint): Promise<TxWriter>;
    allowedOutboxes(outbox: TAddress): Promise<boolean>;
    delayedInboxAccs(input0: bigint): Promise<TEth.Hex>;
    delayedMessageCount(): Promise<bigint>;
    enqueueDelayedMessage(sender: TSender, kind: number, _sender: TAddress, messageDataHash: TEth.Hex): Promise<TxWriter>;
    enqueueSequencerMessage(sender: TSender, dataHash: TEth.Hex, afterDelayedMessagesRead: bigint, prevMessageCount: bigint, newMessageCount: bigint): Promise<TxWriter>;
    executeCall(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    initialize(sender: TSender, rollup_: TAddress): Promise<TxWriter>;
    rollup(): Promise<TAddress>;
    sequencerInbox(): Promise<TAddress>;
    sequencerInboxAccs(input0: bigint): Promise<TEth.Hex>;
    sequencerMessageCount(): Promise<bigint>;
    sequencerReportedSubMessageCount(): Promise<bigint>;
    setDelayedInbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<TxWriter>;
    setOutbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<TxWriter>;
    setSequencerInbox(sender: TSender, _sequencerInbox: TAddress): Promise<TxWriter>;
    submitBatchSpendingReport(sender: TSender, batchPoster: TAddress, dataHash: TEth.Hex): Promise<TxWriter>;
    $call(): IIBridgeTxCaller;
    $signed(): TOverrideReturns<IIBridgeTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIBridgeTxData;
    $gas(): TOverrideReturns<IIBridgeTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIBridgeTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIBridgeTypes['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>[]>;
    onBridgeCallTriggered(fn?: (event: TClientEventsStreamData<TEventArguments<'BridgeCallTriggered'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'BridgeCallTriggered'>>>;
    onInboxToggle(fn?: (event: TClientEventsStreamData<TEventArguments<'InboxToggle'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'InboxToggle'>>>;
    onMessageDelivered(fn?: (event: TClientEventsStreamData<TEventArguments<'MessageDelivered'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'MessageDelivered'>>>;
    onOutboxToggle(fn?: (event: TClientEventsStreamData<TEventArguments<'OutboxToggle'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OutboxToggle'>>>;
    onSequencerInboxUpdated(fn?: (event: TClientEventsStreamData<TEventArguments<'SequencerInboxUpdated'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SequencerInboxUpdated'>>>;
    extractLogsBridgeCallTriggered(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'BridgeCallTriggered'>>[];
    extractLogsInboxToggle(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'InboxToggle'>>[];
    extractLogsMessageDelivered(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'MessageDelivered'>>[];
    extractLogsOutboxToggle(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OutboxToggle'>>[];
    extractLogsSequencerInboxUpdated(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SequencerInboxUpdated'>>[];
    getPastLogsBridgeCallTriggered(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            outbox?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'BridgeCallTriggered'>>[]>;
    getPastLogsInboxToggle(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            inbox?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'InboxToggle'>>[]>;
    getPastLogsMessageDelivered(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            messageIndex?: bigint;
            beforeInboxAcc?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'MessageDelivered'>>[]>;
    getPastLogsOutboxToggle(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            outbox?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OutboxToggle'>>[]>;
    getPastLogsSequencerInboxUpdated(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'SequencerInboxUpdated'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIBridgeTypes = {
    Events: {
        BridgeCallTriggered: {
            outputParams: {
                outbox: TAddress;
                to: TAddress;
                value: bigint;
                data: TEth.Hex;
            };
            outputArgs: [outbox: TAddress, to: TAddress, value: bigint, data: TEth.Hex];
        };
        InboxToggle: {
            outputParams: {
                inbox: TAddress;
                enabled: boolean;
            };
            outputArgs: [inbox: TAddress, enabled: boolean];
        };
        MessageDelivered: {
            outputParams: {
                messageIndex: bigint;
                beforeInboxAcc: TEth.Hex;
                inbox: TAddress;
                kind: number;
                _sender: TAddress;
                messageDataHash: TEth.Hex;
                baseFeeL1: bigint;
                timestamp: number;
            };
            outputArgs: [messageIndex: bigint, beforeInboxAcc: TEth.Hex, inbox: TAddress, kind: number, _sender: TAddress, messageDataHash: TEth.Hex, baseFeeL1: bigint, timestamp: number];
        };
        OutboxToggle: {
            outputParams: {
                outbox: TAddress;
                enabled: boolean;
            };
            outputArgs: [outbox: TAddress, enabled: boolean];
        };
        SequencerInboxUpdated: {
            outputParams: {
                newSequencerInbox: TAddress;
            };
            outputArgs: [newSequencerInbox: TAddress];
        };
    };
    Methods: {
        activeOutbox: {
            method: "activeOutbox";
            arguments: [];
        };
        allowedDelayedInboxList: {
            method: "allowedDelayedInboxList";
            arguments: [input0: bigint];
        };
        allowedDelayedInboxes: {
            method: "allowedDelayedInboxes";
            arguments: [inbox: TAddress];
        };
        allowedOutboxList: {
            method: "allowedOutboxList";
            arguments: [input0: bigint];
        };
        allowedOutboxes: {
            method: "allowedOutboxes";
            arguments: [outbox: TAddress];
        };
        delayedInboxAccs: {
            method: "delayedInboxAccs";
            arguments: [input0: bigint];
        };
        delayedMessageCount: {
            method: "delayedMessageCount";
            arguments: [];
        };
        enqueueDelayedMessage: {
            method: "enqueueDelayedMessage";
            arguments: [kind: number, _sender: TAddress, messageDataHash: TEth.Hex];
        };
        enqueueSequencerMessage: {
            method: "enqueueSequencerMessage";
            arguments: [dataHash: TEth.Hex, afterDelayedMessagesRead: bigint, prevMessageCount: bigint, newMessageCount: bigint];
        };
        executeCall: {
            method: "executeCall";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex];
        };
        initialize: {
            method: "initialize";
            arguments: [rollup_: TAddress];
        };
        rollup: {
            method: "rollup";
            arguments: [];
        };
        sequencerInbox: {
            method: "sequencerInbox";
            arguments: [];
        };
        sequencerInboxAccs: {
            method: "sequencerInboxAccs";
            arguments: [input0: bigint];
        };
        sequencerMessageCount: {
            method: "sequencerMessageCount";
            arguments: [];
        };
        sequencerReportedSubMessageCount: {
            method: "sequencerReportedSubMessageCount";
            arguments: [];
        };
        setDelayedInbox: {
            method: "setDelayedInbox";
            arguments: [inbox: TAddress, enabled: boolean];
        };
        setOutbox: {
            method: "setOutbox";
            arguments: [inbox: TAddress, enabled: boolean];
        };
        setSequencerInbox: {
            method: "setSequencerInbox";
            arguments: [_sequencerInbox: TAddress];
        };
        submitBatchSpendingReport: {
            method: "submitBatchSpendingReport";
            arguments: [batchPoster: TAddress, dataHash: TEth.Hex];
        };
    };
};
interface IIBridgeTxCaller {
    allowedDelayedInboxList(sender: TSender, input0: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    allowedOutboxList(sender: TSender, input0: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    enqueueDelayedMessage(sender: TSender, kind: number, _sender: TAddress, messageDataHash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    enqueueSequencerMessage(sender: TSender, dataHash: TEth.Hex, afterDelayedMessagesRead: bigint, prevMessageCount: bigint, newMessageCount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    executeCall(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    initialize(sender: TSender, rollup_: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setDelayedInbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setOutbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setSequencerInbox(sender: TSender, _sequencerInbox: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    submitBatchSpendingReport(sender: TSender, batchPoster: TAddress, dataHash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIBridgeTxData {
    allowedDelayedInboxList(sender: TSender, input0: bigint): Promise<TEth.TxLike>;
    allowedOutboxList(sender: TSender, input0: bigint): Promise<TEth.TxLike>;
    enqueueDelayedMessage(sender: TSender, kind: number, _sender: TAddress, messageDataHash: TEth.Hex): Promise<TEth.TxLike>;
    enqueueSequencerMessage(sender: TSender, dataHash: TEth.Hex, afterDelayedMessagesRead: bigint, prevMessageCount: bigint, newMessageCount: bigint): Promise<TEth.TxLike>;
    executeCall(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    initialize(sender: TSender, rollup_: TAddress): Promise<TEth.TxLike>;
    setDelayedInbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<TEth.TxLike>;
    setOutbox(sender: TSender, inbox: TAddress, enabled: boolean): Promise<TEth.TxLike>;
    setSequencerInbox(sender: TSender, _sequencerInbox: TAddress): Promise<TEth.TxLike>;
    submitBatchSpendingReport(sender: TSender, batchPoster: TAddress, dataHash: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TIBridgeTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};