import { BN } from "@coral-xyz/anchor";
import { Commitment, Keypair, PublicKey, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
import { BaseClient, type ProtocolPolicyClient, type TxOptions } from "../base";
import { LoopscaleLendingPolicy } from "../../deser/integrationPolicies";
import { LoopscaleLoan, LoopscaleMarketInformation, LoopscaleStrategy } from "../../deser";
import { CloseStrategyAccounts, CreateStrategyParams, DepositStrategyAccounts, LoopscaleApiCollateralTermUpdate, LoopscaleApiUpdateStrategyParams, LoopscaleCoreClient, LoopscaleLendTxBuilder, LoopscaleMappedTransaction, LoopscaleMultiCollateralTermsUpdateParams, LoopscaleSellLedgerTerms, LoopscaleStrategyWithMarket, PriceStrategiesAccounts, SellLedgerAccounts, SellLedgerParams, WithdrawStrategyAccounts } from "./core";
export type CreateStrategyResult = {
    nonce: PublicKey;
    strategy: PublicKey;
    signature: TransactionSignature;
    signatures: TransactionSignature[];
};
export type PriceStrategiesParams = {
    commitment?: Commitment;
    solUsdOracle?: PublicKey;
    baseAssetOracle?: PublicKey;
};
export declare class LoopscaleLendClient implements ProtocolPolicyClient<LoopscaleLendingPolicy> {
    private readonly core;
    readonly txBuilder: LoopscaleLendTxBuilder;
    constructor(core: LoopscaleCoreClient);
    get base(): BaseClient;
    get programId(): PublicKey;
    get integrationAuthorityPda(): PublicKey;
    getEventAuthorityPda(): PublicKey;
    getStrategyPda(nonce: PublicKey): PublicKey;
    getStrategyTokenAta(strategy: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
    fetchPolicy(): Promise<LoopscaleLendingPolicy | null>;
    setPolicy(policy: LoopscaleLendingPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
    fetchMarketInformation(marketInformation: PublicKey): Promise<LoopscaleMarketInformation>;
    fetchStrategy(strategy: PublicKey): Promise<LoopscaleStrategy>;
    fetchOwnedStrategy(strategy: PublicKey, lender?: PublicKey): Promise<LoopscaleStrategy>;
    fetchRegisteredStrategies(commitment?: Commitment): Promise<LoopscaleStrategy[]>;
    fetchStrategyMarket(strategy: PublicKey | LoopscaleStrategy): Promise<LoopscaleMarketInformation>;
    fetchOwnedStrategyWithMarket(strategy: PublicKey, lender?: PublicKey): Promise<LoopscaleStrategyWithMarket>;
    assertStrategyClosable(strategy: LoopscaleStrategy): void;
    resolveSellLedgerMarketAccounts(params: {
        loan: PublicKey | LoopscaleLoan;
        ledgerIndex: number;
        newStrategy: PublicKey | LoopscaleStrategy;
    }): Promise<LoopscaleSellLedgerTerms>;
    buildApiSellLedgerIxs(params: {
        loan: PublicKey;
        oldStrategy: PublicKey;
        newStrategy: PublicKey;
        ledgerIndex: number;
        expectedSalePrice: BN;
        assetIndexGuidance: number[];
    }): Promise<TransactionInstruction[]>;
    buildApiDepositStrategyIxs(params: {
        strategy: PublicKey;
        amount: BN;
    }): Promise<TransactionInstruction[]>;
    buildApiWithdrawStrategyIxs(params: {
        strategy: PublicKey;
        principalMint?: PublicKey;
        amount: BN;
        withdrawAll: boolean;
    }): Promise<TransactionInstruction[]>;
    buildApiCloseStrategyIxs(params: {
        strategy: PublicKey;
    }): Promise<TransactionInstruction[]>;
    buildApiUpdateStrategyTxs(params: {
        strategy: PublicKey;
        collateralTerms?: LoopscaleApiCollateralTermUpdate;
        updateParams?: LoopscaleApiUpdateStrategyParams;
    }): Promise<LoopscaleMappedTransaction[]>;
    buildApiCreateStrategyTxs(params: CreateStrategyParams & {
        amount: BN;
        collateralTerms: LoopscaleMultiCollateralTermsUpdateParams[];
    }, accounts: {
        marketInformation: PublicKey;
        principalMint: PublicKey;
        nonce: Keypair;
    }): Promise<{
        nonce: Keypair;
        strategy: PublicKey;
        txs: LoopscaleMappedTransaction[];
    }>;
    private replaceApiCreateStrategyAccounts;
    /**
     * Creates a strategy account using local ix builder
     *
     * @param params
     * @param accounts
     * @param txOptions
     * @returns
     */
    createStrategy(params: CreateStrategyParams, accounts: {
        marketInformation: PublicKey;
        principalMint: PublicKey;
        nonce?: Keypair;
    }, txOptions?: TxOptions): Promise<CreateStrategyResult>;
    /**
     * Creates a strategy account and deposits initial principal using API
     *
     * @param params
     * @param accounts
     * @param txOptions
     * @returns
     */
    createAndDepositStrategy(params: CreateStrategyParams & {
        amount: BN;
        collateralTerms: LoopscaleMultiCollateralTermsUpdateParams[];
    }, accounts: {
        marketInformation: PublicKey;
        principalMint: PublicKey;
        nonce?: Keypair;
    }, txOptions?: TxOptions): Promise<CreateStrategyResult>;
    depositStrategy(amount: BN, accounts: DepositStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    updateStrategy(params: {
        strategy: PublicKey;
        collateralTerms?: LoopscaleApiCollateralTermUpdate;
        updateParams?: LoopscaleApiUpdateStrategyParams;
    }, txOptions?: TxOptions): Promise<TransactionSignature[]>;
    withdrawStrategy(amount: BN, withdrawAll: boolean, accounts: WithdrawStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    closeStrategy(accounts: CloseStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    sellLedger(params: SellLedgerParams, accounts: SellLedgerAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    priceStrategiesIx(params?: PriceStrategiesParams): Promise<TransactionInstruction | null>;
    priceStrategies(params?: PriceStrategiesParams, txOptions?: TxOptions): Promise<TransactionSignature | null>;
    getPriceStrategiesAccounts(commitment?: Commitment): Promise<PriceStrategiesAccounts | null>;
}