import type { Address, Hash, Hex, PrivateKeyAccount } from "viem";
import { BaseError } from "viem";
import type { Asset, CreditAccountData, ICreditAccountsService, RawTx } from "../sdk/index.js";
import { SDKConstruct } from "../sdk/index.js";
export declare class OpenTxRevertedError extends BaseError {
    readonly txHash: Hash;
    constructor(txHash: Hash);
}
export interface AccountOpenerOptions {
    faucet?: Address;
    borrowerKey?: Hex;
    depositorKey?: Hex;
    poolDepositMultiplier?: bigint | string | number;
    minDebtMultiplier?: bigint | string | number;
    leverageDelta?: bigint | string | number;
    allowMint?: boolean;
}
export interface TargetAccount {
    creditManager: Address;
    /**
     * Everything will be swapped into this token in the end
     */
    target: Address;
    /**
     * This token will be provided as collateral, defaults to underlying token
     * Expected to be found on borrower's address before opening the account
     * Can be claimed from faucet
     *
     * TODO: not implemented
     */
    collateral?: Address;
    /**
     * These tokens will be transferred directly from faucet to credit account
     */
    directTransfer?: Address[];
    /**
     * Leverage, without percentage (e.g. "3" for 300%)
     */
    leverage?: number;
    /**
     * Slippage with percentage (e.g. 100 = 1%)
     */
    slippage?: number;
}
interface OpenAccountPreview {
    tx: RawTx;
    /**
     * Actual leverage, with percentage factor
     */
    leverage: bigint;
    /**
     * What user adds as collateral
     */
    collateral: Asset;
    minQuota: Asset[];
    averageQuota: Asset[];
    slippage: number;
}
export interface OpenAccountHumanizedPreview {
    creditManager: string;
    target: string;
    collateral: string;
    leverage: number;
    slippage: number;
    minQuota: string[];
    averageQuota: string[];
}
export interface OpenAccountResult {
    input: TargetAccount;
    humanizedInput?: OpenAccountHumanizedPreview;
    error?: Error;
    txHash?: string;
    rawTx?: Pick<RawTx, "to" | "callData" | "value">;
    account?: CreditAccountData;
}
export type PoolDepositResult = {
    pool: Address;
    token: Address;
    amount: bigint;
} & ({
    success: true;
    txHash: Hex;
} | {
    success: false;
    error: Error;
    txHash?: Hex;
});
export interface OpenAccountsResult {
    deposits: PoolDepositResult[];
    accounts: OpenAccountResult[];
}
export declare class AccountOpener extends SDKConstruct {
    #private;
    readonly borrowerKey: Hex;
    readonly depositorKey: Hex;
    constructor(service: ICreditAccountsService, options_?: AccountOpenerOptions);
    get borrower(): PrivateKeyAccount;
    get depositor(): PrivateKeyAccount;
    /**
     * Tries to open account with underlying only in each CM
     */
    openCreditAccounts(targets: TargetAccount[], depositIntoPools?: boolean, claimFromFaucet?: boolean): Promise<OpenAccountsResult>;
    prepareOpen(input: TargetAccount): Promise<OpenAccountPreview>;
    getOpenedAccounts(): Promise<CreditAccountData[]>;
    get faucet(): Address;
}
export {};