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 TimelockController extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TTimelockControllerTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, minDelay: bigint, proposers: TAddress[], executors: TAddress[], admin: TAddress): Promise<TxWriter>;
    CANCELLER_ROLE(): Promise<TEth.Hex>;
    DEFAULT_ADMIN_ROLE(): Promise<TEth.Hex>;
    EXECUTOR_ROLE(): Promise<TEth.Hex>;
    PROPOSER_ROLE(): Promise<TEth.Hex>;
    TIMELOCK_ADMIN_ROLE(): Promise<TEth.Hex>;
    cancel(sender: TSender, id: TEth.Hex): Promise<TxWriter>;
    execute(sender: TSender, target: TAddress, value: bigint, payload: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex): Promise<TxWriter>;
    executeBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex): Promise<TxWriter>;
    getMinDelay(): Promise<bigint>;
    getRoleAdmin(role: TEth.Hex): Promise<TEth.Hex>;
    getTimestamp(id: TEth.Hex): Promise<bigint>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    hasRole(role: TEth.Hex, account: TAddress): Promise<boolean>;
    hashOperation(target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex): Promise<TEth.Hex>;
    hashOperationBatch(targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex): Promise<TEth.Hex>;
    isOperation(id: TEth.Hex): Promise<boolean>;
    isOperationDone(id: TEth.Hex): Promise<boolean>;
    isOperationPending(id: TEth.Hex): Promise<boolean>;
    isOperationReady(id: TEth.Hex): Promise<boolean>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<TxWriter>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<TxWriter>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<TxWriter>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    schedule(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<TxWriter>;
    scheduleBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<TxWriter>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    updateDelay(sender: TSender, newDelay: bigint): Promise<TxWriter>;
    $call(): ITimelockControllerTxCaller;
    $signed(): TOverrideReturns<ITimelockControllerTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): ITimelockControllerTxData;
    $gas(): TOverrideReturns<ITimelockControllerTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TTimelockControllerTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TTimelockControllerTypes['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>[]>;
    onCallExecuted(fn?: (event: TClientEventsStreamData<TEventArguments<'CallExecuted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'CallExecuted'>>>;
    onCallSalt(fn?: (event: TClientEventsStreamData<TEventArguments<'CallSalt'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'CallSalt'>>>;
    onCallScheduled(fn?: (event: TClientEventsStreamData<TEventArguments<'CallScheduled'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'CallScheduled'>>>;
    onCancelled(fn?: (event: TClientEventsStreamData<TEventArguments<'Cancelled'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Cancelled'>>>;
    onMinDelayChange(fn?: (event: TClientEventsStreamData<TEventArguments<'MinDelayChange'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'MinDelayChange'>>>;
    onRoleAdminChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleAdminChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleAdminChanged'>>>;
    onRoleGranted(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleGranted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleGranted'>>>;
    onRoleRevoked(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleRevoked'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleRevoked'>>>;
    extractLogsCallExecuted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'CallExecuted'>>[];
    extractLogsCallSalt(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'CallSalt'>>[];
    extractLogsCallScheduled(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'CallScheduled'>>[];
    extractLogsCancelled(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Cancelled'>>[];
    extractLogsMinDelayChange(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'MinDelayChange'>>[];
    extractLogsRoleAdminChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleAdminChanged'>>[];
    extractLogsRoleGranted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleGranted'>>[];
    extractLogsRoleRevoked(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleRevoked'>>[];
    getPastLogsCallExecuted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: TEth.Hex;
            index?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'CallExecuted'>>[]>;
    getPastLogsCallSalt(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'CallSalt'>>[]>;
    getPastLogsCallScheduled(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: TEth.Hex;
            index?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'CallScheduled'>>[]>;
    getPastLogsCancelled(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'Cancelled'>>[]>;
    getPastLogsMinDelayChange(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'MinDelayChange'>>[]>;
    getPastLogsRoleAdminChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            previousAdminRole?: TEth.Hex;
            newAdminRole?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleAdminChanged'>>[]>;
    getPastLogsRoleGranted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            account?: TAddress;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleGranted'>>[]>;
    getPastLogsRoleRevoked(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            account?: TAddress;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleRevoked'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TTimelockControllerTypes = {
    Events: {
        CallExecuted: {
            outputParams: {
                id: TEth.Hex;
                index: bigint;
                target: TAddress;
                value: bigint;
                data: TEth.Hex;
            };
            outputArgs: [id: TEth.Hex, index: bigint, target: TAddress, value: bigint, data: TEth.Hex];
        };
        CallSalt: {
            outputParams: {
                id: TEth.Hex;
                salt: TEth.Hex;
            };
            outputArgs: [id: TEth.Hex, salt: TEth.Hex];
        };
        CallScheduled: {
            outputParams: {
                id: TEth.Hex;
                index: bigint;
                target: TAddress;
                value: bigint;
                data: TEth.Hex;
                predecessor: TEth.Hex;
                delay: bigint;
            };
            outputArgs: [id: TEth.Hex, index: bigint, target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, delay: bigint];
        };
        Cancelled: {
            outputParams: {
                id: TEth.Hex;
            };
            outputArgs: [id: TEth.Hex];
        };
        MinDelayChange: {
            outputParams: {
                oldDuration: bigint;
                newDuration: bigint;
            };
            outputArgs: [oldDuration: bigint, newDuration: bigint];
        };
        RoleAdminChanged: {
            outputParams: {
                role: TEth.Hex;
                previousAdminRole: TEth.Hex;
                newAdminRole: TEth.Hex;
            };
            outputArgs: [role: TEth.Hex, previousAdminRole: TEth.Hex, newAdminRole: TEth.Hex];
        };
        RoleGranted: {
            outputParams: {
                role: TEth.Hex;
                account: TAddress;
                _sender: TAddress;
            };
            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
        };
        RoleRevoked: {
            outputParams: {
                role: TEth.Hex;
                account: TAddress;
                _sender: TAddress;
            };
            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
        };
    };
    Methods: {
        CANCELLER_ROLE: {
            method: "CANCELLER_ROLE";
            arguments: [];
        };
        DEFAULT_ADMIN_ROLE: {
            method: "DEFAULT_ADMIN_ROLE";
            arguments: [];
        };
        EXECUTOR_ROLE: {
            method: "EXECUTOR_ROLE";
            arguments: [];
        };
        PROPOSER_ROLE: {
            method: "PROPOSER_ROLE";
            arguments: [];
        };
        TIMELOCK_ADMIN_ROLE: {
            method: "TIMELOCK_ADMIN_ROLE";
            arguments: [];
        };
        cancel: {
            method: "cancel";
            arguments: [id: TEth.Hex];
        };
        execute: {
            method: "execute";
            arguments: [target: TAddress, value: bigint, payload: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex];
        };
        executeBatch: {
            method: "executeBatch";
            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex];
        };
        getMinDelay: {
            method: "getMinDelay";
            arguments: [];
        };
        getRoleAdmin: {
            method: "getRoleAdmin";
            arguments: [role: TEth.Hex];
        };
        getTimestamp: {
            method: "getTimestamp";
            arguments: [id: TEth.Hex];
        };
        grantRole: {
            method: "grantRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        hasRole: {
            method: "hasRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        hashOperation: {
            method: "hashOperation";
            arguments: [target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex];
        };
        hashOperationBatch: {
            method: "hashOperationBatch";
            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex];
        };
        isOperation: {
            method: "isOperation";
            arguments: [id: TEth.Hex];
        };
        isOperationDone: {
            method: "isOperationDone";
            arguments: [id: TEth.Hex];
        };
        isOperationPending: {
            method: "isOperationPending";
            arguments: [id: TEth.Hex];
        };
        isOperationReady: {
            method: "isOperationReady";
            arguments: [id: TEth.Hex];
        };
        onERC1155BatchReceived: {
            method: "onERC1155BatchReceived";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex];
        };
        onERC1155Received: {
            method: "onERC1155Received";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex];
        };
        onERC721Received: {
            method: "onERC721Received";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex];
        };
        renounceRole: {
            method: "renounceRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        revokeRole: {
            method: "revokeRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        schedule: {
            method: "schedule";
            arguments: [target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint];
        };
        scheduleBatch: {
            method: "scheduleBatch";
            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex];
        };
        updateDelay: {
            method: "updateDelay";
            arguments: [newDelay: bigint];
        };
    };
};
interface ITimelockControllerTxCaller {
    cancel(sender: TSender, id: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execute(sender: TSender, target: TAddress, value: bigint, payload: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    executeBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    schedule(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    scheduleBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    updateDelay(sender: TSender, newDelay: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface ITimelockControllerTxData {
    cancel(sender: TSender, id: TEth.Hex): Promise<TEth.TxLike>;
    execute(sender: TSender, target: TAddress, value: bigint, payload: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex): Promise<TEth.TxLike>;
    executeBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex): Promise<TEth.TxLike>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<TEth.TxLike>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<TEth.TxLike>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<TEth.TxLike>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    schedule(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<TEth.TxLike>;
    scheduleBatch(sender: TSender, targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint): Promise<TEth.TxLike>;
    updateDelay(sender: TSender, newDelay: bigint): Promise<TEth.TxLike>;
}
type TEvents = TTimelockControllerTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};