import * as Pay from '@filoz/synapse-core/pay';
import { type Account, type Address, type Chain, type Client, type Hash, type TransactionReceipt, type Transport } from 'viem';
import type { FundOptions, RailInfo, SettlementResult, TokenAmount, TokenIdentifier } from '../types.ts';
export interface DepositOptions {
    to?: Address;
    amount: TokenAmount;
    token?: TokenIdentifier;
    onAllowanceCheck?: (current: bigint, required: bigint) => void;
    onApprovalTransaction?: (tx: Hash) => void;
    onApprovalConfirmed?: (receipt: TransactionReceipt) => void;
    onDepositStarting?: () => void;
}
export declare class PaymentsService {
    private readonly _client;
    constructor(options: {
        client: Client<Transport, Chain, Account>;
    });
    static create(options: {
        transport?: Transport;
        chain?: Chain;
        account: Account;
    }): PaymentsService;
    balance(options?: {
        token?: TokenIdentifier;
    }): Promise<bigint>;
    accountInfo(options?: {
        token?: TokenIdentifier;
    }): Promise<Pay.accounts.OutputType>;
    walletBalance(options?: {
        token?: TokenIdentifier;
    }): Promise<bigint>;
    decimals(): number;
    allowance(options: {
        spender: Address;
        token?: TokenIdentifier;
    }): Promise<bigint>;
    approve(options: {
        spender: Address;
        amount: TokenAmount;
        token?: TokenIdentifier;
    }): Promise<Hash>;
    approveService(options?: {
        service?: Address;
        rateAllowance?: TokenAmount;
        lockupAllowance?: TokenAmount;
        maxLockupPeriod?: TokenAmount;
        token?: TokenIdentifier;
    }): Promise<Hash>;
    revokeService(options?: {
        service?: Address;
        token?: TokenIdentifier;
    }): Promise<Hash>;
    serviceApproval(options?: {
        service?: Address;
        token?: TokenIdentifier;
    }): Promise<Pay.operatorApprovals.OutputType>;
    deposit(options: DepositOptions): Promise<Hash>;
    depositWithPermit(options: {
        amount: TokenAmount;
        token?: TokenIdentifier;
        deadline?: bigint;
    }): Promise<Hash>;
    depositWithPermitAndApproveOperator(options: {
        amount: TokenAmount;
        operator?: Address;
        rateAllowance?: TokenAmount;
        lockupAllowance?: TokenAmount;
        maxLockupPeriod?: bigint;
        deadline?: bigint;
        token?: TokenIdentifier;
    }): Promise<Hash>;
    fund(options: FundOptions): Promise<Hash>;
    fundSync(options: Pay.fundSync.OptionsType): Promise<Pay.fundSync.OutputType>;
    withdraw(options: {
        amount: TokenAmount;
        token?: TokenIdentifier;
    }): Promise<Hash>;
    settle(options: {
        railId: bigint;
        untilEpoch?: bigint;
    }): Promise<Hash>;
    getSettlementAmounts(options: {
        railId: bigint;
        untilEpoch?: bigint;
    }): Promise<SettlementResult>;
    settleTerminatedRail(options: {
        railId: bigint;
    }): Promise<Hash>;
    getRail(options: {
        railId: bigint;
    }): Promise<Pay.getRail.OutputType>;
    settleAuto(options: {
        railId: bigint;
        untilEpoch?: bigint;
    }): Promise<Hash>;
    accountSummary(options?: {
        token?: TokenIdentifier;
        epoch?: bigint;
    }): Promise<Pay.getAccountSummary.OutputType>;
    totalAccountFixedLockup(options?: {
        token?: TokenIdentifier;
    }): Promise<Pay.totalAccountFixedLockup.OutputType>;
    getRailsAsPayer(options?: {
        token?: TokenIdentifier;
    }): Promise<RailInfo[]>;
    getRailsAsPayee(options?: {
        token?: TokenIdentifier;
    }): Promise<RailInfo[]>;
}
//# sourceMappingURL=service.d.ts.map