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 IInbox extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIInboxTypes;
    $meta: {
        class: string;
    };
    bridge(): Promise<TAddress>;
    calculateRetryableSubmissionFee(dataLength: bigint, baseFee: bigint): Promise<bigint>;
    createRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<TxWriter>;
    depositEth(sender: TSender): Promise<TxWriter>;
    initialize(sender: TSender, _bridge: TAddress, _sequencerInbox: TAddress): Promise<TxWriter>;
    pause(sender: TSender): Promise<TxWriter>;
    postUpgradeInit(sender: TSender, _bridge: TAddress): Promise<TxWriter>;
    sendContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    sendL1FundedContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, data: TEth.Hex): Promise<TxWriter>;
    sendL1FundedUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, data: TEth.Hex): Promise<TxWriter>;
    sendL2Message(sender: TSender, messageData: TEth.Hex): Promise<TxWriter>;
    sendL2MessageFromOrigin(sender: TSender, messageData: TEth.Hex): Promise<TxWriter>;
    sendUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    sequencerInbox(): Promise<TAddress>;
    unpause(sender: TSender): Promise<TxWriter>;
    unsafeCreateRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<TxWriter>;
    $call(): IIInboxTxCaller;
    $signed(): TOverrideReturns<IIInboxTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIInboxTxData;
    $gas(): TOverrideReturns<IIInboxTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIInboxTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIInboxTypes['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>[]>;
    onInboxMessageDelivered(fn?: (event: TClientEventsStreamData<TEventArguments<'InboxMessageDelivered'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'InboxMessageDelivered'>>>;
    onInboxMessageDeliveredFromOrigin(fn?: (event: TClientEventsStreamData<TEventArguments<'InboxMessageDeliveredFromOrigin'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'InboxMessageDeliveredFromOrigin'>>>;
    extractLogsInboxMessageDelivered(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'InboxMessageDelivered'>>[];
    extractLogsInboxMessageDeliveredFromOrigin(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'InboxMessageDeliveredFromOrigin'>>[];
    getPastLogsInboxMessageDelivered(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            messageNum?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'InboxMessageDelivered'>>[]>;
    getPastLogsInboxMessageDeliveredFromOrigin(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            messageNum?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'InboxMessageDeliveredFromOrigin'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIInboxTypes = {
    Events: {
        InboxMessageDelivered: {
            outputParams: {
                messageNum: bigint;
                data: TEth.Hex;
            };
            outputArgs: [messageNum: bigint, data: TEth.Hex];
        };
        InboxMessageDeliveredFromOrigin: {
            outputParams: {
                messageNum: bigint;
            };
            outputArgs: [messageNum: bigint];
        };
    };
    Methods: {
        bridge: {
            method: "bridge";
            arguments: [];
        };
        calculateRetryableSubmissionFee: {
            method: "calculateRetryableSubmissionFee";
            arguments: [dataLength: bigint, baseFee: bigint];
        };
        createRetryableTicket: {
            method: "createRetryableTicket";
            arguments: [to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex];
        };
        depositEth: {
            method: "depositEth";
            arguments: [];
        };
        initialize: {
            method: "initialize";
            arguments: [_bridge: TAddress, _sequencerInbox: TAddress];
        };
        pause: {
            method: "pause";
            arguments: [];
        };
        postUpgradeInit: {
            method: "postUpgradeInit";
            arguments: [_bridge: TAddress];
        };
        sendContractTransaction: {
            method: "sendContractTransaction";
            arguments: [gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, value: bigint, data: TEth.Hex];
        };
        sendL1FundedContractTransaction: {
            method: "sendL1FundedContractTransaction";
            arguments: [gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, data: TEth.Hex];
        };
        sendL1FundedUnsignedTransaction: {
            method: "sendL1FundedUnsignedTransaction";
            arguments: [gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, data: TEth.Hex];
        };
        sendL2Message: {
            method: "sendL2Message";
            arguments: [messageData: TEth.Hex];
        };
        sendL2MessageFromOrigin: {
            method: "sendL2MessageFromOrigin";
            arguments: [messageData: TEth.Hex];
        };
        sendUnsignedTransaction: {
            method: "sendUnsignedTransaction";
            arguments: [gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, value: bigint, data: TEth.Hex];
        };
        sequencerInbox: {
            method: "sequencerInbox";
            arguments: [];
        };
        unpause: {
            method: "unpause";
            arguments: [];
        };
        unsafeCreateRetryableTicket: {
            method: "unsafeCreateRetryableTicket";
            arguments: [to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex];
        };
    };
};
interface IIInboxTxCaller {
    createRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    depositEth(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    initialize(sender: TSender, _bridge: TAddress, _sequencerInbox: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    pause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    postUpgradeInit(sender: TSender, _bridge: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendL1FundedContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendL1FundedUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendL2Message(sender: TSender, messageData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendL2MessageFromOrigin(sender: TSender, messageData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    sendUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unpause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unsafeCreateRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIInboxTxData {
    createRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    depositEth(sender: TSender): Promise<TEth.TxLike>;
    initialize(sender: TSender, _bridge: TAddress, _sequencerInbox: TAddress): Promise<TEth.TxLike>;
    pause(sender: TSender): Promise<TEth.TxLike>;
    postUpgradeInit(sender: TSender, _bridge: TAddress): Promise<TEth.TxLike>;
    sendContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    sendL1FundedContractTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, to: TAddress, data: TEth.Hex): Promise<TEth.TxLike>;
    sendL1FundedUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, data: TEth.Hex): Promise<TEth.TxLike>;
    sendL2Message(sender: TSender, messageData: TEth.Hex): Promise<TEth.TxLike>;
    sendL2MessageFromOrigin(sender: TSender, messageData: TEth.Hex): Promise<TEth.TxLike>;
    sendUnsignedTransaction(sender: TSender, gasLimit: bigint, maxFeePerGas: bigint, nonce: bigint, to: TAddress, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    unpause(sender: TSender): Promise<TEth.TxLike>;
    unsafeCreateRetryableTicket(sender: TSender, to: TAddress, l2CallValue: bigint, maxSubmissionCost: bigint, excessFeeRefundAddress: TAddress, callValueRefundAddress: TAddress, gasLimit: bigint, maxFeePerGas: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TIInboxTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};