export * from './getters';
import type { IAddress, IChainId, INormalizedNumber, IVaultHistoricalParams, IVaultPosition, IVaultUserHistoryItem } from '../../types';
import SolanaAdapter from '../../adapters/solana';
import { AugustBase, IAugustBase } from '../../core';
import SuiAdapter from '../../adapters/sui';
import { IContractWriteOptions, INativeDepositOptions } from './write.actions';
import { Signer, Wallet } from 'ethers';
import type { IVaultBaseOptions, IVaultCustomOptions } from './types';
export type { IVaultBaseOptions, IVaultCustomOptions } from './types';
export declare class AugustVaults extends AugustBase {
    private solanaService;
    private suiService;
    private headers;
    constructor(baseConfig: IAugustBase, solana: SolanaAdapter, sui: SuiAdapter);
    vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
    depositNative(signer: Signer | Wallet, options: INativeDepositOptions): Promise<string>;
    getVaults(options?: {
        chainIds?: number[];
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    } & IVaultCustomOptions): Promise<import("../../types").IVault[]>;
    getTotalDeposited(options?: {
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    }): Promise<number>;
    getVault({ vault, chainId, options, loadSubaccounts, loadSnapshots, }: {
        vault: IAddress;
        chainId?: IChainId;
        options?: IVaultCustomOptions;
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    }): Promise<import("../../types").IVault>;
    getVaultLoans({ vault, chainId, }: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("../../types").IVaultLoan[]>;
    getVaultSubaccountLoans({ vault, chainId, }: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("../../types").IVaultLoan[]>;
    getVaultAllocations({ vault, chainId, }: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("../../types").IVaultAllocations | {
        status: number;
        message: string;
    }>;
    getVaultApy({ vault, historical, }: {
        vault: IAddress;
        historical?: Partial<IVaultHistoricalParams>;
    }): Promise<{
        value: number;
        timestamp: string;
    }[]>;
    getVaultHistoricalTimeseries({ vault, nDays, }: {
        vault: IAddress;
        nDays?: number;
    }): Promise<import("../../types").IHistoricalTimeseriesResponse>;
    getVaultAvailableRedemptions({ vault, chainId, wallet, verbose, }: {
        vault: IAddress;
        chainId?: number;
        wallet?: IAddress;
        verbose?: boolean;
    }): Promise<{
        processedWithdrawals: import("../../types").ISubgraphWithdrawProccessed[];
        requestedWithdrawals: import("../../types").ISubgraphWithdrawRequest[];
        availableRedemptions: import("../../types").IVaultAvailableRedemption[];
        pendingRedemptions: import("../../types").IVaultAvailableRedemption[];
    }>;
    getVaultPositions({ vault, wallet, chainId, showAllVaults, solanaWallet, stellarWallet, options, }: {
        vault?: IAddress;
        wallet?: IAddress;
        chainId?: IChainId;
        showAllVaults?: boolean;
        solanaWallet?: string;
        stellarWallet?: string;
        options?: IVaultBaseOptions;
    }): Promise<IVaultPosition[]>;
    getUserHistory({ wallet, chainId, vault, }: {
        wallet: IAddress;
        chainId?: IChainId;
        vault?: IAddress;
        options?: IVaultBaseOptions;
    }): Promise<IVaultUserHistoryItem[]>;
    getVaultUserLifetimePnl({ vault, wallet, chainId, }: {
        vault: IAddress;
        wallet: IAddress;
        chainId?: IChainId;
    }): Promise<import("../../types").IVaultUserLifetimePnl>;
    getVaultPnl({ vault, chainId, }: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("../../types").IVaultPnl>;
    getUserTransfers({ wallet, chainId, vault, options, }: {
        wallet: IAddress;
        chainId?: IChainId;
        vault?: IAddress;
        options?: IVaultBaseOptions;
    }): Promise<{
        id: string;
        value: string;
        to: string;
        from: string;
        pool: string;
        block: number;
        timestamp: number;
        transactionHash: string;
    }[]>;
    getStakingPositions(wallet?: IAddress, chainId?: IChainId): Promise<import("../../types").IActiveStakingPosition[]>;
    getVaultTvl({ vault, chainId, historical, }: {
        vault: IAddress;
        chainId?: IChainId;
        historical?: IVaultHistoricalParams;
    }): Promise<{
        value: INormalizedNumber;
        timestamp: string;
    }[]>;
    getYieldLastRealizedOn({ vault, chainId, }: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<number>;
    getVaultBorrowerHealthFactor(chainId?: IChainId): Promise<{}>;
    getUserPoints(userAddress: IAddress): Promise<any>;
    registerUserForPoints(userAddress: IAddress, referrerAddress?: IAddress): Promise<Response>;
    fetchPointsLeaderboard(params?: {
        page?: number;
        perPage?: number;
        sortBy?: 'streakDays' | 'totalPoints';
    }): Promise<any>;
    getVaultAnnualizedApy(vault: IAddress): Promise<import("../../types").IVaultAnnualizedApy>;
    getVaultSummary(vault: IAddress): Promise<import("../../types").IVaultSummary>;
    getVaultWithdrawals(vault: IAddress, chainId?: number): Promise<import("../../types").IVaultWithdrawals>;
    getVaultPendingRedemptions({ vault, pastDays, futureDays, }: {
        vault: IAddress;
        pastDays?: number;
        futureDays?: number;
    }): Promise<import("../../types").IVaultPendingRedemptions>;
    previewRedemption({ vault, sharesAmount, chainId, }: {
        vault: IAddress;
        sharesAmount: string | bigint | number;
        chainId?: IChainId;
    }): Promise<INormalizedNumber>;
    getWithdrawalRequestsWithStatus(vault: IAddress, receiver?: IAddress, lookbackBlocks?: number, chainId?: number): Promise<import("./getters").WithdrawalRequestStatus[]>;
    rwaRedeemAsset(signer: Signer | Wallet, { vault, asset, amount, minOut, chainId, wait, }: {
        vault: IAddress;
        asset: IAddress;
        amount: string | bigint | number;
        minOut: string | bigint | number;
        chainId?: IChainId;
        wait?: boolean;
    }): Promise<string>;
    previewRwaRedemption({ vault, asset, amount, chainId, }: {
        vault: IAddress;
        asset: IAddress;
        amount: string | bigint | number;
        chainId?: IChainId;
    }): Promise<INormalizedNumber>;
}
export default AugustVaults;