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 Safe extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TSafeTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender): Promise<TxWriter>;
    VERSION(): Promise<string>;
    addOwnerWithThreshold(sender: TSender, owner: TAddress, _threshold: bigint): Promise<TxWriter>;
    approveHash(sender: TSender, hashToApprove: TEth.Hex): Promise<TxWriter>;
    approvedHashes(input0: TAddress, input1: TEth.Hex): Promise<bigint>;
    changeThreshold(sender: TSender, _threshold: bigint): Promise<TxWriter>;
    checkNSignatures(dataHash: TEth.Hex, data: TEth.Hex, signatures: TEth.Hex, requiredSignatures: bigint): Promise<bigint>;
    checkSignatures(dataHash: TEth.Hex, data: TEth.Hex, signatures: TEth.Hex): Promise<bigint>;
    disableModule(sender: TSender, prevModule: TAddress, module: TAddress): Promise<TxWriter>;
    domainSeparator(): Promise<TEth.Hex>;
    enableModule(sender: TSender, module: TAddress): Promise<TxWriter>;
    encodeTransactionData(to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, _nonce: bigint): Promise<TEth.Hex>;
    execTransaction(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, signatures: TEth.Hex): Promise<TxWriter>;
    execTransactionFromModule(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<TxWriter>;
    execTransactionFromModuleReturnData(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<TxWriter>;
    getChainId(): Promise<bigint>;
    getModulesPaginated(start: TAddress, pageSize: bigint): Promise<{
        array: TAddress[];
        next: TAddress;
    }>;
    getOwners(): Promise<TAddress[]>;
    getStorageAt(offset: bigint, length: bigint): Promise<TEth.Hex>;
    getThreshold(): Promise<bigint>;
    getTransactionHash(to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, _nonce: bigint): Promise<TEth.Hex>;
    isModuleEnabled(module: TAddress): Promise<boolean>;
    isOwner(owner: TAddress): Promise<boolean>;
    nonce(): Promise<bigint>;
    removeOwner(sender: TSender, prevOwner: TAddress, owner: TAddress, _threshold: bigint): Promise<TxWriter>;
    setFallbackHandler(sender: TSender, handler: TAddress): Promise<TxWriter>;
    setGuard(sender: TSender, guard: TAddress): Promise<TxWriter>;
    setup(sender: TSender, _owners: TAddress[], _threshold: bigint, to: TAddress, data: TEth.Hex, fallbackHandler: TAddress, paymentToken: TAddress, payment: bigint, paymentReceiver: TAddress): Promise<TxWriter>;
    signedMessages(input0: TEth.Hex): Promise<bigint>;
    simulateAndRevert(sender: TSender, targetContract: TAddress, calldataPayload: TEth.Hex): Promise<TxWriter>;
    swapOwner(sender: TSender, prevOwner: TAddress, oldOwner: TAddress, newOwner: TAddress): Promise<TxWriter>;
    $call(): ISafeTxCaller;
    $signed(): TOverrideReturns<ISafeTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): ISafeTxData;
    $gas(): TOverrideReturns<ISafeTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TSafeTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TSafeTypes['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>[]>;
    onAddedOwner(fn?: (event: TClientEventsStreamData<TEventArguments<'AddedOwner'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AddedOwner'>>>;
    onApproveHash(fn?: (event: TClientEventsStreamData<TEventArguments<'ApproveHash'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApproveHash'>>>;
    onChangedFallbackHandler(fn?: (event: TClientEventsStreamData<TEventArguments<'ChangedFallbackHandler'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ChangedFallbackHandler'>>>;
    onChangedGuard(fn?: (event: TClientEventsStreamData<TEventArguments<'ChangedGuard'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ChangedGuard'>>>;
    onChangedThreshold(fn?: (event: TClientEventsStreamData<TEventArguments<'ChangedThreshold'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ChangedThreshold'>>>;
    onDisabledModule(fn?: (event: TClientEventsStreamData<TEventArguments<'DisabledModule'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DisabledModule'>>>;
    onEnabledModule(fn?: (event: TClientEventsStreamData<TEventArguments<'EnabledModule'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'EnabledModule'>>>;
    onExecutionFailure(fn?: (event: TClientEventsStreamData<TEventArguments<'ExecutionFailure'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExecutionFailure'>>>;
    onExecutionFromModuleFailure(fn?: (event: TClientEventsStreamData<TEventArguments<'ExecutionFromModuleFailure'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExecutionFromModuleFailure'>>>;
    onExecutionFromModuleSuccess(fn?: (event: TClientEventsStreamData<TEventArguments<'ExecutionFromModuleSuccess'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExecutionFromModuleSuccess'>>>;
    onExecutionSuccess(fn?: (event: TClientEventsStreamData<TEventArguments<'ExecutionSuccess'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExecutionSuccess'>>>;
    onRemovedOwner(fn?: (event: TClientEventsStreamData<TEventArguments<'RemovedOwner'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RemovedOwner'>>>;
    onSafeReceived(fn?: (event: TClientEventsStreamData<TEventArguments<'SafeReceived'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SafeReceived'>>>;
    onSafeSetup(fn?: (event: TClientEventsStreamData<TEventArguments<'SafeSetup'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SafeSetup'>>>;
    onSignMsg(fn?: (event: TClientEventsStreamData<TEventArguments<'SignMsg'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SignMsg'>>>;
    extractLogsAddedOwner(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AddedOwner'>>[];
    extractLogsApproveHash(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApproveHash'>>[];
    extractLogsChangedFallbackHandler(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ChangedFallbackHandler'>>[];
    extractLogsChangedGuard(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ChangedGuard'>>[];
    extractLogsChangedThreshold(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ChangedThreshold'>>[];
    extractLogsDisabledModule(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DisabledModule'>>[];
    extractLogsEnabledModule(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'EnabledModule'>>[];
    extractLogsExecutionFailure(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExecutionFailure'>>[];
    extractLogsExecutionFromModuleFailure(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExecutionFromModuleFailure'>>[];
    extractLogsExecutionFromModuleSuccess(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExecutionFromModuleSuccess'>>[];
    extractLogsExecutionSuccess(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExecutionSuccess'>>[];
    extractLogsRemovedOwner(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RemovedOwner'>>[];
    extractLogsSafeReceived(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SafeReceived'>>[];
    extractLogsSafeSetup(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SafeSetup'>>[];
    extractLogsSignMsg(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SignMsg'>>[];
    getPastLogsAddedOwner(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'AddedOwner'>>[]>;
    getPastLogsApproveHash(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            approvedHash?: TEth.Hex;
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApproveHash'>>[]>;
    getPastLogsChangedFallbackHandler(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            handler?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ChangedFallbackHandler'>>[]>;
    getPastLogsChangedGuard(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            guard?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ChangedGuard'>>[]>;
    getPastLogsChangedThreshold(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'ChangedThreshold'>>[]>;
    getPastLogsDisabledModule(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            module?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'DisabledModule'>>[]>;
    getPastLogsEnabledModule(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            module?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'EnabledModule'>>[]>;
    getPastLogsExecutionFailure(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            txHash?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'ExecutionFailure'>>[]>;
    getPastLogsExecutionFromModuleFailure(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            module?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ExecutionFromModuleFailure'>>[]>;
    getPastLogsExecutionFromModuleSuccess(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            module?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ExecutionFromModuleSuccess'>>[]>;
    getPastLogsExecutionSuccess(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            txHash?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'ExecutionSuccess'>>[]>;
    getPastLogsRemovedOwner(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RemovedOwner'>>[]>;
    getPastLogsSafeReceived(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'SafeReceived'>>[]>;
    getPastLogsSafeSetup(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            initiator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'SafeSetup'>>[]>;
    getPastLogsSignMsg(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            msgHash?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'SignMsg'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TSafeTypes = {
    Events: {
        AddedOwner: {
            outputParams: {
                owner: TAddress;
            };
            outputArgs: [owner: TAddress];
        };
        ApproveHash: {
            outputParams: {
                approvedHash: TEth.Hex;
                owner: TAddress;
            };
            outputArgs: [approvedHash: TEth.Hex, owner: TAddress];
        };
        ChangedFallbackHandler: {
            outputParams: {
                handler: TAddress;
            };
            outputArgs: [handler: TAddress];
        };
        ChangedGuard: {
            outputParams: {
                guard: TAddress;
            };
            outputArgs: [guard: TAddress];
        };
        ChangedThreshold: {
            outputParams: {
                threshold: bigint;
            };
            outputArgs: [threshold: bigint];
        };
        DisabledModule: {
            outputParams: {
                module: TAddress;
            };
            outputArgs: [module: TAddress];
        };
        EnabledModule: {
            outputParams: {
                module: TAddress;
            };
            outputArgs: [module: TAddress];
        };
        ExecutionFailure: {
            outputParams: {
                txHash: TEth.Hex;
                payment: bigint;
            };
            outputArgs: [txHash: TEth.Hex, payment: bigint];
        };
        ExecutionFromModuleFailure: {
            outputParams: {
                module: TAddress;
            };
            outputArgs: [module: TAddress];
        };
        ExecutionFromModuleSuccess: {
            outputParams: {
                module: TAddress;
            };
            outputArgs: [module: TAddress];
        };
        ExecutionSuccess: {
            outputParams: {
                txHash: TEth.Hex;
                payment: bigint;
            };
            outputArgs: [txHash: TEth.Hex, payment: bigint];
        };
        RemovedOwner: {
            outputParams: {
                owner: TAddress;
            };
            outputArgs: [owner: TAddress];
        };
        SafeReceived: {
            outputParams: {
                _sender: TAddress;
                value: bigint;
            };
            outputArgs: [_sender: TAddress, value: bigint];
        };
        SafeSetup: {
            outputParams: {
                initiator: TAddress;
                owners: TAddress[];
                threshold: bigint;
                initializer: TAddress;
                fallbackHandler: TAddress;
            };
            outputArgs: [initiator: TAddress, owners: TAddress[], threshold: bigint, initializer: TAddress, fallbackHandler: TAddress];
        };
        SignMsg: {
            outputParams: {
                msgHash: TEth.Hex;
            };
            outputArgs: [msgHash: TEth.Hex];
        };
    };
    Methods: {
        VERSION: {
            method: "VERSION";
            arguments: [];
        };
        addOwnerWithThreshold: {
            method: "addOwnerWithThreshold";
            arguments: [owner: TAddress, _threshold: bigint];
        };
        approveHash: {
            method: "approveHash";
            arguments: [hashToApprove: TEth.Hex];
        };
        approvedHashes: {
            method: "approvedHashes";
            arguments: [input0: TAddress, input1: TEth.Hex];
        };
        changeThreshold: {
            method: "changeThreshold";
            arguments: [_threshold: bigint];
        };
        checkNSignatures: {
            method: "checkNSignatures";
            arguments: [dataHash: TEth.Hex, data: TEth.Hex, signatures: TEth.Hex, requiredSignatures: bigint];
        };
        checkSignatures: {
            method: "checkSignatures";
            arguments: [dataHash: TEth.Hex, data: TEth.Hex, signatures: TEth.Hex];
        };
        disableModule: {
            method: "disableModule";
            arguments: [prevModule: TAddress, module: TAddress];
        };
        domainSeparator: {
            method: "domainSeparator";
            arguments: [];
        };
        enableModule: {
            method: "enableModule";
            arguments: [module: TAddress];
        };
        encodeTransactionData: {
            method: "encodeTransactionData";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, _nonce: bigint];
        };
        execTransaction: {
            method: "execTransaction";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, signatures: TEth.Hex];
        };
        execTransactionFromModule: {
            method: "execTransactionFromModule";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex, operation: number];
        };
        execTransactionFromModuleReturnData: {
            method: "execTransactionFromModuleReturnData";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex, operation: number];
        };
        getChainId: {
            method: "getChainId";
            arguments: [];
        };
        getModulesPaginated: {
            method: "getModulesPaginated";
            arguments: [start: TAddress, pageSize: bigint];
        };
        getOwners: {
            method: "getOwners";
            arguments: [];
        };
        getStorageAt: {
            method: "getStorageAt";
            arguments: [offset: bigint, length: bigint];
        };
        getThreshold: {
            method: "getThreshold";
            arguments: [];
        };
        getTransactionHash: {
            method: "getTransactionHash";
            arguments: [to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, _nonce: bigint];
        };
        isModuleEnabled: {
            method: "isModuleEnabled";
            arguments: [module: TAddress];
        };
        isOwner: {
            method: "isOwner";
            arguments: [owner: TAddress];
        };
        nonce: {
            method: "nonce";
            arguments: [];
        };
        removeOwner: {
            method: "removeOwner";
            arguments: [prevOwner: TAddress, owner: TAddress, _threshold: bigint];
        };
        setFallbackHandler: {
            method: "setFallbackHandler";
            arguments: [handler: TAddress];
        };
        setGuard: {
            method: "setGuard";
            arguments: [guard: TAddress];
        };
        setup: {
            method: "setup";
            arguments: [_owners: TAddress[], _threshold: bigint, to: TAddress, data: TEth.Hex, fallbackHandler: TAddress, paymentToken: TAddress, payment: bigint, paymentReceiver: TAddress];
        };
        signedMessages: {
            method: "signedMessages";
            arguments: [input0: TEth.Hex];
        };
        simulateAndRevert: {
            method: "simulateAndRevert";
            arguments: [targetContract: TAddress, calldataPayload: TEth.Hex];
        };
        swapOwner: {
            method: "swapOwner";
            arguments: [prevOwner: TAddress, oldOwner: TAddress, newOwner: TAddress];
        };
    };
};
interface ISafeTxCaller {
    addOwnerWithThreshold(sender: TSender, owner: TAddress, _threshold: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    approveHash(sender: TSender, hashToApprove: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    changeThreshold(sender: TSender, _threshold: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    disableModule(sender: TSender, prevModule: TAddress, module: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    enableModule(sender: TSender, module: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execTransaction(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, signatures: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execTransactionFromModule(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execTransactionFromModuleReturnData(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeOwner(sender: TSender, prevOwner: TAddress, owner: TAddress, _threshold: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setFallbackHandler(sender: TSender, handler: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setGuard(sender: TSender, guard: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setup(sender: TSender, _owners: TAddress[], _threshold: bigint, to: TAddress, data: TEth.Hex, fallbackHandler: TAddress, paymentToken: TAddress, payment: bigint, paymentReceiver: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    simulateAndRevert(sender: TSender, targetContract: TAddress, calldataPayload: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapOwner(sender: TSender, prevOwner: TAddress, oldOwner: TAddress, newOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface ISafeTxData {
    addOwnerWithThreshold(sender: TSender, owner: TAddress, _threshold: bigint): Promise<TEth.TxLike>;
    approveHash(sender: TSender, hashToApprove: TEth.Hex): Promise<TEth.TxLike>;
    changeThreshold(sender: TSender, _threshold: bigint): Promise<TEth.TxLike>;
    disableModule(sender: TSender, prevModule: TAddress, module: TAddress): Promise<TEth.TxLike>;
    enableModule(sender: TSender, module: TAddress): Promise<TEth.TxLike>;
    execTransaction(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number, safeTxGas: bigint, baseGas: bigint, gasPrice: bigint, gasToken: TAddress, refundReceiver: TAddress, signatures: TEth.Hex): Promise<TEth.TxLike>;
    execTransactionFromModule(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<TEth.TxLike>;
    execTransactionFromModuleReturnData(sender: TSender, to: TAddress, value: bigint, data: TEth.Hex, operation: number): Promise<TEth.TxLike>;
    removeOwner(sender: TSender, prevOwner: TAddress, owner: TAddress, _threshold: bigint): Promise<TEth.TxLike>;
    setFallbackHandler(sender: TSender, handler: TAddress): Promise<TEth.TxLike>;
    setGuard(sender: TSender, guard: TAddress): Promise<TEth.TxLike>;
    setup(sender: TSender, _owners: TAddress[], _threshold: bigint, to: TAddress, data: TEth.Hex, fallbackHandler: TAddress, paymentToken: TAddress, payment: bigint, paymentReceiver: TAddress): Promise<TEth.TxLike>;
    simulateAndRevert(sender: TSender, targetContract: TAddress, calldataPayload: TEth.Hex): Promise<TEth.TxLike>;
    swapOwner(sender: TSender, prevOwner: TAddress, oldOwner: TAddress, newOwner: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TSafeTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};