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 IArbSys extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIArbSysTypes;
    $meta: {
        class: string;
    };
    arbBlockHash(arbBlockNum: bigint): Promise<TEth.Hex>;
    arbBlockNumber(): Promise<bigint>;
    arbChainID(): Promise<bigint>;
    arbOSVersion(): Promise<bigint>;
    getStorageGasAvailable(): Promise<bigint>;
    isTopLevelCall(): Promise<boolean>;
    mapL1SenderContractAddressToL2Alias(_sender: TAddress, unused: TAddress): Promise<TAddress>;
    myCallersAddressWithoutAliasing(): Promise<TAddress>;
    sendMerkleTreeState(): Promise<{
        size: bigint;
        root: TEth.Hex;
        partials: TEth.Hex[];
    }>;
    sendTxToL1(sender: TSender, destination: TAddress, data: TEth.Hex): Promise<TxWriter>;
    wasMyCallersAddressAliased(): Promise<boolean>;
    withdrawEth(sender: TSender, destination: TAddress): Promise<TxWriter>;
    $call(): IIArbSysTxCaller;
    $signed(): TOverrideReturns<IIArbSysTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIArbSysTxData;
    $gas(): TOverrideReturns<IIArbSysTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIArbSysTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIArbSysTypes['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>[]>;
    onL2ToL1Transaction(fn?: (event: TClientEventsStreamData<TEventArguments<'L2ToL1Transaction'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'L2ToL1Transaction'>>>;
    onL2ToL1Tx(fn?: (event: TClientEventsStreamData<TEventArguments<'L2ToL1Tx'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'L2ToL1Tx'>>>;
    onSendMerkleUpdate(fn?: (event: TClientEventsStreamData<TEventArguments<'SendMerkleUpdate'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SendMerkleUpdate'>>>;
    extractLogsL2ToL1Transaction(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'L2ToL1Transaction'>>[];
    extractLogsL2ToL1Tx(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'L2ToL1Tx'>>[];
    extractLogsSendMerkleUpdate(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SendMerkleUpdate'>>[];
    getPastLogsL2ToL1Transaction(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'L2ToL1Transaction'>>[]>;
    getPastLogsL2ToL1Tx(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'L2ToL1Tx'>>[]>;
    getPastLogsSendMerkleUpdate(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            reserved?: bigint;
            hash?: TEth.Hex;
            position?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'SendMerkleUpdate'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIArbSysTypes = {
    Events: {
        L2ToL1Transaction: {
            outputParams: {
                caller: TAddress;
                destination: TAddress;
                uniqueId: bigint;
                batchNumber: bigint;
                indexInBatch: bigint;
                arbBlockNum: bigint;
                ethBlockNum: bigint;
                timestamp: bigint;
                callvalue: bigint;
                data: TEth.Hex;
            };
            outputArgs: [caller: TAddress, destination: TAddress, uniqueId: bigint, batchNumber: bigint, indexInBatch: bigint, arbBlockNum: bigint, ethBlockNum: bigint, timestamp: bigint, callvalue: bigint, data: TEth.Hex];
        };
        L2ToL1Tx: {
            outputParams: {
                caller: TAddress;
                destination: TAddress;
                hash: bigint;
                position: bigint;
                arbBlockNum: bigint;
                ethBlockNum: bigint;
                timestamp: bigint;
                callvalue: bigint;
                data: TEth.Hex;
            };
            outputArgs: [caller: TAddress, destination: TAddress, hash: bigint, position: bigint, arbBlockNum: bigint, ethBlockNum: bigint, timestamp: bigint, callvalue: bigint, data: TEth.Hex];
        };
        SendMerkleUpdate: {
            outputParams: {
                reserved: bigint;
                hash: TEth.Hex;
                position: bigint;
            };
            outputArgs: [reserved: bigint, hash: TEth.Hex, position: bigint];
        };
    };
    Methods: {
        arbBlockHash: {
            method: "arbBlockHash";
            arguments: [arbBlockNum: bigint];
        };
        arbBlockNumber: {
            method: "arbBlockNumber";
            arguments: [];
        };
        arbChainID: {
            method: "arbChainID";
            arguments: [];
        };
        arbOSVersion: {
            method: "arbOSVersion";
            arguments: [];
        };
        getStorageGasAvailable: {
            method: "getStorageGasAvailable";
            arguments: [];
        };
        isTopLevelCall: {
            method: "isTopLevelCall";
            arguments: [];
        };
        mapL1SenderContractAddressToL2Alias: {
            method: "mapL1SenderContractAddressToL2Alias";
            arguments: [_sender: TAddress, unused: TAddress];
        };
        myCallersAddressWithoutAliasing: {
            method: "myCallersAddressWithoutAliasing";
            arguments: [];
        };
        sendMerkleTreeState: {
            method: "sendMerkleTreeState";
            arguments: [];
        };
        sendTxToL1: {
            method: "sendTxToL1";
            arguments: [destination: TAddress, data: TEth.Hex];
        };
        wasMyCallersAddressAliased: {
            method: "wasMyCallersAddressAliased";
            arguments: [];
        };
        withdrawEth: {
            method: "withdrawEth";
            arguments: [destination: TAddress];
        };
    };
};
interface IIArbSysTxCaller {
    sendTxToL1(sender: TSender, destination: TAddress, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdrawEth(sender: TSender, destination: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIArbSysTxData {
    sendTxToL1(sender: TSender, destination: TAddress, data: TEth.Hex): Promise<TEth.TxLike>;
    withdrawEth(sender: TSender, destination: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TIArbSysTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};