export declare enum LightEventOrderType {
    Limit = "Limit",
    Market = "Market",
    Conditional = "Conditional"
}
export interface AMMStateResponse {
    totalFloatAmount: string;
    normFixedAmount: string;
    totalLp: string;
    latestFTime: string;
    maturity: string;
    seedTime: string;
    minAbsRate: string;
    maxAbsRate: string;
    cutOffTimestamp: string;
    isCutOffReached: boolean;
    disabled: boolean;
    disabledAt?: number;
    disabledReason?: string;
}
export interface GetAMMStateResponse {
    marketId: number;
    tokenId: number;
    ammId: number;
    state: AMMStateResponse;
    isPositive: boolean;
    feeRate: string;
    impliedRate: number;
    totalLp: string;
    totalValue: string;
    totalSupplyCap: string;
    lpApy: number;
    lpPrice: number;
}
export interface GetAMMStatesResponse {
    results: GetAMMStateResponse[];
}
export interface AssetMetadataResponse {
    proSymbol: string;
}
export interface AssetItemResponse {
    id: string;
    address: string;
    tokenId: number;
    name: string;
    symbol: string;
    decimals: number;
    usdPrice: string;
    isCollateral: boolean;
    metadata: AssetMetadataResponse;
}
export interface ListAssetsResponse {
    results: AssetItemResponse[];
}
export interface MarketListItemIMDataResponse {
    name: string;
    symbol: string;
    isIsolatedOnly: boolean;
    maturity: number;
    tickStep: number;
    iTickThresh: number;
    marginFloor: number;
}
export interface LiqSettingsResponse {
    base: string;
    slope: string;
    feeRate: string;
}
export interface MarketListItemConfigResponse {
    maxOpenOrders: number;
    markRateOracle: string;
    fIndexOracle: string;
    hardOICap: string;
    takerFee: string;
    otcFee: string;
    liqSettings: LiqSettingsResponse;
    kIM: string;
    kMM: string;
    tThresh: number;
    maxRateDeviationFactorBase1e4: number;
    closingOrderBoundBase1e4: number;
    loUpperConstBase1e4: number;
    loUpperSlopeBase1e4: number;
    loLowerConstBase1e4: number;
    loLowerSlopeBase1e4: number;
    status: 0 | 1 | 2;
    useImpliedAsMarkRate: boolean;
    softOICap?: number;
    cloLowerThresh?: number;
    cloUpperThresh?: number;
}
export interface MarketListItemExtConfigResponse {
    ammAddress?: string;
    ammId?: number;
    isPositiveAMM?: boolean;
    settleFeeRate: string;
    paymentPeriod: number;
    maxUpdateDelay: number;
}
export interface MarketListItemMetadataResponse {
    name: string;
    underlyingSymbol?: string;
    fundingRateSymbol?: string;
    maxLeverage: number;
    maxPerpLeverage?: number;
    isUiWhitelisted: boolean;
}
export interface MarketListItemDataResponse {
    volume24h: number;
    notionalOI: number;
    markApr: number;
    lastTradedApr: number;
    midApr: number;
    bestBid?: number;
    bestAsk?: number;
    ammImpliedApr?: number;
    floatingApr: number;
    longYieldApr?: number;
    nextSettlementTime?: number;
    timeToMaturity?: number;
    assetMarkPrice: number;
    rateSensitivity: number;
    settlementsToMaturity: number;
    dailyVolatility: number | null;
    dailyVolatilityState: "new" | "calibrating" | "ready";
}
export interface MarketPlatformResponse {
    name: string;
    platformId: string;
}
export interface MarketListItemResponse {
    marketId: number;
    address: string;
    tokenId: number;
    imData: MarketListItemIMDataResponse;
    config: MarketListItemConfigResponse;
    extConfig: MarketListItemExtConfigResponse;
    metadata: MarketListItemMetadataResponse;
    data: MarketListItemDataResponse;
    platform: MarketPlatformResponse;
}
export interface MarketsSyncStatusResponse {
    blockNumber: number;
    timestamp: number;
}
export interface ListMarketsResponse {
    results: MarketListItemResponse[];
    resumeToken?: string | null;
    syncStatus: MarketsSyncStatusResponse;
}
export interface MarketTradeResponse {
    size: number;
    rate: number;
    txHash: string;
    blockTimestamp: number;
}
export interface MarketTradesV2Response {
    results: MarketTradeResponse[];
    resumeToken?: string | null;
}
export interface SideTickResponse {
    ia: number[];
    sz: string[];
}
export interface SyncStatusResponse {
    blockNumber: number;
    timestamp: number;
}
export interface OrderBooksResponse {
    long: SideTickResponse;
    short: SideTickResponse;
    syncStatus: SyncStatusResponse;
}
export interface OhlcvCandleResponse {
    ts: number;
    o: number;
    h: number;
    l: number;
    c: number;
    v: number;
}
export interface OhlcvChartResponse {
    results: OhlcvCandleResponse[];
}
export interface HistoricalUnderlyingAPRResponse {
    ts: number;
    u: number;
}
export interface HistoricalUnderlyingAPRChartResponse {
    results: HistoricalUnderlyingAPRResponse[];
}
export interface IndicatorsMetadata {
    requested: string[];
    available: string[];
    firstDataTimestamp?: object;
    uLastSettledTimestamp?: number;
}
export interface FGIData {
    v: number;
    vc: string;
}
export interface IndicatorDataPoint {
    ts: number;
    u?: number;
    fp?: number;
    fgi?: FGIData;
    udma?: object;
    ap?: number;
    pi?: number;
}
export interface IndicatorsResponse {
    metadata: IndicatorsMetadata;
    results: IndicatorDataPoint[];
}
export interface EncodeMarketAccResponse {
    marketAcc: string;
}
export interface DecodeMarketAccResponse {
    root: string;
    accountId: number;
    tokenId: number;
    marketId: number;
    isCross: boolean;
}
export interface LimitOrderMetadataResponse {
    isRateImproved: boolean;
    isClosePosition?: boolean;
}
export interface LimitOrderResponseV2 {
    side: 0 | 1;
    placedSize: string;
    unfilledSize: string;
    impliedApr: number;
    tick: number;
    marginRequired: string;
    orderId: string;
    root: string;
    marketId: number;
    accountId: number;
    isCross: boolean;
    status: 0 | 1 | 2 | 3 | 4;
    orderType: 0 | 1;
    blockTimestamp: number;
    eventIndex: number;
    placedEventIndex: number;
    placedTimestamp: number;
    placedTxHash: string;
    marketAcc: string;
    metadata?: LimitOrderMetadataResponse;
}
export interface OrdersByTxHashResponse {
    results: LimitOrderResponseV2[];
}
export interface DepositBodyDto {
    marketAcc: string;
    amount: string;
}
export interface CalldataBuilderUserResponse {
    calldata: string;
    from: string;
    to: string;
    gas?: string;
}
export interface RequestWithdrawalBodyDto {
    root: string;
    tokenId: number;
    amount: string;
}
export interface CancelWithdrawalBodyDto {
    root: string;
    tokenId: number;
}
export interface ApproveAgentBodyDto {
    root: string;
    accountId?: number;
    agentAddress: string;
    expiry: number;
}
export interface RevokeAgentBodyDto {
    root: string;
    accountId?: number;
    agentAddress: string;
}
export interface VaultPayTreasuryBodyDto {
    root: string;
    tokenId: number;
    amount: string;
}
export interface PlaceOrderSimpleBodyDto {
    marketAcc: string;
    marketId: number;
    side: 0 | 1;
    size: string;
    tif: 0 | 1 | 2 | 3 | 4;
    rate?: number;
    slippage?: number;
    ammId?: number;
    preCancelOrderId?: string;
}
export interface PlaceOrderResolved {
    side: 0 | 1;
    limitTick: number | null;
    actualRate: number | null;
    requestedRate?: number;
    desiredRate?: number;
}
export interface PlaceOrderCall {
    calldata: string;
    accountId: number;
    resolved?: PlaceOrderResolved;
}
export interface PlaceOrdersResponse {
    calls: PlaceOrderCall[];
}
export interface PlaceSingleOrderBodyDto {
    marketAcc: string;
    marketId: number;
    side: 0 | 1;
    size: string;
    tif: 0 | 1 | 2 | 3 | 4;
    limitTick?: number;
    rate?: number;
    desiredRate?: number;
    slippage?: number;
    ammId?: number;
    preCancelOrderId?: string;
}
export interface BulkOrdersCancelDataDto {
    ids: string[];
    isAll: boolean;
    isStrict: boolean;
}
export interface BulkOrdersLongShortDataDto {
    sizes: string[];
    limitTicks: number[];
    tif: 0 | 1 | 2 | 3 | 4;
    side: 0 | 1;
}
export interface PlaceBulkOrdersEntryDto {
    marketId: number;
    cancelData: BulkOrdersCancelDataDto;
    orders: BulkOrdersLongShortDataDto;
    desiredRate?: number;
    slippage?: number;
}
export interface PlaceBulkOrdersDto {
    accountId?: number;
    cross: boolean;
    bulks: PlaceBulkOrdersEntryDto[];
}
export interface OrderRequestDto {
    singleOrder?: PlaceSingleOrderBodyDto;
    bulkOrders?: PlaceBulkOrdersDto;
}
export interface PlaceOrdersBodyDto {
    orderRequests: OrderRequestDto[];
}
export interface CancelOrdersMarketDto {
    marketAcc: string;
    marketId: number;
    cancelAll: boolean;
    orderIds?: string[];
}
export interface CancelOrdersBodyDto {
    markets: CancelOrdersMarketDto[];
}
export interface AgentCall {
    calldata: string;
    accountId: number;
}
export interface AgentCalldataResponse {
    calls: AgentCall[];
}
export interface CashTransferBodyDto {
    accountId?: number;
    marketId: number;
    direction: "CROSS_TO_ISOLATED" | "ISOLATED_TO_CROSS";
    amount: string;
}
export interface EnterExitMarketsBodyDto {
    accountId?: number;
    isCross?: boolean;
    marketIds: number[];
}
export interface PayTreasuryBodyDto {
    accountId?: number;
    isCross: boolean;
    marketId: number;
    amount: string;
}
export interface AddLiquidityToAmmAgentBodyDto {
    root: string;
    marketId: number;
    netCashIn: string;
    minLpOut: string;
}
export interface AgentExecuteParams {
    calldata: string;
    accountId: number;
}
export interface BulkAgentExecuteParamsResponseV2 {
    executeParams: AgentExecuteParams[];
}
export interface RemoveLiquidityFromAmmAgentBodyDto {
    marketId: number;
    lpToRemove: string;
    minCashOut: string;
}
export interface FundingRateSymbolResponse {
    fundingRateSymbol: string;
    assetSymbol: string;
    exchange: string;
}
export interface FundingRateSymbolListResponse {
    fundingRateSymbols: FundingRateSymbolResponse[];
}
export interface GetSettlementSummaryByMarketQueryDto {
    marketIds?: number[];
    fromTimestamp: number;
    toTimestamp: number;
}
export interface SettlementMarketSummaryResponse {
    marketId: number;
    marketName: string;
    fundingRateSymbol: string;
    periodTimestamp: number;
    eventIndex: number;
    blockTimestamp: number;
    settlementApr: number;
    totalFee: number;
    totalNotionalSize: number;
    totalSettledValue: number;
}
export interface SettlementMarketSummaryListResponse {
    settlementMarketSummaries: SettlementMarketSummaryResponse[];
}
export interface LiquidateMarketAccPositionResponse {
    marketAcc: string;
    prevPositionRate: number;
    prevPositionSize: number;
    postPositionRate: number;
    postPositionSize: number;
}
export interface LiquidationEventResponse {
    marketId: number;
    blockNumber: number;
    timestamp: number;
    txHash: string;
    size: number;
    rate: number;
    tradeRate: number;
    violator: LiquidateMarketAccPositionResponse;
    liquidator: LiquidateMarketAccPositionResponse;
}
export interface LiquidationEventListResponse {
    liquidationEvents: LiquidationEventResponse[];
}
export interface OnChainEventItem {
    eventName: string;
    id: string;
    sourceAddress: string;
    blockNumber: number;
    logIndex: number;
    txHash: string;
    blockHash: string;
    blockTimestamp: number;
    eventIndex: number;
    isFinalized?: boolean;
    data?: object;
}
export interface OnChainEventsResponse {
    events: OnChainEventItem[];
    resumeToken?: string;
}
export interface DepositSimulationBodyDto {
    marketAcc: string;
    amount: string;
}
export interface DepositStateResponse {
    collateralBalance: string;
    maintenanceMargin: string;
    marginRatio: number;
}
export interface DepositSimulationResponse {
    minReceived: string;
    preUserState: DepositStateResponse;
    postUserState: DepositStateResponse;
}
export interface RequestWithdrawalSimulationBodyDto {
    root: string;
    tokenId: number;
    amount: string;
}
export interface WithdrawStateResponse {
    collateralBalance: string;
    marginRatio: number;
}
export interface WithdrawSimulationResponse {
    preUserState: WithdrawStateResponse;
    postUserState: WithdrawStateResponse;
}
export interface CashTransferSimulationBodyDto {
    root: string;
    accountId?: number;
    marketId: number;
    direction: "CROSS_TO_ISOLATED" | "ISOLATED_TO_CROSS";
    amount: string;
}
export interface CashTransferStateResponse {
    collateralBalance: string;
    maintenanceMargin: string;
    marginRatio: number;
}
export interface CashTransferPrePostSimulationResponse {
    preUserState: CashTransferStateResponse;
    postUserState: CashTransferStateResponse;
}
export interface CashTransferSimulationResponseV2 {
    crossAccState: CashTransferPrePostSimulationResponse;
    isolatedAccState: CashTransferPrePostSimulationResponse;
}
export interface PlaceOrderSimulationBodyDto {
    marketAcc: string;
    marketId: number;
    side: 0 | 1;
    size: string;
    tif: 0 | 1 | 2 | 3 | 4;
    rate?: number;
    slippage?: number;
    ammId?: number;
}
export interface PlaceOrderPreStateResponse {
    activePositionSize: string;
}
export interface ContractSwapPositionResponse {
    size: string;
    cost: string;
    rate: number;
}
export interface PlaceOrderPostStateResponse {
    marginRequired: string;
    liquidationApr?: number | null;
    longYieldApr: number;
}
export interface PlaceOrderResolvedResponse {
    side: 0 | 1;
    limitTick: number;
    actualRate: number;
    requestedRate?: number;
    desiredRate?: number | null;
}
export interface PlaceOrderSimulationResponseV3 {
    preState: PlaceOrderPreStateResponse;
    matched: ContractSwapPositionResponse;
    postState: PlaceOrderPostStateResponse;
    priceImpact: number;
    status: string;
    statusCode: string;
    makerOrderReward: number;
    resolved: PlaceOrderResolvedResponse;
}
export interface PlaceOrderAnonymousSimulationBodyDto {
    marketId: number;
    side: 0 | 1;
    size: string;
    tif: 0 | 1 | 2 | 3 | 4;
    rate?: number;
    slippage?: number;
    ammId?: number;
}
export interface AnonymousPlaceOrderFeeBreakdownResponse {
    takerOtcFee?: string;
    takerOtcFeeInUSD?: number;
}
export interface MakerIncentiveSimulationResponse {
    filledVolumeIncentiveReward: number;
    provideLiquidityIncentiveReward: number;
    makerFeeRebate: number;
    makerFeeRebateToken: string;
}
export interface AnonymousPlaceOrderSimulationResponse {
    matched: ContractSwapPositionResponse;
    marginRequired: string;
    priceImpact: number;
    feeBreakdown: AnonymousPlaceOrderFeeBreakdownResponse;
    makerOrderReward: number;
    makerIncentive: MakerIncentiveSimulationResponse;
    resolved: PlaceOrderResolvedResponse;
}
export interface AddLiquidityToAmmV2SimulationBodyDto {
    root: string;
    accountId?: number;
    marketId: number;
    netCashIn: string;
}
export interface AddLiquidityFeeBreakdownResponse {
    marketEntranceFee?: string;
    vaultDepositFee?: string;
    marketEntranceFeeInUSD?: number;
    vaultDepositFeeInUSD?: number;
}
export interface AddLiquidityToAmmFeeSimulationResponse {
    feeBreakdown: AddLiquidityFeeBreakdownResponse;
}
export interface RemoveLiquidityFromAmmV2SimulationBodyDto {
    root: string;
    accountId?: number;
    marketId: number;
    lpToRemove: string;
}
export interface RemoveLiquidityFeeBreakdownResponse {
    vaultWithdrawalFee?: string;
    vaultWithdrawalFeeInUSD?: number;
}
export interface RemoveLiquidityFromAmmFeeSimulationResponse {
    feeBreakdown: RemoveLiquidityFeeBreakdownResponse;
}
export interface UserVaultStateEntry {
    marketId: number;
    tokenId: number;
    ammId: number;
    averageLpPrice: number;
    depositValue: string;
    totalLp: string;
    availableBalanceToDeposit: string;
}
export interface UserVaultStatesResponse {
    results: UserVaultStateEntry[];
}
export interface AccountGasBalanceResponse {
    balanceInUSD: number;
}
export interface GasConsumptionV2Response {
    actionType: string;
    root: string;
    gasFee: number;
    topUpAmount?: number;
    txHash: string;
    blockTimestamp: number;
    chainId: number;
}
export interface GasConsumptionHistoryV2RootResponse {
    results: GasConsumptionV2Response[];
    resumeToken?: string;
}
export interface FundLocationResponse {
    fundType: "wallet" | "cross_account" | "isolated_account" | "amm";
    marketId?: number;
    tokenId?: number;
    amount?: string;
}
export interface TransferLogResponse {
    transferLogId: string;
    blockTimestamp: number;
    root: string;
    accountId: number;
    tokenId: number;
    amount: string;
    fromFundLocation: FundLocationResponse;
    toFundLocation: FundLocationResponse;
    status: "pending" | "success" | "failed";
}
export interface TransferLogsV2Response {
    results: TransferLogResponse[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface LimitOrdersV2Response {
    results: LimitOrderResponseV2[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface TransactionResponse {
    id: string;
    timestamp: number;
    side: 0 | 1;
    tradeSize: string;
    tradeRate: number;
    tradeValue: string;
    fee: string;
    pnl: string;
    txHash: string;
    isLimitOrderTrade: boolean;
    blockNumber: number;
    orderId: string;
    marketId: number;
    marketAcc: string;
    prevPositionS: string;
    prevPositionF: string;
    postPositionF: string;
    postPositionS: string;
}
export interface TransactionsV2Response {
    results: TransactionResponse[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface SettlementResponse {
    id: string;
    timestamp: number;
    marketAcc: string;
    marketId: number;
    side: 0 | 1;
    positionSize: string;
    positionValue: string;
    yieldPaid: string;
    yieldReceived: string;
    fee: string;
    settlement: string;
    settlementRate: number;
    cumulativeSettlementPnl: string;
    sinceOpenSettlementPnl: string;
}
export interface SettlementsV2Response {
    results: SettlementResponse[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface GetMarketAccInfosV2Dto {
    marketAccs: string[];
}
export interface OrderResponse {
    id: string;
    maker: string;
    size: string;
    side: 0 | 1;
    tick: number;
    rate: string;
    initialMargin: string;
    initialMarginWithLeverage: string;
}
export interface PositionResponse {
    marketId: number;
    signedSize: string;
    positionValue: string;
    liquidationApr: string;
    initialMargin: string;
    initialMarginWithLeverage: string;
    maintMargin: string;
    orders: OrderResponse[];
}
export interface MarketAccInfoResponse {
    marketAcc: string;
    totalCash: string;
    netBalance: string;
    positions: PositionResponse[];
    initialMargin: string;
    initialMarginWithLeverage: string;
    availableInitialMargin: string;
    availableMaintMargin: string;
}
export interface MarketAccInfosResponse {
    results: MarketAccInfoResponse[];
    syncStatus: SyncStatusResponse;
}
export interface ActivePositionWithPnlResponse {
    marketId: number;
    marketAcc: string;
    isCross: boolean;
    fixedApr: number;
    signedSize: string;
    side: 0 | 1;
    cumulativePnl: string;
    isMatured: boolean;
    unrealisedPnl: string;
    settlementPnl: string;
}
export interface ActivePositionsWithPnlResponse {
    results: ActivePositionWithPnlResponse[];
    syncStatus: SyncStatusResponse;
}
export interface EnteredMarketResponse {
    marketId: number;
    isMatured: boolean;
}
export interface EnteredMarketsResponse {
    results: EnteredMarketResponse[];
}
export interface MarginConfigResponse {
    marketAcc: object;
    marketId: number;
    kIM: string;
}
export interface MarginConfigsResponse {
    results: MarginConfigResponse[];
    syncStatus: SyncStatusResponse;
}
export interface LightEventFeedOrderChangeResponse {
    orderId: string;
    orderType: LightEventOrderType;
    status: 0 | 1 | 2 | 3 | 4;
    unfilledSize: string;
    eventFilledSize: string;
    side: 0 | 1;
    tick?: number;
    rate?: number;
    takerAcc?: string;
    tif?: 0 | 1 | 2 | 3 | 4;
}
export interface LightEventFeedPositionChangeResponse {
    size: string;
    changedSize: string;
}
export interface LightEventFeedItemResponse {
    eventIndex: number;
    blockNumber: number;
    blockTimestamp: number;
    eventName: string;
    eventType: "LimitOrderPlaced" | "LimitOrderFilled" | "LimitOrderCancelled" | "MarketOrderExecuted" | "OtcSwap" | "Liquidate" | "Deleverage" | "Unknown";
    txHash: string;
    marketAcc: string;
    marketId: number;
    orders?: LightEventFeedOrderChangeResponse[];
    position?: LightEventFeedPositionChangeResponse;
}
export interface LightEventFeedResponse {
    results: LightEventFeedItemResponse[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface AddLiquidityIncentiveSideResponse {
    incentiveRange: number;
    budgetPerHour: number;
    currentInRangeLiquidity: string;
    currentCappedDistributionPerHour: number;
    currentEligibleShare: number;
    accumulatedReward: number;
}
export interface AddLiquidityIncentiveResponse {
    long: AddLiquidityIncentiveSideResponse;
    short: AddLiquidityIncentiveSideResponse;
}
export interface FilledVolumeIncentiveResponse {
    userMakerVolume: number;
    totalMakerVolume: number;
    totalEpochReward: number;
    avgRewardPerYu: number;
}
export interface MakerFeeRebateCampaignResponse {
    feeShareRate: number;
    currentEpochRebate: number;
    takerFeeContribution: number;
}
export interface MakerIncentiveCampaignResponse {
    epochTimestamp: number;
    addLiquidityIncentive: AddLiquidityIncentiveResponse;
    filledVolumeIncentive: FilledVolumeIncentiveResponse;
    makerFeeRebate: MakerFeeRebateCampaignResponse;
}
export interface AmmIncentivesAllTimeRewards {
    pendleRewards: number;
    swapFeeRewards: number;
}
export interface AmmIncentivesMarketEntry {
    marketId: number;
    unclaimedRewards: string;
    allTimeRewards: AmmIncentivesAllTimeRewards;
}
export interface AmmIncentivesResponse {
    accruedAmountInUsd: number;
    unclaimedAmountInUsd: number;
    perMarket: AmmIncentivesMarketEntry[];
}
export interface RollingVolumeMarketEntry {
    marketId: number;
    volume: string;
    userVolume?: string;
}
export interface RollingVolumeResponse {
    windowHours: number;
    markets: RollingVolumeMarketEntry[];
    syncStatus: SyncStatusResponse;
}
export interface RollingTradeVolumeMarketEntry {
    marketId: number;
    totalVolume: string;
    userMakerVolume?: string;
    userTakerVolume?: string;
}
export interface RollingTradeVolumeResponse {
    windowHours: number;
    markets: RollingTradeVolumeMarketEntry[];
    syncStatus: SyncStatusResponse;
}
export interface AgentExpiryTimeResponse {
    expiryTime: number;
}
export interface StrategyMarketResponse {
    marketId: number;
    address: string;
    tokenId: number;
    name: string;
    assetSymbol: string;
    maturity: number;
    state: string;
    impliedApr: number;
    maxLeverage: number;
    maxPerpLeverage: number;
    ammId?: number;
    platformName?: string;
}
export interface StrategyResponse {
    id: string;
    longMarket: StrategyMarketResponse;
    shortMarket: StrategyMarketResponse;
    daysToMaturity: number;
    impliedAprSpread: number;
    maxPerpLeverage: number;
    aprTimesMaxLeverage: number;
}
export interface FindStrategiesResponse {
    strategies: StrategyResponse[];
    totalCount: number;
}
export interface GasPriceInfoResponse {
    gasPriceWei: object | null;
    gasPriceUsd: object | null;
    estimatedOrderGasCostUsd: object | null;
    timestamp: object | null;
    chainId: number;
}
export interface LeaderboardEntryResponse {
    rank: number;
    root: string;
    accountId: number;
    pnl: string;
    netBalance: string;
    tradingVolume: string;
    maxCapital: string;
    roi: number;
}
export interface LeaderboardResponse {
    snapshotTimestamp: number;
    entries: LeaderboardEntryResponse[];
    totalEntries: number;
}
export interface UserSearchResponse {
    rank?: number;
    pnl: string;
    netBalance: string;
    tradingVolume: string;
    roi?: number;
}
export interface TvlTokenBreakdownResponse {
    address: string;
    symbol: string;
    decimals: number;
    balance: string;
    usdPrice: string;
    tokenInUSD: string;
}
export interface TvlResponse {
    totalInUSD: string;
    breakdown: TvlTokenBreakdownResponse[];
}
export interface PendleSignTxDto {
    account: string;
    connectionId: string;
    nonce: string;
}
export interface AgentExecuteDto {
    agent: string;
    message: PendleSignTxDto;
    signature: string;
    calldata: string;
}
export interface BulkAgentExecuteDto {
    datas: AgentExecuteDto[];
    requireSuccess?: boolean;
    skipReceipt?: boolean;
}
export interface TxResponse {
    txHash?: string;
    status?: "success" | "reverted";
    index?: number;
    error?: string;
}
export interface ApproveAgentQueryDto {
    approveAgentCalldata: string;
    skipReceipt?: boolean;
}
export interface ApproveAgentResponse {
    approveAgentResult: TxResponse;
}
export interface TraceQueryDto {
    agent: string;
    nonce: string;
}
export interface TraceResponse {
    submissionStatus: "HAVENT_SEEN" | "PROCESSING" | "PROCESSED" | "SEND_FAILED";
    nonceStatus: "HAVENT_SEEN" | "PROCESSING" | "PROCESSED" | "SEND_FAILED";
    result?: TxResponse;
}
export interface TxStatusQueryDto {
    txHash: string;
}
export interface DedicatedTxStatusItem {
    status: string;
    index: number;
    error?: string;
}
export interface DedicatedTxStatusResponseV2 {
    status: string;
    blockNumber: number;
    blockTimestamp: number;
    statuses: DedicatedTxStatusItem[];
}
export interface LimitOrderPlacedEventItem {
    marketAddress: string;
    marketId: number;
    orderIds: string[];
    sizes: string[];
}
export interface LimitOrderCancelledEventItem {
    marketAddress: string;
    marketId: number;
    orderIds: string[];
}
export interface MarketOrderExecutedItem {
    marketAddress: string;
    marketId: number;
    orderId: string;
    user: string;
    side: 0 | 1;
    size: string;
}
export interface DedicatedTxStatusWithEventsItem {
    status: string;
    index: number;
    error?: string;
    limitOrdersPlaced: LimitOrderPlacedEventItem[];
    limitOrdersCancelled: LimitOrderCancelledEventItem[];
    marketOrdersExecuted: MarketOrderExecutedItem[];
}
export interface DedicatedTxStatusWithEventsResponse {
    status: string;
    blockNumber: number;
    blockTimestamp: number;
    statuses: DedicatedTxStatusWithEventsItem[];
}
export interface DedicatedBulkAgentExecuteDto {
    datas: AgentExecuteDto[];
    requireSuccess?: boolean;
    simulate?: boolean;
}
export interface FailedSimulationItem {
    index: number;
    calldata: string;
    reason: string;
}
export interface DedicatedTxResponse {
    txHash?: string | null;
    failedSimulations?: FailedSimulationItem[];
}
export interface CreateSigningKeyDto {
    root: string;
    timestamp: number;
    nonce: string;
    signature: string;
    agent?: string;
    name: string;
    expiresInDays?: number;
}
export interface SigningKeySecretDto {
    keyId: string;
    name: string;
    createdAt: number;
    expiresAt?: number;
    lastUsedAt?: number;
    createdByAgent?: string;
    root: string;
    privateKey: string;
}
export interface SigningKeyDto {
    keyId: string;
    name: string;
    createdAt: number;
    expiresAt?: number;
    lastUsedAt?: number;
    createdByAgent?: string;
}
export interface UpdateSigningKeyDto {
    root: string;
    timestamp: number;
    nonce: string;
    signature: string;
    agent?: string;
    keyId: string;
    name: string;
}
export interface SigningKeyIdDto {
    root: string;
    timestamp: number;
    nonce: string;
    signature: string;
    agent?: string;
    keyId: string;
}
export interface Eip712DomainDto {
    name: string;
    version: string;
    chainId: number;
    verifyingContract: string;
}
export interface StopOrderRowResponse {
    orderId: string;
    root: string;
    marketId: number;
    accountId: number;
    marketAcc: string;
    isCross: boolean;
    side: 0 | 1;
    status: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
    orderType: 2 | 3;
    stopApr: number;
    placedSize: string;
    unfilledSize: string;
    marginRequired: string;
    tick: number;
    isClosePosition: boolean;
    blockTimestamp: number;
}
export interface StopOrdersResponse {
    results: StopOrderRowResponse[];
    resumeToken?: string;
    syncStatus: SyncStatusResponse;
}
export interface StopOrderRequestResponse {
    account: string;
    cross: boolean;
    marketId: number;
    side: 0 | 1;
    tif: 0 | 1 | 2 | 3 | 4;
    size: string;
    tick: number;
    reduceOnly: boolean;
    salt: string;
    expiry: string;
    offchainCondition: string;
}
export interface PrepareTpslStopOrderResponse {
    req: StopOrderRequestResponse;
    offchainCondition: string;
}
export interface StopOrderResponse {
    result: StopOrderRowResponse;
    syncStatus: SyncStatusResponse;
}
export interface PlaceStopOrderMsgDto {
    actionHash: string;
}
export interface PlaceStopOrderRequestDto {
    cross: boolean;
    marketId: number;
    side: 0 | 1;
    tif: 0 | 1 | 2 | 3 | 4;
    size: string;
    tick: number;
    reduceOnly: boolean;
    salt: string;
    expiry: string;
}
export interface PlaceStopOrderBodyDto {
    agent: string;
    placeMsg: PlaceStopOrderMsgDto;
    placeSignature: string;
    request: PlaceStopOrderRequestDto;
    offchainCondition: string;
    type: 2 | 3;
    closePosition: boolean;
}
export interface PlaceStopOrderResponse {
    orderHash: string;
}
export interface CancelStopOrdersBodyDto {
    agent: string;
    orderIds: string[];
    cancelSignature: string;
}
export interface CancelStopOrdersResponse {
    message: string;
}
import type { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
export type QueryParamsType = Record<string | number, any>;
export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
    secure?: boolean;
    path: string;
    type?: ContentType;
    query?: QueryParamsType;
    format?: ResponseType;
    body?: unknown;
}
export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, "data" | "cancelToken"> {
    securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
    secure?: boolean;
    format?: ResponseType;
}
export declare enum ContentType {
    Json = "application/json",
    JsonApi = "application/vnd.api+json",
    FormData = "multipart/form-data",
    UrlEncoded = "application/x-www-form-urlencoded",
    Text = "text/plain"
}
export declare class HttpClient<SecurityDataType = unknown> {
    instance: AxiosInstance;
    private securityData;
    private securityWorker?;
    private secure?;
    private format?;
    constructor({ securityWorker, secure, format, ...axiosConfig }?: ApiConfig<SecurityDataType>);
    setSecurityData: (data: SecurityDataType | null) => void;
    protected mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig;
    protected stringifyFormItem(formItem: unknown): string;
    protected createFormData(input: Record<string, unknown>): FormData;
    request: <T = any, _E = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<AxiosResponse<T>>;
}
export declare class Sdk<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
    amm: {
        ammv2ControllerGetAmmStates: (query: {
            marketIds: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetAMMStatesResponse, any, {}, any>>;
    };
    assets: {
        assetsControllerListAssets: (query?: {
            isCollateral?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<ListAssetsResponse, any, {}, any>>;
    };
    markets: {
        marketsControllerListMarkets: (query?: {
            isMatured?: boolean;
            isUiWhitelisted?: boolean;
            limit?: number;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<ListMarketsResponse, any, {}, any>>;
        marketsControllerGetMarketsByIds: (query: {
            marketIds: string;
        }, params?: RequestParams) => Promise<AxiosResponse<ListMarketsResponse, any, {}, any>>;
        marketsControllerListMarketTrades: (query: {
            marketId: number;
            limit?: number;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketTradesV2Response, any, {}, any>>;
        marketsControllerGetOrderBook: (query: {
            marketId: number;
            tickSize: 0.0001 | 0.001 | 0.01 | 0.1;
            includeAmm?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<OrderBooksResponse, any, {}, any>>;
        marketsControllerGetOhlcv: (query: {
            marketId: number;
            timeFrame: "5m" | "1h" | "1d" | "1w";
            startTimestamp?: number;
            endTimestamp?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<OhlcvChartResponse, any, {}, any>>;
        marketsControllerGetHistoricalUnderlyingApr: (query: {
            assetSymbol: string;
            exchange: string;
            timeFrame: number;
            startTimestamp?: number;
            endTimestamp?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<HistoricalUnderlyingAPRChartResponse, any, {}, any>>;
    };
    indicators: {
        indicatorsControllerGetIndicators: (query: {
            marketId: number;
            timeFrame: "5m" | "1h" | "1d" | "1w";
            startTimestamp?: number;
            endTimestamp?: number;
            select: string;
        }, params?: RequestParams) => Promise<AxiosResponse<IndicatorsResponse, any, {}, any>>;
        indicatorsControllerGetIndicatorsExport: (query: {
            marketId: number;
            timeFrame: "5m" | "1h" | "1d" | "1w";
            startTimestamp?: number;
            endTimestamp?: number;
            select?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<File, any, {}, any>>;
    };
    marketAccountUtilities: {
        marketAccV2ControllerEncode: (query: {
            root: string;
            accountId?: number;
            tokenId: number;
            marketId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<EncodeMarketAccResponse, any, {}, any>>;
        marketAccV2ControllerDecode: (query: {
            marketAcc: string;
        }, params?: RequestParams) => Promise<AxiosResponse<DecodeMarketAccResponse, any, {}, any>>;
    };
    miscellaneous: {
        ordersV2ControllerGetOrdersByPlacedTxHash: (query: {
            placedTxHash: string;
        }, params?: RequestParams) => Promise<AxiosResponse<OrdersByTxHashResponse, any, {}, any>>;
        fundingRateV2ControllerGetAllFundingRateSymbols: (params?: RequestParams) => Promise<AxiosResponse<FundingRateSymbolListResponse, any, {}, any>>;
        fundingRateV2ControllerGetSettlementSummaryByMarket: (data: GetSettlementSummaryByMarketQueryDto, params?: RequestParams) => Promise<AxiosResponse<SettlementMarketSummaryListResponse, any, {}, any>>;
        eventsV2ControllerGetLiquidationEvents: (query?: {
            marketId?: number;
            fromTimestamp?: number;
            toTimestamp?: number;
            limit?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<LiquidationEventListResponse, any, {}, any>>;
        onChainEventsV2ControllerGetEvents: (query?: {
            limit?: number;
            resumeToken?: string;
            eventName?: string;
            sourceAddress?: string;
            fromBlockNumber?: number;
            toBlockNumber?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<OnChainEventsResponse, any, {}, any>>;
        incentivesControllerGetMakerIncentiveCampaign: (marketId: number, query?: {
            maker?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MakerIncentiveCampaignResponse, any, {}, any>>;
        incentivesControllerGetAmmIncentives: (query?: {
            user?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AmmIncentivesResponse, any, {}, any>>;
        makerVolumeControllerGetRollingVolume: (query?: {
            user?: string;
            windowHours?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<RollingVolumeResponse, any, {}, any>>;
        tradeVolumeControllerGetRollingTradeVolume: (query?: {
            user?: string;
            windowHours?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<RollingTradeVolumeResponse, any, {}, any>>;
        strategiesV2ControllerFindStrategies: (params?: RequestParams) => Promise<AxiosResponse<FindStrategiesResponse, any, {}, any>>;
        gasPriceV2ControllerGetGasPriceInfo: (params?: RequestParams) => Promise<AxiosResponse<GasPriceInfoResponse, any, {}, any>>;
        leaderboardV2ControllerGetLeaderboard: (query: {
            period: "all_time" | "30d" | "7d";
            tokenId: number;
            limit?: number;
            offset?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<LeaderboardResponse, any, {}, any>>;
        leaderboardV2ControllerSearchUser: (query: {
            userAddress: string;
            accountId: number;
            period: "all_time" | "30d" | "7d";
            tokenId: number;
        }, params?: RequestParams) => Promise<AxiosResponse<UserSearchResponse, any, {}, any>>;
        tvlV2ControllerGetTvl: (params?: RequestParams) => Promise<AxiosResponse<TvlResponse, any, {}, any>>;
    };
    calldataBuilderUserSigned: {
        calldataBuilderUserControllerBuildDeposit: (data: DepositBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
        calldataBuilderUserControllerBuildRequestWithdrawal: (data: RequestWithdrawalBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
        calldataBuilderUserControllerBuildCancelWithdrawal: (data: CancelWithdrawalBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
        calldataBuilderUserControllerBuildApproveAgent: (data: ApproveAgentBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
        calldataBuilderUserControllerBuildRevokeAgent: (data: RevokeAgentBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
        calldataBuilderUserControllerBuildVaultPayTreasury: (data: VaultPayTreasuryBodyDto, params?: RequestParams) => Promise<AxiosResponse<CalldataBuilderUserResponse, any, {}, any>>;
    };
    calldataBuilderAgentExecutable: {
        calldataBuilderAgentControllerBuildPlaceOrder: (data: PlaceOrderSimpleBodyDto, params?: RequestParams) => Promise<AxiosResponse<PlaceOrdersResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildPlaceOrders: (data: PlaceOrdersBodyDto, params?: RequestParams) => Promise<AxiosResponse<PlaceOrdersResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildCancelOrders: (data: CancelOrdersBodyDto, params?: RequestParams) => Promise<AxiosResponse<AgentCalldataResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildCashTransfer: (data: CashTransferBodyDto, params?: RequestParams) => Promise<AxiosResponse<AgentCalldataResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildEnterMarkets: (data: EnterExitMarketsBodyDto, params?: RequestParams) => Promise<AxiosResponse<AgentCalldataResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildExitMarkets: (data: EnterExitMarketsBodyDto, params?: RequestParams) => Promise<AxiosResponse<AgentCalldataResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildPayTreasury: (data: PayTreasuryBodyDto, params?: RequestParams) => Promise<AxiosResponse<AgentCalldataResponse, any, {}, any>>;
        calldataBuilderAgentControllerBuildAddLiquidityToAmm: (data: AddLiquidityToAmmAgentBodyDto, params?: RequestParams) => Promise<AxiosResponse<BulkAgentExecuteParamsResponseV2, any, {}, any>>;
        calldataBuilderAgentControllerBuildRemoveLiquidityFromAmm: (data: RemoveLiquidityFromAmmAgentBodyDto, params?: RequestParams) => Promise<AxiosResponse<BulkAgentExecuteParamsResponseV2, any, {}, any>>;
    };
    simulations: {
        simulationsControllerSimulateDeposit: (data: DepositSimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<DepositSimulationResponse, any, {}, any>>;
        simulationsControllerSimulateRequestWithdrawal: (data: RequestWithdrawalSimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<WithdrawSimulationResponse, any, {}, any>>;
        simulationsControllerSimulateCashTransfer: (data: CashTransferSimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<CashTransferSimulationResponseV2, any, {}, any>>;
        simulationsControllerSimulatePlaceOrder: (data: PlaceOrderSimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<PlaceOrderSimulationResponseV3, any, {}, any>>;
        simulationsControllerSimulatePlaceOrderAnonymous: (data: PlaceOrderAnonymousSimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<AnonymousPlaceOrderSimulationResponse, any, {}, any>>;
        simulationsControllerSimulateAddLiquidityToAmm: (data: AddLiquidityToAmmV2SimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<AddLiquidityToAmmFeeSimulationResponse, any, {}, any>>;
        simulationsControllerSimulateRemoveLiquidityFromAmm: (data: RemoveLiquidityFromAmmV2SimulationBodyDto, params?: RequestParams) => Promise<AxiosResponse<RemoveLiquidityFromAmmFeeSimulationResponse, any, {}, any>>;
    };
    accounts: {
        accountsV2ControllerGetUserAmmStates: (query: {
            account: string;
        }, params?: RequestParams) => Promise<AxiosResponse<UserVaultStatesResponse, any, {}, any>>;
        accountsV2ControllerGetAccountGasBalance: (query: {
            root: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AccountGasBalanceResponse, any, {}, any>>;
        accountsV2ControllerGetGasConsumptionHistory: (query: {
            root: string;
            limit?: number;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GasConsumptionHistoryV2RootResponse, any, {}, any>>;
        accountsV2ControllerGetTransferLogs: (query: {
            resumeToken?: string;
            limit?: number;
            root: string;
            accountId?: number;
            tokenId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<TransferLogsV2Response, any, {}, any>>;
        accountsV2ControllerGetOrders: (query: {
            root: string;
            accountId?: number;
            marketId?: number;
            resumeToken?: string;
            limit?: number;
            isActive?: boolean;
            orderType?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersV2Response, any, {}, any>>;
        accountsV2ControllerGetOrdersByPlacedTime: (query: {
            root: string;
            accountId?: number;
            resumeToken?: string;
            limit?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersV2Response, any, {}, any>>;
        accountsV2ControllerGetPositionUpdateEvents: (query: {
            marketAcc: string;
            marketId: number;
            limit?: number;
            resumeToken?: string;
            fromBlockNumber?: number;
            toBlockNumber?: number;
            isLimitOrderTrade?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<TransactionsV2Response, any, {}, any>>;
        accountsV2ControllerGetSettlementEvents: (query: {
            root: string;
            accountId?: number;
            marketId?: number;
            resumeToken?: string;
            limit?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<SettlementsV2Response, any, {}, any>>;
        accountsV2ControllerGetMarketAccInfos: (data: GetMarketAccInfosV2Dto, params?: RequestParams) => Promise<AxiosResponse<MarketAccInfosResponse, any, {}, any>>;
        accountsV2ControllerGetMarketAccInfosByRoot: (query: {
            root: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketAccInfosResponse, any, {}, any>>;
        accountsV2ControllerGetActivePositions: (query: {
            root: string;
            accountId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<ActivePositionsWithPnlResponse, any, {}, any>>;
        accountsV2ControllerGetEnteredMarkets: (query: {
            marketAcc: string;
        }, params?: RequestParams) => Promise<AxiosResponse<EnteredMarketsResponse, any, {}, any>>;
        accountsV2ControllerGetMarginConfig: (query: {
            marketAcc: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarginConfigsResponse, any, {}, any>>;
        accountsV2ControllerGetLightEventFeed: (query: {
            root: string;
            limit?: number;
            resumeToken?: string;
            onlyPositionChange?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<LightEventFeedResponse, any, {}, any>>;
    };
    agents: {
        agentsV2ControllerGetAgentExpiryTime: (query: {
            root: string;
            accountId?: number;
            agentAddress: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AgentExpiryTimeResponse, any, {}, any>>;
    };
    sendTxs: {
        sendTxsControllerBulkCalls: (data: BulkAgentExecuteDto, params?: RequestParams) => Promise<AxiosResponse<TxResponse[], any, {}, any>>;
        sendTxsControllerApprove: (data: ApproveAgentQueryDto, params?: RequestParams) => Promise<AxiosResponse<ApproveAgentResponse, any, {}, any>>;
        sendTxsControllerTrace: (data: TraceQueryDto, params?: RequestParams) => Promise<AxiosResponse<TraceResponse, any, {}, any>>;
        sendTxsControllerTxStatus: (data: TxStatusQueryDto, params?: RequestParams) => Promise<AxiosResponse<DedicatedTxStatusResponseV2, any, {}, any>>;
        sendTxsControllerTxStatusWithEvents: (data: TxStatusQueryDto, params?: RequestParams) => Promise<AxiosResponse<DedicatedTxStatusWithEventsResponse, any, {}, any>>;
        sendTxsControllerDedicatedBulkCalls: (data: DedicatedBulkAgentExecuteDto, params?: RequestParams) => Promise<AxiosResponse<DedicatedTxResponse, any, {}, any>>;
    };
    apiKeys: {
        apiKeysControllerCreate: (data: CreateSigningKeyDto, params?: RequestParams) => Promise<AxiosResponse<SigningKeySecretDto, any, {}, any>>;
        apiKeysControllerList: (query: {
            root: string;
            timestamp: number;
            nonce: string;
            signature: string;
            agent?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<SigningKeyDto[], any, {}, any>>;
        apiKeysControllerUpdate: (data: UpdateSigningKeyDto, params?: RequestParams) => Promise<AxiosResponse<SigningKeyDto, any, {}, any>>;
        apiKeysControllerRevoke: (data: SigningKeyIdDto, params?: RequestParams) => Promise<AxiosResponse<void, any, {}, any>>;
        apiKeysMetaControllerDomain: (params?: RequestParams) => Promise<AxiosResponse<Eip712DomainDto, any, {}, any>>;
    };
    stopOrders: {
        stopOrdersControllerGetStopOrders: (query?: {
            marketId?: number;
            tokenId?: number;
            isActive?: boolean;
            resumeToken?: string;
            limit?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<StopOrdersResponse, any, {}, any>>;
        stopOrdersControllerPrepareTpslStopOrder: (query: {
            marketId: number;
            isCross: boolean;
            side: 0 | 1;
            type: 2 | 3;
            closePosition: boolean;
            size: string;
            stopApr: number;
        }, params?: RequestParams) => Promise<AxiosResponse<PrepareTpslStopOrderResponse, any, {}, any>>;
        stopOrdersControllerGetStopOrder: (query: {
            orderId: string;
        }, params?: RequestParams) => Promise<AxiosResponse<StopOrderResponse, any, {}, any>>;
        stopOrdersControllerPlaceStopOrder: (data: PlaceStopOrderBodyDto, params?: RequestParams) => Promise<AxiosResponse<PlaceStopOrderResponse, any, {}, any>>;
        stopOrdersControllerCancelStopOrders: (data: CancelStopOrdersBodyDto, params?: RequestParams) => Promise<AxiosResponse<CancelStopOrdersResponse, any, {}, any>>;
    };
}