import type { Transaction } from "@sovereign-sdk/types";
import { type Authenticator, type SolanaSignableRollup, type TransactionResult } from "@sovereign-sdk/web3";
export type { Authenticator };
import Decimal from "decimal.js";
import type { EquityType, MarginType } from "./bullet-wasm";
import { type Endpoints } from "./constants";
import type { Orderbook } from "./orderbook";
import type { RuntimeCall } from "./rollupTypes";
import type { Address, AdminType, AssetId, AssetName, FeeTier, MarketId, MarketMetadata, MarketName, MarkPriceUpdateArgs, Network, NewOrderArgs, NewTwapOrderArgs, OraclePriceUpdateArgs, OrderType, Side, SpotCollateralTransferDirection, TokenId, TpslPair } from "./types";
import type { Wallet } from "./wallet";
import { WebSocketManager } from "./websocket";
import { type AccountAddresses, type BorrowLendPool, type OrderbookL2, type PerpMarketConfig, type SpotMarketConfig, type UserAccount, type VersionedExchangeAssets, type VersionedExchangeInfo, type VersionedExecutionIds, type VersionedPerpMarket, type VersionedRiskEngine, type VersionedSpotMarket, type VersionedUserAccountConfig } from "./zod-types/rest";
export interface TransactionOpts {
    /**
     * Maximum priority fee in basis points.
     * @default 0
     */
    maxPriorityFeeBps?: number;
    /**
     * Maximum fee for the transaction.
     * @default "10000000000"
     */
    maxFee?: string;
    /**
     * Gas limit for the transaction.
     * @default null
     */
    gasLimit?: number[] | null;
    /**
     * The authenticator scheme for this client. Set once at construction time
     * and used for all subsequent transactions — cannot be overridden per-call.
     *
     * This also determines how Decimal values are serialized:
     * - Solana authenticators use serde (string format, e.g. "10000")
     * - Standard authenticator uses Borsh (SurrogateDecimal { flags, hi, lo, mid })
     *
     * Options:
     *
     * - "solanaAuto": Auto-detect based on signer type (recommended for Solana wallets)
     *   - Uses "solana" for LedgerSolanaSigner (with preamble)
     *   - Uses "solanaSimple" for other Solana signers (no preamble)
     *
     * - "solanaSimple": For browser wallets (Phantom, Solflare, etc.) - no preamble
     *   - Signs raw JSON bytes directly
     *   - Smaller message size
     *
     * - "solana": For Ledger hardware wallets - with preamble
     *   - Adds 85-byte preamble required by Ledger's signOffchainMessage API
     *   - Provides metadata for Ledger's display
     *
     * - "standard": Standard Sovereign SDK authentication (not Solana off-chain)
     *   - Uses the rollup's native authentication scheme
     *   - For non-Solana wallets or when you need standard SDK auth
     *   - Uses "/sequencer/txs" endpoint instead of "/sequencer/accept-solana-offchain-tx"
     *
     * @default "standard"
     */
    authenticator?: Authenticator;
}
type AmendOrderOptions = {
    existingOrderId: bigint;
    existingClientOrderId?: never;
    newOrderArgs: NewOrderArgs;
} | {
    existingOrderId?: never;
    existingClientOrderId: bigint;
    newOrderArgs: NewOrderArgs;
};
type CancelOrderOptions = {
    orderId: bigint;
    clientOrderId?: never;
} | {
    orderId?: never;
    clientOrderId: bigint;
};
type AssetInfo = {
    id: AssetId;
    name: AssetName;
    tokenId: TokenId | null;
    decimals: number;
    withdrawFee: string;
};
export declare class ReadOnlyClient {
    rollup: SolanaSignableRollup<RuntimeCall>;
    readonly endpoint: string;
    protected readonly wsManager?: WebSocketManager;
    protected assetInfoRegistry?: Map<AssetName, AssetInfo>;
    protected assetInfoRegistryReverse?: Map<AssetId, AssetInfo>;
    protected marketRegistry?: Map<MarketName, MarketMetadata>;
    protected marketRegistryReverse?: Map<MarketId, MarketName>;
    protected generationOverride?: () => number;
    /**
     * @internal
     * Do not construct directly. Use Client.fromNetwork() or Client.fromEndpoints()
     */
    constructor(endpoints: Endpoints, rollup: SolanaSignableRollup<RuntimeCall>);
    static fromEndpoints(endpoints: Endpoints): Promise<ReadOnlyClient>;
    static fromNetwork(network: Network): Promise<ReadOnlyClient>;
    setGenerationOverride(generation: (() => number) | undefined): void;
    private fetchApiResource;
    private fetchBulkApiResource;
    /**
     * @internal
     * Initializes exchange info and registries. Called automatically by factory methods.
     */
    initializeExchangeInfo(): Promise<void>;
    getExchangeInfo(): Promise<VersionedExchangeInfo | null>;
    private getMarketMapping;
    getAssetInfo(asset: AssetName): AssetInfo;
    getAssetId(asset: AssetName): AssetId;
    getAssetName(assetId: AssetId): AssetName;
    getTokenAddress(assetName: AssetName): TokenId;
    getTokenAddresses(): Record<AssetName, TokenId>;
    getMarketId(market: MarketName): MarketId;
    getMarketMeta(market: MarketName): MarketMetadata;
    getMarketName(marketId: MarketId): MarketName;
    getOrderbookL2(market: MarketName, levels?: number): Promise<OrderbookL2>;
    getOrderbookL2s(markets: MarketName[], levels?: number): Promise<Map<MarketId, OrderbookL2>>;
    getChainId(): Promise<number>;
    getUserAccountAddresses(offset?: number, limit?: number): Promise<AccountAddresses>;
    getUserAccount(address: Address): Promise<UserAccount>;
    getUserAccounts(addresses: Address[]): Promise<Map<Address, UserAccount>>;
    getUserAccountConfig(address: Address): Promise<VersionedUserAccountConfig>;
    getExchangeAssets(): Promise<VersionedExchangeAssets | null>;
    getRiskEngine(): Promise<VersionedRiskEngine | null>;
    getPerpMarket(market: MarketName): Promise<VersionedPerpMarket>;
    getPerpMarketsConfig(): Promise<Map<MarketId, PerpMarketConfig>>;
    getSpotMarket(market: MarketName): Promise<VersionedSpotMarket>;
    getSpotMarketsConfig(): Promise<Map<MarketId, SpotMarketConfig>>;
    getExecutionIds(): Promise<VersionedExecutionIds | null>;
    getTokenBalance(tokenId: TokenId, address: Address): Promise<bigint>;
    getTotalSupply(tokenId: TokenId): Promise<bigint>;
    getGasTokenAddress(): Promise<TokenId>;
    calculateOrderbookMidpoint(orderbook: OrderbookL2): Decimal | undefined;
    calculateEntryPrice(market: MarketName, userAccount: UserAccount): Decimal;
    calculateTotalPerpUnrealizedPnl(userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateAccountEquity(equityType: EquityType, conservative: boolean, userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateAccountLeverage(userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateAvailableMargin(marginType: MarginType, conservative: boolean, userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateUsedMargin(withdrawal: boolean, marginType: MarginType, userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateUsedPerpMargin(userAccount: UserAccount, marginType: MarginType, riskEngine: VersionedRiskEngine): Decimal;
    calculateUsedSpotMargin(userAccount: UserAccount, marginType: MarginType, riskEngine: VersionedRiskEngine): Decimal;
    calculateEstimatedLiquidationPrice(market: MarketName, userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateLiquidationRiskPercentage(userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateMarginBalance(userAccount: UserAccount, riskEngine: VersionedRiskEngine): {
        collateral_value: Decimal;
        assets: Decimal;
        liabilities: Decimal;
        pnl: Decimal;
    };
    calculateTotalPerpMarginRequirement(userAccount: UserAccount, marginType: MarginType, withdrawal: boolean, riskEngine: VersionedRiskEngine): Decimal;
    calculateForceCancelRiskPercentage(userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateMaxBorrowAmount(asset: AssetName, userAccount: UserAccount, riskEngine: VersionedRiskEngine): Decimal;
    calculateMaxOrderSize(market: MarketName, price: Decimal, side: Side, orderType: OrderType, reduceOnly: boolean, userAccount: UserAccount, riskEngine: VersionedRiskEngine, orderbook: OrderbookL2, nIterations?: number, errorTolerance?: Decimal): Decimal;
    calculateWithdrawableAmountOfAsset(asset: AssetName, forTransferSpotCollateral: boolean, userAccount: UserAccount, riskEngine: VersionedRiskEngine, exchangeInfo: VersionedExchangeInfo): Decimal;
    simulateUsedMarginOnBorrow(asset: AssetName, borrowAmount: Decimal, userAccount: UserAccount, marginType: MarginType, riskEngine: VersionedRiskEngine): {
        current: Decimal;
        updated: Decimal;
    };
    simulateUsedMarginOnOrder(market: MarketName, newOrderArgs: NewOrderArgs, userAccount: UserAccount, riskEngine: VersionedRiskEngine, orderbook: OrderbookL2): {
        current: Decimal;
        updated: Decimal;
    };
    simulateEstimatedLiquidationPriceOnOrder(market: MarketName, newOrderArgs: NewOrderArgs, userAccount: UserAccount, riskEngine: VersionedRiskEngine, orderbook: OrderbookL2): {
        current: Decimal;
        updated: Decimal;
    };
    calculatePositionsAdditionalMetadata(userAccount: UserAccount, riskEngine: VersionedRiskEngine, exchangeInfo: VersionedExchangeInfo): Map<number, {
        projected_funding_payment: Decimal;
        unrealized_pnl: Decimal;
        liquidation_price: Decimal;
        liquidation_risk_percentage: Decimal;
        max_leverage_to_use: number;
    }>;
    calculateBorrowLendPoolAdditionalMetadata(borrowLendPools: Map<AssetId, BorrowLendPool>, asset: AssetName): {
        utilization_rate: Decimal;
        current_deposit_rate: Decimal;
        current_borrow_rate: Decimal;
    };
    calculateAccountSummaryBatch(userAccounts: UserAccount[], riskEngine: VersionedRiskEngine, useWeightedEquity?: boolean): {
        address: string;
        equity: Decimal;
        unrealized_pnl: Decimal;
        available_initial_margin: Decimal;
        available_maintenance_margin: Decimal;
        leverage: Decimal;
        account_variant?: string | undefined;
    }[];
    private getWebSocketManager;
    subscribeOrderbook(market: MarketName, signal?: AbortSignal): AsyncIterable<Orderbook>;
    unsubscribeOrderbook(market: MarketName): Promise<void>;
    /**
     * Dispose of all resources: WebSocket connections, Maps, and references
     * Call this when the client is no longer needed to prevent memory leaks
     */
    dispose(): void;
}
export declare class AuthenticatedClient extends ReadOnlyClient {
    readonly address: Address;
    private readonly wallet;
    private readonly authenticator;
    private readonly useSerdePath;
    /**
     * @internal
     * Do not construct directly. Use Client.fromNetwork() or Client.fromEndpoints()
     */
    constructor(endpoints: Endpoints, rollup: SolanaSignableRollup<RuntimeCall>, wallet: Wallet, delegatorAddress?: Address, authenticator?: Authenticator);
    /**
     * Encodes a Decimal.js value for the configured authenticator:
     * - Solana auth (serde): returns string (e.g. "10000")
     * - Standard auth (borsh): returns SurrogateDecimal { flags, hi, lo, mid }
     */
    private encodeDecimal;
    getUserAccount(address?: Address): Promise<UserAccount>;
    getUserAccountConfig(address?: Address): Promise<VersionedUserAccountConfig>;
    getTokenBalance(tokenId: TokenId, address?: Address): Promise<bigint>;
    getNonce(): Promise<number>;
    submitTransaction(runtimeCall: RuntimeCall): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    createToken(tokenName: string, tokenDecimals: number | null, initialBalance: bigint, mintToAddress: Address, admins: Address[], supplyCap: bigint | null): Promise<{
        rawBytestokenId: Uint8Array<ArrayBufferLike>;
        response: TransactionResult<Transaction<RuntimeCall>>;
    }>;
    transfer(to: Address, amount: bigint, tokenId: TokenId): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    mint(to: Address, amount: bigint, tokenId: TokenId): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    deposit(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    depositToVault(vaultAddress: Address, asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    withdraw(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    borrowSpot(asset: AssetName, amount: Decimal, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    depositSpotCollateral(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    withdrawSpotCollateral(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    transferSpotCollateral(direction: SpotCollateralTransferDirection, asset: AssetName, amount: Decimal, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    placeOrders(market: MarketName, newOrders: NewOrderArgs[], replace?: boolean, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    createPerpPositionTpsl(market: MarketName, tpslPair: TpslPair, size?: Decimal, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    amendOrders(market: MarketName, options: AmendOrderOptions[], subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelTriggerOrders(market: MarketName, triggerOrderIds: bigint[], subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelOrders(market: MarketName, options: CancelOrderOptions[], subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminCancelOrders(address: Address, market: MarketName, orderId: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminCancelTriggerOrder(address: Address, market: MarketName, triggerOrderId: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateAdmin(adminType: AdminType, newAdmin: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminAddTradingCredits(address: Address, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminRemoveTradingCredits(address: Address, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminSetCumulativeReferralRewards(address: Address, asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUpdateUserFeeDiscountBps(address: Address, feeDiscountBps: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUpdateUserFeeTier(address: Address, feeTier: FeeTier): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelMarketOrders(market: MarketName, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelAllOrders(subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateOraclePrices(pricesToUpdate: OraclePriceUpdateArgs[], publishTimestamp?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateMarkPrices(pricesToUpdate: MarkPriceUpdateArgs[], publishTimestamp?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateMaxLeverageForMarket(market: MarketName, maxLeverage: number, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    claimReferralRewards(asset: AssetName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updatePremiumIndexes(markets: MarketName[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    executeTriggerOrders(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    createTwapOrder(market: MarketName, twapOrderArgs: NewTwapOrderArgs, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    executeTwapOrders(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelTwapOrder(market: MarketName, twapId: bigint, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    activateTwapOrders(markets: MarketName[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateFunding(markets: MarketName[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    applyFunding(addresses: Address[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    accrueBorrowLendInterest(): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    forceCancelOrders(address: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    liquidatePerpPositions(address: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    backstopLiquidatePerpPositions(address: Address, positions?: {
        market: MarketName;
        size: Decimal;
    }[], subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    liquidateBorrowLendLiability(address: Address, liabilityAsset: AssetName, collateralAsset: AssetName, liabilityAmount: Decimal, subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    depositToUsdcPnlPool(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    depositToInsuranceFund(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    initAssetInfo(assetId: AssetId, assetName: AssetName, tokenId: TokenId | null, decimals: number, withdrawFee: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateAssetInfo(asset: AssetName, withdrawFee: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateGlobalConfig(options: {
        maxOrdersPerUser?: number;
        maxTriggerOrdersPerUser?: number;
        maxOrdersPerBatchMsg?: number;
        maxTriggerOrdersToExecutePerMsg?: number;
        minNotionalTwapValue?: Decimal;
        minNotionalTwapValuePerOrder?: Decimal;
        twapExecutionIntervalSeconds?: number;
        depositLimitsPerUser?: [AssetId, Decimal][];
        whitelistedUsersForDeposit?: Address[];
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    createVault(name: string, description: string, leader: Address, depositAssets: AssetName[], withdrawAsset: AssetName, withdrawLockupPeriodHours: number, whitelistDeposits: boolean, profitSharePercentage: number, withdrawalFeeBps: number, depositLimit: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    initSpotMarket(marketId: MarketId, baseAssetId: AssetId, quoteAssetId: AssetId, baseMinLotSize: Decimal, quoteMinLotSize: Decimal, maxOrdersPerSide: number, maxOrdersPerUser: number, maxTriggerOrdersPerUser: number, takerFeesTenthBps: number[], makerFeesTenthBps: number[], maxOrderToTriggerPriceDeviationRatio: Decimal, name: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateSpotMarket(market: MarketName, options: {
        baseMinLotSize?: Decimal;
        quoteMinLotSize?: Decimal;
        maxOrdersPerSide?: number;
        maxOrdersPerUser?: number;
        maxTriggerOrdersPerUser?: number;
        takerFeesTenthBps?: number[];
        makerFeesTenthBps?: number[];
        maxOrderToTriggerPriceDeviationRatio?: Decimal;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    initPerpMarket(marketId: MarketId, baseAssetId: AssetId, name: string, tradingMode: string, minTickSize: Decimal, minLotSize: Decimal, maxOrdersPerSide: number, maxOrdersPerUser: number, maxTriggerOrdersPerUser: number, minInterestRateClamp: Decimal, maxInterestRateClamp: Decimal, minFundingRateClamp: Decimal, maxFundingRateClamp: Decimal, maxOiNotional: Decimal, maxOrderToMarkPriceDeviationRatio: Decimal, maxTriggerToComparisonPriceDeviationRatio: Decimal, maxOrderToTriggerPriceDeviationRatio: Decimal, impactMargin: Decimal, interestRate: Decimal, leverageTable: Record<string, number>, takerFeesTenthBps: number[], makerFeesTenthBps: number[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updatePerpMarket(market: MarketName, options: {
        minTickSize?: Decimal;
        minLotSize?: Decimal;
        maxOrdersPerSide?: number;
        maxOrdersPerUser?: number;
        maxTriggerOrdersPerUser?: number;
        minInterestRateClamp?: Decimal;
        maxInterestRateClamp?: Decimal;
        minFundingRateClamp?: Decimal;
        maxFundingRateClamp?: Decimal;
        maxOiNotional?: Decimal;
        impactMargin?: Decimal;
        interestRate?: Decimal;
        takerFeesTenthBps?: number[];
        makerFeesTenthBps?: number[];
        maxOrderToMarkPriceDeviationRatio?: Decimal;
        maxTriggerToComparisonPriceDeviationRatio?: Decimal;
        maxOrderToTriggerPriceDeviationRatio?: Decimal;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    initBorrowLendPool(assetId: AssetId, optimalUtilisationRate: Decimal, minBorrowRate: Decimal, maxBorrowRate: Decimal, optimalBorrowRate: Decimal, assetWeight: Decimal, initialLiabilityWeight: Decimal, maintenanceLiabilityWeight: Decimal, depositLimit: Decimal, borrowLimit: Decimal, maxUtilizationRate: Decimal, liquidationTotalRewardRatio: Decimal, protocolRewardRatio: Decimal, liabilityLiquidationLimitRatio: Decimal, interestFeeTenthBps: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateBorrowLendPool(asset: AssetName, options: {
        optimalUtilizationRate?: Decimal;
        minBorrowRate?: Decimal;
        maxBorrowRate?: Decimal;
        optimalBorrowRate?: Decimal;
        assetWeight?: Decimal;
        initialLiabilityWeight?: Decimal;
        maintenanceLiabilityWeight?: Decimal;
        depositLimit?: Decimal;
        borrowLimit?: Decimal;
        maxUtilizationRate?: Decimal;
        liquidationTotalRewardRatio?: Decimal;
        protocolRewardRatio?: Decimal;
        liabilityLiquidationLimitRatio?: Decimal;
        interestFeeTenthBps?: number;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateLeverageTable(market: MarketName, leverageTable: Record<string, number>): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    createSubAccount(index: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    transferSubAccount(subAccountIndex: number, toSubAccount: boolean, asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    delegateUser(delegate: Address, name: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    revokeDelegation(delegate: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    vaultDelegateUser(vaultAddress: Address, delegate: Address, name: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    vaultRevokeDelegation(vaultAddress: Address, delegate: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminPruneMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminForceSettlePerpPosition(market: MarketName, usersToForceSettle: Address[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminHaltPerpMarket(market: MarketName, settlementPrice: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminHaltSpotMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUnhaltPerpMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUnhaltSpotMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminHaltBorrowLendPool(asset: AssetName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUnhaltBorrowLendPool(asset: AssetName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminForceRemoveDelegate(delegator: Address, delegate: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    settleFromPnlPool(subAccountIndex?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    depositToTreasury(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    claimBorrowLendFees(): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    queueWithdrawal(vaultAddress: Address, shares: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    cancelQueuedWithdrawal(vaultAddress: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    forceWithdrawVault(vaultAddress: Address, shares: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    updateVaultConfig(vaultAddress: Address, options: {
        depositLimit?: Decimal;
        withdrawLockupPeriodHours?: number;
        profitSharePercentage?: number;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    processWithdrawalQueue(vaultAddress: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    whitelistDepositor(vaultAddress: Address, userAddress: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    unwhitelistDepositor(vaultAddress: Address, userAddress: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminDeleteAsset(asset: AssetName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminDeleteMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminCleanupUserMarketState(market: MarketName, users: Address[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUpdatePerpLiquidationConfig(options: {
        liquidationFee?: Decimal;
        liquidationIocBuffer?: Decimal;
        backstopLiquidationThreshold?: Decimal;
        liquidationProtocolRewardRatio?: Decimal;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminUpdateGlobalVaultConfig(options: {
        leaderMinimumHoldingPercentage?: number;
        creationFeeUsdc?: Decimal;
        minDepositValue?: Decimal;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminWithdrawFromTreasury(asset: AssetName, amount: Decimal, to: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminAutoDeleverage(options: {
        counterpartyA: Address;
        counterpartyASubAccountIndex?: number;
        counterpartyB: Address;
        counterpartyBSubAccountIndex?: number;
        market: MarketName;
        size?: Decimal;
        settlementPrice: Decimal;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    adminDeposit(userAddress: Address, asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    warpRegister(options: {
        admin: Address;
        remoteTokenId: string;
        localDecimals: number;
        remoteDecimals: number;
        ismThreshold: number;
        ismValidators: string[];
        remoteRouters: [number, string][];
        inboundTransferrableTokensLimit: string;
        inboundLimitReplenishmentPerSlot: string;
        outboundTransferrableTokensLimit: string;
        outboundLimitReplenishmentPerSlot: string;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    warpUpdate(options: {
        warpRoute: string;
        admin?: Address;
        ismThreshold?: number;
        ismValidators?: string[];
        inboundTransferrableTokensLimit?: string;
        inboundLimitReplenishmentPerSlot?: string;
        outboundTransferrableTokensLimit?: string;
        outboundLimitReplenishmentPerSlot?: string;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    warpEnrollRemoteRouter(warpRoute: string, remoteDomain: number, remoteRouterAddress: string): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    warpUnenrollRemoteRouter(warpRoute: string, remoteDomain: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    warpTransferRemote(options: {
        warpRoute: string;
        amount: number;
        destinationDomain: number;
        gasPaymentLimit: number;
        recipient: string;
        relayer?: {
            Standard?: string;
            Vm?: string;
        };
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
    setRelayerConfig(options: {
        domainOracleData: {
            domain: number;
            dataValue: {
                gasPrice: number;
                tokenExchangeRate: number;
            };
        }[];
        domainDefaultGas: {
            domain: number;
            defaultGas: number;
        }[];
        defaultGas: number;
        beneficiary?: string;
    }): Promise<TransactionResult<Transaction<RuntimeCall>>>;
}
export declare namespace Client {
    function fromEndpoints(endpoints: Endpoints, wallet: Wallet, delegatorAddress?: Address, txOpts?: TransactionOpts): Promise<AuthenticatedClient>;
    function fromEndpoints(endpoints: Endpoints): Promise<ReadOnlyClient>;
    function fromNetwork(network: Network, wallet: Wallet, delegatorAddress?: Address, txOpts?: TransactionOpts): Promise<AuthenticatedClient>;
    function fromNetwork(network: Network): Promise<ReadOnlyClient>;
}
//# sourceMappingURL=client.d.ts.map