import { BN } from "@coral-xyz/anchor";
import { Commitment, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
import { BaseClient, type ProtocolPolicyClient, type TxOptions } from "../base";
import { LoopscaleBorrowPolicy } from "../../deser/integrationPolicies";
import { LoopscaleLoan, LoopscaleMarketInformation, LoopscaleStrategy } from "../../deser";
import { BorrowMarketAccounts, BorrowPrincipalAccounts, BorrowPrincipalParams, CreateLoanParams, DepositCollateralAccounts, DepositCollateralParams, LoopscaleBorrowPrincipalTerms, LoopscaleBorrowQuoteTerms, LoopscaleBorrowTxBuilder, LoopscaleCoreClient, LoopscaleMaxQuoteParams, LoopscaleQuote, PriceLoansAccounts, RepayPrincipalAccounts, RepayPrincipalParams, UpdateWeightMatrixAccounts, UpdateWeightMatrixParams, WithdrawCollateralAccounts, WithdrawCollateralParams } from "./core";
export type Tuple5 = [number, number, number, number, number];
export declare class LoopscaleBorrowClient implements ProtocolPolicyClient<LoopscaleBorrowPolicy> {
    private readonly core;
    readonly txBuilder: LoopscaleBorrowTxBuilder;
    constructor(core: LoopscaleCoreClient);
    get base(): BaseClient;
    get programId(): PublicKey;
    get integrationAuthorityPda(): PublicKey;
    getEventAuthorityPda(): PublicKey;
    getLoanPda: (nonce: BN, borrower?: PublicKey) => PublicKey;
    getLoanTokenAta(loan: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
    fetchPolicy(): Promise<LoopscaleBorrowPolicy | null>;
    setPolicy(policy: LoopscaleBorrowPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
    fetchLoan(loan: PublicKey): Promise<LoopscaleLoan>;
    fetchOwnedLoan(loan: PublicKey, borrower?: PublicKey): Promise<LoopscaleLoan>;
    fetchRegisteredLoans(commitment?: Commitment): Promise<LoopscaleLoan[]>;
    fetchMarketInformation(marketInformation: PublicKey): Promise<LoopscaleMarketInformation>;
    fetchStrategy(strategy: PublicKey): Promise<LoopscaleStrategy>;
    fetchMaxQuotes(params: LoopscaleMaxQuoteParams): Promise<LoopscaleQuote[]>;
    selectBestQuote(quotes: LoopscaleQuote[], externalYieldSource?: number, borrowAmount?: BN): Promise<LoopscaleQuote>;
    fetchBestQuote(params: LoopscaleMaxQuoteParams): Promise<LoopscaleQuote>;
    resolveBorrowMarketAccounts(params: {
        strategy: PublicKey | LoopscaleStrategy;
        collateralMint: PublicKey;
        expectedApy: BN;
    }): Promise<BorrowMarketAccounts>;
    resolveBorrowTermsFromStrategy(params: {
        strategy: PublicKey | LoopscaleStrategy;
        principalMint: PublicKey;
        assetIdentifier: PublicKey;
        expectedApy: BN;
        expectedLqt: Tuple5;
    }): Promise<LoopscaleBorrowPrincipalTerms>;
    resolveBorrowTermsFromTargetStrategy(params: {
        strategy: PublicKey | LoopscaleStrategy;
        principalMint: PublicKey;
        assetIdentifier: PublicKey;
        requestedDurationIndex?: number;
    }): Promise<LoopscaleBorrowPrincipalTerms>;
    resolveBorrowTermsFromQuote(params: {
        principalMint: PublicKey;
        collateralMint: PublicKey;
        assetIdentifier: PublicKey;
        collateralAmount: BN;
        borrowAmount: BN;
        durationType: number;
        duration: number;
        externalYieldSource?: number;
    }): Promise<LoopscaleBorrowQuoteTerms>;
    buildApiCreateLoanIxs(params: CreateLoanParams): Promise<{
        loan: PublicKey;
        ixs: TransactionInstruction[];
    }>;
    buildApiDepositCollateralIxs(params: {
        loan: PublicKey;
        depositMint: PublicKey;
        amount: BN;
        assetType: number;
        assetIdentifier: PublicKey;
        assetIndexGuidance: number[];
    }): Promise<TransactionInstruction[]>;
    buildApiBorrowPrincipalIxs(params: {
        loan: PublicKey;
        strategy: PublicKey;
        amount: BN;
        assetIndexGuidance: number[];
        duration: number;
        expectedLoanValues: {
            expectedApy: BN;
            expectedLqt: Tuple5;
        };
        skipSolUnwrap: boolean;
    }): Promise<TransactionInstruction[]>;
    buildApiWithdrawCollateralIxs(params: {
        loan: PublicKey;
        collateralMint: PublicKey;
        amount: BN;
        collateralIndex: number;
        assetIndexGuidance: number[];
        expectedLoanValues: {
            expectedApy: BN;
            expectedLqt: Tuple5;
        };
    }): Promise<TransactionInstruction[]>;
    buildApiRepayPrincipalIxs(params: {
        loan: PublicKey;
        strategy: PublicKey;
        amount: BN;
        ledgerIndex: number;
        repayAll: boolean;
    }): Promise<TransactionInstruction[]>;
    cosignTransaction(params: {
        tx: VersionedTransaction;
        identifier: string;
    }): Promise<VersionedTransaction>;
    createLoan(params: CreateLoanParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    closeLoan(loan: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
    depositCollateral(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    /** @deprecated */
    updateWeightMatrix(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    borrowPrincipal(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    withdrawCollateral(params: WithdrawCollateralParams, accounts: WithdrawCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    repayPrincipal(params: RepayPrincipalParams, accounts: RepayPrincipalAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    /** @deprecated */
    resolveLedgerStrategyAccounts(strategy: PublicKey): Promise<{
        strategy: PublicKey;
        marketInformation: PublicKey;
        principalMint: PublicKey;
    }>;
    getPriceLoansAccounts(commitment?: Commitment): Promise<PriceLoansAccounts | null>;
}