import SolanaAdapter from './adapters/solana';
import SuiAdapter from './adapters/sui';
import StellarAdapter from './adapters/stellar';
import EVMAdapter from './adapters/evm';
import { IAddress, IChainId, IVaultHistoricalParams, IWSMonitorHeaders } from './types';
import { AugustBase, IAugustBase } from './core';
import { AugustVaults, IVaultBaseOptions, IVaultCustomOptions } from './modules/vaults';
import { Signer, Wallet } from 'ethers';
import { IContractWriteOptions } from './modules/vaults/write.actions';
import { AugustSubAccounts } from './modules/sub-accounts';
export declare class AugustSDK extends AugustBase {
    private vaults;
    private subaccounts;
    solana: SolanaAdapter;
    sui: SuiAdapter;
    stellar: StellarAdapter;
    evm: EVMAdapter;
    name: string;
    constructor(baseConfig: IAugustBase);
    get subAccountsModule(): AugustSubAccounts;
    get vaultsModule(): AugustVaults;
    switchNetwork(chainId: IChainId): void;
    updateWallet(address: IAddress): void;
    clearWallet(): void;
    getPrice(symbol: string): Promise<any>;
    getVaults(options?: {
        chainIds?: number[];
        headers?: IWSMonitorHeaders;
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    } & IVaultCustomOptions): Promise<import("./types").IVault[]>;
    getTotalDeposited(options?: {
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    }): Promise<number>;
    vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
    getVault(props: {
        vault: IAddress;
        chainId?: IChainId;
        options?: IVaultCustomOptions;
        loadSubaccounts?: boolean;
        loadSnapshots?: boolean;
    }): Promise<import("./types").IVault>;
    getVaultLoans(props: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IVaultLoan[]>;
    getVaultAllocations(props: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IVaultAllocations | {
        status: number;
        message: string;
    }>;
    getVaultApy(props: {
        vault: IAddress;
        historical?: {
            daysAgo?: number;
        };
    }): Promise<{
        value: number;
        timestamp: string;
    }[]>;
    getVaultTvl(props: {
        vault: IAddress;
        historical?: IVaultHistoricalParams;
        chainId?: IChainId;
    }): Promise<{
        value: import("./types").INormalizedNumber;
        timestamp: string;
    }[]>;
    getVaultHistoricalTimeseries(props: {
        vault: IAddress;
        nDays?: number;
    }): Promise<import("./types").IHistoricalTimeseriesResponse>;
    getYieldLastRealizedOn(props: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<number>;
    getVaultAvailableRedemptions(props: {
        vault: IAddress;
        chainId?: IChainId;
        wallet?: IAddress;
        verbose?: boolean;
    }): Promise<{
        processedWithdrawals: import("./types").ISubgraphWithdrawProccessed[];
        requestedWithdrawals: import("./types").ISubgraphWithdrawRequest[];
        availableRedemptions: import("./types").IVaultAvailableRedemption[];
        pendingRedemptions: import("./types").IVaultAvailableRedemption[];
    }>;
    getVaultPositions(props: {
        vault?: IAddress;
        wallet?: IAddress;
        chainId?: IChainId;
        showAllVaults?: boolean;
        solanaWallet?: string;
        stellarWallet?: string;
        options?: IVaultBaseOptions;
    }): Promise<import("./types").IVaultPosition[]>;
    getVaultUserHistory(props: {
        wallet: IAddress;
        chainId?: IChainId;
        vault?: IAddress;
        options?: IVaultBaseOptions;
    }): Promise<import("./types").IVaultUserHistoryItem[]>;
    getVaultUserTransfers(props: {
        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;
    }[]>;
    getVaultUserLifetimePnl(props: {
        vault: IAddress;
        wallet: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IVaultUserLifetimePnl>;
    getVaultPnl(props: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IVaultPnl>;
    getVaultStakingPositions(props: {
        wallet?: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IActiveStakingPosition[]>;
    getVaultBorrowerHealthFactor(props?: {
        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(props: {
        vault: IAddress;
    }): Promise<import("./types").IVaultAnnualizedApy>;
    getVaultSummary(props: {
        vault: IAddress;
    }): Promise<import("./types").IVaultSummary>;
    getVaultWithdrawals(props: {
        vault: IAddress;
        chainId?: IChainId;
    }): Promise<import("./types").IVaultWithdrawals>;
    previewRedemption(props: {
        vault: IAddress;
        sharesAmount: string | bigint | number;
        chainId?: IChainId;
    }): Promise<import("./types").INormalizedNumber>;
    getLayerZeroDeposits(props: {
        receiptToken: 'upusdc' | 'coreusdc' | 'earnausd';
        wallet?: IAddress;
    }): Promise<import("./services/layerzero/deposits").ILayerZeroDeposit[]>;
    getLayerZeroRedeems(props?: {
        wallet?: IAddress;
    }): Promise<import("./services/layerzero/redeems").ILayerZeroRedeem[]>;
}