/// <reference types="@project-serum/anchor/node_modules/@solana/web3.js" />
import { web3 } from "@project-serum/anchor";
import { PublicKey } from "@solana/web3.js";
import { CreateReceivableConfig, CredixPassConfig, DealConfig, UpdateGlobalMarketConfig, UpdateMarketAdminsConfig } from "../config";
import { GlobalMarketState } from "../idl/idl.types";
import { Base } from "../rpc/Base";
import { CredixClient, SolanaContext } from "../rpc/CredixClient";
import { BorrowerInfo } from "./BorrowerInfo";
import { CredixPass } from "./CredixPass";
import { Deal, DealStatus } from "./Deal";
import { Fraction } from "./Fraction";
import { ManagedBorrower } from "./ManagedBorrower";
import { MarketAdmins } from "./MarketAdmins";
import { Receivable } from "./Receivable";
import { RepaymentSchedule } from "./RepaymentSchedule";
import { ScowPoolInvestor } from "./ScowPoolInvestor";
import { ScowTrancheInvestor } from "./ScowTrancheInvestor";
import { SecondaryMarket } from "./SecondaryMarket";
import { Tranche } from "./Tranche";
import { Tranches } from "./Tranches";
import { WithdrawEpoch } from "./WithdrawEpoch";
export declare enum MarketStatus {
    OPEN_FOR_FUNDING = 0,
    PRIVATE = 1,
    CLOSED = 2
}
export declare class Market extends Base<GlobalMarketState> {
    address: PublicKey;
    constructor(address: PublicKey, solanaContext: SolanaContext, client: CredixClient, programVersion: GlobalMarketState);
    reload(): Promise<void>;
    get programId(): web3.PublicKey;
    get secondaryMarketProgramId(): web3.PublicKey;
    get baseMintPK(): web3.PublicKey;
    get lpMintPK(): web3.PublicKey;
    get poolOutstandingCredit(): web3.TokenAmount;
    get status(): MarketStatus;
    totalOutstandingCredit(deals: Deal[], tranches: (Tranches | null)[], schedules: (RepaymentSchedule | null)[]): Promise<web3.TokenAmount>;
    get treasury(): web3.PublicKey;
    get hasWithdrawEpochs(): boolean;
    get withdrawFee(): Fraction;
    get poolSizeLimitPercentage(): Fraction;
    get isFrozen(): boolean;
    get lockedLiquidity(): web3.TokenAmount;
    get latestWithdrawEpochIdx(): number;
    get withdrawEpochAvailableLiquidityDays(): number;
    get withdrawEpochAvailableLiquiditySeconds(): number;
    get latestWithdrawEpochEnd(): number;
    get withdrawEpochRequestDays(): number;
    get withdrawEpochRequestSeconds(): number;
    get withdrawEpochRedeemDays(): number;
    get withdrawEpochRedeemSeconds(): number;
    get name(): string;
    get totalRedeemedBaseAmount(): web3.TokenAmount;
    get lockupDuration(): number;
    get isUncapped(): boolean;
    get baseMintMetadata(): {
        name: string;
        symbol: string;
    };
    get isCrossChain(): boolean;
    private depositBuilder;
    deposit(amount: number): Promise<string>;
    depositIx(amount: number, investor?: PublicKey): Promise<web3.TransactionInstruction>;
    private withdrawBuilder;
    withdraw(amount: number): Promise<string>;
    withdrawIx(amount: number, investor?: PublicKey): Promise<web3.TransactionInstruction>;
    createDeal(dealConfig: DealConfig): Promise<string>;
    getTreasuryBalance(): Promise<web3.TokenAmount>;
    getLPSupply(): Promise<web3.TokenAmount>;
    getLPPrice(): Promise<number>;
    getBasePrice(): Promise<number>;
    findBaseTokenAccount(pk: PublicKey): web3.PublicKey;
    findLPTokenAccount(pk: PublicKey): web3.PublicKey;
    userBaseBalance(user: PublicKey): Promise<web3.TokenAmount>;
    userBaseTokenAccountBalance(userBaseTokenAccount: PublicKey): Promise<web3.TokenAmount>;
    userLPBalance(user: PublicKey): Promise<web3.TokenAmount>;
    fetchLiquidityPoolBalance(): Promise<web3.TokenAmount>;
    fetchDeal(borrower: PublicKey, dealNumber: number): Promise<Deal | null>;
    fetchMarketAdmins(): Promise<MarketAdmins>;
    calculateTVL(): Promise<web3.TokenAmount>;
    fetchDeals(status?: DealStatus): Promise<Deal[]>;
    fetchAllScowTrancheInvestors(): Promise<ScowTrancheInvestor[]>;
    fetchAllScowPoolInvestors(): Promise<ScowPoolInvestor[]>;
    fetchBorrowerInfo(borrower: PublicKey): Promise<BorrowerInfo | null>;
    fetchCredixPass(holder: PublicKey): Promise<CredixPass | null>;
    static generatePDA(marketName: string, programId: PublicKey): [web3.PublicKey, number];
    static generateLPTokenMintPDA(marketName: string, programId: PublicKey): [web3.PublicKey, number];
    private generateCredixPassPDA;
    generateSigningAuthorityPDA(): [web3.PublicKey, number];
    findLiquidityPoolTokenAccount(): web3.PublicKey;
    getUserStake(user: PublicKey): Promise<web3.TokenAmount>;
    private issueCredixPassBuilder;
    issueCredixPassIx(holder: PublicKey, credixPassConfig: CredixPassConfig, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    issueCredixPass(holder: PublicKey, credixPassConfig: CredixPassConfig): Promise<string>;
    private updateCredixPassBuilder;
    updateCredixPassIx(holder: PublicKey, credixPassConfig: CredixPassConfig, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    updateCredixPass(holder: PublicKey, credixPassConfig: CredixPassConfig): Promise<string>;
    private freezeBuilder;
    freezeIx(owner?: PublicKey): Promise<web3.TransactionInstruction>;
    freeze(): Promise<string>;
    private thawBuilder;
    thawIx(owner?: PublicKey): Promise<web3.TransactionInstruction>;
    thaw(): Promise<string>;
    get credixFeePercentage(): Fraction;
    calculateAvgFinancingFee(): Promise<number>;
    updateCredixFees(credixFeePercentage: Fraction): Promise<string>;
    private updateConfigBuilder;
    updateConfig(updateConfig: UpdateGlobalMarketConfig): Promise<string>;
    updateConfigIx(updateConfig: UpdateGlobalMarketConfig, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    private updateMarketAdminsBuilder;
    updateMarketAdminsIx(marketAdminsConfig: UpdateMarketAdminsConfig, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    updateMarketAdmins(marketAdminsConfig: UpdateMarketAdminsConfig): Promise<string>;
    private thawFreezeTokenAccountBuilder;
    thawFreezeTokenAccountIx(freeze: boolean, mint: PublicKey, tokenAccount: PublicKey, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    thawFreezeTokenAccount(freeze: boolean, mint: PublicKey, tokenAccount: PublicKey): Promise<string>;
    isManager(user: PublicKey): Promise<boolean>;
    private createWithdrawEpochBuilder;
    createWithdrawEpochIx(owner?: PublicKey): Promise<web3.TransactionInstruction>;
    createWithdrawEpoch(): Promise<string>;
    fetchWithdrawEpoch(withEpochIdx: number): Promise<WithdrawEpoch | null>;
    fetchLatestWithdrawEpoch(): Promise<WithdrawEpoch>;
    private setLockedLiquidityBuilder;
    setLockedLiquidityIx(owner?: PublicKey): Promise<web3.TransactionInstruction>;
    setLockedLiquidity(): Promise<string>;
    fetchPortfolio(investor: PublicKey): Promise<{
        dealsInvested: {
            deal: Deal & {
                dealTranches: Tranches;
                repaymentSchedule: RepaymentSchedule;
            };
            tranches: {
                tranche: Tranche;
                baseAmountInvested: web3.TokenAmount;
                withdrawable: web3.TokenAmount;
                withdrawn: web3.TokenAmount;
                gains: web3.TokenAmount;
            }[];
        }[];
        poolValue: web3.TokenAmount;
    }>;
    averageTenorInDays(): Promise<number>;
    private initSecondaryMarketBuilder;
    initSecondaryMarketIx(owner?: PublicKey): Promise<web3.TransactionInstruction>;
    initSecondaryMarket(): Promise<string>;
    fetchSecondaryMarket(): Promise<SecondaryMarket | null>;
    fetchManagedBorrower(borrowerName: string): Promise<ManagedBorrower | null>;
    private createManagedBorrowerBuilder;
    createManagedBorrower(borrowerName: string): Promise<string>;
    createManagedBorrowerIx(borrowerName: string, ownerPk?: PublicKey): Promise<web3.TransactionInstruction>;
    fetchScowPoolInvestor(investorBaseTokenAccount: PublicKey): Promise<ScowPoolInvestor>;
    private createScowPoolInvestorBuilder;
    createScowPoolInvestor(investorBaseTokenAccount: PublicKey): Promise<string>;
    createScowPoolInvestorIx(investorBaseTokenAccount: PublicKey, ownerPk?: PublicKey): Promise<web3.TransactionInstruction>;
    private createReceivableBuilder;
    createReceivableIx(receivableConfig: CreateReceivableConfig, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    createReceivable(receivableConfig: CreateReceivableConfig): Promise<string>;
    private fundReceivableBuilder;
    fundReceivableIx(receivable: Receivable, owner?: PublicKey): Promise<web3.TransactionInstruction>;
    fundReceivable(receivable: Receivable): Promise<string>;
}
//# sourceMappingURL=Market.d.ts.map