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 IAMB extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIAMBTypes;
    $meta: {
        class: string;
    };
    destinationChainId(): Promise<bigint>;
    failedMessageDataHash(_messageId: TEth.Hex): Promise<TEth.Hex>;
    failedMessageReceiver(_messageId: TEth.Hex): Promise<TAddress>;
    failedMessageSender(_messageId: TEth.Hex): Promise<TAddress>;
    maxGasPerTx(): Promise<bigint>;
    messageCallStatus(_messageId: TEth.Hex): Promise<boolean>;
    messageId(): Promise<TEth.Hex>;
    messageSender(): Promise<TAddress>;
    messageSourceChainId(): Promise<TEth.Hex>;
    requireToConfirmMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<TxWriter>;
    requireToPassMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<TxWriter>;
    sourceChainId(): Promise<bigint>;
    transactionHash(): Promise<TEth.Hex>;
    $call(): IIAMBTxCaller;
    $signed(): TOverrideReturns<IIAMBTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIAMBTxData;
    $gas(): TOverrideReturns<IIAMBTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIAMBTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIAMBTypes['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>[]>;
    onAffirmationCompleted(fn?: (event: TClientEventsStreamData<TEventArguments<'AffirmationCompleted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AffirmationCompleted'>>>;
    onRelayedMessage(fn?: (event: TClientEventsStreamData<TEventArguments<'RelayedMessage'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RelayedMessage'>>>;
    onUserRequestForAffirmation(fn?: (event: TClientEventsStreamData<TEventArguments<'UserRequestForAffirmation'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'UserRequestForAffirmation'>>>;
    onUserRequestForSignature(fn?: (event: TClientEventsStreamData<TEventArguments<'UserRequestForSignature'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'UserRequestForSignature'>>>;
    extractLogsAffirmationCompleted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AffirmationCompleted'>>[];
    extractLogsRelayedMessage(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RelayedMessage'>>[];
    extractLogsUserRequestForAffirmation(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'UserRequestForAffirmation'>>[];
    extractLogsUserRequestForSignature(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'UserRequestForSignature'>>[];
    getPastLogsAffirmationCompleted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
            executor?: TAddress;
            messageId?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'AffirmationCompleted'>>[]>;
    getPastLogsRelayedMessage(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
            executor?: TAddress;
            messageId?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'RelayedMessage'>>[]>;
    getPastLogsUserRequestForAffirmation(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            messageId?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'UserRequestForAffirmation'>>[]>;
    getPastLogsUserRequestForSignature(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            messageId?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'UserRequestForSignature'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIAMBTypes = {
    Events: {
        AffirmationCompleted: {
            outputParams: {
                _sender: TAddress;
                executor: TAddress;
                messageId: TEth.Hex;
                status: boolean;
            };
            outputArgs: [_sender: TAddress, executor: TAddress, messageId: TEth.Hex, status: boolean];
        };
        RelayedMessage: {
            outputParams: {
                _sender: TAddress;
                executor: TAddress;
                messageId: TEth.Hex;
                status: boolean;
            };
            outputArgs: [_sender: TAddress, executor: TAddress, messageId: TEth.Hex, status: boolean];
        };
        UserRequestForAffirmation: {
            outputParams: {
                messageId: TEth.Hex;
                encodedData: TEth.Hex;
            };
            outputArgs: [messageId: TEth.Hex, encodedData: TEth.Hex];
        };
        UserRequestForSignature: {
            outputParams: {
                messageId: TEth.Hex;
                encodedData: TEth.Hex;
            };
            outputArgs: [messageId: TEth.Hex, encodedData: TEth.Hex];
        };
    };
    Methods: {
        destinationChainId: {
            method: "destinationChainId";
            arguments: [];
        };
        failedMessageDataHash: {
            method: "failedMessageDataHash";
            arguments: [_messageId: TEth.Hex];
        };
        failedMessageReceiver: {
            method: "failedMessageReceiver";
            arguments: [_messageId: TEth.Hex];
        };
        failedMessageSender: {
            method: "failedMessageSender";
            arguments: [_messageId: TEth.Hex];
        };
        maxGasPerTx: {
            method: "maxGasPerTx";
            arguments: [];
        };
        messageCallStatus: {
            method: "messageCallStatus";
            arguments: [_messageId: TEth.Hex];
        };
        messageId: {
            method: "messageId";
            arguments: [];
        };
        messageSender: {
            method: "messageSender";
            arguments: [];
        };
        messageSourceChainId: {
            method: "messageSourceChainId";
            arguments: [];
        };
        requireToConfirmMessage: {
            method: "requireToConfirmMessage";
            arguments: [_contract: TAddress, _data: TEth.Hex, _gas: bigint];
        };
        requireToPassMessage: {
            method: "requireToPassMessage";
            arguments: [_contract: TAddress, _data: TEth.Hex, _gas: bigint];
        };
        sourceChainId: {
            method: "sourceChainId";
            arguments: [];
        };
        transactionHash: {
            method: "transactionHash";
            arguments: [];
        };
    };
};
interface IIAMBTxCaller {
    requireToConfirmMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    requireToPassMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIAMBTxData {
    requireToConfirmMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<TEth.TxLike>;
    requireToPassMessage(sender: TSender, _contract: TAddress, _data: TEth.Hex, _gas: bigint): Promise<TEth.TxLike>;
}
type TEvents = TIAMBTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};