import { CommandCtor, EVMExecuteCommandInstance, EVMDependencies, CommandInfo, ExecutionContext, Input, TransactionResponse as CoreTransactionResponse, IWallet, IProvider, Env } from '@chainlink/evm-gauntlet';
import { ContractFactory, Provider as EthersProvider, TransactionRequest, TransactionResponse, AbstractSigner as EthersWallet } from 'ethers';
import { Result, WriteCommand } from '@chainlink/gauntlet-core';
import { ProposalAction, Transaction } from '../../../types';
import { Timelock } from '../../../contracts/timelock';
export type UserInput = {
    tx: Transaction;
};
export type ContractInput = [];
export type UnregisteredCommand<UI, CI extends Iterable<any>> = (deps: EVMDependencies) => CommandCtor<EVMExecuteCommandInstance<UI, CI>>;
export type TimelockWrapperCommandConfig<UI, CI extends Iterable<any>> = {
    id: string;
    action: ProposalAction;
    examples: string[];
    createCommand: (c: WrappedTimelockCommandCtor<UI, CI>, registeredCommands: {
        [key: string]: CommandCtor<EVMExecuteCommandInstance<UI, CI>>;
    }) => Promise<void>;
};
export declare function createWrapperCommand<UI, CI extends Iterable<any>>(config: TimelockWrapperCommandConfig<UI, CI>): (registeredCommands: {
    [key: string]: CommandCtor<EVMExecuteCommandInstance<UI, CI>>;
}) => UnregisteredCommand<UserInput, ContractInput>;
export declare class WrappedTimelockCommandCtor<UI, CI extends Iterable<any>> extends WriteCommand<CoreTransactionResponse<TransactionResponse>> {
    id: string;
    env: Env;
    input: Input<UserInput, ContractInput>;
    executionContext: ExecutionContext<EthersWallet, EthersProvider, ContractFactory, TransactionRequest, TransactionResponse>;
    registeredCommands: {
        [key: string]: CommandCtor<EVMExecuteCommandInstance<UI, CI>>;
    };
    getCommandInfo: () => CommandInfo;
    wallet: IWallet<EthersWallet>;
    deps: EVMDependencies;
    provider: IProvider<EthersProvider, ContractFactory, TransactionRequest, TransactionResponse, EthersWallet>;
    account: string;
    contractAddress: string;
    contract: ContractFactory;
    action: ProposalAction;
    timelockAddress: string;
    timelockObj: Timelock;
    makeMessage: () => Promise<TransactionRequest[]>;
    timelockCommand: EVMExecuteCommandInstance<any, any>;
    commandsToExecute: EVMExecuteCommandInstance<any, any>[];
    constructor(flags: any, args: any, id: any, action: any, deps: any, registeredCommands: any);
    getCommandsToExecute: (tx: Transaction) => Promise<EVMExecuteCommandInstance<any, any>[]>;
    simulate: (signer: string) => Promise<string[]>;
    beforeExecute: () => Promise<void>;
    afterExport: (result: Result<null>) => Promise<void>;
    afterExecute: (result: Result<CoreTransactionResponse<TransactionResponse>>) => Promise<void>;
    simulateInternalTransactions: () => Promise<string[]>;
    beforeExecuteInternalTransactions: () => Promise<void>;
    afterExecuteInternalTransactions: (result: Result<CoreTransactionResponse<TransactionResponse>>) => Promise<any[]>;
    registerMakeMessage: () => () => Promise<TransactionRequest[]>;
    execute: () => Promise<Result<CoreTransactionResponse<TransactionResponse>, {}>>;
}
//# sourceMappingURL=base.d.ts.map