@pyron-finance/pyron-client 2.5.2 → 2.6.0

package/dist/index.d.cts

@@ -1,2 +1,3445 @@
-import { $ as lendrAccountToDto, $a as InterestRateConfigOpt, $i as getConfig, $n as getLiabilityShares, $r as makePriorityFeeMicroIx, $t as LendrClientOptions, A as StakePoolMevMap, Aa as InterestRateConfigOptRaw, Ai as MAX_U64, An as hasEmodeEntryFlag, Ar as MakeDepositWithSessionIxOpts, At as HealthCacheSimulationError, B as FogoMetadataFetcher, Ba as BankConfigFlag, Bi as DEFAULT_CONFIRM_OPTS, Bn as computeBaseInterestRate, Br as Bank, Bt as LendrRequirementTypeRaw, C as fetchNativeStakeAccounts, Ca as BankConfigOptRaw, Ci as SYSVAR_CLOCK_ID, Cn as dtoToBankConfigRaw, Cr as RepayWithCollateralTxProps, Ct as computeHealthComponentsLegacy, D as dtoToValidatorStakeGroup, Da as EmodeConfigRaw, Di as GROUP_PK, Dn as dtoToInterestRateConfig, Dr as MakeBorrowIxOpts, Dt as computeQuantityUi, E as fetchStakePoolMev, Ea as BankRaw, Ei as DEFAULT_CLUSTER, En as dtoToEmodeSettingsRaw, Er as LendrRequirementType, Et as computeQuantity, F as IMetadataFetcher, Fa as RatePointRaw, Fi as DISABLED_FLAG, Fn as parseEmodeTag, Fr as isWeightedPrice, Ft as simulateAccountHealthCache, G as LendrGroupType, Ga as EmodeEntryFlags, Gi as PRIORITY_TX_SIZE, Gn as computeRemainingCapacity, Gr as PythPushFeedIdMap, Gt as BalanceType, H as groupToDto, Ha as BankConfigType, Hi as DEFAULT_SEND_OPTS, Hn as computeLiabilityUsdValue, Hr as EmodeSettings, Ht as HealthCacheTypeDto, I as MetadataService, Ia as RiskTierRaw, Ii as FLASHLOAN_ENABLED_FLAG, In as parseOperationalState, Ir as Balance, It as simulateAccountHealthCacheWithFallback, J as makePoolAddBankIx, Ja as EmodeImpactStatus, Ji as PDA_BANK_FEE_VAULT_SEED, Jn as computeUtilizationRate, Jr as findOracleKey, Jt as LendrAccountType, K as LendrGroupTypeDto, Ka as EmodeFlags, Ki as SKIP_SIMULATION, Kn as computeTvl, Kr as buildFeedIdMap, Kt as HealthCacheFlags, L as MetadataServiceProps, La as ActionEmodeImpact, Li as TRANSFER_ACCOUNT_AUTHORITY_FLAG, Ln as parseOracleSetup, Lr as index_d_exports, Lt as BalanceRaw, M as ValidatorStakeGroup, Ma as OperationalStateRaw, Mi as PYTH_PRICE_CONF_INTERVALS, Mn as parseBankConfigRaw, Mr as MakeRepayWithSessionIxOpts, Mt as createUpdateFeedIx, N as ValidatorStakeGroupDto, Na as OracleConfigOptRaw, Ni as PYTH_PUSH_ORACLE_ID, Nn as parseBankRaw, Nr as MakeWithdrawIxOpts, Nt as getActiveStaleBanks, O as ActiveStakePoolMap, Oa as EmodeSettingsRaw, Oi as HOURS_PER_YEAR, On as getActiveEmodeEntryFlags, Or as MakeBorrowWithSessionIxOpts, Ot as computeTotalOutstandingEmissions, P as MetaplexMetadataFetcher, Pa as OracleSetupRaw, Pi as SWB_PRICE_CONF_INTERVALS, Pn as parseEmodeSettingsRaw, Pr as MakeWithdrawWithSessionIxOpts, Pt as makePulseHealthIx, Q as healthCacheToDto, Qa as InterestRateConfig, Qi as PDA_BANK_LIQUIDITY_VAULT_SEED, Qn as getLiabilityQuantity, Qr as makePriorityFeeIx, Qt as LendrClientFetchOptions, R as TMetadata, Ra as ActiveEmodePair, Ri as BUNDLE_TX_SIZE, Rn as parseRiskTier, Rr as HealthCache, Rt as HealthCacheRaw, S as validatorStakeGroupToDto, Sa as BankConfigCompactRaw, Si as SYSTEM_PROGRAM_ID, Sn as dtoToBankConfig, Sr as RepayWithCollateralProps, St as computeHealthComponents, T as fetchStakePoolActiveStates, Ta as BankMetadataRaw, Ti as SYSVAR_STAKE_HISTORY_ID, Tn as dtoToEmodeSettings, Tr as LendrAccount, Tt as computeNetApy, U as dtoToGroup, Ua as BankType, Ui as MAX_ACCOUNT_KEYS, Un as computeLoopingParams, Ur as LENDR_SPONSORED_SHARD_ID, Ut as LendrAccountTypeDto, V as DummyMetadataFetcher, Va as BankConfigOpt, Vi as DEFAULT_ORACLE_MAX_AGE, Vn as computeInterestRates, Vr as BankConfig, Vt as BalanceTypeDto, W as LendrGroupRaw, Wa as EmodeEntry, Wi as MAX_TX_SIZE, Wn as computeMaxLeverage, Wr as PYTH_SPONSORED_SHARD_ID, Wt as AccountFlags, X as accountFlagToBN, Xa as EmodeSettingsType, Xi as PDA_BANK_INSURANCE_VAULT_SEED, Xn as getAssetShares, Xr as getBankVaultAuthority, Xt as FetchGroupDataFn, Y as makePoolConfigureBankIx, Ya as EmodePair, Yi as PDA_BANK_INSURANCE_VAULT_AUTH_SEED, Yn as getAssetQuantity, Yr as findPythPushOracleAddress, Yt as BankMap, Z as balanceToDto, Za as EmodeTag, Zi as PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, Zn as getAssetWeight, Zr as getBankVaultSeeds, Zt as LendrClient, _ as SpecificBroadcastMethod, _a as EmodeEntryDto, _i as LUT_PROGRAM_AUTHORITY_INDEX, _n as toEmodeSettingsDto, _r as makeBundleTipIx, _t as computeClaimedEmissions, aa as PriceWithConfidenceDto, ai as ProgramError, an as FetchRawBanksArgs, ao as AccountType, ar as fetchOracleData, at as dtoToBalance, b as processTransactions, ba as InterestRateConfigDto, bi as STAKE_CONFIG_ID, bn as decodeBankRaw, br as LoopProps, bt as computeHealthAccountMetas, ca as freezeBankConfigIx, ci as parseTransactionError, cn as bankRawToDto, co as Environment, cr as dtoToOraclePrice, ct as getActiveAccountFlags, d as DEFAULT_PROCESS_TX_OPTS, da as getTreasuryPda, di as USDC_DECIMALS, dn as serializeOperationalState, do as LendrConfig, dr as getPriceWithConfidence, dt as hasAccountFlag, ea as instructions, ei as makeUnwrapSolIx, en as LendrClientProps, eo as OperationalState, er as getLiabilityWeight, et as fetchLendrAccountAddresses, f as DEFAULT_PROCESS_TX_STRATEGY, fa as BankConfigDto, fi as USDC_MINT, fn as serializeOracleSetup, fo as LendrProgram, fr as isOracleSetupSupported, ft as hasHealthCacheFlag, g as ProcessTransactionsClientOpts, ga as EmodeConfigRawDto, gi as LENDR_PROGRAM, gn as toBankDto, go as LendrIdlType, gr as SimulationResult, gt as computeBalanceUsdValue, h as ProcessTransactionStrategy, ha as BankTypeDto, hi as JUPITER_V6_PROGRAM, hn as toBankConfigDto, ho as LENDR_IDL, hr as LendrAccountWrapper, ht as computeAccountValue, ia as PriceWithConfidence, ii as ProcessTransactionErrorType, in as DataFetcher, io as RiskTier, ir as extractPythOracleKeys, it as decodeAccountRaw, j as ValidatorRateData, ja as InterestRateConfigRaw, ji as PROGRAM_ID, jn as hasEmodeFlag, jr as MakeRepayIxOpts, jt as createLendrAccountTx, k as StakeAccount, ka as InterestRateConfigCompactRaw, ki as MAX_CONFIDENCE_INTERVAL_RATIO, kn as getActiveEmodeFlags, kr as MakeDepositIxOpts, kt as getBalanceUsdValueWithPriceBias, la as getConfigPda, li as DUMMY_USDC_MINT, ln as emodeSettingsRawToDto, lo as LendingAccountDepositOrRepayWithSessionAccounts, lr as SupportedOracleSetup, lt as getActiveHealthCacheFlags, m as ProcessTransactionOpts, ma as BankRawDto, mi as WSOL_MINT, mn as serializeRiskTier, mo as TLogger, mr as FlashLoanArgs, mt as parseLendrAccountRaw, na as OraclePriceDto, ni as makeWrapSolIxs, nn as MintDataMap, no as OracleSetup, nr as getTotalLiabilityQuantity, nt as computeActiveEmodePairs, oa as addOracleToBanksIx, oi as ProgramErrorWithDescription, on as bankConfigRawToDto, oo as BankAddress, or as fetchPythOracleData, ot as dtoToHealthCache, p as PriorityFees, pa as BankConfigRawDto, pi as WSOL_EXTENDED_METADATA, pn as serializeOracleSetupToIndex, po as LogFn, pr as parseOraclePriceData, pt as parseBalanceRaw, q as makeAddPermissionlessStakedBankIx, qa as EmodeImpact, qi as PDA_BANK_FEE_VAULT_AUTH_SEED, qn as computeUsdValue, qr as feedIdToString, qt as HealthCacheType, ra as PriceBias, ri as ProcessTransactionError, rn as OraclePriceMap, ro as RatePoint, rr as oraclePriceToDto, rt as computeEmodeImpacts, sa as crankPythOracleIx, si as parseErrorFromLogs, sn as bankConfigToBankConfigRaw, so as BankVaultType, sr as fetchSwbOracleData, st as dtoToLendrAccount, ta as OraclePrice, ti as makeVersionedTransaction, tn as MintData, to as OracleConfigOpt, tr as getTotalAssetQuantity, tt as fetchLendrAccountData, u as BroadcastMethodType, ua as getPriceFeedAccountForProgram, ui as LST_MINT, un as serializeBankConfigOpt, uo as LendingAccountWithdrawOrBorrowWithSessionAccounts, ur as getPrice, ut as getHealthCacheStatusDescription, v as SpecificBroadcastMethodType, va as EmodeSettingsDto, vi as MPL_METADATA_PROGRAM_ID, vn as toInterestRateConfigDto, vr as makeTxPriorityIx, vt as computeFreeCollateral, w as fetchStakeAccount, wa as BankConfigRaw, wi as SYSVAR_RENT_ID, wn as dtoToBankRaw, wr as TransactionBuilderResult, wt as computeHealthComponentsWithoutBiasLegacy, x as simulateTransactions, xa as RatePointDto, xi as STAKE_PROGRAM_ID, xn as dtoToBank, xr as LoopTxProps, xt as computeHealthCheckAccounts, y as confirmTransaction, ya as EmodeSettingsRawDto, yi as SINGLE_POOL_PROGRAM_ID, yn as fetchMultipleBanks, yr as FlashloanActionResult, yt as computeFreeCollateralLegacy, z as metadataSchema, za as AssetTag, zi as DEFAULT_COMMITMENT, zn as computeAssetUsdValue, zr as LendrGroup, zt as LendrAccountRaw } from "./index-Mtc43T83.cjs";
-export { AccountFlags, AccountType, ActionEmodeImpact, ActiveEmodePair, ActiveStakePoolMap, AssetTag, BUNDLE_TX_SIZE, Balance, BalanceRaw, BalanceType, BalanceTypeDto, Bank, BankAddress, BankConfig, BankConfigCompactRaw, BankConfigDto, BankConfigFlag, BankConfigOpt, BankConfigOptRaw, BankConfigRaw, BankConfigRawDto, BankConfigType, BankMap, BankMetadataRaw, BankRaw, BankRawDto, BankType, BankTypeDto, BankVaultType, BroadcastMethodType, DEFAULT_CLUSTER, DEFAULT_COMMITMENT, DEFAULT_CONFIRM_OPTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_PROCESS_TX_OPTS, DEFAULT_PROCESS_TX_STRATEGY, DEFAULT_SEND_OPTS, DISABLED_FLAG, DUMMY_USDC_MINT, DataFetcher, DummyMetadataFetcher, EmodeConfigRaw, EmodeConfigRawDto, EmodeEntry, EmodeEntryDto, EmodeEntryFlags, EmodeFlags, EmodeImpact, EmodeImpactStatus, EmodePair, EmodeSettings, EmodeSettingsDto, EmodeSettingsRaw, EmodeSettingsRawDto, EmodeSettingsType, EmodeTag, Environment, FLASHLOAN_ENABLED_FLAG, FetchGroupDataFn, FetchRawBanksArgs, FlashLoanArgs, FlashloanActionResult, FogoMetadataFetcher, GROUP_PK, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheRaw, HealthCacheSimulationError, HealthCacheType, HealthCacheTypeDto, IMetadataFetcher, InterestRateConfig, InterestRateConfigCompactRaw, InterestRateConfigDto, InterestRateConfigOpt, InterestRateConfigOptRaw, InterestRateConfigRaw, JUPITER_V6_PROGRAM, LENDR_IDL, LENDR_PROGRAM, LENDR_SPONSORED_SHARD_ID, LST_MINT, LUT_PROGRAM_AUTHORITY_INDEX, LendingAccountDepositOrRepayWithSessionAccounts, LendingAccountWithdrawOrBorrowWithSessionAccounts, LendrAccount, LendrAccountRaw, LendrAccountType, LendrAccountTypeDto, LendrAccountWrapper, LendrClient, LendrClientFetchOptions, LendrClientOptions, LendrClientProps, LendrConfig, LendrGroup, LendrGroupRaw, LendrGroupType, LendrGroupTypeDto, LendrIdlType, LendrProgram, LendrRequirementType, LendrRequirementTypeRaw, LogFn, LoopProps, LoopTxProps, MAX_ACCOUNT_KEYS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MakeBorrowIxOpts, MakeBorrowWithSessionIxOpts, MakeDepositIxOpts, MakeDepositWithSessionIxOpts, MakeRepayIxOpts, MakeRepayWithSessionIxOpts, MakeWithdrawIxOpts, MakeWithdrawWithSessionIxOpts, MetadataService, MetadataServiceProps, MetaplexMetadataFetcher, MintData, MintDataMap, OperationalState, OperationalStateRaw, OracleConfigOpt, OracleConfigOptRaw, OraclePrice, OraclePriceDto, OraclePriceMap, OracleSetup, OracleSetupRaw, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PRIORITY_TX_SIZE, PROGRAM_ID, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, PriceWithConfidence, PriceWithConfidenceDto, PriorityFees, ProcessTransactionError, ProcessTransactionErrorType, ProcessTransactionOpts, ProcessTransactionStrategy, ProcessTransactionsClientOpts, ProgramError, ProgramErrorWithDescription, PythPushFeedIdMap, RatePoint, RatePointDto, RatePointRaw, RepayWithCollateralProps, RepayWithCollateralTxProps, RiskTier, RiskTierRaw, SINGLE_POOL_PROGRAM_ID, SKIP_SIMULATION, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SimulationResult, SpecificBroadcastMethod, SpecificBroadcastMethodType, StakeAccount, StakePoolMevMap, SupportedOracleSetup, TLogger, TMetadata, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionBuilderResult, USDC_DECIMALS, USDC_MINT, ValidatorRateData, ValidatorStakeGroup, ValidatorStakeGroupDto, WSOL_EXTENDED_METADATA, WSOL_MINT, accountFlagToBN, addOracleToBanksIx, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankRawToDto, buildFeedIdMap, computeAccountValue, computeActiveEmodePairs, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeEmodeImpacts, computeFreeCollateral, computeFreeCollateralLegacy, computeHealthAccountMetas, computeHealthCheckAccounts, computeHealthComponents, computeHealthComponentsLegacy, computeHealthComponentsWithoutBiasLegacy, computeInterestRates, computeLiabilityUsdValue, computeLoopingParams, computeMaxLeverage, computeNetApy, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, confirmTransaction, crankPythOracleIx, createLendrAccountTx, createUpdateFeedIx, decodeAccountRaw, decodeBankRaw, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToLendrAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, feedIdToString, fetchLendrAccountAddresses, fetchLendrAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchPythOracleData, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleData, findOracleKey, findPythPushOracleAddress, freezeBankConfigIx, getActiveAccountFlags, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getActiveStaleBanks, getAssetQuantity, getAssetShares, getAssetWeight, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getConfig, getConfigPda, getHealthCacheStatusDescription, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getPrice, getPriceFeedAccountForProgram, getPriceWithConfidence, getTotalAssetQuantity, getTotalLiabilityQuantity, getTreasuryPda, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, instructions, isOracleSetupSupported, isWeightedPrice, lendrAccountToDto, makeAddPermissionlessStakedBankIx, makeBundleTipIx, makePoolAddBankIx, makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeTxPriorityIx, makeUnwrapSolIx, makeVersionedTransaction, makeWrapSolIxs, metadataSchema, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseErrorFromLogs, parseLendrAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseTransactionError, processTransactions, serializeBankConfigOpt, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateTransactions, toBankConfigDto, toBankDto, toEmodeSettingsDto, toInterestRateConfigDto, validatorStakeGroupToDto, index_d_exports as vendor };
+import * as anchor from '@coral-xyz/anchor';
+import { Address, Provider, AnchorProvider, BorshCoder, Program as Program$1 } from '@coral-xyz/anchor';
+import { TransactionResult } from '@fogo/sessions-sdk';
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, TransactionInstruction, VersionedTransaction, Blockhash, Transaction, AddressLookupTableAccount, Connection, AccountMeta, Commitment, TransactionSignature, Signer, TransactionError, ConfirmOptions, SimulatedTransactionResponse, Keypair, SendOptions } from '@solana/web3.js';
+import { Storage } from 'unstorage';
+import { B as BankVaultType, a as BankExtendedMetadata, L as LendrIdlType, P as Program, b as BankMetadataMap, T as TLogger, A as Amount, c as LendrProgram, I as InstructionsWrapper, S as SolanaTransaction, d as TransactionOptions, E as ExtendedTransaction, e as ExtendedTransactionProperties, f as ExtendedV0Transaction, g as TransactionBroadcastType, W as WrappedI80F48, h as BankMetadata, i as IMetadataFetcher, j as Wallet, k as LendrConfig, l as BanksExtendedMetadataOverrideMap, M as MetadataService, m as BankExtendedMetadataMap, n as AccountType$1, o as LendingAccountDepositOrRepayWithSessionAccounts, p as LendingAccountWithdrawOrBorrowWithSessionAccounts, q as Environment } from './bank-metadata-X4_5k9-u.cjs';
+export { v as BankAddress, r as LENDR_IDL, w as LogFn, u as MetadataServiceProps, t as TMetadata, s as metadataSchema } from './bank-metadata-X4_5k9-u.cjs';
+import BN from 'bn.js';
+import BigNumber from 'bignumber.js';
+import 'zod';
+import '@solana/wallet-adapter-base';
+import 'zod/v4-mini';
+
+type EstablishedSessionState = {
+    walletPublicKey: PublicKey;
+    sessionPublicKey: PublicKey;
+    payer: PublicKey;
+    sendTransaction: (instructions: Array<TransactionInstruction> | VersionedTransaction, options?: {
+        variation?: string;
+    }) => Promise<TransactionResult>;
+};
+
+interface PriceWithConfidence {
+    price: BigNumber;
+    confidence: BigNumber;
+    lowestPrice: BigNumber;
+    highestPrice: BigNumber;
+}
+interface OraclePrice {
+    priceRealtime: PriceWithConfidence;
+    priceWeighted: PriceWithConfidence;
+    timestamp: BigNumber;
+    pythShardId?: number;
+}
+declare enum PriceBias {
+    Lowest = 0,
+    None = 1,
+    Highest = 2
+}
+interface PriceWithConfidenceDto {
+    price: string;
+    confidence: string;
+    lowestPrice: string;
+    highestPrice: string;
+}
+interface OraclePriceDto {
+    priceRealtime: PriceWithConfidenceDto;
+    priceWeighted: PriceWithConfidenceDto;
+    timestamp: string;
+    pythShardId?: number;
+}
+
+declare function getBankVaultSeeds(type: BankVaultType): Buffer;
+/**
+ * Compute authority PDA for a specific lendr group bank vault
+ */
+declare function getBankVaultAuthority(bankVaultType: BankVaultType, bankPk: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function makeWrapSolIxs(walletAddress: PublicKey, amount: BigNumber): TransactionInstruction[];
+declare function makeUnwrapSolIx(walletAddress: PublicKey): TransactionInstruction;
+declare function makeVersionedTransaction(blockhash: Blockhash, transaction: Transaction, payer: PublicKey, addressLookupTables?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
+/**
+ * Creates a compute budget instruction to set the priority fee for a transaction.
+ * The priority fee is specified in micro-lamports per compute unit.
+ *
+ * @param priorityFeeMicro - Priority fee in micro-lamports per compute unit. If not provided, defaults to 1.
+ * @returns A compute budget instruction with the specified priority fee
+ */
+declare function makePriorityFeeMicroIx(priorityFeeMicro?: number): TransactionInstruction;
+declare function makePriorityFeeIx(priorityFeeUi?: number, computeUnitsLimit?: number): TransactionInstruction[];
+declare function feedIdToString(feedId: PublicKey): string;
+type PythPushFeedIdMap = Map<string, {
+    feedId: PublicKey;
+    shardId?: number;
+}>;
+declare function buildFeedIdMap(bankConfigs: BankConfigRaw[], connection: Connection): Promise<PythPushFeedIdMap>;
+declare function findOracleKey(bankConfig: BankConfig, feedIdMap?: PythPushFeedIdMap): {
+    oracleKey: PublicKey;
+    shardId?: number;
+};
+declare const PYTH_SPONSORED_SHARD_ID = 0;
+declare const LENDR_SPONSORED_SHARD_ID = 3301;
+declare function findPythPushOracleAddress(feedId: Buffer, programId: PublicKey, shardId: number): PublicKey;
+
+declare class EmodeSettings implements EmodeSettingsType {
+    emodeTag: EmodeTag;
+    timestamp: number;
+    flags: EmodeFlags[];
+    emodeEntries: EmodeEntry[];
+    constructor(emodeTag: EmodeTag, timestamp: number, flags: EmodeFlags[], emodeEntries: EmodeEntry[]);
+    static from(emodeSettingsRaw: EmodeSettingsRaw): EmodeSettings;
+}
+
+declare class Bank implements BankType {
+    readonly address: PublicKey;
+    readonly mint: PublicKey;
+    readonly mintDecimals: number;
+    readonly group: PublicKey;
+    readonly mintRate: number | null;
+    readonly mintPrice: number;
+    readonly assetShareValue: BigNumber;
+    readonly liabilityShareValue: BigNumber;
+    readonly liquidityVault: PublicKey;
+    readonly liquidityVaultBump: number;
+    readonly liquidityVaultAuthorityBump: number;
+    readonly insuranceVault: PublicKey;
+    readonly insuranceVaultBump: number;
+    readonly insuranceVaultAuthorityBump: number;
+    readonly collectedInsuranceFeesOutstanding: BigNumber;
+    readonly feeVault: PublicKey;
+    readonly feeVaultBump: number;
+    readonly feeVaultAuthorityBump: number;
+    readonly collectedGroupFeesOutstanding: BigNumber;
+    readonly lastUpdate: number;
+    config: BankConfig;
+    readonly totalAssetShares: BigNumber;
+    readonly totalLiabilityShares: BigNumber;
+    readonly emissionsActiveBorrowing: boolean;
+    readonly emissionsActiveLending: boolean;
+    readonly emissionsRate: number;
+    readonly emissionsMint: PublicKey;
+    readonly emissionsRemaining: BigNumber;
+    readonly oracleKey: PublicKey;
+    readonly emode: EmodeSettings;
+    readonly feesDestinationAccount?: PublicKey | undefined;
+    readonly lendingPositionCount?: BigNumber | undefined;
+    readonly borrowingPositionCount?: BigNumber | undefined;
+    readonly pythShardId?: number | undefined;
+    readonly tokenSymbol?: string | undefined;
+    readonly extendedMetadata?: BankExtendedMetadata | undefined;
+    readonly owner?: PublicKey | undefined;
+    constructor(address: PublicKey, mint: PublicKey, mintDecimals: number, group: PublicKey, mintRate: number | null, mintPrice: number, assetShareValue: BigNumber, liabilityShareValue: BigNumber, liquidityVault: PublicKey, liquidityVaultBump: number, liquidityVaultAuthorityBump: number, insuranceVault: PublicKey, insuranceVaultBump: number, insuranceVaultAuthorityBump: number, collectedInsuranceFeesOutstanding: BigNumber, feeVault: PublicKey, feeVaultBump: number, feeVaultAuthorityBump: number, collectedGroupFeesOutstanding: BigNumber, lastUpdate: number, config: BankConfig, totalAssetShares: BigNumber, totalLiabilityShares: BigNumber, emissionsActiveBorrowing: boolean, emissionsActiveLending: boolean, emissionsRate: number, emissionsMint: PublicKey, emissionsRemaining: BigNumber, oracleKey: PublicKey, emode: EmodeSettings, feesDestinationAccount?: PublicKey | undefined, lendingPositionCount?: BigNumber | undefined, borrowingPositionCount?: BigNumber | undefined, pythShardId?: number | undefined, tokenSymbol?: string | undefined, extendedMetadata?: BankExtendedMetadata | undefined, owner?: PublicKey | undefined);
+    static decodeBankRaw(encoded: Buffer, idl: LendrIdlType): BankRaw;
+    static fromBuffer(bankPk: PublicKey, rawData: Buffer, idl: LendrIdlType, feedIdMap: PythPushFeedIdMap): Bank;
+    static fromBankType(bankType: BankType): Bank;
+    static fromAccountParsed(address: PublicKey, accountParsed: BankRaw, feedIdMap?: PythPushFeedIdMap, extendedMetadata?: BankExtendedMetadata, owner?: PublicKey): Bank;
+    static withEmodeWeights(bank: Bank, emodeWeights: {
+        assetWeightMaint: BigNumber;
+        assetWeightInit: BigNumber;
+    }): Bank;
+    static getPrice(oraclePrice: OraclePrice, priceBias?: PriceBias, weightedPrice?: boolean): BigNumber;
+    static computeQuantityFromUsdValue(oraclePrice: OraclePrice, usdValue: BigNumber, priceBias: PriceBias, weightedPrice: boolean): BigNumber;
+    getTotalAssetQuantity(): BigNumber;
+    getTotalLiabilityQuantity(): BigNumber;
+    getAssetQuantity(assetShares: BigNumber): BigNumber;
+    getLiabilityQuantity(liabilityShares: BigNumber): BigNumber;
+    getAssetShares(assetQuantity: BigNumber): BigNumber;
+    getLiabilityShares(liabilityQuantity: BigNumber): BigNumber;
+    computeAssetUsdValue(oraclePrice: OraclePrice, assetShares: BigNumber, lendrRequirementType: LendrRequirementType, priceBias: PriceBias): BigNumber;
+    computeLiabilityUsdValue(oraclePrice: OraclePrice, liabilityShares: BigNumber, lendrRequirementType: LendrRequirementType, priceBias: PriceBias): BigNumber;
+    computeUsdValue(oraclePrice: OraclePrice, quantity: BigNumber, priceBias: PriceBias, weightedPrice: boolean, weight?: BigNumber, scaleToBase?: boolean): BigNumber;
+    getAssetWeight(lendrRequirementType: LendrRequirementType, oraclePrice: OraclePrice, ignoreSoftLimits?: boolean, assetWeightInitOverride?: BigNumber): BigNumber;
+    getLiabilityWeight(lendrRequirementType: LendrRequirementType): BigNumber;
+    computeTvl(oraclePrice: OraclePrice): BigNumber;
+    computeInterestRates(): {
+        lendingRate: BigNumber;
+        borrowingRate: BigNumber;
+    };
+    computeBaseInterestRate(): BigNumber;
+    computeUtilizationRate(): BigNumber;
+    computeRemainingCapacity(): {
+        depositCapacity: BigNumber;
+        borrowCapacity: BigNumber;
+    };
+    describe(oraclePrice: OraclePrice): string;
+}
+declare class BankConfig implements BankConfigType {
+    assetWeightInit: BigNumber;
+    assetWeightMaint: BigNumber;
+    readonly liabilityWeightInit: BigNumber;
+    readonly liabilityWeightMaint: BigNumber;
+    readonly depositLimit: BigNumber;
+    readonly borrowLimit: BigNumber;
+    readonly riskTier: RiskTier;
+    readonly totalAssetValueInitLimit: BigNumber;
+    readonly assetTag: AssetTag;
+    readonly oracleSetup: OracleSetup;
+    readonly oracleKeys: PublicKey[];
+    readonly oracleMaxAge: number;
+    readonly interestRateConfig: InterestRateConfig;
+    readonly operationalState: OperationalState;
+    readonly oracleMaxConfidence: number;
+    readonly fixedPrice: BigNumber;
+    readonly configFlags?: BankConfigFlag | undefined;
+    constructor(assetWeightInit: BigNumber, assetWeightMaint: BigNumber, liabilityWeightInit: BigNumber, liabilityWeightMaint: BigNumber, depositLimit: BigNumber, borrowLimit: BigNumber, riskTier: RiskTier, totalAssetValueInitLimit: BigNumber, assetTag: AssetTag, oracleSetup: OracleSetup, oracleKeys: PublicKey[], oracleMaxAge: number, interestRateConfig: InterestRateConfig, operationalState: OperationalState, oracleMaxConfidence: number, fixedPrice: BigNumber, configFlags?: BankConfigFlag | undefined);
+    static fromAccountParsed(bankConfigRaw: BankConfigRaw): BankConfig;
+}
+
+declare class Balance implements BalanceType {
+    active: boolean;
+    bankPk: PublicKey;
+    assetShares: BigNumber;
+    liabilityShares: BigNumber;
+    emissionsOutstanding: BigNumber;
+    lastUpdate: number;
+    constructor(active: boolean, bankPk: PublicKey, assetShares: BigNumber, liabilityShares: BigNumber, emissionsOutstanding: BigNumber, lastUpdate: number);
+    static from(balanceRaw: BalanceRaw): Balance;
+    static fromBalanceType(balance: BalanceType): Balance;
+    static createEmpty(bankPk: PublicKey): Balance;
+    computeUsdValue(bank: Bank, oraclePrice: OraclePrice, lendrRequirementType?: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    getUsdValueWithPriceBias(bank: Bank, oraclePrice: OraclePrice, lendrRequirementType?: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeQuantity(bank: Bank): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeQuantityUi(bank: Bank): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeTotalOutstandingEmissions(bank: Bank): BigNumber;
+    computeClaimedEmissions(bank: Bank, currentTimestamp: number): BigNumber;
+    describe(bank: Bank, oraclePrice: OraclePrice): string;
+}
+
+declare class HealthCache implements HealthCacheType {
+    assetValue: BigNumber;
+    liabilityValue: BigNumber;
+    assetValueMaint: BigNumber;
+    liabilityValueMaint: BigNumber;
+    assetValueEquity: BigNumber;
+    liabilityValueEquity: BigNumber;
+    timestamp: BigNumber;
+    flags: HealthCacheFlags[];
+    prices: number[][];
+    simulationFailed?: boolean | undefined;
+    constructor(assetValue: BigNumber, liabilityValue: BigNumber, assetValueMaint: BigNumber, liabilityValueMaint: BigNumber, assetValueEquity: BigNumber, liabilityValueEquity: BigNumber, timestamp: BigNumber, flags: HealthCacheFlags[], prices: number[][], simulationFailed?: boolean | undefined);
+    static from(healthCacheRaw: HealthCacheRaw): HealthCache;
+}
+
+declare class LendrAccount implements LendrAccountType {
+    readonly address: PublicKey;
+    readonly group: PublicKey;
+    readonly authority: PublicKey;
+    readonly balances: Balance[];
+    readonly accountFlags: AccountFlags[];
+    readonly emissionsDestinationAccount: PublicKey;
+    healthCache: HealthCache;
+    constructor(address: PublicKey, group: PublicKey, authority: PublicKey, balances: Balance[], accountFlags: AccountFlags[], emissionsDestinationAccount: PublicKey, healthCache: HealthCache);
+    static fetch(address: PublicKey, client: LendrClient): Promise<LendrAccount>;
+    /**
+     * @deprecated use decodeAccountRaw instead
+     */
+    static decode(encoded: Buffer, idl: LendrIdlType): LendrAccountRaw;
+    static decodeAccountRaw(encoded: Buffer, idl: LendrIdlType): LendrAccountRaw;
+    static fromAccountType(account: LendrAccountType): LendrAccount;
+    static fromAccountParsed(lendrAccountPk: PublicKey, accountData: LendrAccountRaw): LendrAccount;
+    simulateHealthCache(program: Program<LendrIdlType>, bankMap: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankMetadataMap: BankMetadataMap): Promise<{
+        lendrAccount: LendrAccount;
+        error?: HealthCacheSimulationError;
+    }>;
+    static fromAccountDataRaw(lendrAccountPk: PublicKey, rawData: Buffer, idl: LendrIdlType): LendrAccount;
+    get activeBalances(): Balance[];
+    getBalance(bankPk: PublicKey): Balance;
+    get isDisabled(): boolean;
+    get isFlashLoanEnabled(): boolean;
+    get isTransferAccountAuthorityEnabled(): boolean;
+    setHealthCache(value: HealthCache): void;
+    computeFreeCollateral(opts?: {
+        clamped?: boolean;
+    }): BigNumber;
+    computeFreeCollateralLegacy(banks: Map<string, BankType>, oraclePrices: Map<string, OraclePrice>, opts?: {
+        clamped?: boolean;
+    }): BigNumber;
+    computeHealthComponents(lendrReqType: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    /**
+     * @deprecated use computeHealthComponents instead
+     */
+    computeHealthComponentsLegacy(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, lendrReqType: LendrRequirementType, excludedBanks?: PublicKey[]): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    /**
+     *  @deprecated use computeHealthComponents instead
+     */
+    computeHealthComponentsWithoutBiasLegacy(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, lendrReqType: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeAccountValue(): BigNumber;
+    computeNetApy(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>): number;
+    /**
+     * Calculate the maximum amount of asset that can be withdrawn from a bank given existing deposits of the asset
+     * and the untied collateral of the lendr account.
+     *
+     * fc = free collateral
+     * ucb = untied collateral for bank
+     *
+     * q = (min(fc, ucb) / (price_lowest_bias * deposit_weight)) + (fc - min(fc, ucb)) / (price_highest_bias * liab_weight)
+     *
+     *
+     *
+     * NOTE FOR LIQUIDATORS
+     * This function doesn't take into account the collateral received when liquidating an account.
+     */
+    computeMaxBorrowForBank(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankAddress: PublicKey, opts?: {
+        emodeImpactStatus?: EmodeImpactStatus;
+        volatilityFactor?: number;
+        emodeWeights?: {
+            assetWeightMaint: BigNumber;
+            assetWeightInit: BigNumber;
+            collateralTags: EmodeTag[];
+        };
+    }, logger?: TLogger): BigNumber;
+    /**
+     * Calculate the maximum amount that can be withdrawn form a bank without borrowing.
+     */
+    computeMaxWithdrawForBank(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankAddress: PublicKey, opts?: {
+        volatilityFactor?: number;
+    }): BigNumber;
+    /**
+     * Calculate the price at which the user position for the given bank will lead to liquidation, all other prices constant.
+     */
+    computeLiquidationPriceForBank(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankAddress: PublicKey): number | null;
+    /**
+     * Calculate the price at which the user position for the given bank will lead to liquidation, all other prices constant.
+     */
+    computeLiquidationPriceForBankHealth(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankAddress: PublicKey, opts?: {
+        assetWeightMaint: BigNumber;
+    }): number | null;
+    /**
+     * Calculate the price at which the user position for the given bank and amount will lead to liquidation, all other prices constant.
+     */
+    computeLiquidationPriceForBankAmount(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankAddress: PublicKey, isLending: boolean, amount: number): number | null;
+    computeMaxLiquidatableAssetAmount(banks: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, assetBankAddress: PublicKey, liabilityBankAddress: PublicKey, logger?: TLogger): BigNumber;
+    getHealthCheckAccounts(banks: Map<string, Bank>, mandatoryBanks?: PublicKey[], excludedBanks?: PublicKey[]): BankType[];
+    /**
+     * Determines which E-mode pairs are currently active for this account based on its balances
+     *
+     * @param emodePairs - All available E-mode pairs to check against the account's balances
+     * @returns Array of active E-mode pairs for this account, or empty array if no E-mode is active
+     */
+    computeActiveEmodePairs(emodePairs: EmodePair[]): EmodePair[];
+    /**
+     * Calculates the impact of different actions on E-mode status for each bank
+     *
+     * For each bank, this method simulates the following actions and their effect on E-mode:
+     * - Borrowing from the bank (for banks not currently borrowed from)
+     * - Supplying to the bank (for supported collateral banks not currently supplied)
+     * - Repaying all borrowing from the bank (for banks with active liabilities)
+     * - Withdrawing all supply from the bank (for banks with active collateral)
+     *
+     * @param emodePairs - All available E-mode pairs to check against
+     * @param banks - Array of bank PublicKeys to calculate impacts for
+     * @returns Object mapping bank PublicKey strings to impact analysis for each possible action
+     */
+    computeEmodeImpacts(emodePairs: EmodePair[], banks: PublicKey[]): Record<string, ActionEmodeImpact>;
+    prepareDepositIx(banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, opts?: MakeDepositIxOpts): Promise<{
+        depositIxs: TransactionInstruction[];
+        userTokenAtaPk: PublicKey;
+        mintData: MintData;
+        bank: Bank;
+        ixArguments: {
+            amount: BN;
+        };
+        remainingAccounts: AccountMeta[];
+    }>;
+    makeDepositIx(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, opts?: MakeDepositIxOpts): Promise<InstructionsWrapper>;
+    makeDepositWithSessionIx(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, opts?: MakeDepositWithSessionIxOpts): Promise<InstructionsWrapper>;
+    makeSettleEmissionsIx(program: LendrProgram, bank: PublicKey): Promise<InstructionsWrapper>;
+    prepareRepayInstruction(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, repayAll?: boolean, opts?: MakeRepayIxOpts): Promise<{
+        repayIxs: TransactionInstruction[];
+        mintData: MintData;
+        bank: Bank;
+        userAta: PublicKey;
+        ixArguments: {
+            amount: BN;
+            repayAll: boolean;
+        };
+        remainingAccounts: PublicKey[];
+    }>;
+    makeRepayIx(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, repayAll?: boolean, opts?: MakeRepayIxOpts): Promise<InstructionsWrapper>;
+    makeRepayWithSessionIx(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, repayAll?: boolean, opts?: MakeRepayWithSessionIxOpts): Promise<InstructionsWrapper>;
+    prepareWithdrawInstruction(program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, bankAddress: PublicKey, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawIxOpts & {
+        createAtaPayer?: PublicKey;
+    }): Promise<{
+        withdrawIxs: TransactionInstruction[];
+        wrapAndUnwrapSol: boolean;
+        mintData: MintData;
+        userAta: PublicKey;
+        bank: Bank;
+        remainingAccounts: {
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }[];
+    }>;
+    makeWithdrawIx(program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, amount: Amount, bankAddress: PublicKey, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawIxOpts): Promise<InstructionsWrapper>;
+    makeWithdrawWithSessionIx(program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawWithSessionIxOpts): Promise<InstructionsWrapper>;
+    prepareBorrowInstrcution(bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, bankAddress: PublicKey, borrowOpts?: MakeBorrowIxOpts & {
+        createAtaPayer?: PublicKey;
+    }): Promise<{
+        borrowIxs: TransactionInstruction[];
+        bank: Bank;
+        mintData: MintData;
+        userAta: PublicKey;
+        wrapAndUnwrapSol: boolean;
+        remainingAccounts: {
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }[];
+    }>;
+    makeBorrowIx(program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, amount: Amount, bankAddress: PublicKey, borrowOpts?: MakeBorrowIxOpts): Promise<InstructionsWrapper>;
+    makeBorrowWithSessionIx(program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, borrowOpts?: MakeBorrowWithSessionIxOpts): Promise<InstructionsWrapper>;
+    makeWithdrawEmissionsIx(program: LendrProgram, banks: Map<string, Bank>, mintDatas: Map<string, MintData>, bankAddress: PublicKey): Promise<InstructionsWrapper>;
+    makeLendingAccountLiquidateIx(liquidateeLendrAccount: LendrAccount, program: LendrProgram, bankMap: Map<string, Bank>, mintDatas: Map<string, MintData>, bankMetadataMap: BankMetadataMap, assetBankAddress: PublicKey, assetQuantityUi: Amount, liabilityBankAddress: PublicKey): Promise<InstructionsWrapper>;
+    makeBeginFlashLoanIx(program: LendrProgram, endIndex: number): Promise<InstructionsWrapper>;
+    makeBeginFlashLoanWithSessionIx(program: LendrProgram, endIndex: number, sessionKey: PublicKey): Promise<InstructionsWrapper>;
+    makeEndFlashLoanIx(program: LendrProgram, bankMap: Map<string, Bank>, projectedActiveBalances: PublicKey[]): Promise<InstructionsWrapper>;
+    makeEndFlashLoanWithSessionIx(program: LendrProgram, bankMap: Map<string, Bank>, projectedActiveBalances: PublicKey[], sessionKey: PublicKey): Promise<InstructionsWrapper>;
+    makeAccountAuthorityTransferIx(program: LendrProgram, newAccountAuthority: PublicKey): Promise<InstructionsWrapper>;
+    makeCloseAccountIx(program: LendrProgram): Promise<InstructionsWrapper>;
+    makePulseHealthIx(program: LendrProgram, banks: Map<string, Bank>, mandatoryBanks: PublicKey[], excludedBanks: PublicKey[], bankMetadataMap: BankMetadataMap): Promise<InstructionsWrapper>;
+    projectActiveBalancesNoCpi(program: LendrProgram, instructions: TransactionInstruction[]): PublicKey[];
+    wrapInstructionForWSol(ix: TransactionInstruction, amount?: Amount): TransactionInstruction[];
+    describe(banks: BankMap, oraclePrices: OraclePriceMap): string;
+}
+declare enum LendrRequirementType {
+    Initial = 0,
+    Maintenance = 1,
+    Equity = 2
+}
+interface MakeDepositIxOpts {
+    wrapAndUnwrapSol?: boolean;
+    wSolBalanceUi?: number;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+        liquidityVault?: PublicKey;
+    };
+}
+interface MakeDepositWithSessionIxOpts extends MakeDepositIxOpts {
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        liquidityVault?: PublicKey;
+    };
+}
+interface MakeRepayIxOpts {
+    wrapAndUnwrapSol?: boolean;
+    wSolBalanceUi?: number;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+        liquidityVault?: PublicKey;
+    };
+}
+interface MakeRepayWithSessionIxOpts extends MakeRepayIxOpts {
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        liquidityVault?: PublicKey;
+    };
+}
+interface MakeWithdrawIxOpts {
+    observationBanksOverride?: PublicKey[];
+    wrapAndUnwrapSol?: boolean;
+    createAtas?: boolean;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+    };
+}
+interface MakeWithdrawWithSessionIxOpts extends MakeWithdrawIxOpts {
+    overrideInferAccounts?: {
+        group?: PublicKey;
+    };
+}
+interface MakeBorrowIxOpts {
+    observationBanksOverride?: PublicKey[];
+    wrapAndUnwrapSol?: boolean;
+    createAtas?: boolean;
+    overrideInferAccounts?: {
+        group?: PublicKey;
+        authority?: PublicKey;
+    };
+}
+interface MakeBorrowWithSessionIxOpts extends MakeBorrowIxOpts {
+    overrideInferAccounts?: {
+        group?: PublicKey;
+    };
+}
+declare function isWeightedPrice(reqType: LendrRequirementType): boolean;
+
+interface LoopProps extends LoopTxProps {
+    processOpts?: ProcessTransactionsClientOpts;
+    txOpts?: TransactionOptions;
+}
+type LoopTxProps = {
+    /** Amount to deposit */
+    depositAmount: Amount;
+    /** Amount to borrow */
+    borrowAmount: Amount;
+    /** Bank address to deposit into */
+    depositBankAddress: PublicKey;
+    /** Bank address to borrow from */
+    borrowBankAddress: PublicKey;
+    /** Swap configuration */
+    swap: {
+        /** Instructions for swapping borrowed amount */
+        instructions: TransactionInstruction[];
+        /** Address lookup tables needed for swap instructions */
+        lookupTables: AddressLookupTableAccount[];
+    };
+    /** Optional recent blockhash */
+    blockhash?: string;
+    /** The amount the user entered to deposit before applying leverage */
+    inputDepositAmount?: Amount;
+    /** Optional setup banks addresses */
+    setupBankAddresses?: PublicKey[];
+    /**
+     * Optional override for inferred accounts in the transaction instructions.
+     * The group and authority public keys can be overridden if the user has
+     * custom configuration.
+     */
+    overrideInferAccounts?: {
+        /**
+         * Group public key to use instead of the one inferred from the account
+         * type.
+         */
+        group?: PublicKey;
+        /**
+         * Authority public key to use instead of the one inferred from the account
+         * type.
+         */
+        authority?: PublicKey;
+    };
+};
+interface RepayWithCollateralProps extends RepayWithCollateralTxProps {
+    processOpts?: ProcessTransactionsClientOpts;
+    txOpts?: TransactionOptions;
+}
+type RepayWithCollateralTxProps = {
+    /** Amount to repay */
+    repayAmount: Amount;
+    /** Amount of collateral to withdraw */
+    withdrawAmount: Amount;
+    /** Bank address where the loan is being repaid */
+    borrowBankAddress: PublicKey;
+    /** Bank address where collateral is being withdrawn from */
+    depositBankAddress: PublicKey;
+    /** Whether to withdraw all collateral from deposit bank */
+    withdrawAll?: boolean;
+    /** Whether to repay entire loan amount */
+    repayAll?: boolean;
+    /** Swap configuration */
+    swap: {
+        instructions: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    };
+    /** Optional recent blockhash */
+    blockhash?: string;
+    /**
+     * @deprecated This property is no longer supported.
+     */
+    withdrawOpts?: MakeWithdrawIxOpts;
+    /**
+     * @deprecated This property is no longer supported.
+     */
+    repayOpts?: MakeRepayIxOpts;
+};
+interface TransactionBuilderResult {
+    transactions: SolanaTransaction[];
+    actionTxIndex: number;
+}
+interface FlashloanActionResult extends TransactionBuilderResult {
+    /** Whether transaction size exceeds limits */
+    txOverflown: boolean;
+}
+
+declare class LendrGroup implements LendrGroupType {
+    address: PublicKey;
+    admin: PublicKey;
+    constructor(admin: PublicKey, address: PublicKey);
+    static fromAccountParsed(address: PublicKey, accountData: LendrGroupRaw): LendrGroup;
+    static fromBuffer(address: PublicKey, rawData: Buffer, idl: LendrIdlType): LendrGroup;
+    static decode(encoded: Buffer, idl: LendrIdlType): LendrGroupRaw;
+    static encode(decoded: LendrGroupRaw, idl: LendrIdlType): Promise<Buffer>;
+    makePoolConfigureBankIx(program: LendrProgram, bank: PublicKey, args: BankConfigOptRaw): Promise<InstructionsWrapper>;
+    makeAddPermissionlessStakedBankIx(program: LendrProgram, voteAccountAddress: PublicKey, feePayer: PublicKey, pythOracle: PublicKey): Promise<InstructionsWrapper>;
+    makePoolAddBankIx(program: LendrProgram, bankPubkey: PublicKey, bankMint: PublicKey, bankConfig: BankConfigOpt, feePayer?: PublicKey): Promise<InstructionsWrapper>;
+}
+
+interface SimulationResult {
+    banks: Map<string, Bank>;
+    lendrAccount: LendrAccountWrapper;
+}
+interface FlashLoanArgs {
+    ixs: TransactionInstruction[];
+    signers?: Signer[];
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+    blockhash?: string;
+}
+declare class LendrAccountWrapper {
+    readonly client: LendrClient;
+    readonly address: PublicKey;
+    private _lendrAccount;
+    /**
+     * @internal
+     */
+    constructor(lendrAccountPk: PublicKey, client: LendrClient, lendrAccount: LendrAccount);
+    static fetch(lendrAccountPk: Address, client: LendrClient, commitment?: Commitment): Promise<LendrAccountWrapper>;
+    static fromAccountParsed(lendrAccountPk: Address, client: LendrClient, accountData: LendrAccountRaw): LendrAccountWrapper;
+    static fromAccountDataRaw(lendrAccountPk: PublicKey, client: LendrClient, lendrAccountRawData: Buffer, idl: LendrIdlType): LendrAccountWrapper;
+    get authority(): PublicKey;
+    get group(): LendrGroup;
+    get balances(): Balance[];
+    get data(): LendrAccount;
+    get pureAccount(): LendrAccount;
+    /** @internal */
+    private get _program();
+    /** @internal */
+    private get _config();
+    get activeBalances(): Balance[];
+    get isDisabled(): boolean;
+    get isFlashLoanEnabled(): boolean;
+    get isTransferAccountAuthorityEnabled(): boolean;
+    getBalance(bankPk: PublicKey): Balance;
+    simulateHealthCache(): Promise<LendrAccountWrapper>;
+    canBeLiquidated(): boolean;
+    computeHealthComponents(lendrRequirement: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeHealthComponentsLegacy(lendrRequirement: LendrRequirementType, excludedBanks?: PublicKey[]): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeHealthComponentsWithoutBiasLegacy(lendrRequirement: LendrRequirementType): {
+        assets: BigNumber;
+        liabilities: BigNumber;
+    };
+    computeFreeCollateral(opts?: {
+        clamped?: boolean;
+    }): BigNumber;
+    computeFreeCollateralLegacy(opts?: {
+        clamped?: boolean;
+    }): BigNumber;
+    computeAccountValue(): BigNumber;
+    computeActiveEmodePairs(emodePairs: EmodePair[]): EmodePair[];
+    computeEmodeImpacts(emodePairs: EmodePair[]): Record<string, ActionEmodeImpact>;
+    computeMaxBorrowForBank(bankAddress: PublicKey, opts?: {
+        volatilityFactor?: number;
+        emodeWeights?: {
+            assetWeightMaint: BigNumber;
+            assetWeightInit: BigNumber;
+            collateralTags: EmodeTag[];
+        };
+    }): BigNumber;
+    computeMaxWithdrawForBank(bankAddress: PublicKey, opts?: {
+        volatilityFactor?: number;
+    }): BigNumber;
+    computeMaxLiquidatableAssetAmount(assetBankAddress: PublicKey, liabilityBankAddress: PublicKey): BigNumber;
+    computeLiquidationPriceForBank(bankAddress: PublicKey): number | null;
+    computeLiquidationPriceForBankAmount(bankAddress: PublicKey, isLending: boolean, amount: number): number | null;
+    computeNetApy(): number;
+    /** Todo move this into client */
+    computeLoopingParams(principal: Amount, targetLeverage: number, depositBankAddress: PublicKey, borrowBankAddress: PublicKey): {
+        borrowAmount: BigNumber;
+        totalDepositAmount: BigNumber;
+    };
+    makeComputeBudgetIx(): TransactionInstruction[];
+    makeSetupIx(banks: PublicKey[]): Promise<TransactionInstruction[]>;
+    /**
+     * Moves a position from one lendr account to another by withdrawing from source account and depositing to destination account.
+     *
+     * @param amount - The amount of tokens to move, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to move position from/to
+     * @param destinationAccount - The lendr account to move the position to
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction options
+     * @returns Array of transaction signatures - includes signatures for any required oracle feed updates, withdraw transaction, and deposit transaction
+     */
+    movePosition(amount: Amount, bankAddress: PublicKey, destinationAccountPk: PublicKey, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature[]>;
+    /**
+     * Creates transactions for moving a position from one lendr account to another.
+     *
+     * @param amount - The amount of tokens to move, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to move position from/to
+     * @param destinationAccount - The lendr account to move the position to
+     * @returns Object containing feed crank transactions, withdraw transaction, and deposit transaction
+     */
+    makeMovePositionTx(amount: Amount, bankAddress: PublicKey, destinationAccountPk: PublicKey): Promise<TransactionBuilderResult>;
+    /**
+     * Repays a loan using collateral from another bank by:
+     * 1. Withdrawing collateral from one bank
+     * 2. Swapping it to the repayment asset
+     * 3. Repaying the loan in another bank
+     *
+     * @param {RepayWithCollateralProps} props - Parameters for the repay with collateral transaction
+     * @param {Amount} props.repayAmount - Amount to repay
+     * @param {Amount} props.withdrawAmount - Amount of collateral to withdraw
+     * @param {PublicKey} props.borrowBankAddress - Bank address where the loan is being repaid
+     * @param {PublicKey} props.depositBankAddress - Bank address where collateral is being withdrawn from
+     * @param {boolean} [props.withdrawAll=false] - Whether to withdraw all collateral from deposit bank
+     * @param {boolean} [props.repayAll=false] - Whether to repay entire loan amount
+     * @param {Object} props.swap - Swap configuration with instructions and lookup tables
+     * @param {ProcessTransactionsClientOpts} [props.processOpts] - Optional transaction processing configuration
+     * @param {TransactionOptions} [props.txOpts] - Optional transaction options
+     * @returns {Promise<TransactionSignature[]>} Array of transaction signatures
+     */
+    repayWithCollatV2(props: RepayWithCollateralProps): Promise<TransactionSignature[]>;
+    /**
+     * Creates a transaction to repay a loan using collateral by:
+     * 1. Withdrawing collateral from one bank
+     * 2. Swapping it to the repayment asset
+     * 3. Repaying the loan in another bank
+     *
+     * @param {RepayWithCollateralProps} params - Parameters for the repay with collateral transaction
+     * @param {Amount} params.repayAmount - Amount to repay
+     * @param {Amount} params.withdrawAmount - Amount of collateral to withdraw
+     * @param {PublicKey} params.borrowBankAddress - Bank address where the loan is being repaid
+     * @param {PublicKey} params.depositBankAddress - Bank address where collateral is being withdrawn from
+     * @param {boolean} [params.withdrawAll=false] - Whether to withdraw all collateral from deposit bank
+     * @param {boolean} [params.repayAll=false] - Whether to repay entire loan amount
+     * @param {Object} params.swap - Swap configuration with instructions and lookup tables
+     * @param {string} [params.blockhash] - Optional recent blockhash
+     * @param {MakeWithdrawIxOpts} [params.withdrawOpts] - Optional withdraw configuration
+     * @param {MakeRepayIxOpts} [params.repayOpts] - Optional repay configuration
+     * @returns {Promise<RepayWithCollateralResult>} Result containing feed crank and flashloan transactions
+     */
+    makeRepayWithCollatTxV2({ repayAmount, withdrawAmount, borrowBankAddress, depositBankAddress, withdrawAll, repayAll, swap, blockhash: blockhashArg, }: RepayWithCollateralProps): Promise<FlashloanActionResult>;
+    loopV2(props: LoopProps): Promise<TransactionSignature[]>;
+    makeLoopTxV2({ depositAmount, inputDepositAmount, borrowAmount, depositBankAddress, borrowBankAddress, swap, blockhash: blockhashArg, setupBankAddresses, overrideInferAccounts, }: LoopTxProps): Promise<FlashloanActionResult>;
+    /**
+     * Creates instructions for closing a lendr account.
+     * The account must have no active positions or balances to be closed.
+     * Closing an account will return any remaining SOL to the fee payer.
+     *
+     * @returns An InstructionsWrapper containing the close account instruction
+     */
+    makeCloseAccountIx(): Promise<InstructionsWrapper>;
+    /**
+     * Closes a lendr account. The account must have no active positions or balances to be closed.
+     * Closing an account will return any remaining SOL to the fee payer.
+     *
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction options
+     * @returns The transaction signature of the close account operation
+     */
+    closeAccount(processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    /**
+     * Creates a transaction for closing a lendr account.
+     * The account must have no active positions or balances to be closed.
+     *
+     * @returns A transaction configured to close the lendr account
+     */
+    makeCloseAccountTx(): Promise<ExtendedTransaction>;
+    /**
+     * Creates instructions for depositing tokens into a lendr bank account.
+     *
+     * @param amount - The amount of tokens to deposit, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to deposit into
+     * @param depositOpts - Optional deposit configuration parameters
+     * @returns An InstructionsWrapper containing the deposit instructions
+     */
+    makeDepositIx(amount: Amount, bankAddress: PublicKey, depositOpts?: MakeDepositIxOpts): Promise<InstructionsWrapper>;
+    makeDepositWithSessionIx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, depositOpts?: MakeDepositWithSessionIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Creates a transaction for depositing native stake into a lendr staked asset bank account.
+     * - Split stake account if required
+     * - Authorize stake account to single spl pool pogram
+     * - Deposit stake into pool for LST
+     * - Deposit LST into lendr bank
+     *
+     * @param amount - The amount of tokens to deposit, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to deposit into
+     * @param stakeAccountPk - The public key of the stake account to delegate
+     * @param validator - The public key of the validator to delegate to
+     * @param depositOpts - Optional deposit configuration parameters
+     * @returns A transaction object ready to be signed and sent
+     */
+    makeDepositStakedTx(amount: Amount, bankAddress: PublicKey, stakeAccountPk: PublicKey, validator: PublicKey, depositOpts?: MakeDepositIxOpts): Promise<ExtendedTransaction>;
+    makeMergeStakeAccountsTx(stakeAccountSrc: PublicKey, stakeAccountDest: PublicKey): Promise<ExtendedTransaction>;
+    /**
+     * Deposits tokens into a lendr bank account.
+     *
+     * @param amount - The amount of tokens to deposit, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to deposit into
+     * @param depositOpts - Optional deposit configuration parameters
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction options
+     * @returns The transaction signature of the deposit
+     */
+    deposit(amount: Amount, bankAddress: PublicKey, depositOpts?: MakeDepositIxOpts, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    depositWithSession(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, depositOpts?: MakeDepositWithSessionIxOpts): Promise<TransactionResult>;
+    /**
+     * Creates a transaction for depositing tokens into a lendr bank account.
+     *
+     * @param amount - The amount of tokens to deposit, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to deposit into
+     * @param depositOpts - Optional deposit configuration parameters
+     * @returns A transaction object ready to be signed and sent
+     */
+    makeDepositTx(amount: Amount, bankAddress: PublicKey, depositOpts?: MakeDepositIxOpts): Promise<ExtendedTransaction>;
+    makeDepositWithSessionTx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, depositOpts?: MakeDepositWithSessionIxOpts): Promise<ExtendedTransaction>;
+    /**
+     * Simulates a lendr transaction to preview its effects.
+     *
+     * @param txs - Array of transactions to simulate, can be either VersionedTransaction or Transaction
+     * @param bankAddress - The public key of the bank to inspect
+     * @param additionalAccountsToInspect - Optional array of additional account public keys to inspect during simulation
+     * @returns A SimulationResult containing the preview state of both the lendr account and bank
+     * @throws Will throw an error if simulation fails
+     */
+    simulateBorrowLendTransaction(txs: (VersionedTransaction | Transaction)[], banksToInspect: PublicKey[], healthSimOptions?: {
+        enabled: boolean;
+        mandatoryBanks: PublicKey[];
+        excludedBanks: PublicKey[];
+    }): Promise<SimulationResult>;
+    /**
+     * Creates a transaction instruction for repaying a loan.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @returns An InstructionsWrapper containing the deposit instructions
+     * @throws Will throw an error if the repay mint is not found
+     */
+    makeRepayIx(amount: Amount, bankAddress: PublicKey, repayAll?: boolean, repayOpts?: MakeRepayIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Creates a transaction instruction for repaying a loan.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param sessionKey - The session key of the logged in user (with session)
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @returns An InstructionsWrapper containing the deposit instructions
+     * @throws Will throw an error if the repay mint is not found
+     */
+    makeRepayWithSessionIx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, repayAll?: boolean, repayOpts?: MakeRepayWithSessionIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Repays a loan in a lendr bank account.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction options
+     * @returns The transaction signature of the repayment
+     */
+    repay(amount: Amount, bankAddress: PublicKey, repayAll?: boolean, repayOpts?: MakeRepayIxOpts, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    /**
+     * Repays a loan in a lendr bank account.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param session: Session object in Established state (o.w. sendTransaction method won't work!)
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @returns The transaction signature of the repayment
+     */
+    repayWithSession(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, repayAll?: boolean, repayOpts?: MakeRepayWithSessionIxOpts): Promise<TransactionResult>;
+    /**
+     * Creates a transaction for repaying a loan in a lendr bank account.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @returns A transaction object containing the repay instructions
+     */
+    makeRepayTx(amount: Amount, bankAddress: PublicKey, repayAll?: boolean, repayOpts?: MakeRepayIxOpts): Promise<ExtendedTransaction>;
+    /**
+     * Creates a transaction for repaying a loan in a lendr bank account.
+     *
+     * @param amount - The amount to repay, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to repay to
+     * @param repayAll - Whether to repay the entire loan balance, defaults to false
+     * @param repayOpts - Optional parameters for the repay instruction
+     * @returns A transaction object containing the repay instructions
+     */
+    makeRepayWithSessionTx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, repayAll?: boolean, repayOpts?: MakeRepayWithSessionIxOpts): Promise<ExtendedTransaction>;
+    /**
+     * Creates instructions for withdrawing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param withdrawAll - Whether to withdraw the entire balance, defaults to false
+     * @param withdrawOpts - Optional parameters for the withdraw instruction
+     * @returns An InstructionsWrapper containing the withdraw instructions and signers
+     * @throws Will throw an error if the withdraw mint is not found
+     */
+    makeWithdrawIx(amount: Amount, bankAddress: PublicKey, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Creates instructions for withdrawing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param session - User's logged in session object in Established state.
+     * @param withdrawAll - Whether to withdraw the entire balance, defaults to false
+     * @param withdrawOpts - Optional parameters for the withdraw instruction
+     * @returns An InstructionsWrapper containing the withdraw instructions and signers
+     * @throws Will throw an error if the withdraw mint is not found
+     */
+    makeWithdrawWithSessionIx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawWithSessionIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Creates a transaction for withdrawing tokens from a lendr bank account and staking them.
+     * - Withdraw from lendr bank
+     * - Create stake account
+     * - Approve mint authority to burn tokens
+     * - Delegate stake account
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param isWholePosition - Whether to withdraw the entire position, defaults to false
+     * @returns A transaction object ready to be signed and sent
+     */
+    makeWithdrawStakedTx(amount: Amount, bankAddress: PublicKey, isWholePosition: boolean): Promise<TransactionBuilderResult>;
+    /**
+     * Creates a transaction for withdrawing all tokens from multiple lendr banks.
+     *
+     * @param banks - Array of objects containing amount and bank address for each withdrawal
+     * @param withdrawOpts - Optional parameters for the withdraw instructions
+     * @returns A transaction object ready to be signed and sent
+     */
+    makeWithdrawAllTx(banks: {
+        amount: Amount;
+        bankAddress: PublicKey;
+    }[], withdrawOpts?: MakeWithdrawIxOpts): Promise<ExtendedTransaction>;
+    /**
+     * Creates a transaction for withdrawing all tokens from multiple lendr banks.
+     *
+     * @param banks - Array of objects containing amount and bank address for each withdrawal
+     * @param session - user session object (in Established state)
+     * @param withdrawOpts - Optional parameters for the withdraw instructions
+     * @returns A transaction object ready to be signed and sent
+     */
+    makeWithdrawAllWithSessionTx(banks: {
+        amount: Amount;
+        bankAddress: PublicKey;
+    }[], session: EstablishedSessionState, withdrawOpts?: MakeWithdrawWithSessionIxOpts): Promise<ExtendedTransaction>;
+    finalizeWithdrawAllTransaction(withdrawIxsWrapped: InstructionsWrapper[]): Promise<Transaction & ExtendedTransactionProperties>;
+    /**
+     * Withdraws tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param withdrawAll - If true, withdraws entire balance from the bank
+     * @param withdrawOpts - Optional withdraw configuration parameters
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction options
+     * @returns Array of transaction signatures - includes signatures for any required oracle feed updates followed by the withdraw transaction
+     */
+    withdraw(amount: Amount, bankAddress: PublicKey, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawIxOpts, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature[]>;
+    /**
+     * Withdraws tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param withdrawAll - If true, withdraws entire balance from the bank
+     * @param withdrawOpts - Optional withdraw configuration parameters
+     * @returns Array of transaction signatures - includes signatures for any required oracle feed updates followed by the withdraw transaction
+     */
+    withdrawWithSession(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawWithSessionIxOpts): Promise<TransactionResult>;
+    /**
+     * Creates a versioned transaction for withdrawing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param withdrawAll - If true, withdraws entire balance from the bank
+     * @param withdrawOpts - Optional withdraw configuration parameters
+     * @returns Object containing feed crank transactions and the withdraw transaction
+     */
+    makeWithdrawTx(amount: Amount, bankAddress: PublicKey, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawIxOpts): Promise<TransactionBuilderResult>;
+    /**
+     * Creates a versioned transaction for withdrawing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to withdraw, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to withdraw from
+     * @param session - Logged in user session object in Established state.
+     * @param withdrawAll - If true, withdraws entire balance from the bank
+     * @param withdrawOpts - Optional withdraw configuration parameters
+     * @returns Object containing feed crank transactions and the withdraw transaction
+     */
+    makeWithdrawWithSessionTx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, withdrawAll?: boolean, withdrawOpts?: MakeWithdrawWithSessionIxOpts): Promise<{
+        transactions: ExtendedV0Transaction[];
+        instructions: TransactionInstruction[];
+        actionTxIndex: number;
+    }>;
+    /**
+     * Creates instructions for borrowing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @returns An InstructionsWrapper containing the borrow instructions
+     */
+    makeBorrowIx(amount: Amount, bankAddress: PublicKey, borrowOpts?: MakeBorrowIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Creates instructions for borrowing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param session
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @returns An InstructionsWrapper containing the borrow instructions
+     */
+    makeBorrowWithSessionIx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, borrowOpts?: MakeBorrowWithSessionIxOpts): Promise<InstructionsWrapper>;
+    /**
+     * Borrows tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @param processOpts - Optional transaction processing configuration
+     * @param txOpts - Optional transaction configuration parameters
+     * @returns Array of transaction signatures from the borrow operation
+     */
+    borrow(amount: Amount, bankAddress: PublicKey, borrowOpts?: MakeBorrowIxOpts, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature[]>;
+    /**
+     * Borrows tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param session - Fogo session object in Established state.
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @returns Array of transaction signatures from the borrow operation
+     */
+    borrowWithSession(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, borrowOpts?: MakeBorrowWithSessionIxOpts): Promise<TransactionResult>;
+    /**
+     * Creates a versioned transaction for borrowing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @returns Object containing feed crank transactions and the borrow transaction
+     */
+    makeBorrowTx(amount: Amount, bankAddress: PublicKey, borrowOpts?: MakeBorrowIxOpts): Promise<TransactionBuilderResult>;
+    /**
+     * Creates a versioned transaction for borrowing tokens from a lendr bank account.
+     *
+     * @param amount - The amount of tokens to borrow, can be a number or Amount object
+     * @param bankAddress - The public key of the bank to borrow from
+     * @param session
+     * @param borrowOpts - Optional borrow configuration parameters
+     * @returns Object containing feed crank transactions and the borrow transaction
+     */
+    makeBorrowWithSessionTx(amount: Amount, bankAddress: PublicKey, session: EstablishedSessionState, borrowOpts?: MakeBorrowWithSessionIxOpts): Promise<{
+        transactions: ExtendedV0Transaction[];
+        instructions: TransactionInstruction[];
+        actionTxIndex: number;
+    }>;
+    /**
+     * Creates instructions for withdrawing emissions rewards from a lendr bank account.
+     *
+     * @param bankAddress - The public key of the bank to withdraw emissions from
+     * @returns An InstructionsWrapper containing the withdraw emissions instructions
+     */
+    makeWithdrawEmissionsIx(bankAddress: PublicKey): Promise<InstructionsWrapper>;
+    /**
+     * Creates a versioned transaction for withdrawing emissions rewards from multiple lendr bank accounts.
+     *
+     * @param bankAddresses - Array of public keys for the banks to withdraw emissions from
+     * @returns A versioned transaction containing the withdraw emissions instructions
+     */
+    makeWithdrawEmissionsTx(bankAddresses: PublicKey[]): Promise<ExtendedV0Transaction>;
+    /**
+     * Withdraws emissions rewards from multiple lendr bank accounts.
+     *
+     * @param bankAddresses - Array of public keys for the banks to withdraw emissions from
+     * @param processOpts - Optional processing options for the transaction
+     * @param txOpts - Optional transaction options
+     * @returns The transaction signature of the withdraw emissions transaction
+     */
+    withdrawEmissions(bankAddresses: PublicKey[], processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    /**
+     * Creates an instruction wrapper for liquidating a lending account position.
+     *
+     * @param liquidateeLendrAccount - The lendr account to be liquidated
+     * @param assetBankAddress - Public key of the bank containing the asset to receive in liquidation
+     * @param assetQuantityUi - Amount of the asset to receive, in UI units
+     * @param liabBankAddress - Public key of the bank containing the liability to repay
+     * @returns An instruction wrapper containing the liquidation instructions
+     */
+    makeLendingAccountLiquidateIx(liquidateeLendrAccount: LendrAccount, assetBankAddress: PublicKey, assetQuantityUi: Amount, liabBankAddress: PublicKey): Promise<InstructionsWrapper>;
+    /**
+     * Liquidates a lending account position.
+     *
+     * @param liquidateeLendrAccount - The lendr account to be liquidated
+     * @param assetBankAddress - Public key of the bank containing the asset to receive in liquidation
+     * @param assetQuantityUi - Amount of the asset to receive, in UI units
+     * @param liabBankAddress - Public key of the bank containing the liability to repay
+     * @param processOpts - Optional processing options for the transaction
+     * @param txOpts - Optional transaction options
+     * @returns The transaction signature of the liquidation transaction
+     */
+    lendingAccountLiquidate(liquidateeLendrAccount: LendrAccount, assetBankAddress: PublicKey, assetQuantityUi: Amount, liabBankAddress: PublicKey, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    /**
+     * Creates an instruction to begin a flash loan operation.
+     *
+     * @param endIndex - The index where the flash loan instructions end in the transaction
+     * @returns An InstructionsWrapper containing the begin flash loan instruction
+     */
+    makeBeginFlashLoanIx(endIndex: number): Promise<InstructionsWrapper>;
+    /**
+     * Creates an instruction to begin a flash loan operation.
+     *
+     * @param endIndex - The index where the flash loan instructions end in the transaction
+     * @param session - established session state
+     * @returns An InstructionsWrapper containing the begin flash loan instruction
+     */
+    makeBeginFlashLoanWithSessionIx(endIndex: number, session: EstablishedSessionState): Promise<InstructionsWrapper>;
+    /**
+     * Creates an instruction to end a flash loan operation.
+     *
+     * @param projectedActiveBalances - Array of PublicKeys representing the projected active balance accounts after flash loan
+     * @returns An InstructionsWrapper containing the end flash loan instruction
+     */
+    makeEndFlashLoanIx(projectedActiveBalances: PublicKey[]): Promise<InstructionsWrapper>;
+    /**
+     * Creates an instruction to end a flash loan operation.
+     *
+     * @param projectedActiveBalances - Array of PublicKeys representing the projected active balance accounts after flash loan
+     * @param session - established session state
+     * @returns An InstructionsWrapper containing the end flash loan instruction
+     */
+    makeEndFlashLoanWithSessionIx(projectedActiveBalances: PublicKey[], session: EstablishedSessionState): Promise<InstructionsWrapper>;
+    flashLoan(args: FlashLoanArgs, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    flashLoanWithSession(args: FlashLoanArgs, session: EstablishedSessionState): Promise<TransactionResult>;
+    buildFlashLoanTx(args: FlashLoanArgs, lookupTables?: AddressLookupTableAccount[]): Promise<ExtendedV0Transaction>;
+    buildFlashLoanWithSessionTx(args: FlashLoanArgs, session: EstablishedSessionState, lookupTables?: AddressLookupTableAccount[]): Promise<ExtendedV0Transaction>;
+    makeTransferAccountAuthorityIx(newAccountAuthority: PublicKey): Promise<InstructionsWrapper>;
+    transferAccountAuthority(newAccountAuthority: PublicKey, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<string>;
+    makeUpdateFeedIx(newBanksPk: PublicKey[], txLandingBuffer?: number): Promise<{
+        instructions: TransactionInstruction[];
+        luts: AddressLookupTableAccount[];
+    }>;
+    makePulseHealthIx(mandatoryBanks?: PublicKey[], excludedBanks?: PublicKey[]): Promise<InstructionsWrapper>;
+    private static fetchAccountData;
+    static encode(decoded: LendrAccountRaw, idl: LendrIdlType): Promise<Buffer>;
+    reload(): Promise<void>;
+    private _updateFromAccountParsed;
+    describe(): string;
+    /**
+     * @deprecated This method is deprecated. Please use simulateBorrowLendTransaction instead.
+     */
+    simulateDeposit(amount: Amount, bankAddress: PublicKey): Promise<SimulationResult>;
+    /**
+     * @deprecated This method is deprecated. Please use simulateBorrowLendTransaction instead.
+     */
+    simulateWithdraw(bankAddress: PublicKey, txs: VersionedTransaction[]): Promise<SimulationResult>;
+    /**
+     * @deprecated This method is deprecated. Please use simulateBorrowLendTransaction instead.
+     */
+    simulateBorrow(bankAddress: PublicKey, txs: VersionedTransaction[]): Promise<SimulationResult>;
+    /**
+     * @deprecated This method is deprecated. Please use simulateBorrowLendTransaction instead.
+     */
+    simulateRepay(amount: Amount, bankAddress: PublicKey, repayAll?: boolean): Promise<SimulationResult>;
+    getBankUnclaimedOutstandingEmissions(bank: PublicKey): Promise<BigNumber>;
+}
+/**
+ * @deprecated This method is deprecated.
+ */
+declare function makeTxPriorityIx(feePayer: PublicKey, feeUi?: number, broadcastType?: TransactionBroadcastType, computeUnitsLimit?: number): {
+    bundleTipIx: TransactionInstruction | undefined;
+    priorityFeeIx: TransactionInstruction;
+};
+declare function makeBundleTipIx(feePayer: PublicKey, bundleTip?: number): TransactionInstruction;
+
+/**
+ * An instruction with some extra information that will be used to build transactions.
+ */
+type InstructionWithEphemeralSigners = {
+    /** The instruction */
+    instruction: TransactionInstruction;
+    /** The ephemeral signers that need to sign the transaction where this instruction will be */
+    signers: Signer[];
+    /** The compute units that this instruction requires, useful if greater than `DEFAULT_COMPUTE_BUDGET_UNITS`  */
+    computeUnits?: number;
+};
+
+declare enum RiskTier {
+    Collateral = "Collateral",
+    Isolated = "Isolated"
+}
+declare enum OperationalState {
+    Paused = "Paused",
+    Operational = "Operational",
+    ReduceOnly = "ReduceOnly",
+    KilledByBankruptcy = "KilledByBankruptcy"
+}
+interface RatePoint {
+    util: number;
+    rate: number;
+}
+interface InterestRateConfig {
+    optimalUtilizationRate: BigNumber;
+    plateauInterestRate: BigNumber;
+    maxInterestRate: BigNumber;
+    insuranceFeeFixedApr: BigNumber;
+    insuranceIrFee: BigNumber;
+    protocolFixedFeeApr: BigNumber;
+    protocolIrFee: BigNumber;
+    protocolOriginationFee: BigNumber;
+    zeroUtilRate: number;
+    hundredUtilRate: number;
+    points: RatePoint[];
+    curveType: number;
+}
+interface InterestRateConfigOpt extends Omit<InterestRateConfig, "optimalUtilizationRate" | "plateauInterestRate" | "maxInterestRate" | "curveType"> {
+}
+declare enum OracleSetup {
+    None = "None",
+    PythLegacy = "PythLegacy",
+    SwitchboardV2 = "SwitchboardV2",
+    PythPushOracle = "PythPushOracle",
+    SwitchboardPull = "SwitchboardPull",
+    StakedWithPythPush = "StakedWithPythPush",
+    KaminoPythPush = "KaminoPythPush",
+    KaminoSwitchboardPull = "KaminoSwitchboardPull",
+    Fixed = "Fixed"
+}
+declare enum AssetTag {
+    DEFAULT = 0,
+    SOL = 1,
+    STAKED = 2
+}
+declare enum BankConfigFlag {
+    PYTH_MIGRATED = 1
+}
+interface BankConfigOpt {
+    assetWeightInit: BigNumber | null;
+    assetWeightMaint: BigNumber | null;
+    liabilityWeightInit: BigNumber | null;
+    liabilityWeightMaint: BigNumber | null;
+    depositLimit: BigNumber | null;
+    borrowLimit: BigNumber | null;
+    interestRateConfig: InterestRateConfig | null;
+    operationalState: OperationalState | null;
+    riskTier: RiskTier | null;
+    assetTag: AssetTag | null;
+    totalAssetValueInitLimit: BigNumber | null;
+    oracleMaxConfidence: number | null;
+    oracleMaxAge: number | null;
+    permissionlessBadDebtSettlement: boolean | null;
+    freezeSettings: boolean | null;
+    tokenlessRepaymentsAllowed: boolean | null;
+}
+interface BankConfigType {
+    assetWeightInit: BigNumber;
+    assetWeightMaint: BigNumber;
+    liabilityWeightInit: BigNumber;
+    liabilityWeightMaint: BigNumber;
+    depositLimit: BigNumber;
+    borrowLimit: BigNumber;
+    riskTier: RiskTier;
+    totalAssetValueInitLimit: BigNumber;
+    assetTag: AssetTag;
+    configFlags?: BankConfigFlag;
+    interestRateConfig: InterestRateConfig;
+    operationalState: OperationalState;
+    oracleSetup: OracleSetup;
+    oracleKeys: PublicKey[];
+    oracleMaxAge: number;
+    oracleMaxConfidence: number;
+    fixedPrice: BigNumber;
+}
+interface BankType {
+    address: PublicKey;
+    tokenSymbol?: string;
+    group: PublicKey;
+    mint: PublicKey;
+    mintDecimals: number;
+    mintRate: number | null;
+    mintPrice: number;
+    assetShareValue: BigNumber;
+    liabilityShareValue: BigNumber;
+    liquidityVault: PublicKey;
+    liquidityVaultBump: number;
+    liquidityVaultAuthorityBump: number;
+    insuranceVault: PublicKey;
+    insuranceVaultBump: number;
+    insuranceVaultAuthorityBump: number;
+    collectedInsuranceFeesOutstanding: BigNumber;
+    feeVault: PublicKey;
+    feeVaultBump: number;
+    feeVaultAuthorityBump: number;
+    collectedGroupFeesOutstanding: BigNumber;
+    lastUpdate: number;
+    config: BankConfigType;
+    totalAssetShares: BigNumber;
+    totalLiabilityShares: BigNumber;
+    emissionsActiveBorrowing: boolean;
+    emissionsActiveLending: boolean;
+    emissionsRate: number;
+    emissionsMint: PublicKey;
+    emissionsRemaining: BigNumber;
+    oracleKey: PublicKey;
+    pythShardId?: number;
+    emode: EmodeSettingsType;
+    feesDestinationAccount?: PublicKey;
+    lendingPositionCount?: BigNumber;
+    borrowingPositionCount?: BigNumber;
+}
+/**
+ * Bitwise flags for EMode entry
+ */
+declare enum EmodeEntryFlags {
+    /**
+     * If set, isolated banks with this tag also benefit.
+     * If not set, isolated banks continue to offer zero collateral, even if they use this tag.
+     * (NOT YET IMPLEMENTED)
+     */
+    APPLIES_TO_ISOLATED = 1,// 1
+    /** Reserved for future use */
+    RESERVED_1 = 2,// 2
+    RESERVED_2 = 4,// 4
+    RESERVED_3 = 8,// 8
+    RESERVED_4 = 16,// 16
+    RESERVED_5 = 32
+}
+interface EmodeEntry {
+    collateralBankEmodeTag: EmodeTag;
+    flags: EmodeEntryFlags[];
+    assetWeightInit: BigNumber;
+    assetWeightMaint: BigNumber;
+}
+/**
+ * Bitwise flags for EMode settings
+ */
+declare enum EmodeFlags {
+    /** If set, at least one entry is configured */
+    EMODE_ON = 1,// 1
+    /** Reserved for future use */
+    RESERVED_1 = 2,// 2
+    RESERVED_2 = 4,// 4
+    RESERVED_3 = 8
+}
+declare enum EmodeTag {
+    UNSET = 0,
+    SOL = 501,
+    LST_T1 = 1571,
+    LST_T2 = 1572,
+    UNKNOWN = 9999
+}
+interface EmodeSettingsType {
+    emodeTag: EmodeTag;
+    timestamp: number;
+    flags: EmodeFlags[];
+    emodeEntries: EmodeEntry[];
+}
+interface OracleConfigOpt {
+    setup: OracleSetup;
+    keys: PublicKey[];
+}
+type EmodePair = {
+    collateralBanks: PublicKey[];
+    collateralBankTag: EmodeTag;
+    liabilityBank: PublicKey;
+    liabilityBankTag: EmodeTag;
+    assetWeightMaint: BigNumber;
+    assetWeightInit: BigNumber;
+};
+type ActiveEmodePair = {
+    collateralBanks: PublicKey[];
+    collateralBankTags: EmodeTag[];
+    liabilityBanks: PublicKey[];
+    liabilityBankTags: EmodeTag[];
+    assetWeightMaint: BigNumber;
+    assetWeightInit: BigNumber;
+};
+declare enum EmodeImpactStatus {
+    ActivateEmode = 0,
+    ExtendEmode = 1,
+    IncreaseEmode = 2,
+    ReduceEmode = 3,
+    RemoveEmode = 4,
+    InactiveEmode = 5
+}
+interface EmodeImpact {
+    status: EmodeImpactStatus;
+    resultingPairs: EmodePair[];
+    activePair?: ActiveEmodePair;
+}
+interface ActionEmodeImpact {
+    borrowImpact?: EmodeImpact;
+    supplyImpact?: EmodeImpact;
+    repayAllImpact?: EmodeImpact;
+    withdrawAllImpact?: EmodeImpact;
+}
+
+interface BankRaw {
+    group: PublicKey;
+    mint: PublicKey;
+    mintDecimals: number;
+    assetShareValue: WrappedI80F48;
+    liabilityShareValue: WrappedI80F48;
+    liquidityVault: PublicKey;
+    liquidityVaultBump: number;
+    liquidityVaultAuthorityBump: number;
+    insuranceVault: PublicKey;
+    insuranceVaultBump: number;
+    insuranceVaultAuthorityBump: number;
+    collectedInsuranceFeesOutstanding: WrappedI80F48;
+    feeVault: PublicKey;
+    feeVaultBump: number;
+    feeVaultAuthorityBump: number;
+    collectedGroupFeesOutstanding: WrappedI80F48;
+    lastUpdate: BN;
+    config: BankConfigRaw;
+    totalLiabilityShares: WrappedI80F48;
+    totalAssetShares: WrappedI80F48;
+    flags: BN;
+    emissionsRate: BN;
+    emissionsRemaining: WrappedI80F48;
+    emissionsMint: PublicKey;
+    emode: EmodeSettingsRaw;
+    feesDestinationAccount?: PublicKey;
+    cache?: BankCacheRaw;
+    lendingPositionCount?: number;
+    borrowingPositionCount?: number;
+}
+interface BankCacheRaw {
+    baseRate: number;
+    lendingRate: number;
+    borrowingRate: number;
+    interestAccumulatedFor: number;
+    accumulatedSinceLastUpdate: WrappedI80F48;
+}
+interface BankConfigRaw {
+    assetWeightInit: WrappedI80F48;
+    assetWeightMaint: WrappedI80F48;
+    liabilityWeightInit: WrappedI80F48;
+    liabilityWeightMaint: WrappedI80F48;
+    depositLimit: BN;
+    interestRateConfig: InterestRateConfigRaw;
+    operationalState: OperationalStateRaw;
+    oracleSetup: OracleSetupRaw;
+    oracleKeys: PublicKey[];
+    borrowLimit: BN;
+    riskTier: RiskTierRaw;
+    assetTag: number;
+    configFlags?: number;
+    totalAssetValueInitLimit: BN;
+    oracleMaxAge: number;
+    oracleMaxConfidence: number;
+    fixedPrice: WrappedI80F48;
+}
+interface BankConfigOptRaw {
+    assetWeightInit: WrappedI80F48 | null;
+    assetWeightMaint: WrappedI80F48 | null;
+    liabilityWeightInit: WrappedI80F48 | null;
+    liabilityWeightMaint: WrappedI80F48 | null;
+    depositLimit: BN | null;
+    borrowLimit: BN | null;
+    operationalState: OperationalStateRaw | null;
+    interestRateConfig: InterestRateConfigOptRaw | null;
+    riskTier: RiskTierRaw | null;
+    assetTag: number | null;
+    totalAssetValueInitLimit: BN | null;
+    oracleMaxConfidence: number | null;
+    oracleMaxAge: number | null;
+    permissionlessBadDebtSettlement: boolean | null;
+    freezeSettings: boolean | null;
+    tokenlessRepaymentsAllowed: boolean | null;
+}
+interface BankConfigCompactRaw extends Omit<BankConfigRaw, "oracleKeys" | "oracleSetup" | "fixedPrice" | "interestRateConfig"> {
+    interestRateConfig: InterestRateConfigCompactRaw;
+}
+type RiskTierRaw = {
+    collateral: {};
+} | {
+    isolated: {};
+};
+type OperationalStateRaw = {
+    paused: {};
+} | {
+    operational: {};
+} | {
+    reduceOnly: {};
+} | {
+    killedByBankruptcy: {};
+};
+interface RatePointRaw {
+    util: number;
+    rate: number;
+}
+interface InterestRateConfigRaw {
+    optimalUtilizationRate: WrappedI80F48;
+    plateauInterestRate: WrappedI80F48;
+    maxInterestRate: WrappedI80F48;
+    insuranceFeeFixedApr: WrappedI80F48;
+    insuranceIrFee: WrappedI80F48;
+    protocolFixedFeeApr: WrappedI80F48;
+    protocolIrFee: WrappedI80F48;
+    protocolOriginationFee: WrappedI80F48;
+    zeroUtilRate: number;
+    hundredUtilRate: number;
+    points: RatePointRaw[];
+    curveType: number;
+}
+interface InterestRateConfigCompactRaw extends Omit<InterestRateConfigRaw, "optimalUtilizationRate" | "plateauInterestRate" | "maxInterestRate" | "curveType"> {
+}
+interface InterestRateConfigOptRaw extends InterestRateConfigCompactRaw {
+}
+type OracleSetupRaw = {
+    none: {};
+} | {
+    pythLegacy: {};
+} | {
+    switchboardV2: {};
+} | {
+    pythPushOracle: {};
+} | {
+    switchboardPull: {};
+} | {
+    stakedWithPythPush: {};
+} | {
+    kaminoPythPush: {};
+} | {
+    kaminoSwitchboardPull: {};
+} | {
+    fixed: {};
+};
+interface OracleConfigOptRaw {
+    setup: OracleSetupRaw;
+    keys: PublicKey[];
+}
+interface BankMetadataRaw {
+    bank: PublicKey;
+    placeholder: BN;
+    ticker: number[];
+    description: number[];
+    dataBlob: number[];
+    endDescriptionByte: number;
+    endDataBlob: number;
+    endTickerByte: number;
+    bump: number;
+    pad0: number[];
+}
+interface EmodeEntryRaw {
+    collateralBankEmodeTag: number;
+    flags: number;
+    assetWeightInit: WrappedI80F48;
+    assetWeightMaint: WrappedI80F48;
+}
+interface EmodeSettingsRaw {
+    emodeTag: number;
+    timestamp: BN;
+    flags: BN;
+    emodeConfig: EmodeConfigRaw;
+}
+interface EmodeConfigRaw {
+    entries: EmodeEntryRaw[];
+}
+
+interface RatePointDto {
+    util: number;
+    rate: number;
+}
+interface InterestRateConfigDto {
+    optimalUtilizationRate: string;
+    plateauInterestRate: string;
+    maxInterestRate: string;
+    insuranceFeeFixedApr: string;
+    insuranceIrFee: string;
+    protocolFixedFeeApr: string;
+    protocolIrFee: string;
+    protocolOriginationFee: string;
+    zeroUtilRate: number;
+    hundredUtilRate: number;
+    points: RatePointDto[];
+    curveType: number;
+}
+interface BankConfigDto {
+    assetWeightInit: string;
+    assetWeightMaint: string;
+    liabilityWeightInit: string;
+    liabilityWeightMaint: string;
+    depositLimit: string;
+    borrowLimit: string;
+    riskTier: RiskTier;
+    totalAssetValueInitLimit: string;
+    assetTag: AssetTag;
+    configFlags?: BankConfigFlag;
+    interestRateConfig: InterestRateConfigDto;
+    operationalState: OperationalState;
+    oracleSetup: OracleSetup;
+    oracleKeys: string[];
+    oracleMaxAge: number;
+    oracleMaxConfidence: number;
+    fixedPrice: string;
+}
+interface EmodeEntryDto {
+    collateralBankEmodeTag: EmodeTag;
+    flags: EmodeEntryFlags[];
+    assetWeightInit: string;
+    assetWeightMaint: string;
+}
+interface EmodeSettingsDto {
+    emodeTag: EmodeTag;
+    timestamp: number;
+    flags: EmodeFlags[];
+    emodeEntries: EmodeEntryDto[];
+}
+interface BankTypeDto {
+    address: string;
+    tokenSymbol?: string;
+    group: string;
+    mint: string;
+    mintDecimals: number;
+    assetShareValue: string;
+    liabilityShareValue: string;
+    liquidityVault: string;
+    liquidityVaultBump: number;
+    liquidityVaultAuthorityBump: number;
+    insuranceVault: string;
+    insuranceVaultBump: number;
+    insuranceVaultAuthorityBump: number;
+    collectedInsuranceFeesOutstanding: string;
+    feeVault: string;
+    feeVaultBump: number;
+    feeVaultAuthorityBump: number;
+    collectedGroupFeesOutstanding: string;
+    lastUpdate: number;
+    config: BankConfigDto;
+    totalAssetShares: string;
+    totalLiabilityShares: string;
+    emissionsActiveBorrowing: boolean;
+    emissionsActiveLending: boolean;
+    emissionsRate: number;
+    emissionsMint: string;
+    emissionsRemaining: string;
+    oracleKey: string;
+    pythShardId?: number;
+    emode: EmodeSettingsDto;
+    feesDestinationAccount?: string;
+    lendingPositionCount?: string;
+    borrowingPositionCount?: string;
+}
+interface BankRawDto {
+    group: string;
+    mint: string;
+    mintDecimals: number;
+    assetShareValue: WrappedI80F48;
+    liabilityShareValue: WrappedI80F48;
+    liquidityVault: string;
+    liquidityVaultBump: number;
+    liquidityVaultAuthorityBump: number;
+    insuranceVault: string;
+    insuranceVaultBump: number;
+    insuranceVaultAuthorityBump: number;
+    collectedInsuranceFeesOutstanding: WrappedI80F48;
+    feeVault: string;
+    feeVaultBump: number;
+    feeVaultAuthorityBump: number;
+    collectedGroupFeesOutstanding: WrappedI80F48;
+    lastUpdate: string;
+    config: BankConfigRawDto;
+    totalLiabilityShares: WrappedI80F48;
+    totalAssetShares: WrappedI80F48;
+    flags: string;
+    emissionsRate: string;
+    emissionsRemaining: WrappedI80F48;
+    emissionsMint: string;
+    feesDestinationAccount?: string;
+    lendingPositionCount?: string;
+    borrowingPositionCount?: string;
+    emode: EmodeSettingsRawDto;
+}
+interface BankConfigRawDto {
+    assetWeightInit: WrappedI80F48;
+    assetWeightMaint: WrappedI80F48;
+    liabilityWeightInit: WrappedI80F48;
+    liabilityWeightMaint: WrappedI80F48;
+    depositLimit: string;
+    interestRateConfig: InterestRateConfigRaw;
+    operationalState: OperationalStateRaw;
+    oracleSetup: OracleSetupRaw;
+    oracleKeys: string[];
+    borrowLimit: string;
+    riskTier: RiskTierRaw;
+    assetTag: number;
+    configFlags?: number;
+    totalAssetValueInitLimit: string;
+    oracleMaxAge: number;
+    oracleMaxConfidence: number;
+    fixedPrice: WrappedI80F48;
+}
+interface EmodeSettingsRawDto {
+    emodeTag: number;
+    timestamp: string;
+    flags: string;
+    emodeConfig: EmodeConfigRawDto;
+}
+interface EmodeConfigRawDto {
+    entries: EmodeEntryRawDto[];
+}
+interface EmodeEntryRawDto {
+    collateralBankEmodeTag: number;
+    flags: number;
+    assetWeightInit: WrappedI80F48;
+    assetWeightMaint: WrappedI80F48;
+}
+
+declare function freezeBankConfigIx(program: LendrProgram, bankAddress: PublicKey, bankConfigOpt: BankConfigOpt): Promise<InstructionsWrapper>;
+type AddOracleToBanksIxArgs = {
+    program: LendrProgram;
+    bankAddress: PublicKey;
+    /**
+     * The feed ID for the oracle. For Pyth Push oracles, this is the price feed ID.
+     * The function will automatically derive the PDA from this feed ID.
+     */
+    feedId: PublicKey;
+    /**
+     * The oracle setup type (e.g., PythPushOracle, KaminoPythPush, etc.)
+     */
+    setup: OracleSetup;
+    /**
+     * The shard ID for Pyth Push oracles. Defaults to PYTH_SPONSORED_SHARD_ID.
+     * Only relevant for PythPushOracle and KaminoPythPush setups.
+     */
+    shardId?: number;
+    groupAddress?: PublicKey;
+    adminAddress?: PublicKey;
+};
+/**
+ * Creates an instruction to configure a bank's oracle.
+ * For Pyth Push oracles, automatically derives the PDA from the feed ID.
+ */
+declare function addOracleToBanksIx({ program, bankAddress, feedId, setup, shardId, groupAddress, adminAddress, }: AddOracleToBanksIxArgs): Promise<InstructionsWrapper>;
+/**
+ * Derive the address of a price feed account
+ * @param shardId The shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+ * @param priceFeedId The price feed ID, as either a 32-byte buffer or hexadecimal string with or without a leading "0x" prefix.
+ * @param pushOracleProgramId The program ID of the Pyth Push Oracle program. If not provided, the default deployment will be used.
+ * @returns The address of the price feed account
+ */
+declare function getPriceFeedAccountForProgram(shardId: number, priceFeedId: Buffer | string, pushOracleProgramId?: PublicKey): PublicKey;
+declare const getTreasuryPda: (treasuryId: number, receiverProgramId: PublicKey) => PublicKey;
+declare const getConfigPda: (receiverProgramId: PublicKey) => PublicKey;
+declare function crankPythOracleIx(oracles: {
+    feedId: string;
+    shardId: number;
+}[], provider: Provider): Promise<{
+    postInstructions: InstructionWithEphemeralSigners[];
+    closeInstructions: InstructionWithEphemeralSigners[];
+    keys: never[];
+    lut: _solana_web3_js.AddressLookupTableAccount | null;
+}>;
+
+declare function getPriceWithConfidence(oraclePrice: OraclePrice, weighted: boolean): PriceWithConfidence;
+declare function getPrice(oraclePrice: OraclePrice, priceBias?: PriceBias, weightedPrice?: boolean): BigNumber;
+type SupportedOracleSetup = OracleSetup.PythLegacy | OracleSetup.PythPushOracle | OracleSetup.StakedWithPythPush | OracleSetup.SwitchboardV2 | OracleSetup.SwitchboardPull | OracleSetup.KaminoPythPush | OracleSetup.KaminoSwitchboardPull | OracleSetup.Fixed;
+declare function isOracleSetupSupported(oracleSetup: OracleSetup): oracleSetup is SupportedOracleSetup;
+declare function parseOraclePriceData(oracleSetup: SupportedOracleSetup, rawData: Buffer, fixedPrice?: BigNumber, logger?: TLogger): OraclePrice;
+
+declare function dtoToOraclePrice(dto: OraclePriceDto): OraclePrice;
+
+/**
+ * Extracts oracle keys for Pyth price fetching
+ */
+declare const extractPythOracleKeys: (pythBanks: {
+    address: PublicKey;
+    data: BankRaw;
+}[]) => string[];
+declare const fetchPythOracleData: (banks: {
+    address: PublicKey;
+    data: BankRaw;
+}[], bankMetadataMap: {
+    [address: string]: BankMetadata;
+}, connection?: Connection, opts?: {
+    useApiEndpoint?: boolean;
+}) => Promise<{
+    pythFeedMap: PythPushFeedIdMap;
+    bankOraclePriceMap: Map<string, OraclePrice>;
+}>;
+/**
+ * =============================================================================
+ * SWITCHBOARD ORACLE UTILS
+ * =============================================================================
+ *
+ * Utility functions for fetching Switchboard oracle data
+ */
+declare const fetchSwbOracleData: (banks: {
+    address: PublicKey;
+    data: BankRaw;
+}[], opts?: {
+    useApiEndpoint?: boolean;
+}) => Promise<{
+    bankOraclePriceMap: Map<string, OraclePrice>;
+}>;
+/**
+ * =============================================================================
+ * ORACLE UTILS
+ * =============================================================================
+ *
+ * Utility functions for fetching all oracle data
+ */
+declare const fetchOracleData: (banks: {
+    address: PublicKey;
+    data: BankRaw;
+}[], bankMetadataMap: {
+    [address: string]: BankMetadata;
+}, connection?: Connection, opts?: {
+    useApiEndpoint?: boolean;
+}) => Promise<{
+    bankOraclePriceMap: Map<string, OraclePrice>;
+    pythFeedMap: PythPushFeedIdMap;
+}>;
+
+declare function oraclePriceToDto(oraclePrice: OraclePrice): OraclePriceDto;
+
+declare function computeMaxLeverage(depositBank: BankType, borrowBank: BankType, opts?: {
+    assetWeightInit?: BigNumber;
+    liabilityWeightInit?: BigNumber;
+}): {
+    maxLeverage: number;
+    ltv: number;
+};
+declare function computeLoopingParams(principal: Amount, targetLeverage: number, depositBank: BankType, borrowBank: BankType, depositOracleInfo: OraclePrice, borrowOracleInfo: OraclePrice): {
+    borrowAmount: BigNumber;
+    totalDepositAmount: BigNumber;
+};
+/** Small getters */
+declare function getTotalAssetQuantity(bank: BankType): BigNumber;
+declare function getTotalLiabilityQuantity(bank: BankType): BigNumber;
+declare function getAssetQuantity(bank: BankType, assetShares: BigNumber): BigNumber;
+declare function getLiabilityQuantity(bank: BankType, liabilityShares: BigNumber): BigNumber;
+declare function getAssetShares(bank: BankType, assetQuantity: BigNumber): BigNumber;
+declare function getLiabilityShares(bank: BankType, liabilityQuantity: BigNumber): BigNumber;
+declare function getAssetWeight(bank: BankType, lendrRequirementType: LendrRequirementType, oraclePrice: OraclePrice, opts?: {
+    ignoreSoftLimits?: boolean;
+    assetWeightInitOverride?: BigNumber;
+}): BigNumber;
+declare function getLiabilityWeight(config: BankConfigType, lendrRequirementType: LendrRequirementType): BigNumber;
+/** Computes  */
+declare function computeLiabilityUsdValue(bank: BankType, oraclePrice: OraclePrice, liabilityShares: BigNumber, lendrRequirementType: LendrRequirementType, priceBias: PriceBias): BigNumber;
+declare function computeAssetUsdValue(bank: BankType, oraclePrice: OraclePrice, assetShares: BigNumber, lendrRequirementType: LendrRequirementType, priceBias: PriceBias): BigNumber;
+declare function computeUsdValue(bank: BankType, oraclePrice: OraclePrice, quantity: BigNumber, priceBias: PriceBias, weightedPrice: boolean, weight?: BigNumber, scaleToBase?: boolean): BigNumber;
+declare function computeTvl(bank: BankType, oraclePrice: OraclePrice): BigNumber;
+declare function computeInterestRates(bank: BankType): {
+    lendingRate: BigNumber;
+    borrowingRate: BigNumber;
+};
+declare function computeBaseInterestRate(bank: BankType): BigNumber;
+declare function computeUtilizationRate(bank: BankType): BigNumber;
+declare function computeRemainingCapacity(bank: BankType): {
+    depositCapacity: BigNumber;
+    borrowCapacity: BigNumber;
+};
+
+declare function decodeBankRaw(encoded: Buffer, idl: LendrIdlType): BankRaw;
+declare function parseEmodeSettingsRaw(emodeSettingsRaw: EmodeSettingsRaw): EmodeSettingsType;
+declare function parseBankRaw(address: PublicKey, accountParsed: BankRaw, feedIdMap?: PythPushFeedIdMap, bankMetadata?: BankMetadata, mintData?: {
+    mintRate: number | null;
+    mintPrice: number;
+}): BankType;
+declare function dtoToBank(bankDto: BankTypeDto): BankType;
+declare function dtoToEmodeSettings(emodeSettingsDto: EmodeSettingsDto): EmodeSettingsType;
+declare function dtoToBankConfig(bankConfigDto: BankConfigDto): BankConfigType;
+declare function dtoToInterestRateConfig(interestRateConfigDto: InterestRateConfigDto): InterestRateConfig;
+declare function dtoToBankRaw(bankDto: BankRawDto): BankRaw;
+declare function dtoToEmodeSettingsRaw(emodeSettingsDto: EmodeSettingsRawDto): EmodeSettingsRaw;
+declare function dtoToBankConfigRaw(bankConfigDto: BankConfigRawDto): BankConfigRaw;
+declare function parseBankConfigRaw(bankConfigRaw: BankConfigRaw): BankConfigType;
+declare function parseRiskTier(riskTierRaw: RiskTierRaw): RiskTier;
+declare function parseOperationalState(operationalStateRaw: OperationalStateRaw): OperationalState;
+declare function parseOracleSetup(oracleSetupRaw: OracleSetupRaw): OracleSetup;
+/**
+ * Get all active EMode flags as an array of flag names
+ */
+declare function getActiveEmodeFlags(flags: BN): EmodeFlags[];
+/**
+ * Check if a specific EMode flag is set
+ */
+declare function hasEmodeFlag(flags: BN, flag: number): boolean;
+/**
+ * Get all active EMode entry flags as an array of flag names
+ */
+declare function getActiveEmodeEntryFlags(flags: number): EmodeEntryFlags[];
+/**
+ * Check if a specific EMode entry flag is set
+ */
+declare function hasEmodeEntryFlag(flags: number, flag: number): boolean;
+/**
+ * Parse a raw EMode tag number into the corresponding EmodeTag enum value
+ */
+declare function parseEmodeTag(emodeTagRaw: number): EmodeTag;
+
+declare const fetchMultipleBanks: (program: LendrProgram, opts?: {
+    bankAddresses?: Address[];
+    groupAddress?: PublicKey;
+}) => Promise<{
+    address: PublicKey;
+    data: BankRaw;
+}[]>;
+
+declare function serializeBankConfigOpt(bankConfigOpt: BankConfigOpt): BankConfigOptRaw;
+declare function serializeRiskTier(riskTier: RiskTier): RiskTierRaw;
+declare function serializeOperationalState(operationalState: OperationalState): {
+    paused: {};
+} | {
+    operational: {};
+} | {
+    reduceOnly: {};
+};
+declare function serializeOracleSetupToIndex(oracleSetup: OracleSetup): number;
+declare function serializeOracleSetup(oracleSetup: OracleSetup): OracleSetupRaw;
+declare function toBankDto(bank: BankType): BankTypeDto;
+declare function toEmodeSettingsDto(emodeSettings: EmodeSettingsType): EmodeSettingsDto;
+declare function toBankConfigDto(bankConfig: BankConfigType): BankConfigDto;
+declare function toInterestRateConfigDto(interestRateConfig: InterestRateConfig): InterestRateConfigDto;
+declare function bankConfigToBankConfigRaw(config: BankConfigType): BankConfigRaw;
+declare function bankRawToDto(bankRaw: BankRaw): BankRawDto;
+declare function emodeSettingsRawToDto(emodeSettingsRaw: EmodeSettingsRaw): EmodeSettingsRawDto;
+declare function bankConfigRawToDto(bankConfigRaw: BankConfigRaw): BankConfigRawDto;
+
+interface BalanceType {
+    active: boolean;
+    bankPk: PublicKey;
+    assetShares: BigNumber;
+    liabilityShares: BigNumber;
+    emissionsOutstanding: BigNumber;
+    lastUpdate: number;
+}
+declare enum HealthCacheFlags {
+    /**
+     * If set (1), the account is considered healthy and cannot be liquidated.
+     * If not set (0), the account is unhealthy and can be liquidated.
+     */
+    HEALTHY = 1,// 1
+    /**
+     * If set (1), the engine did not error during the last health pulse.
+     * If not set (0), the engine would have errored and this cache is likely invalid.
+     * `RiskEngineInitRejected` is ignored and will allow the flag to be set anyways.
+     */
+    ENGINE_STATUS_OK = 2,// 2
+    /**
+     * If set (1), the engine did not error due to an oracle issue.
+     * If not set (0), engine was passed a bad bank or oracle account, or an oracle was stale.
+     * Check the order in which accounts were passed and ensure each balance has the correct banks/oracles,
+     * and that oracle cranks ran recently enough. Check `internal_err` and `err_index` for more details
+     * in some circumstances. Invalid if generated after borrow/withdraw (these instructions will
+     * ignore oracle issues if health is still satisfactory with some balance zeroed out).
+     */
+    ORACLE_OK = 4
+}
+interface HealthCacheType {
+    assetValue: BigNumber;
+    liabilityValue: BigNumber;
+    assetValueMaint: BigNumber;
+    liabilityValueMaint: BigNumber;
+    assetValueEquity: BigNumber;
+    liabilityValueEquity: BigNumber;
+    timestamp: BigNumber;
+    flags: HealthCacheFlags[];
+    prices: number[][];
+    simulationFailed?: boolean;
+}
+interface LendrAccountType {
+    address: PublicKey;
+    group: PublicKey;
+    authority: PublicKey;
+    balances: BalanceType[];
+    accountFlags: AccountFlags[];
+    emissionsDestinationAccount: PublicKey;
+    healthCache: HealthCacheType;
+}
+declare enum AccountFlags {
+    ACCOUNT_DISABLED = 1,// 1
+    ACCOUNT_IN_FLASHLOAN = 2,// 2
+    ACCOUNT_FLAG_DEPRECATED = 4,// 4
+    ACCOUNT_TRANSFER_AUTHORITY_ALLOWED = 8
+}
+
+interface BalanceTypeDto {
+    active: boolean;
+    bankPk: string;
+    assetShares: string;
+    liabilityShares: string;
+    emissionsOutstanding: string;
+    lastUpdate: number;
+}
+interface HealthCacheTypeDto {
+    assetValue: string;
+    liabilityValue: string;
+    assetValueMaint: string;
+    liabilityValueMaint: string;
+    assetValueEquity: string;
+    liabilityValueEquity: string;
+    timestamp: string;
+    flags: HealthCacheFlags[];
+    prices: number[][];
+    simulationFailed?: boolean;
+}
+interface LendrAccountTypeDto {
+    address: string;
+    group: string;
+    authority: string;
+    balances: BalanceTypeDto[];
+    accountFlags: AccountFlags[];
+    emissionsDestinationAccount: string;
+    healthCache: HealthCacheTypeDto;
+}
+
+interface BalanceRaw {
+    active: boolean | number;
+    bankPk: PublicKey;
+    assetShares: WrappedI80F48;
+    liabilityShares: WrappedI80F48;
+    emissionsOutstanding: WrappedI80F48;
+    lastUpdate: BN;
+}
+interface HealthCacheRaw {
+    assetValue: WrappedI80F48;
+    liabilityValue: WrappedI80F48;
+    assetValueMaint: WrappedI80F48;
+    liabilityValueMaint: WrappedI80F48;
+    assetValueEquity: WrappedI80F48;
+    liabilityValueEquity: WrappedI80F48;
+    timestamp: BN;
+    flags: number;
+    prices: number[][];
+    errIndex: number;
+    internalErr: number;
+    internalBankruptcyErr: number;
+    internalLiqErr: number;
+    lndrErr: number;
+}
+interface LendrAccountRaw {
+    group: PublicKey;
+    authority: PublicKey;
+    lendingAccount: {
+        balances: BalanceRaw[];
+    };
+    accountFlags: BN;
+    emissionsDestinationAccount: PublicKey;
+    healthCache: HealthCacheRaw;
+    padding0?: BN[];
+}
+type LendrRequirementTypeRaw = {
+    initial: {};
+} | {
+    maintenance: {};
+} | {
+    equity: {};
+};
+
+/**
+ * Custom error class for health cache simulation failures
+ */
+declare class HealthCacheSimulationError extends Error {
+    lndrErr: number | null;
+    internalErr: number | null;
+    constructor(message: string, lndrErr: number | null, internalErr: number | null);
+}
+declare function simulateAccountHealthCacheWithFallback(props: {
+    program: Program<LendrIdlType>;
+    bankMap: Map<string, Bank>;
+    oraclePrices: Map<string, OraclePrice>;
+    lendrAccount: LendrAccount;
+    balances: Balance[];
+    bankMetadataMap: BankMetadataMap;
+}): Promise<{
+    lendrAccount: LendrAccount;
+    error?: HealthCacheSimulationError;
+}>;
+declare function simulateAccountHealthCache(props: {
+    program: Program<LendrIdlType>;
+    bankMap: Map<string, Bank>;
+    oraclePrices: Map<string, OraclePrice>;
+    lendrAccountPk: PublicKey;
+    balances: Balance[];
+    bankMetadataMap: BankMetadataMap;
+}): Promise<LendrAccountRaw>;
+declare function makePulseHealthIx$1(program: LendrProgram, lendrAccountPk: PublicKey, banks: Map<string, BankType>, balances: BalanceType[], mandatoryBanks: PublicKey[], excludedBanks: PublicKey[], bankMetadataMap: BankMetadataMap): Promise<{
+    instructions: TransactionInstruction[];
+    keys: never[];
+}>;
+declare function createUpdateFeedIx(_props: {
+    swbPullOracles: PublicKey[];
+    provider: AnchorProvider;
+}): Promise<{
+    instructions: TransactionInstruction[];
+    luts: AddressLookupTableAccount[];
+}>;
+/**
+ * This function creates a new Lendr account transaction and returns a projected dummy account for simulation.
+ * Note: This function is subject to future updates and improvements.
+ */
+declare function createLendrAccountTx(props: {
+    lendrAccount: LendrAccountWrapper | null;
+    lendrClient: LendrClient;
+}): Promise<{
+    account: LendrAccountWrapper;
+    tx: SolanaTransaction;
+}>;
+declare function getActiveStaleBanks(balances: Balance[], banks: BankMap, additionalBanks: Bank[], oraclePrices: OraclePriceMap, maxAgeOffset?: number): {
+    stalePythFeeds: {
+        feedId: string;
+        shardId: number;
+    }[];
+    staleSwbOracles: {
+        oracleKey: PublicKey;
+    }[];
+};
+
+/**
+ * Lendr Account Computes
+ * =========================
+ */
+declare function computeFreeCollateral(lendrAccount: LendrAccountType, opts?: {
+    clamped?: boolean;
+}): BigNumber;
+declare function computeFreeCollateralLegacy(activeBalances: BalanceType[], banks: Map<string, BankType>, oraclePrices: Map<string, OraclePrice>, opts?: {
+    clamped?: boolean;
+}): BigNumber;
+declare function computeHealthComponents(lendrAccount: LendrAccountType, lendrReqType: LendrRequirementType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeHealthComponentsLegacy(activeBalances: BalanceType[], banks: Map<string, BankType>, oraclePrices: Map<string, OraclePrice>, lendrReqType: LendrRequirementType, excludedBanks?: PublicKey[]): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeHealthComponentsWithoutBiasLegacy(activeBalances: BalanceType[], banks: Map<string, BankType>, oraclePrices: Map<string, OraclePrice>, lendrReqType: LendrRequirementType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeAccountValue(lendrAccount: LendrAccountType): BigNumber;
+declare function computeNetApy(lendrAccount: LendrAccountType, activeBalances: BalanceType[], banks: Map<string, BankType>, oraclePrices: Map<string, OraclePrice>): number;
+/**
+ * Lendr Balance Computes
+ * =========================
+ */
+declare function computeBalanceUsdValue(balance: BalanceType, bank: BankType, oraclePrice: OraclePrice, lendrRequirementType: LendrRequirementType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function getBalanceUsdValueWithPriceBias(balance: BalanceType, bank: BankType, oraclePrice: OraclePrice, lendrRequirementType: LendrRequirementType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeQuantity(balance: BalanceType, bank: BankType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeQuantityUi(balance: BalanceType, bank: BankType): {
+    assets: BigNumber;
+    liabilities: BigNumber;
+};
+declare function computeClaimedEmissions(balance: BalanceType, bank: BankType, currentTimestamp: number): BigNumber;
+declare function computeTotalOutstandingEmissions(balance: BalanceType, bank: BankType): BigNumber;
+declare function computeHealthCheckAccounts(balances: BalanceType[], banks: Map<string, BankType>, mandatoryBanks?: PublicKey[], excludedBanks?: PublicKey[]): BankType[];
+declare function computeHealthAccountMetas(banksToInclude: BankType[], bankMetadataMap?: BankMetadataMap, enableSorting?: boolean, bankExtendedMetadata?: BankExtendedMetadata): PublicKey[];
+
+declare function decodeAccountRaw(encoded: Buffer, idl: LendrIdlType): LendrAccountRaw;
+declare function parseBalanceRaw(balanceRaw: BalanceRaw): BalanceType;
+declare function parseLendrAccountRaw(lendrAccountPk: PublicKey, accountData: LendrAccountRaw): {
+    address: PublicKey;
+    group: PublicKey;
+    authority: PublicKey;
+    balances: Balance[];
+    accountFlags: AccountFlags[];
+    emissionsDestinationAccount: PublicKey;
+    healthCache: HealthCache;
+};
+/**
+ * Get all active account flags as an array of flag names
+ */
+declare function getActiveAccountFlags(flags: BN): AccountFlags[];
+/**
+ * Check if an account flag is set
+ */
+declare function hasAccountFlag(flags: BN, flag: number): boolean;
+/**
+ * Convert on-chain health cache flags (BN) to an array of HealthCacheFlags enum values
+ *
+ * According to the IDL, health cache flags are defined as:
+ * - HEALTHY = 1 (bit 0) - If set, the account cannot be liquidated
+ * - ENGINE_STATUS_OK = 2 (bit 1) - If set, the engine did not error during health calculation
+ * - ORACLE_OK = 4 (bit 2) - If set, the engine did not encounter oracle issues
+ */
+declare function getActiveHealthCacheFlags(flags: number): HealthCacheFlags[];
+/**
+ * Check if a health cache flag is set
+ */
+declare function hasHealthCacheFlag(flags: number, flag: HealthCacheFlags): boolean;
+/**
+ * Convert numeric health cache flags to a human-readable status message
+ */
+declare function getHealthCacheStatusDescription(flags: number): string;
+declare function dtoToLendrAccount(lendrAccountDto: LendrAccountTypeDto): LendrAccountType;
+declare function dtoToBalance(balanceDto: BalanceTypeDto): BalanceType;
+declare function dtoToHealthCache(healthCacheDto: HealthCacheTypeDto): HealthCacheType;
+
+declare function computeEmodeImpacts(emodePairs: EmodePair[], activeLiabilities: PublicKey[], activeCollateral: PublicKey[], allBanks: PublicKey[]): Record<string, ActionEmodeImpact>;
+declare function computeActiveEmodePairs(emodePairs: EmodePair[], activeLiabilities: PublicKey[], activeCollateral: PublicKey[]): EmodePair[];
+
+declare const fetchLendrAccountAddresses: (program: LendrProgram, authority: PublicKey, group: PublicKey) => Promise<PublicKey[]>;
+declare const fetchLendrAccountData: (program: LendrProgram, lendrAccountPk: PublicKey, bankMap: Map<string, Bank>, oraclePrices: Map<string, OraclePrice>, bankMetadataMap: BankMetadataMap) => Promise<{
+    lendrAccount: LendrAccountType;
+    error?: HealthCacheSimulationError;
+}>;
+
+/**
+ * Convert numeric flag to BN for Solana compatibility
+ */
+declare function accountFlagToBN(flag: AccountFlags): BN;
+declare function lendrAccountToDto(lendrAccount: LendrAccountType): LendrAccountTypeDto;
+declare function balanceToDto(balance: BalanceType): BalanceTypeDto;
+declare function healthCacheToDto(healthCache: HealthCacheType): HealthCacheTypeDto;
+
+interface FetchRawBanksArgs {
+    program: LendrProgram;
+    groupAddress: PublicKey;
+    logger: TLogger;
+    bankAddresses?: Array<PublicKey>;
+    commitment?: Commitment;
+}
+declare class DataFetcher {
+    fetchRawBanks({ program, groupAddress, logger, bankAddresses, commitment }: FetchRawBanksArgs): Promise<{
+        address: PublicKey;
+        data: BankRaw;
+    }[]>;
+}
+
+declare function makePoolConfigureBankIx$1(program: LendrProgram, bank: PublicKey, args: BankConfigOptRaw): Promise<InstructionsWrapper>;
+declare function makeAddPermissionlessStakedBankIx(program: LendrProgram, group: PublicKey, voteAccountAddress: PublicKey, feePayer: PublicKey, pythOracle: PublicKey): Promise<InstructionsWrapper>;
+declare function makePoolAddBankIx$1(program: LendrProgram, group: PublicKey, bank: PublicKey, feePayer: PublicKey, bankMint: PublicKey, bankConfig: BankConfigOpt, tokenProgram?: PublicKey, overrideOpt?: {
+    admin?: PublicKey;
+    globalFeeWallet?: PublicKey;
+}): Promise<InstructionsWrapper>;
+
+type LendrGroupType = {
+    admin: PublicKey;
+    address: PublicKey;
+};
+type LendrGroupTypeDto = {
+    admin: string;
+    address: string;
+};
+
+interface LendrGroupRaw {
+    admin: PublicKey;
+    padding0: BN[];
+    padding1: BN[];
+}
+
+declare function dtoToGroup(groupDto: LendrGroupTypeDto): LendrGroupType;
+
+declare function groupToDto(group: LendrGroupType): LendrGroupTypeDto;
+
+declare class DummyMetadataFetcher implements IMetadataFetcher {
+    readonly name = "DummyMetadataFetcher";
+    fetch(mints: Array<string>): Promise<Record<string, {
+        name: string;
+        symbol: string;
+        image: string;
+        uri?: string | undefined;
+    }>>;
+}
+
+type FogoNetworks = "mainnet" | "testnet";
+declare class FogoMetadataFetcher implements IMetadataFetcher {
+    network: FogoNetworks;
+    readonly name = "FogoMetadataFetcher";
+    constructor(network?: FogoNetworks);
+    fetch(mints: Array<string>): Promise<Record<string, {
+        name: string;
+        symbol: string;
+        image: string;
+        uri?: string | undefined;
+    }>>;
+}
+
+declare class MetaplexMetadataFetcher implements IMetadataFetcher {
+    readonly name = "MetaplexMetadataFetcher";
+    private readonly _umi;
+    constructor(rpcEndpoint: string);
+    fetch(mints: Array<string>): Promise<Record<string, {
+        name: string;
+        symbol: string;
+        image: string;
+        uri?: string | undefined;
+    }>>;
+    private _getImage;
+}
+
+type ValidatorStakeGroup = {
+    validator: PublicKey;
+    poolKey: PublicKey;
+    poolMintKey: PublicKey;
+    totalStake: number;
+    selectedAccount: {
+        pubkey: PublicKey;
+        amount: number;
+    };
+    accounts: {
+        pubkey: PublicKey;
+        amount: number;
+    }[];
+};
+type ValidatorStakeGroupDto = {
+    validator: string;
+    poolKey: string;
+    poolMintKey: string;
+    totalStake: number;
+    selectedAccount: {
+        pubkey: string;
+        amount: number;
+    };
+    accounts: {
+        pubkey: string;
+        amount: number;
+    }[];
+};
+type StakeAccount$1 = {
+    discriminant: number;
+    meta: {
+        rentExemptReserve: bigint;
+        authorized: {
+            staker: PublicKey;
+            withdrawer: PublicKey;
+        };
+        lockup: {
+            unixTimestamp: bigint;
+            epoch: bigint;
+            custodian: PublicKey;
+        };
+    };
+    stake: {
+        delegation: {
+            voterPubkey: PublicKey;
+            stake: bigint;
+            activationEpoch: bigint;
+            deactivationEpoch: bigint;
+        };
+        creditsObserved: bigint;
+    };
+};
+type StakePoolMevMap = Map<string, {
+    pool: number;
+    onramp: number;
+}>;
+type ValidatorRateData = {
+    validator: string;
+    totalApy: number;
+    stakingApy: number;
+};
+type ActiveStakePoolMap = Map<string, boolean>;
+
+declare function dtoToValidatorStakeGroup(validatorStakeGroupDto: ValidatorStakeGroupDto): ValidatorStakeGroup;
+
+/**
+ * Retrieves all active stake accounts associated with a given public key grouped by validator
+ *
+ * @warning this is an expensive rpc call and should be heavily cached
+ *
+ * @param connection - Solana RPC connection
+ * @param publicKey - Users's public key
+ * @param opts - Options for filtering inactive stake accounts
+ * @returns {Promise<ValidatorStakeGroup[]>} An array of validator stake groups
+ */
+declare const fetchNativeStakeAccounts: (connection: Connection, publicKey: PublicKey, opts?: {
+    filterInactive: boolean;
+}) => Promise<ValidatorStakeGroup[]>;
+/**
+ * Gets active states for stake pools associated with staked asset banks
+ *
+ * @param connection - Solana RPC connection
+ * @param bankInfos - Array of ExtendedBankInfo objects
+ * @returns Promise<Map<string, boolean>> - Map of bank addresses to active states
+ */
+declare const fetchStakePoolActiveStates: (connection: Connection, validatorVoteAccounts: PublicKey[]) => Promise<Map<string, boolean>>;
+/**
+ * Gets APY rates for validators associated with staked asset banks
+ *
+ * @param validatorVoteAccounts - Array of validator vote account public keys
+ * @returns Promise<Map<string, number>> - Map of bank addresses to APY rates
+ */
+declare const fetchStakeAccount: (data: Buffer) => StakeAccount$1;
+declare const fetchStakePoolMev: (connection: Connection, validatorVoteAccounts: PublicKey[]) => Promise<StakePoolMevMap>;
+
+declare function validatorStakeGroupToDto(validatorStakeGroup: ValidatorStakeGroup): ValidatorStakeGroupDto;
+
+interface RpcSimulateBundleTransactionResult {
+    err?: TransactionError;
+    logs: string[];
+    preExecutionAccounts?: any;
+    postExecutionAccounts?: any;
+    unitsConsumed?: string;
+    returnData?: any;
+}
+
+declare const DEFAULT_PROCESS_TX_OPTS: {
+    broadcastType: TransactionBroadcastType;
+    isSequentialTxs: boolean;
+    isReadOnly: boolean;
+};
+interface ProcessTransactionOpts extends ProcessTransactionsClientOpts {
+    isReadOnly?: boolean;
+    programId?: PublicKey;
+    bundleSimRpcEndpoint?: string;
+    addArenaTxTag?: boolean;
+}
+type PriorityFees = {
+    bundleTipUi?: number;
+    priorityFeeMicro?: number;
+    maxCapUi?: number;
+};
+type BroadcastMethodType = Extract<TransactionBroadcastType, "BUNDLE" | "RPC">;
+type SpecificBroadcastMethodType = "GRPC_BUNDLE" | "API_BUNDLE" | "RPC_BUNDLE" | "RPC_SEQUENTIAL";
+type SpecificBroadcastMethod = {
+    method: SpecificBroadcastMethodType;
+    broadcastType: BroadcastMethodType;
+};
+type ProcessTransactionStrategy = {
+    splitExecutionsStrategy?: {
+        singleTx: BroadcastMethodType;
+        multiTx: BroadcastMethodType;
+    };
+    fallbackSequence: SpecificBroadcastMethod[];
+};
+declare const DEFAULT_PROCESS_TX_STRATEGY: ProcessTransactionStrategy;
+interface ProcessTransactionsClientOpts extends PriorityFees {
+    broadcastType?: TransactionBroadcastType;
+    dynamicStrategy?: ProcessTransactionStrategy;
+    isSequentialTxs?: boolean;
+    addArenaTxTag?: boolean;
+    callback?: (index?: number, success?: boolean, signature?: string, stepsToAdvance?: number) => void;
+}
+type ProcessTransactionsProps = {
+    transactions: SolanaTransaction[];
+    connection: Connection;
+    wallet: Wallet;
+    txOpts?: TransactionOptions;
+    processOpts?: ProcessTransactionOpts;
+};
+/**
+ * Processes a batch of Solana transactions by signing, simulating, and sending them to the network.
+ *
+ * @param {ProcessTransactionsProps} props - The properties required to process transactions.
+ * @param {SolanaTransaction[]} props.transactions - The transactions to be processed.
+ * @param {Connection} props.connection - The connection to the Solana network.
+ * @param {Wallet} props.wallet - The wallet used to sign the transactions.
+ * @param {ProcessTransactionOpts} [props.processOpts] - Optional processing options.
+ * @param {TransactionOptions} [props.txOpts] - Optional transaction options.
+ *
+ * @returns {Promise<TransactionSignature[]>} - A promise that resolves to an array of transaction signatures.
+ *
+ * @throws {ProcessTransactionError} - Throws an error if transaction processing fails.
+ */
+declare function processTransactions({ transactions, connection, wallet, processOpts: processOptsArgs, txOpts, }: ProcessTransactionsProps): Promise<TransactionSignature[]>;
+declare const simulateTransactions: (processOpts: ProcessTransactionOpts, connection: Connection, solanaTransactions: VersionedTransaction[] | Transaction[] | SolanaTransaction[], confirmOpts?: ConfirmOptions, txOpts?: {
+    feePayer: PublicKey;
+    blockhash: string;
+}) => Promise<SimulatedTransactionResponse | RpcSimulateBundleTransactionResult[]>;
+declare function confirmTransaction(connection: Connection, signature: string, commitment?: Commitment): Promise<_solana_web3_js.SignatureStatus>;
+
+type BankMap = Map<string, Bank>;
+type OraclePriceMap = Map<string, OraclePrice>;
+type MintDataMap = Map<string, MintData>;
+type MintData = {
+    mint: PublicKey;
+    tokenProgram: PublicKey;
+    feeBps: number;
+    emissionTokenProgram: PublicKey | null;
+};
+type FetchGroupDataFn = (props: {
+    connection: Connection;
+    program: LendrProgram;
+    groupAddress: PublicKey;
+    logger?: TLogger;
+    commitment?: Commitment;
+    overrideBankAddresses?: PublicKey[];
+    overrideBanksMetadata?: BanksExtendedMetadataOverrideMap;
+    metadataService: MetadataService;
+    dataFetcher: DataFetcher;
+}) => Promise<{
+    lendrGroup: LendrGroup;
+    banks: Map<string, Bank>;
+    priceInfos: Map<string, OraclePrice>;
+    tokensData: Map<string, MintData>;
+    feedIdMap: PythPushFeedIdMap;
+    banksExtendedMetadata: BankExtendedMetadataMap;
+}>;
+type LendrClientOptions = {
+    confirmOpts?: ConfirmOptions;
+    readOnly?: boolean;
+    overrideBankAddresses?: PublicKey[];
+    overrideBanksMetadata?: BanksExtendedMetadataOverrideMap;
+    bundleSimRpcEndpoint?: string;
+    processTransactionStrategy?: ProcessTransactionStrategy;
+    fetchGroupDataOverride?: FetchGroupDataFn;
+    addressLookupTableAddresses?: PublicKey[];
+    logger?: TLogger;
+    storage?: Storage;
+    metadataFetchers?: Array<IMetadataFetcher>;
+    dataFetcher?: DataFetcher;
+};
+interface LendrClientFetchOptions {
+    wallet: Wallet;
+    connection: Connection;
+    clientOptions?: LendrClientOptions;
+    config?: LendrConfig;
+}
+interface LendrClientProps {
+    readonly config?: LendrConfig;
+    readonly program: LendrProgram;
+    readonly wallet: Wallet;
+    readonly isReadOnly: boolean;
+    group: LendrGroup;
+    banks: BankMap;
+    priceInfos: OraclePriceMap;
+    mintDatas: MintDataMap;
+    feedIdMap: PythPushFeedIdMap;
+    addressLookupTables?: AddressLookupTableAccount[];
+    processTransactionStrategy?: ProcessTransactionStrategy;
+    lookupTablesAddresses?: Array<PublicKey>;
+    readonly overrideBankAddresses?: PublicKey[];
+    readonly overrideBanksMetadata?: BanksExtendedMetadataOverrideMap;
+    readonly bankMetadataMap?: BankMetadataMap;
+    metadataService: MetadataService;
+    bundleSimRpcEndpoint?: string;
+    logger?: TLogger;
+    storage?: Storage;
+    dataFetcher?: DataFetcher;
+}
+/**
+ * Entrypoint to interact with the lendr contract.
+ */
+declare class LendrClient {
+    readonly program: LendrProgram;
+    readonly wallet: Wallet;
+    readonly config: LendrConfig;
+    readonly isReadOnly: boolean;
+    readonly logger: TLogger;
+    group: LendrGroup;
+    banks: BankMap;
+    oraclePrices: OraclePriceMap;
+    mintDatas: MintDataMap;
+    addressLookupTables: AddressLookupTableAccount[];
+    lookupTablesAddresses: PublicKey[];
+    feedIdMap: PythPushFeedIdMap;
+    processTransactionStrategy?: ProcessTransactionStrategy;
+    private readonly bundleSimRpcEndpoint;
+    bankMetadataMap?: BankMetadataMap;
+    readonly overrideBankAddresses?: Array<PublicKey>;
+    readonly overrideBanksMetadata?: BanksExtendedMetadataOverrideMap;
+    readonly metadataService: MetadataService;
+    readonly storage: Storage;
+    readonly dataFetcher: DataFetcher;
+    constructor({ program, wallet, config, isReadOnly, group, banks, priceInfos, mintDatas, addressLookupTables, feedIdMap, logger, bankMetadataMap, overrideBanksMetadata, overrideBankAddresses, bundleSimRpcEndpoint, processTransactionStrategy, lookupTablesAddresses, storage, metadataService, dataFetcher, }: LendrClientProps);
+    /**
+     * LendrClient factory
+     *
+     * Fetch account data according to the config and instantiate the corresponding LendrAccount.
+     *
+     * @param config lendr config
+     * @param wallet User wallet (used to pay fees and sign transactions)
+     * @param connection Solana web.js Connection object
+     * @param clientOptions optional client options
+     * @returns LendrClient instance
+     */
+    static fetch({ wallet, connection, clientOptions, config }: LendrClientFetchOptions): Promise<LendrClient>;
+    /**
+     * Fetches address lookup tables from the provided addresses
+     * @param connection The Solana connection
+     * @param addressLookupTableAddresses Optional array of address lookup table addresses to fetch
+     * @param logger Optional logger
+     * @returns Array of address lookup table accounts
+     */
+    private static fetchAddressLookupTables;
+    /**
+     * Fetches all data for a group, including banks and oracle prices
+     * NOTE: If bankAddresses not provided, this will make 2 RPC calls
+     * @param connection
+     * @param program The Lendr program
+     * @param groupAddress The address of the group
+     * @param logger Optional logger
+     * @param commitment Transaction commitment level
+     * @param overrideBankAddresses Optional list of bank addresses to fetch
+     * @param overrideBanksMetadata Optional bank metadata for overriding on-chain metadata
+     * @param metadataService Metadata service for fetching mint metadata
+     * @returns Lending group data, banks, and oracle prices
+     */
+    static fetchGroupData: FetchGroupDataFn;
+    reload(): Promise<void>;
+    get groupAddress(): PublicKey;
+    get provider(): AnchorProvider;
+    get programId(): PublicKey;
+    getAllLendrAccountPubkeys(): Promise<PublicKey[]>;
+    /**
+     * Fetches multiple lendr accounts based on an array of public keys using the getMultipleAccounts RPC call.
+     *
+     * @param pubkeys - The public keys of the lendr accounts to fetch.
+     * @returns An array of LendrAccountWrapper instances.
+     */
+    getMultipleLendrAccounts(pubkeys: PublicKey[]): Promise<LendrAccountWrapper[]>;
+    /**
+     * Retrieves the addresses of all lendr accounts in the underlying group.
+     *
+     * @returns Account addresses
+     */
+    getAllLendrAccountAddresses(): Promise<PublicKey[]>;
+    /**
+     * Retrieves all lendr accounts under the specified authority.
+     *
+     * @returns LendrAccount instances
+     */
+    getLendrAccountsForAuthority(authority?: Address): Promise<LendrAccountWrapper[]>;
+    /**
+     * Retrieves the addresses of all accounts owned by the lendr program.
+     *
+     * @returns Account addresses
+     */
+    getAllProgramAccountAddresses(_type: AccountType$1): Promise<PublicKey[]>;
+    getBankByPk(bankAddress: Address): Bank | null;
+    getBankByMint(mint: Address): Bank | null;
+    getBankByTokenSymbol(tokenSymbol: string): Bank | null;
+    getOraclePriceByBank(bankAddress: Address): OraclePrice | null;
+    /**
+     * Create transaction instruction to create a new lendr account under the authority of the user.
+     *
+     * @returns transaction instruction
+     */
+    makeCreateLendrAccountIx(lendrAccountPk: PublicKey): Promise<InstructionsWrapper>;
+    makeCreateLendrAccountWithSessionIx(session: EstablishedSessionState, accountIndex: number, thirdPartyId?: number): Promise<InstructionsWrapper>;
+    /**
+     * Create a new lendr account under the authority of the user.
+     *
+     * @param createOpts - Options for creating the account
+     * @param createOpts.newAccountKey - Optional public key to use for the new account. If not provided, a new keypair will be generated.
+     * @param processOpts - Options for processing the transaction
+     * @param txOpts - Transaction options
+     * @returns Object containing the transaction signature and the created LendrAccount instance
+     */
+    createLendrAccount(createOpts?: {
+        newAccountKey?: PublicKey | undefined;
+    }, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<LendrAccountWrapper>;
+    /**
+     * Create a new lendr account under the authority of the user using fogo session.
+     *
+     * @param session - Session object in Established state
+     * @param commitment - desired commitment level
+     * @param customAccountSeed - undefined/null/0 for canonical lendr account in a group; positive for multi-accounts.
+     *
+     * @returns Object containing the transaction signature and the created LendrAccount instance
+     */
+    createLendrAccountWithSession(session: EstablishedSessionState, commitment?: Commitment, accountIndex?: number, thirdPartyId?: number): Promise<{
+        account: LendrAccountWrapper | null;
+        accountPublicKey: PublicKey;
+        result: TransactionResult;
+    }>;
+    /**
+     * Create a transaction to initialize a new lendr account under the authority of the user.
+     *
+     * @param createOpts - Options for creating the account
+     * @param createOpts.newAccountKey - Optional public key to use for the new account. If not provided, a new keypair will be generated.
+     * @returns Transaction that can be used to create a new lendr account
+     */
+    createLendrAccountTx(createOpts?: {
+        accountKeypair?: Keypair;
+    }): Promise<SolanaTransaction>;
+    getLatestBlockHashForSure(): Promise<string>;
+    createVersionTransaction(instructions: TransactionInstruction[], payerKey: PublicKey, signers?: Array<Signer>, extraMetaData?: ExtendedTransactionProperties): Promise<VersionedTransaction>;
+    createLendrAccountWithSessionTx(session: EstablishedSessionState, accountIndex: number, thirdPartyId?: number): Promise<VersionedTransaction>;
+    /**
+     * Create transaction instruction to initialize a new group.
+     *
+     * @returns transaction instruction
+     */
+    makeCreateLendrGroupIx(lendrGroup: PublicKey): Promise<InstructionsWrapper>;
+    /**
+     * Initiates a new permissionless lendr bank under the authority of the user.
+     *
+     * @param {Object} params - The parameters for creating a permissionless bank.
+     * @param {PublicKey} params.mint - The public key of the mint for the bank.
+     * @param {BankConfigOpt} params.bankConfig - The configuration options for the bank.
+     * @param {PublicKey} params.group - The public key of the group to which the bank belongs.
+     * @param {PublicKey} params.admin - The public key of the admin who will have authority over the bank.
+     * @param {Keypair} [params.seed] - An optional keypair used as a seed for generating the bank account.
+     * @param {TransactionOptions} [params.txOpts] - Optional transaction options for processing.
+     * @param {ProcessTransactionsClientOpts} [params.processOpts] - Optional processing options for transactions.
+     * @returns {Promise<TransactionSignature>} A promise that resolves to the transaction signature as a string.
+     */
+    createPermissionlessBank({ mint, bankConfig, group: _group, admin, seed, txOpts, processOpts, }: {
+        mint: PublicKey;
+        bankConfig: BankConfigOpt;
+        group: PublicKey;
+        admin: PublicKey;
+        seed?: Keypair;
+        processOpts?: ProcessTransactionsClientOpts;
+        txOpts?: TransactionOptions;
+    }): Promise<TransactionSignature>;
+    /**
+     * Initializes a new lendr group with the specified parameters.
+     *
+     * @param seed - Optional keypair used for generating the group account.
+     * @param additionalIxs - Optional array of additional transaction instructions to include.
+     * @param txOpts - Optional transaction options for processing.
+     * @param processOpts - Optional processing options for transactions.
+     * @returns The public key of the newly created lendr group.
+     */
+    createLendrGroup(seed?: Keypair, additionalIxs?: TransactionInstruction[], processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<PublicKey>;
+    /**
+     * Create a new bank under the authority of the user.
+     *
+     * @param bankMint - The public key of the token mint for the bank.
+     * @param bankConfig - Configuration options for the bank.
+     * @param seed - Optional keypair for the bank.
+     * @param txOpts - Optional transaction options for processing.
+     * @param processOpts - Optional processing options for transactions.
+     * @returns The bank's public key and the transaction signature
+     */
+    createLendingPool(bankMint: PublicKey, bankConfig: BankConfigOpt, seed?: Keypair, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<{
+        bankAddress: PublicKey;
+        signature: TransactionSignature;
+    }>;
+    /**
+     * Processes multiple Solana transactions by signing and sending them to the network.
+     *
+     * @param {SolanaTransaction[]} transactions - An array of transactions to be processed.
+     * @param {ProcessTransactionsClientOpts} [processOpts] - Optional processing options for transactions.
+     * @param {TransactionOptions} [txOpts] - Optional transaction options for processing.
+     *
+     * @returns {Promise<TransactionSignature[]>} - A promise that resolves to an array of transaction signatures.
+     *
+     * @throws {ProcessTransactionError} - Throws an error if transaction processing fails.
+     */
+    processTransactions(transactions: SolanaTransaction[], processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature[]>;
+    /**
+     * Processes a single Solana transaction by signing and sending it to the network.
+     *
+     * @param {SolanaTransaction} transaction - The transaction to be processed.
+     * @param {TransactionOptions} [txOpts] - Optional transaction options.
+     * @param {ProcessTransactionsClientOpts} [processOpts] - Optional processing options.
+     *
+     * @returns {Promise<TransactionSignature>} - A promise that resolves to the transaction signature.
+     *
+     * @throws {ProcessTransactionError} - Throws an error if transaction processing fails.
+     */
+    processTransaction(transaction: SolanaTransaction, processOpts?: ProcessTransactionsClientOpts, txOpts?: TransactionOptions): Promise<TransactionSignature>;
+    simulateTransactions(transactions: (Transaction | VersionedTransaction)[], accountsToInspect: PublicKey[]): Promise<(Buffer | null)[]>;
+}
+
+declare function makeInitLendrAccountIx(ldProgram: LendrProgram, accounts: {
+    lendrGroup: PublicKey;
+    lendrAccount: PublicKey;
+    authority: PublicKey;
+    feePayer: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeInitLendrAccountWithSessionIx(ldProgram: LendrProgram, { lendrGroup, session, feePayer, }: {
+    lendrGroup: PublicKey;
+    session: EstablishedSessionState;
+    feePayer: PublicKey;
+}, accountIndex: number, thirdPartyId?: number): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeDepositIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    signerTokenAccount: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+    depositUpToLimit?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeDepositWithSessionIx(ldProgram: LendrProgram, accounts: LendingAccountDepositOrRepayWithSessionAccounts, args: {
+    amount: BN;
+    depositUpToLimit?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeRepayIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    signerTokenAccount: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+    repayAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeRepayWithSessionIx(ldProgram: LendrProgram, accounts: LendingAccountDepositOrRepayWithSessionAccounts, args: {
+    amount: BN;
+    repayAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeWithdrawIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    bankLiquidityVaultAuthority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+    withdrawAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeWithdrawWithSessionIx(ldProgram: LendrProgram, accounts: LendingAccountWithdrawOrBorrowWithSessionAccounts, args: {
+    amount: BN;
+    withdrawAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBorrowIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    bankLiquidityVaultAuthority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBorrowWithSessionIx(ldProgram: LendrProgram, accounts: LendingAccountWithdrawOrBorrowWithSessionAccounts, args: {
+    amount: BN;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeLendingAccountLiquidateIx(ldrProgram: LendrProgram, accounts: {
+    assetBank: PublicKey;
+    liabBank: PublicKey;
+    liquidatorLendrAccount: PublicKey;
+    liquidateeLendrAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    assetAmount: BN;
+    liquidateeAccounts: number;
+    liquidatorAccounts: number;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makelendingAccountWithdrawEmissionIx(ldrProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    destinationAccount: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    emissionsMint?: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePoolConfigureBankIx(ldrProgram: LendrProgram, accounts: {
+    bank: PublicKey;
+    group?: PublicKey;
+    admin?: PublicKey;
+}, args: {
+    bankConfigOpt: BankConfigOptRaw;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBeginFlashLoanIx(ldrProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    authority?: PublicKey;
+    ixsSysvar?: PublicKey;
+}, args: {
+    endIndex: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBeginFlashLoanWithSessionIx(ldrProgram: LendrProgram, accounts: {
+    sessionKey: PublicKey;
+    lendrAccount: PublicKey;
+    ixsSysvar?: PublicKey;
+}, args: {
+    endIndex: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeEndFlashLoanIx(ldrProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    authority?: PublicKey;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeEndFlashLoanWithSessionIx(ldrProgram: LendrProgram, accounts: {
+    sessionKey: PublicKey;
+    lendrAccount: PublicKey;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeGroupInitIx(ldProgram: LendrProgram, accounts: {
+    lendrGroup: PublicKey;
+    admin: PublicKey;
+}, args?: {
+    isArenaGroup?: boolean;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+/**
+ * Configure the oracle for a bank
+ * @param ldProgram The lendr program
+ * @param accounts The accounts required for this instruction
+ * @param args The oracle setup index and feed id
+ * @param remainingAccounts The remaining accounts required for this instruction, should include the feed oracle key
+ */
+declare function makeLendingPoolConfigureBankOracleIx(ldProgram: LendrProgram, accounts: {
+    bank: PublicKey;
+    group?: PublicKey;
+    admin?: PublicKey;
+}, args: {
+    /**
+     * The oracle setup index, see {@link serializeOracleSetupToIndex}
+     */
+    setup: number;
+    /**
+     * The oracle feed id
+     */
+    feedId: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction, should include the feed oracle key (non writable & signable)
+ */
+remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeLendingAccountSettleEmissionsIx(ldrProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    bank: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+/**
+ * Creates an instruction to add a permissionless staked bank to a lending pool.
+ * @param ldProgram - The lendr program instance
+ * @param accounts - The accounts required for this instruction
+ * @param remainingAccounts - The remaining accounts required for this instruction, including pythOracle, solPool and bankMint
+ * @param args - Optional arguments for this instruction
+ */
+declare function makePoolAddPermissionlessStakedBankIx(ldProgram: LendrProgram, accounts: {
+    stakedSettings: PublicKey;
+    feePayer: PublicKey;
+    bankMint: PublicKey;
+    solPool: PublicKey;
+    stakePool: PublicKey;
+    lendrGroup?: PublicKey;
+    /**
+     * The token program to use for this instruction, defaults to the SPL token program
+     */
+    tokenProgram?: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction. Should include:
+ * - pythOracle: The pyth oracle key (non writable & non signer)
+ * - solPool: The sol pool key (non writable & non signer)
+ * - bankMint: The bank mint key (non writable & non signer)
+ */
+remainingAccounts: AccountMeta[], args: {
+    /**
+     * The seed to use for the bank account. Defaults to 0 (new BN(0)).
+     * If the seed is not specified, the seed is set to 0, and the bank account
+     * will be created at the address {@link findPoolAddress} with the default
+     * bump.
+     */
+    seed?: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePoolAddBankIx(ldProgram: LendrProgram, accounts: {
+    lendrGroup: PublicKey;
+    feePayer: PublicKey;
+    bankMint: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    admin?: PublicKey;
+    globalFeeWallet?: PublicKey;
+}, args: {
+    bankConfig: BankConfigCompactRaw;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeCloseAccountIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+    feePayer: PublicKey;
+    authority?: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePulseHealthIx(ldProgram: LendrProgram, accounts: {
+    lendrAccount: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction. Should include:
+ * - For each balance the user has, pass bank and oracle: <bank1, oracle1, bank2, oracle2>
+ */
+remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare const instructions: {
+    makeDepositIx: typeof makeDepositIx;
+    makeDepositWithSessionIx: typeof makeDepositWithSessionIx;
+    makeRepayIx: typeof makeRepayIx;
+    makeRepayWithSessionIx: typeof makeRepayWithSessionIx;
+    makeWithdrawIx: typeof makeWithdrawIx;
+    makeWithdrawWithSessionIx: typeof makeWithdrawWithSessionIx;
+    makeBorrowIx: typeof makeBorrowIx;
+    makeBorrowWithSessionIx: typeof makeBorrowWithSessionIx;
+    makeInitLendrAccountIx: typeof makeInitLendrAccountIx;
+    makeInitLendrAccountWithSessionIx: typeof makeInitLendrAccountWithSessionIx;
+    makeLendingAccountLiquidateIx: typeof makeLendingAccountLiquidateIx;
+    makelendingAccountWithdrawEmissionIx: typeof makelendingAccountWithdrawEmissionIx;
+    makePoolAddBankIx: typeof makePoolAddBankIx;
+    makePoolConfigureBankIx: typeof makePoolConfigureBankIx;
+    makeBeginFlashLoanIx: typeof makeBeginFlashLoanIx;
+    makeBeginFlashLoanWithSessionIx: typeof makeBeginFlashLoanWithSessionIx;
+    makeEndFlashLoanIx: typeof makeEndFlashLoanIx;
+    makeEndFlashLoanWithSessionIx: typeof makeEndFlashLoanWithSessionIx;
+    makeGroupInitIx: typeof makeGroupInitIx;
+    makeCloseAccountIx: typeof makeCloseAccountIx;
+    makePoolAddPermissionlessStakedBankIx: typeof makePoolAddPermissionlessStakedBankIx;
+    makeLendingPoolConfigureBankOracleIx: typeof makeLendingPoolConfigureBankOracleIx;
+    makePulseHealthIx: typeof makePulseHealthIx;
+    makeLendingAccountSettleEmissionsIx: typeof makeLendingAccountSettleEmissionsIx;
+};
+
+declare function getConfig({ environment, overrides, }?: {
+    environment?: Environment;
+    overrides?: Partial<Omit<LendrConfig, "environment">>;
+}): LendrConfig;
+
+declare const PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED: Buffer<ArrayBuffer>;
+declare const PDA_BANK_INSURANCE_VAULT_AUTH_SEED: Buffer<ArrayBuffer>;
+declare const PDA_BANK_FEE_VAULT_AUTH_SEED: Buffer<ArrayBuffer>;
+declare const PDA_BANK_LIQUIDITY_VAULT_SEED: Buffer<ArrayBuffer>;
+declare const PDA_BANK_INSURANCE_VAULT_SEED: Buffer<ArrayBuffer>;
+declare const PDA_BANK_FEE_VAULT_SEED: Buffer<ArrayBuffer>;
+
+declare const DEFAULT_COMMITMENT: Commitment;
+declare const DEFAULT_SEND_OPTS: SendOptions;
+declare const DEFAULT_CONFIRM_OPTS: ConfirmOptions;
+declare const MAX_TX_SIZE = 1232;
+declare const MAX_ACCOUNT_KEYS = 64;
+declare const BUNDLE_TX_SIZE = 81;
+declare const PRIORITY_TX_SIZE = 44;
+declare const SKIP_SIMULATION = false;
+declare const DEFAULT_ORACLE_MAX_AGE = 60;
+
+declare const DISABLED_FLAG: number;
+declare const FLASHLOAN_ENABLED_FLAG: number;
+declare const TRANSFER_ACCOUNT_AUTHORITY_FLAG: number;
+
+declare const HOURS_PER_YEAR: number;
+declare const MAX_U64: string;
+declare const PYTH_PRICE_CONF_INTERVALS: BigNumber;
+declare const SWB_PRICE_CONF_INTERVALS: BigNumber;
+declare const MAX_CONFIDENCE_INTERVAL_RATIO: BigNumber;
+declare const PYTH_PUSH_ORACLE_ID: PublicKey;
+declare const GROUP_PK: PublicKey;
+declare const PROGRAM_ID: PublicKey;
+declare const DEFAULT_CLUSTER: string;
+
+declare const LUT_PROGRAM_AUTHORITY_INDEX = 5;
+declare const JUPITER_V6_PROGRAM: PublicKey;
+declare const LENDR_PROGRAM: PublicKey;
+declare const SINGLE_POOL_PROGRAM_ID: PublicKey;
+declare const STAKE_PROGRAM_ID: PublicKey;
+declare const MPL_METADATA_PROGRAM_ID: PublicKey;
+declare const SYSTEM_PROGRAM_ID: PublicKey;
+declare const SYSVAR_RENT_ID: PublicKey;
+declare const SYSVAR_CLOCK_ID: PublicKey;
+declare const SYSVAR_STAKE_HISTORY_ID: PublicKey;
+declare const STAKE_CONFIG_ID: PublicKey;
+
+declare const WSOL_MINT: PublicKey;
+declare const WSOL_EXTENDED_METADATA: BankExtendedMetadata;
+declare const LST_MINT: PublicKey;
+declare const USDC_MINT: PublicKey;
+declare const DUMMY_USDC_MINT: PublicKey;
+declare const USDC_DECIMALS = 6;
+
+declare enum ProcessTransactionErrorType {
+    TransactionBuildingError = 0,
+    TransactionSendingError = 1,
+    SimulationError = 2,
+    TransactionTupleError = 3,
+    FallthroughError = 4,
+    TimeoutError = 5
+}
+declare class ProcessTransactionError extends Error {
+    logs?: string[];
+    type: ProcessTransactionErrorType;
+    programId?: string;
+    failedTxs?: SolanaTransaction[];
+    _error?: Error;
+    constructor({ message, type, logs, programId, code: _code, failedTxs, _error, }: {
+        message: string;
+        type: ProcessTransactionErrorType;
+        logs?: string[];
+        programId?: string;
+        code?: number;
+        failedTxs?: SolanaTransaction[];
+        _error?: Error;
+    });
+    static withFailedTransactions(error: ProcessTransactionError, failedTxs: SolanaTransaction[]): ProcessTransactionError;
+}
+interface ProgramError {
+    programId: string;
+    code: number;
+}
+interface ProgramErrorWithDescription extends ProgramError {
+    description: string;
+}
+declare function parseTransactionError(error: any, ldrProgramId: PublicKey): {
+    programId: any;
+    type: any;
+    description: any;
+    code: any;
+};
+declare function parseErrorFromLogs(logs: string[], ldrProgramId: PublicKey): ProgramErrorWithDescription | null;
+
+/** Number of slots that can pass before a publisher's price is no longer included in the aggregate. */
+declare const MAX_SLOT_DIFFERENCE = 25;
+interface Price {
+    priceComponent: bigint;
+    price: number;
+    confidenceComponent: bigint;
+    confidence: number;
+    status: PriceStatus;
+    corporateAction: CorpAction;
+    publishSlot: number;
+}
+declare enum PriceStatus {
+    Unknown = 0,
+    Trading = 1,
+    Halted = 2,
+    Auction = 3,
+    Ignored = 4
+}
+declare enum CorpAction {
+    NoCorpAct = 0
+}
+interface PriceData extends Base {
+    priceType: PriceType;
+    exponent: number;
+    numComponentPrices: number;
+    numQuoters: number;
+    lastSlot: bigint;
+    validSlot: bigint;
+    emaPrice: Ema;
+    emaConfidence: Ema;
+    timestamp: bigint;
+    minPublishers: number;
+    drv2: number;
+    drv3: number;
+    drv4: number;
+    productAccountKey: PublicKey;
+    nextPriceAccountKey: PublicKey | null;
+    previousSlot: bigint;
+    previousPriceComponent: bigint;
+    previousPrice: number;
+    previousConfidenceComponent: bigint;
+    previousConfidence: number;
+    previousTimestamp: bigint;
+    priceComponents: PriceComponent[];
+    aggregate: Price;
+    price: number | undefined;
+    confidence: number | undefined;
+    status: PriceStatus;
+}
+interface Base {
+    magic: number;
+    version: number;
+    type: AccountType;
+    size: number;
+}
+declare enum AccountType {
+    Unknown = 0,
+    Mapping = 1,
+    Product = 2,
+    Price = 3,
+    Test = 4,
+    Permission = 5
+}
+declare enum PriceType {
+    Unknown = 0,
+    Price = 1
+}
+/**
+ * valueComponent = numerator / denominator
+ * value = valueComponent * 10 ^ exponent (from PriceData)
+ */
+interface Ema {
+    valueComponent: bigint;
+    value: number;
+    numerator: bigint;
+    denominator: bigint;
+}
+interface PriceComponent {
+    publisher: PublicKey;
+    aggregate: Price;
+    latest: Price;
+}
+declare const parsePriceData: (data: Buffer, currentSlot?: number) => PriceData;
+
+type PriceUpdateV2 = {
+    writeAuthority: Buffer;
+    verificationLevel: number;
+    priceMessage: {
+        feedId: Buffer;
+        price: bigint;
+        conf: bigint;
+        exponent: number;
+        publishTime: bigint;
+        prevPublishTime: bigint;
+        emaPrice: bigint;
+        emaConf: bigint;
+    };
+};
+declare const parsePriceInfo: (data: Buffer) => PriceUpdateV2;
+
+/**
+ * Parsed content of an on-chain StakeAccount
+ *
+ * Copied from https://github.com/solana-developers/solana-rpc-get-stake-activation/blob/main/web3js-1.0/src/stake.ts
+ * */
+type StakeAccount = {
+    discriminant: bigint;
+    meta: {
+        rentExemptReserve: bigint;
+        authorized: {
+            staker: PublicKey;
+            withdrawer: PublicKey;
+        };
+        lockup: {
+            unixTimestamp: bigint;
+            epoch: bigint;
+            custodian: PublicKey;
+        };
+    };
+    stake: {
+        delegation: {
+            voterPubkey: PublicKey;
+            stake: bigint;
+            activationEpoch: bigint;
+            deactivationEpoch: bigint;
+        };
+        creditsObserved: bigint;
+    };
+};
+/**
+ * Decode a StakeAccount from parsed account data.
+ *
+ * Copied from https://github.com/solana-developers/solana-rpc-get-stake-activation/blob/main/web3js-1.0/src/stake.ts
+ * */
+declare const getStakeAccount: (data: Buffer) => StakeAccount;
+
+declare const SinglePoolInstruction: {
+    initializePool: (voteAccount: PublicKey) => TransactionInstruction;
+    initializeOnRamp: (pool: PublicKey) => TransactionInstruction;
+    depositStake: (pool: PublicKey, userStakeAccount: PublicKey, userTokenAccount: PublicKey, userLamportAccount: PublicKey) => Promise<TransactionInstruction>;
+    withdrawStake: (pool: PublicKey, userStakeAccount: PublicKey, userStakeAuthority: PublicKey, userTokenAccount: PublicKey, tokenAmount: BigNumber) => Promise<TransactionInstruction>;
+    createTokenMetadata: (pool: PublicKey, payer: PublicKey) => Promise<TransactionInstruction>;
+    updateTokenMetadata: (voteAccount: PublicKey, authorizedWithdrawer: PublicKey, tokenName: string, tokenSymbol: string, tokenUri?: string) => Promise<TransactionInstruction>;
+};
+declare const findPoolMintAddressByVoteAccount: (voteAccountAddress: PublicKey) => PublicKey;
+declare const findPoolAddress: (voteAccountAddress: PublicKey) => PublicKey;
+declare const findPoolMintAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findPoolStakeAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findPoolStakeAuthorityAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findPoolMintAuthorityAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findPoolMplAuthorityAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findPoolOnRampAddress: (poolAddress: PublicKey) => PublicKey;
+declare const findMplMetadataAddress: (poolMintAddress: PublicKey) => Promise<PublicKey>;
+declare function initializeStakedPoolTx(connection: Connection, payer: PublicKey, voteAccountAddress: PublicKey): Promise<Transaction>;
+declare function initializeStakedPoolIxs(connection: Connection, payer: PublicKey, voteAccountAddress: PublicKey): Promise<TransactionInstruction[]>;
+declare const createAccountIx: (from: PublicKey, newAccount: PublicKey, lamports: number, space: number, programAddress: PublicKey) => TransactionInstruction;
+declare const createPoolOnrampIx: (voteAccount: PublicKey) => TransactionInstruction;
+declare const replenishPoolIx: (voteAccount: PublicKey) => TransactionInstruction;
+
+declare class Account {
+    program: any;
+    publicKey: any;
+    /**
+     * Account constructor
+     * @param program SwitchboardProgram
+     * @param publicKey PublicKey of the on-chain resource
+     */
+    constructor(program: any, publicKey: anchor.web3.PublicKey);
+}
+
+declare class AggregatorAccount extends Account {
+    static decodeLatestValue(aggregator: {
+        latestConfirmedRound: {
+            numSuccess: any;
+            result: {
+                toBig: () => any;
+            };
+        };
+    }): any;
+}
+
+declare class AggregatorAccountData {
+    /** Name of the aggregator to store on-chain. */
+    name: any;
+    /** Metadata of the aggregator to store on-chain. */
+    metadata: any;
+    /** Reserved. */
+    reserved1: any;
+    /** Pubkey of the queue the aggregator belongs to. */
+    queuePubkey: any;
+    /**
+     * CONFIGS
+     * Number of oracles assigned to an update request.
+     */
+    oracleRequestBatchSize: any;
+    /** Minimum number of oracle responses required before a round is validated. */
+    minOracleResults: any;
+    /** Minimum number of job results before an oracle accepts a result. */
+    minJobResults: any;
+    /** Minimum number of seconds required between aggregator rounds. */
+    minUpdateDelaySeconds: any;
+    /** Unix timestamp for which no feed update will occur before. */
+    startAfter: any;
+    /** Change percentage required between a previous round and the current round. If variance percentage is not met, reject new oracle responses. */
+    varianceThreshold: any;
+    /** Number of seconds for which, even if the variance threshold is not passed, accept new responses from oracles. */
+    forceReportPeriod: any;
+    /** Timestamp when the feed is no longer needed. */
+    expiration: any;
+    /** Counter for the number of consecutive failures before a feed is removed from a queue. If set to 0, failed feeds will remain on the queue. */
+    consecutiveFailureCount: any;
+    /** Timestamp when the next update request will be available. */
+    nextAllowedUpdateTime: any;
+    /** Flag for whether an aggregators configuration is locked for editing. */
+    isLocked: any;
+    /** Optional, public key of the crank the aggregator is currently using. Event based feeds do not need a crank. */
+    crankPubkey: any;
+    /** Latest confirmed update request result that has been accepted as valid. */
+    latestConfirmedRound: any;
+    /** Oracle results from the current round of update request that has not been accepted as valid yet. */
+    currentRound: any;
+    /** List of public keys containing the job definitions for how data is sourced off-chain by oracles. */
+    jobPubkeysData: any;
+    /** Used to protect against malicious RPC nodes providing incorrect task definitions to oracles before fulfillment. */
+    jobHashes: any;
+    /** Number of jobs assigned to an oracle. */
+    jobPubkeysSize: any;
+    /** Used to protect against malicious RPC nodes providing incorrect task definitions to oracles before fulfillment. */
+    jobsChecksum: any;
+    /** The account delegated as the authority for making account changes. */
+    authority: any;
+    /** Optional, public key of a history buffer account storing the last N accepted results and their timestamps. */
+    historyBuffer: any;
+    /** The previous confirmed round result. */
+    previousConfirmedRoundResult: any;
+    /** The slot when the previous confirmed round was opened. */
+    previousConfirmedRoundSlot: any;
+    /** Whether an aggregator is permitted to join a crank. */
+    disableCrank: any;
+    /** Job weights used for the weighted median of the aggregator's assigned job accounts. */
+    jobWeights: any;
+    /** Unix timestamp when the feed was created. */
+    creationTimestamp: any;
+    /**
+     * Use sliding window or round based resolution
+     * NOTE: This changes result propogation in latest_round_result
+     */
+    resolutionMode: any;
+    basePriorityFee: any;
+    priorityFeeBump: any;
+    priorityFeeBumpPeriod: any;
+    maxPriorityFeeMultiplier: any;
+    /** Reserved for future info. */
+    ebuf: any;
+    static discriminator: Buffer<ArrayBuffer>;
+    static layout: any;
+    constructor(fields: any);
+    static decode(data: any): AggregatorAccountData;
+}
+
+declare const SWITCHBOARD_ONDEMANDE_PRICE_PRECISION = 18;
+interface CurrentResult {
+    value: BN;
+    std_dev: BN;
+    mean: BN;
+    range: BN;
+    min_value: BN;
+    max_vaalue: BN;
+    slot: BN;
+    min_slot: BN;
+    max_slot: BN;
+}
+interface OracleSubmission {
+    oracle: PublicKey;
+    slot: BN;
+    value: BN;
+}
+interface PullFeedAccountData {
+    submissions: OracleSubmission[];
+    authority: PublicKey;
+    queue: PublicKey;
+    feed_hash: Buffer;
+    initialized_at: BN;
+    permissions: BN;
+    max_variance: BN;
+    min_responses: number;
+    name: Buffer;
+    sample_size: number;
+    last_update_timestamp: BN;
+    lut_slot: BN;
+    result: CurrentResult;
+    max_staleness: number;
+    min_sample_size: number;
+}
+type CrossbarSimulatePayload = FeedResponse[];
+interface FeedResponse {
+    feedHash: string;
+    results: number[];
+}
+declare const switchboardAccountCoder: BorshCoder<string, string>;
+declare function getSwitchboardProgram(provider: Provider): Program$1;
+declare function decodeSwitchboardPullFeedData(data: Buffer): PullFeedAccountData;
+
+type index_AccountType = AccountType;
+declare const index_AccountType: typeof AccountType;
+type index_AggregatorAccount = AggregatorAccount;
+declare const index_AggregatorAccount: typeof AggregatorAccount;
+type index_AggregatorAccountData = AggregatorAccountData;
+declare const index_AggregatorAccountData: typeof AggregatorAccountData;
+type index_Base = Base;
+type index_CorpAction = CorpAction;
+declare const index_CorpAction: typeof CorpAction;
+type index_CrossbarSimulatePayload = CrossbarSimulatePayload;
+type index_CurrentResult = CurrentResult;
+type index_Ema = Ema;
+type index_FeedResponse = FeedResponse;
+declare const index_MAX_SLOT_DIFFERENCE: typeof MAX_SLOT_DIFFERENCE;
+type index_OracleSubmission = OracleSubmission;
+type index_Price = Price;
+type index_PriceComponent = PriceComponent;
+type index_PriceData = PriceData;
+type index_PriceStatus = PriceStatus;
+declare const index_PriceStatus: typeof PriceStatus;
+type index_PriceType = PriceType;
+declare const index_PriceType: typeof PriceType;
+type index_PullFeedAccountData = PullFeedAccountData;
+declare const index_SWITCHBOARD_ONDEMANDE_PRICE_PRECISION: typeof SWITCHBOARD_ONDEMANDE_PRICE_PRECISION;
+declare const index_SinglePoolInstruction: typeof SinglePoolInstruction;
+type index_StakeAccount = StakeAccount;
+declare const index_createAccountIx: typeof createAccountIx;
+declare const index_createPoolOnrampIx: typeof createPoolOnrampIx;
+declare const index_decodeSwitchboardPullFeedData: typeof decodeSwitchboardPullFeedData;
+declare const index_findMplMetadataAddress: typeof findMplMetadataAddress;
+declare const index_findPoolAddress: typeof findPoolAddress;
+declare const index_findPoolMintAddress: typeof findPoolMintAddress;
+declare const index_findPoolMintAddressByVoteAccount: typeof findPoolMintAddressByVoteAccount;
+declare const index_findPoolMintAuthorityAddress: typeof findPoolMintAuthorityAddress;
+declare const index_findPoolMplAuthorityAddress: typeof findPoolMplAuthorityAddress;
+declare const index_findPoolOnRampAddress: typeof findPoolOnRampAddress;
+declare const index_findPoolStakeAddress: typeof findPoolStakeAddress;
+declare const index_findPoolStakeAuthorityAddress: typeof findPoolStakeAuthorityAddress;
+declare const index_getStakeAccount: typeof getStakeAccount;
+declare const index_getSwitchboardProgram: typeof getSwitchboardProgram;
+declare const index_initializeStakedPoolIxs: typeof initializeStakedPoolIxs;
+declare const index_initializeStakedPoolTx: typeof initializeStakedPoolTx;
+declare const index_parsePriceData: typeof parsePriceData;
+declare const index_parsePriceInfo: typeof parsePriceInfo;
+declare const index_replenishPoolIx: typeof replenishPoolIx;
+declare const index_switchboardAccountCoder: typeof switchboardAccountCoder;
+declare namespace index {
+  export { index_AccountType as AccountType, index_AggregatorAccount as AggregatorAccount, index_AggregatorAccountData as AggregatorAccountData, type index_Base as Base, index_CorpAction as CorpAction, type index_CrossbarSimulatePayload as CrossbarSimulatePayload, type index_CurrentResult as CurrentResult, type index_Ema as Ema, type index_FeedResponse as FeedResponse, index_MAX_SLOT_DIFFERENCE as MAX_SLOT_DIFFERENCE, type index_OracleSubmission as OracleSubmission, type index_Price as Price, type index_PriceComponent as PriceComponent, type index_PriceData as PriceData, index_PriceStatus as PriceStatus, index_PriceType as PriceType, type index_PullFeedAccountData as PullFeedAccountData, index_SWITCHBOARD_ONDEMANDE_PRICE_PRECISION as SWITCHBOARD_ONDEMANDE_PRICE_PRECISION, index_SinglePoolInstruction as SinglePoolInstruction, type index_StakeAccount as StakeAccount, index_createAccountIx as createAccountIx, index_createPoolOnrampIx as createPoolOnrampIx, index_decodeSwitchboardPullFeedData as decodeSwitchboardPullFeedData, index_findMplMetadataAddress as findMplMetadataAddress, index_findPoolAddress as findPoolAddress, index_findPoolMintAddress as findPoolMintAddress, index_findPoolMintAddressByVoteAccount as findPoolMintAddressByVoteAccount, index_findPoolMintAuthorityAddress as findPoolMintAuthorityAddress, index_findPoolMplAuthorityAddress as findPoolMplAuthorityAddress, index_findPoolOnRampAddress as findPoolOnRampAddress, index_findPoolStakeAddress as findPoolStakeAddress, index_findPoolStakeAuthorityAddress as findPoolStakeAuthorityAddress, index_getStakeAccount as getStakeAccount, index_getSwitchboardProgram as getSwitchboardProgram, index_initializeStakedPoolIxs as initializeStakedPoolIxs, index_initializeStakedPoolTx as initializeStakedPoolTx, index_parsePriceData as parsePriceData, index_parsePriceInfo as parsePriceInfo, index_replenishPoolIx as replenishPoolIx, index_switchboardAccountCoder as switchboardAccountCoder };
+}
+
+export { AccountFlags, AccountType$1 as AccountType, type ActionEmodeImpact, type ActiveEmodePair, type ActiveStakePoolMap, AssetTag, BUNDLE_TX_SIZE, Balance, type BalanceRaw, type BalanceType, type BalanceTypeDto, Bank, BankConfig, type BankConfigCompactRaw, type BankConfigDto, BankConfigFlag, type BankConfigOpt, type BankConfigOptRaw, type BankConfigRaw, type BankConfigRawDto, type BankConfigType, type BankMap, type BankMetadataRaw, type BankRaw, type BankRawDto, type BankType, type BankTypeDto, BankVaultType, type BroadcastMethodType, DEFAULT_CLUSTER, DEFAULT_COMMITMENT, DEFAULT_CONFIRM_OPTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_PROCESS_TX_OPTS, DEFAULT_PROCESS_TX_STRATEGY, DEFAULT_SEND_OPTS, DISABLED_FLAG, DUMMY_USDC_MINT, DataFetcher, DummyMetadataFetcher, type EmodeConfigRaw, type EmodeConfigRawDto, type EmodeEntry, type EmodeEntryDto, EmodeEntryFlags, EmodeFlags, type EmodeImpact, EmodeImpactStatus, type EmodePair, EmodeSettings, type EmodeSettingsDto, type EmodeSettingsRaw, type EmodeSettingsRawDto, type EmodeSettingsType, EmodeTag, Environment, FLASHLOAN_ENABLED_FLAG, type FetchGroupDataFn, type FetchRawBanksArgs, type FlashLoanArgs, type FlashloanActionResult, FogoMetadataFetcher, GROUP_PK, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, type HealthCacheRaw, HealthCacheSimulationError, type HealthCacheType, type HealthCacheTypeDto, IMetadataFetcher, type InterestRateConfig, type InterestRateConfigCompactRaw, type InterestRateConfigDto, type InterestRateConfigOpt, type InterestRateConfigOptRaw, type InterestRateConfigRaw, JUPITER_V6_PROGRAM, LENDR_PROGRAM, LENDR_SPONSORED_SHARD_ID, LST_MINT, LUT_PROGRAM_AUTHORITY_INDEX, LendingAccountDepositOrRepayWithSessionAccounts, LendingAccountWithdrawOrBorrowWithSessionAccounts, LendrAccount, type LendrAccountRaw, type LendrAccountType, type LendrAccountTypeDto, LendrAccountWrapper, LendrClient, type LendrClientFetchOptions, type LendrClientOptions, type LendrClientProps, LendrConfig, LendrGroup, type LendrGroupRaw, type LendrGroupType, type LendrGroupTypeDto, LendrIdlType, LendrProgram, LendrRequirementType, type LendrRequirementTypeRaw, type LoopProps, type LoopTxProps, MAX_ACCOUNT_KEYS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, type MakeBorrowIxOpts, type MakeBorrowWithSessionIxOpts, type MakeDepositIxOpts, type MakeDepositWithSessionIxOpts, type MakeRepayIxOpts, type MakeRepayWithSessionIxOpts, type MakeWithdrawIxOpts, type MakeWithdrawWithSessionIxOpts, MetadataService, MetaplexMetadataFetcher, type MintData, type MintDataMap, OperationalState, type OperationalStateRaw, type OracleConfigOpt, type OracleConfigOptRaw, type OraclePrice, type OraclePriceDto, type OraclePriceMap, OracleSetup, type OracleSetupRaw, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PRIORITY_TX_SIZE, PROGRAM_ID, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, type PriceWithConfidence, type PriceWithConfidenceDto, type PriorityFees, ProcessTransactionError, ProcessTransactionErrorType, type ProcessTransactionOpts, type ProcessTransactionStrategy, type ProcessTransactionsClientOpts, type ProgramError, type ProgramErrorWithDescription, type PythPushFeedIdMap, type RatePoint, type RatePointDto, type RatePointRaw, type RepayWithCollateralProps, type RepayWithCollateralTxProps, RiskTier, type RiskTierRaw, SINGLE_POOL_PROGRAM_ID, SKIP_SIMULATION, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, type SimulationResult, type SpecificBroadcastMethod, type SpecificBroadcastMethodType, type StakeAccount$1 as StakeAccount, type StakePoolMevMap, type SupportedOracleSetup, TLogger, TRANSFER_ACCOUNT_AUTHORITY_FLAG, type TransactionBuilderResult, USDC_DECIMALS, USDC_MINT, type ValidatorRateData, type ValidatorStakeGroup, type ValidatorStakeGroupDto, WSOL_EXTENDED_METADATA, WSOL_MINT, accountFlagToBN, addOracleToBanksIx, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankRawToDto, buildFeedIdMap, computeAccountValue, computeActiveEmodePairs, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeEmodeImpacts, computeFreeCollateral, computeFreeCollateralLegacy, computeHealthAccountMetas, computeHealthCheckAccounts, computeHealthComponents, computeHealthComponentsLegacy, computeHealthComponentsWithoutBiasLegacy, computeInterestRates, computeLiabilityUsdValue, computeLoopingParams, computeMaxLeverage, computeNetApy, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, confirmTransaction, crankPythOracleIx, createLendrAccountTx, createUpdateFeedIx, decodeAccountRaw, decodeBankRaw, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToLendrAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, feedIdToString, fetchLendrAccountAddresses, fetchLendrAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchPythOracleData, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleData, findOracleKey, findPythPushOracleAddress, freezeBankConfigIx, getActiveAccountFlags, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getActiveStaleBanks, getAssetQuantity, getAssetShares, getAssetWeight, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getConfig, getConfigPda, getHealthCacheStatusDescription, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getPrice, getPriceFeedAccountForProgram, getPriceWithConfidence, getTotalAssetQuantity, getTotalLiabilityQuantity, getTreasuryPda, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, instructions, isOracleSetupSupported, isWeightedPrice, lendrAccountToDto, makeAddPermissionlessStakedBankIx, makeBundleTipIx, makePoolAddBankIx$1 as makePoolAddBankIx, makePoolConfigureBankIx$1 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx$1 as makePulseHealthIx, makeTxPriorityIx, makeUnwrapSolIx, makeVersionedTransaction, makeWrapSolIxs, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseErrorFromLogs, parseLendrAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseTransactionError, processTransactions, serializeBankConfigOpt, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateTransactions, toBankConfigDto, toBankDto, toEmodeSettingsDto, toInterestRateConfigDto, validatorStakeGroupToDto, index as vendor };