import { ChainAddresses, ChainProviders, EngineEvent, EngineEventMap, IChannelSigner, INodeService, OptionalPublicIdentifier, Result, NodeParams, NodeResponses, EngineParams, GetTransfersFilterOpts } from "@connext/vector-types";
import pino, { BaseLogger } from "pino";
import { IRpcChannelProvider } from "./channelProvider";
import { BrowserNodeError } from "./errors";
export * from "./constants";
export declare type BrowserNodeSignerConfig = {
    natsUrl?: string;
    authUrl?: string;
    messagingUrl?: string;
    logger?: BaseLogger;
    signer: IChannelSigner;
    chainProviders: ChainProviders;
    chainAddresses: ChainAddresses;
};
export declare class BrowserNode implements INodeService {
    channelProvider: IRpcChannelProvider | undefined;
    publicIdentifier: string;
    signerAddress: string;
    private readonly logger;
    private supportedChains;
    private routerPublicIdentifier?;
    private iframeSrc?;
    private chainProviders;
    private chainAddresses?;
    private messagingUrl?;
    private natsUrl?;
    private authUrl?;
    constructor(params: {
        logger?: pino.BaseLogger;
        routerPublicIdentifier?: string;
        supportedChains?: number[];
        iframeSrc?: string;
        chainProviders: ChainProviders;
        messagingUrl?: string;
        natsUrl?: string;
        authUrl?: string;
        chainAddresses?: ChainAddresses;
    });
    static connect(config: BrowserNodeSignerConfig): Promise<BrowserNode>;
    init(params?: {
        signature?: string;
        signer?: string;
    }): Promise<void>;
    createNode(params: NodeParams.CreateNode): Promise<Result<NodeResponses.CreateNode, BrowserNodeError>>;
    getConfig(): Promise<NodeResponses.GetConfig>;
    getRouterConfig(params: OptionalPublicIdentifier<NodeParams.GetRouterConfig>): Promise<Result<NodeResponses.GetRouterConfig, BrowserNodeError>>;
    getStatus(): Promise<Result<NodeResponses.GetStatus, BrowserNodeError>>;
    getStateChannelByParticipants(params: OptionalPublicIdentifier<NodeParams.GetChannelStateByParticipants>): Promise<Result<NodeResponses.GetChannelStateByParticipants, BrowserNodeError>>;
    getStateChannel(params: OptionalPublicIdentifier<NodeParams.GetChannelState>): Promise<Result<NodeResponses.GetChannelState, BrowserNodeError>>;
    getStateChannels(): Promise<Result<NodeResponses.GetChannelStates, BrowserNodeError>>;
    getTransferQuote(params: OptionalPublicIdentifier<NodeParams.TransferQuote>): Promise<Result<NodeResponses.TransferQuote, BrowserNodeError>>;
    getTransferByRoutingId(params: OptionalPublicIdentifier<NodeParams.GetTransferStateByRoutingId>): Promise<Result<NodeResponses.GetTransferStateByRoutingId, BrowserNodeError>>;
    getTransfersByRoutingId(params: OptionalPublicIdentifier<NodeParams.GetTransferStatesByRoutingId>): Promise<Result<NodeResponses.GetTransferStatesByRoutingId, BrowserNodeError>>;
    getTransfer(params: OptionalPublicIdentifier<NodeParams.GetTransferState>): Promise<Result<NodeResponses.GetTransferState, BrowserNodeError>>;
    getActiveTransfers(params: OptionalPublicIdentifier<NodeParams.GetActiveTransfersByChannelAddress>): Promise<Result<NodeResponses.GetActiveTransfersByChannelAddress, BrowserNodeError>>;
    getTransfers(params: OptionalPublicIdentifier<NodeParams.GetTransfers & Omit<GetTransfersFilterOpts, "startDate" | "endDate"> & {
        startDate: Date;
        endDate: Date;
    }>): Promise<Result<NodeResponses.GetActiveTransfersByChannelAddress, BrowserNodeError>>;
    getRegisteredTransfers(params: OptionalPublicIdentifier<NodeParams.GetRegisteredTransfers>): Promise<Result<NodeResponses.GetRegisteredTransfers, BrowserNodeError>>;
    getWithdrawalCommitment(params: OptionalPublicIdentifier<NodeParams.GetWithdrawalCommitment>): Promise<Result<NodeResponses.GetWithdrawalCommitment, BrowserNodeError>>;
    getWithdrawalCommitmentByTransactionHash(params: OptionalPublicIdentifier<NodeParams.GetWithdrawalCommitmentByTransactionHash>): Promise<Result<NodeResponses.GetWithdrawalCommitmentByTransactionHash, BrowserNodeError>>;
    setup(params: OptionalPublicIdentifier<NodeParams.RequestSetup>): Promise<Result<NodeResponses.RequestSetup, BrowserNodeError>>;
    internalSetup(): Promise<Result<NodeResponses.Setup, BrowserNodeError>>;
    sendDepositTx(): Promise<Result<NodeResponses.SendDepositTx, BrowserNodeError>>;
    reconcileDeposit(params: OptionalPublicIdentifier<NodeParams.Deposit>): Promise<Result<NodeResponses.Deposit, BrowserNodeError>>;
    requestCollateral(params: OptionalPublicIdentifier<NodeParams.RequestCollateral>): Promise<Result<NodeResponses.RequestCollateral, BrowserNodeError>>;
    conditionalTransfer(params: OptionalPublicIdentifier<NodeParams.ConditionalTransfer>): Promise<Result<NodeResponses.ConditionalTransfer, BrowserNodeError>>;
    resolveTransfer(params: OptionalPublicIdentifier<NodeParams.ResolveTransfer>): Promise<Result<NodeResponses.ResolveTransfer, BrowserNodeError>>;
    getWithdrawalQuote(params: OptionalPublicIdentifier<NodeParams.WithdrawalQuote>): Promise<Result<NodeResponses.WithdrawalQuote, BrowserNodeError>>;
    withdraw(params: OptionalPublicIdentifier<NodeParams.Withdraw>): Promise<Result<NodeResponses.Withdraw, BrowserNodeError>>;
    withdrawRetry(params: OptionalPublicIdentifier<NodeParams.WithdrawRetry>): Promise<Result<NodeResponses.WithdrawRetry, BrowserNodeError>>;
    addTransactionToCommitment(params: OptionalPublicIdentifier<NodeParams.AddTransactionToCommitment>): Promise<Result<void, BrowserNodeError>>;
    restoreState(params: OptionalPublicIdentifier<NodeParams.RestoreState>): Promise<Result<NodeResponses.RestoreState, BrowserNodeError>>;
    signUtilityMessage(params: OptionalPublicIdentifier<NodeParams.SignUtilityMessage>): Promise<Result<NodeResponses.SignUtilityMessage, BrowserNodeError>>;
    sendIsAliveMessage(params: OptionalPublicIdentifier<NodeParams.SendIsAlive>): Promise<Result<NodeResponses.SendIsAlive, BrowserNodeError>>;
    send(payload: EngineParams.RpcRequest): Promise<any>;
    getChannelDispute(params: OptionalPublicIdentifier<NodeParams.GetChannelDispute>): Promise<Result<NodeResponses.GetChannelDispute, BrowserNodeError>>;
    sendDisputeChannelTx(params: OptionalPublicIdentifier<NodeParams.SendDisputeChannelTx>): Promise<Result<NodeResponses.SendDisputeChannelTx, BrowserNodeError>>;
    sendDefundChannelTx(params: OptionalPublicIdentifier<NodeParams.SendDefundChannelTx>): Promise<Result<NodeResponses.SendDefundChannelTx, BrowserNodeError>>;
    getTransferDispute(params: OptionalPublicIdentifier<NodeParams.GetTransferDispute>): Promise<Result<NodeResponses.GetTransferDispute, BrowserNodeError>>;
    sendDisputeTransferTx(params: OptionalPublicIdentifier<NodeParams.SendDisputeTransferTx>): Promise<Result<NodeResponses.SendDisputeTransferTx, BrowserNodeError>>;
    sendDefundTransferTx(params: OptionalPublicIdentifier<NodeParams.SendDefundTransferTx>): Promise<Result<NodeResponses.SendDefundTransferTx, BrowserNodeError>>;
    sendExitChannelTx(params: OptionalPublicIdentifier<NodeParams.SendExitChannelTx>): Promise<Result<NodeResponses.SendExitChannelTx, BrowserNodeError>>;
    syncDisputes(): Promise<Result<void, BrowserNodeError>>;
    waitFor<T extends EngineEvent>(event: T, timeout: number, filter?: (payload: EngineEventMap[T]) => boolean): Promise<EngineEventMap[T] | undefined>;
    once<T extends EngineEvent>(event: T, callback: (payload: EngineEventMap[T]) => void | Promise<void>, filter?: (payload: EngineEventMap[T]) => boolean): Promise<void>;
    on<T extends EngineEvent>(event: T, callback: (payload: EngineEventMap[T]) => void | Promise<void>, filter?: (payload: EngineEventMap[T]) => boolean): Promise<void>;
    off<T extends EngineEvent>(event: T): Promise<void>;
}
//# sourceMappingURL=index.d.ts.map