import { CommandCtor, CommandInfo, ExecutionContext, Input, IWallet, IProvider, EVMExecuteCommandInstance, EVMDependencies, TransactionResponse as CoreTransactionResponse, Env } from '@chainlink/evm-gauntlet';
import { Result, WriteCommand } from '@chainlink/gauntlet-core';
import { State, Proposal, Topic } from './types';
import { ethers, Contract, ContractFactory, AbstractSigner as EthersWallet, Provider as EthersProvider, TransactionRequest, TransactionResponse } from 'ethers';
import { UserInput, ContractInput, ProposalAction, SafeTxInput } from './types';
import { EVMTransaction } from '@chainlink/evm-gauntlet';
export declare class BaseMsigCommand<UI, CI extends Iterable<any>> extends WriteCommand<CoreTransactionResponse<TransactionResponse>> {
    id: string;
    deps: EVMDependencies;
    env: Env;
    wallet: IWallet<EthersWallet>;
    provider: IProvider<EthersProvider, ContractFactory, TransactionRequest, TransactionResponse, EthersWallet>;
    contractAddress: string;
    account: string;
    executionContext: ExecutionContext<EthersWallet, EthersProvider, ContractFactory, TransactionRequest, TransactionResponse>;
    contract: ContractFactory;
    multisendContract: ContractFactory;
    allCommands: {
        [key: string]: CommandCtor<EVMExecuteCommandInstance<UI, CI>>;
    };
    input: Input<UserInput, ContractInput>;
    commands: EVMExecuteCommandInstance<UI, CI>[];
    safeAddress: string;
    multisendAddress: string;
    safeExecutor: string;
    initialState: State;
    connectedContract: Contract;
    proposalId: string;
    getCommandInfo: () => CommandInfo;
    makeMessage: () => Promise<TransactionRequest[]>;
    safeNonceToUse: number;
    constructor(flags: any, args: any, id: any, deps: any);
    validateSafeExecutionNonce: (safeNonce: number, userNonce: number) => void;
    fetchSafeState: (proposalId: string) => Promise<State>;
    fetchProposal: (proposalId: string, owners: string[], threshold: number, selfApprovalStatus: bigint) => Promise<Proposal>;
    getConfirmations: (owners: string[], threshold: number, safeTxHash: string) => Promise<{
        approvers: string[];
        hasEnoughConfirmations: boolean;
    }>;
    getApprovers: (owners: string[], safeTxHash: string) => Promise<string[]>;
    getProposalStateMsgOpts: (result?: Result<CoreTransactionResponse<TransactionResponse>>) => Promise<{
        execute: string;
        approve: string;
        none: string;
    }>;
    safeInputToPayload: (safeInput: SafeTxInput, signatures?: string) => any[];
    buildSafeTxInput: (nonce: number) => Promise<SafeTxInput>;
    buildSafeInputFromMessages: (messages: TransactionRequest[]) => {
        to: string;
        value: ethers.BigNumberish;
        data: ethers.BytesLike;
        operation: number;
    };
    validateSafeHash: (providedHash: string, generatedHash: string) => Promise<void>;
    makeExecuteMessage: ProposalAction;
    makeAcceptMessage: ProposalAction;
    registerMakeMessage: (proposalId: string, safeNonce: number) => () => Promise<ethers.TransactionRequest[]>;
    addGasLimitToMessage: (safeMessage: any) => Promise<any>;
    getEmittedEvent: (txn: EVMTransaction) => Promise<Topic | undefined>;
    beforeExecute: () => Promise<void>;
    afterExport: (result: Result<null>, proposalId?: string, safeNonce?: number, message?: TransactionRequest) => Promise<{
        proposalId: string;
        safeNonce: number;
        to: ethers.AddressLike;
        data: string;
        commandData: any[];
    }>;
    afterExecute: (result: Result<CoreTransactionResponse<TransactionResponse>>, proposalId?: string, safeNonce?: number) => Promise<{
        proposalId: string;
        safeNonce: number;
        commandData: any[];
    }>;
    buildProposalId: (safeNonce: number) => Promise<string>;
    export: () => Promise<{
        data: {
            signedTx: {
                tx: string;
                message: ethers.TransactionRequest;
            };
        };
        responses: any[];
    }>;
    execute: () => Promise<{
        data: {};
        responses: any[];
    }>;
}
//# sourceMappingURL=base.d.ts.map