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 ICompoundTimelock extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TICompoundTimelockTypes;
    $meta: {
        class: string;
    };
    GRACE_PERIOD(): Promise<bigint>;
    MAXIMUM_DELAY(): Promise<bigint>;
    MINIMUM_DELAY(): Promise<bigint>;
    acceptAdmin(sender: TSender): Promise<TxWriter>;
    admin(): Promise<TAddress>;
    cancelTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TxWriter>;
    delay(): Promise<bigint>;
    executeTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TxWriter>;
    pendingAdmin(): Promise<TAddress>;
    queueTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TxWriter>;
    queuedTransactions(input0: TEth.Hex): Promise<boolean>;
    setDelay(sender: TSender, input0: bigint): Promise<TxWriter>;
    setPendingAdmin(sender: TSender, input0: TAddress): Promise<TxWriter>;
    $call(): IICompoundTimelockTxCaller;
    $signed(): TOverrideReturns<IICompoundTimelockTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IICompoundTimelockTxData;
    $gas(): TOverrideReturns<IICompoundTimelockTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TICompoundTimelockTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TICompoundTimelockTypes['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>[]>;
    onCancelTransaction(fn?: (event: TClientEventsStreamData<TEventArguments<'CancelTransaction'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'CancelTransaction'>>>;
    onExecuteTransaction(fn?: (event: TClientEventsStreamData<TEventArguments<'ExecuteTransaction'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExecuteTransaction'>>>;
    onNewAdmin(fn?: (event: TClientEventsStreamData<TEventArguments<'NewAdmin'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewAdmin'>>>;
    onNewDelay(fn?: (event: TClientEventsStreamData<TEventArguments<'NewDelay'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewDelay'>>>;
    onNewPendingAdmin(fn?: (event: TClientEventsStreamData<TEventArguments<'NewPendingAdmin'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewPendingAdmin'>>>;
    onQueueTransaction(fn?: (event: TClientEventsStreamData<TEventArguments<'QueueTransaction'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'QueueTransaction'>>>;
    extractLogsCancelTransaction(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'CancelTransaction'>>[];
    extractLogsExecuteTransaction(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExecuteTransaction'>>[];
    extractLogsNewAdmin(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewAdmin'>>[];
    extractLogsNewDelay(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewDelay'>>[];
    extractLogsNewPendingAdmin(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewPendingAdmin'>>[];
    extractLogsQueueTransaction(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'QueueTransaction'>>[];
    getPastLogsCancelTransaction(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            txHash?: TEth.Hex;
            target?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'CancelTransaction'>>[]>;
    getPastLogsExecuteTransaction(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            txHash?: TEth.Hex;
            target?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ExecuteTransaction'>>[]>;
    getPastLogsNewAdmin(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            newAdmin?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'NewAdmin'>>[]>;
    getPastLogsNewDelay(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            newDelay?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'NewDelay'>>[]>;
    getPastLogsNewPendingAdmin(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            newPendingAdmin?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'NewPendingAdmin'>>[]>;
    getPastLogsQueueTransaction(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            txHash?: TEth.Hex;
            target?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'QueueTransaction'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TICompoundTimelockTypes = {
    Events: {
        CancelTransaction: {
            outputParams: {
                txHash: TEth.Hex;
                target: TAddress;
                value: bigint;
                signature: string;
                data: TEth.Hex;
                eta: bigint;
            };
            outputArgs: [txHash: TEth.Hex, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
        ExecuteTransaction: {
            outputParams: {
                txHash: TEth.Hex;
                target: TAddress;
                value: bigint;
                signature: string;
                data: TEth.Hex;
                eta: bigint;
            };
            outputArgs: [txHash: TEth.Hex, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
        NewAdmin: {
            outputParams: {
                newAdmin: TAddress;
            };
            outputArgs: [newAdmin: TAddress];
        };
        NewDelay: {
            outputParams: {
                newDelay: bigint;
            };
            outputArgs: [newDelay: bigint];
        };
        NewPendingAdmin: {
            outputParams: {
                newPendingAdmin: TAddress;
            };
            outputArgs: [newPendingAdmin: TAddress];
        };
        QueueTransaction: {
            outputParams: {
                txHash: TEth.Hex;
                target: TAddress;
                value: bigint;
                signature: string;
                data: TEth.Hex;
                eta: bigint;
            };
            outputArgs: [txHash: TEth.Hex, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
    };
    Methods: {
        GRACE_PERIOD: {
            method: "GRACE_PERIOD";
            arguments: [];
        };
        MAXIMUM_DELAY: {
            method: "MAXIMUM_DELAY";
            arguments: [];
        };
        MINIMUM_DELAY: {
            method: "MINIMUM_DELAY";
            arguments: [];
        };
        acceptAdmin: {
            method: "acceptAdmin";
            arguments: [];
        };
        admin: {
            method: "admin";
            arguments: [];
        };
        cancelTransaction: {
            method: "cancelTransaction";
            arguments: [target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
        delay: {
            method: "delay";
            arguments: [];
        };
        executeTransaction: {
            method: "executeTransaction";
            arguments: [target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
        pendingAdmin: {
            method: "pendingAdmin";
            arguments: [];
        };
        queueTransaction: {
            method: "queueTransaction";
            arguments: [target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint];
        };
        queuedTransactions: {
            method: "queuedTransactions";
            arguments: [input0: TEth.Hex];
        };
        setDelay: {
            method: "setDelay";
            arguments: [input0: bigint];
        };
        setPendingAdmin: {
            method: "setPendingAdmin";
            arguments: [input0: TAddress];
        };
    };
};
interface IICompoundTimelockTxCaller {
    acceptAdmin(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    cancelTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    executeTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    queueTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setDelay(sender: TSender, input0: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setPendingAdmin(sender: TSender, input0: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IICompoundTimelockTxData {
    acceptAdmin(sender: TSender): Promise<TEth.TxLike>;
    cancelTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TEth.TxLike>;
    executeTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TEth.TxLike>;
    queueTransaction(sender: TSender, target: TAddress, value: bigint, signature: string, data: TEth.Hex, eta: bigint): Promise<TEth.TxLike>;
    setDelay(sender: TSender, input0: bigint): Promise<TEth.TxLike>;
    setPendingAdmin(sender: TSender, input0: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TICompoundTimelockTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};