import { ethers } from "ethers";
import { TransactionService, DisputeService, ArbitratorService, IPFSService, EventService } from "../services";
import { KlerosEscrowConfig } from "../types";
import { TransactionActions, DisputeActions, EvidenceActions } from "../actions";
/**
 * Client for interacting with Kleros Escrow services
 */
export declare class KlerosEscrowClient {
    private config;
    /**
     * Services for reading data
     */
    readonly services: {
        transaction: TransactionService;
        dispute: DisputeService;
        arbitrator: ArbitratorService;
        event: EventService;
        ipfs: IPFSService;
    };
    /**
     * Actions for writing data (only available if a signer is provided)
     */
    readonly actions?: {
        transaction: TransactionActions;
        dispute: DisputeActions;
        evidence: EvidenceActions;
    };
    /**
     * Creates a new KlerosEscrowClient
     * @param config The Kleros Escrow configuration
     * @param signer Optional signer for write operations
     */
    constructor(config: KlerosEscrowConfig, signer?: ethers.Signer);
    /**
     * Gets the configuration used by this client
     * @returns The Kleros Escrow configuration
     */
    getConfig(): KlerosEscrowConfig;
    /**
     * Checks if this client has write capabilities
     * @returns True if the client can perform write operations
     */
    canWrite(): boolean;
    /**
     * Convenience method to get a transaction by ID
     * @param transactionId The ID of the transaction to fetch
     * @returns The transaction data
     */
    getTransaction(transactionId: string): Promise<import("../types").Transaction>;
    /**
     * Convenience method to get a dispute by transaction ID
     * @param transactionId The ID of the transaction
     * @returns The dispute data if it exists
     */
    getDispute(transactionId: string): Promise<import("../types").Dispute | null>;
    /**
     * Convenience method to get the arbitrator information
     * @returns The arbitrator information
     */
    getArbitrator(): Promise<import("../types").Arbitrator>;
    /**
     * Convenience method to fetch data from IPFS
     * @param path The IPFS path or CID
     * @returns The data from IPFS
     */
    fetchFromIPFS(path: string): Promise<any>;
    getTransactionDetails(transactionId: string): Promise<{
        rulings: {
            _arbitrator: string;
            _disputeID: string;
            blockNumber: string;
            blockTimestamp: string;
            _ruling: string;
            transactionHash: string;
        }[];
        metaEvidences: {
            id: string;
            blockTimestamp: string;
            transactionHash: string;
            _evidence: string;
            blockNumber: string;
            _metaEvidenceID: string;
        }[];
        payments: {
            id: string;
            _transactionID: string;
            _amount: string;
            _party: string;
            blockNumber: string;
            blockTimestamp: string;
            transactionHash: string;
        }[];
        evidences: {
            _arbitrator: string;
            _party: string;
            _evidence: string;
            _evidenceGroupID: string;
            blockNumber: string;
            transactionHash: string;
        }[];
        disputes: {
            _arbitrator: string;
            _disputeID: string;
            blockNumber: string;
            blockTimestamp: string;
            _metaEvidenceID: string;
            _evidenceGroupID: string;
            transactionHash: string;
        }[];
        hasToPayFees: {
            _transactionID: string;
            blockNumber: string;
            blockTimestamp: string;
            _party: string;
            transactionHash: string;
        }[];
    }>;
}