export declare enum TransactionAction {
    LONG_YIELD = "LONG_YIELD",
    SHORT_YIELD = "SHORT_YIELD",
    ADD_LIQUIDITY = "ADD_LIQUIDITY",
    REMOVE_LIQUIDITY = "REMOVE_LIQUIDITY"
}
export declare enum TransactionType {
    TRADES = "TRADES",
    LIQUIDITY = "LIQUIDITY"
}
export declare enum PendleAssetType {
    PENDLE_LP = "PENDLE_LP",
    SY = "SY",
    PT = "PT",
    YT = "YT"
}
export interface OrderFilledStatusResponse {
    netInputFromMaker: string;
    netOutputToMaker: string;
    feeAmount: string;
    notionalVolume: string;
}
export interface OrderStateResponse {
    orderType: string;
    exchangeRate: string;
    psAmountToTaker: string;
    psAmountFromTaker: string;
    ysAmountToTaker: string;
    ysAmountFromTaker: string;
    fee: string;
    psRate: number;
    ysRate: number;
    netToMakerIfFullyFilled: string;
    netFromMakerIfFullyFilled: string;
    notionalVolume: string;
    matchableAmount: string;
    notionalVolumeUSD: number;
}
export interface LimitOrderResponse {
    id: string;
    signature: string;
    chainId: number;
    salt: string;
    expiry: string;
    nonce: string;
    type: 0 | 1 | 2 | 3;
    token: string;
    yt: string;
    maker: string;
    receiver: string;
    makingAmount: string;
    currentMakingAmount: string;
    lnImpliedRate: string;
    failSafeRate: string;
    permit: string;
    orderFilledStatus: OrderFilledStatusResponse;
    isActive: boolean;
    isCanceled: boolean;
    createdAt: string;
    orderState?: OrderStateResponse;
    fullyExecutedTimestamp?: string;
    canceledTimestamp?: string;
    latestEventTimestamp?: string;
    sy: string;
    pt: string;
    makerBalance: string;
    failedMintSy: boolean;
    failedMintSyReason: string;
    orderBookBalance: string;
    makingToken: string;
    takingToken: string;
    status: 'FILLABLE' | 'PARTIAL_FILLABLE' | 'FAILED_TRANSFER_TOKEN' | 'EMPTY_MAKER_BALANCE' | 'CANCELLED' | 'FULLY_FILLED' | 'EXPIRED';
}
export interface LimitOrdersResponse {
    total: number;
    limit: number;
    skip: number;
    results: LimitOrderResponse[];
}
export interface LimitOrdersV2Response {
    total: number;
    limit: number;
    results: LimitOrderResponse[];
    resumeToken: string;
}
export interface MakerResponse {
    maker: string;
    sumOrderSizeUsd: number;
    numOrders: number;
}
export interface MakersResponse {
    result: MakerResponse[];
}
export interface GenerateLimitOrderDataDto {
    chainId: number;
    YT: string;
    orderType: 0 | 1 | 2 | 3;
    token: string;
    maker: string;
    makingAmount: string;
    impliedApy: number;
    expiry: string;
}
export interface GenerateLimitOrderDataResponse {
    chainId: number;
    YT: string;
    salt: string;
    expiry: string;
    nonce: string;
    token: string;
    orderType: 0 | 1 | 2 | 3;
    failSafeRate: string;
    maker: string;
    receiver: string;
    makingAmount: string;
    permit: string;
    lnImpliedRate: number;
}
export interface HttpErrorResponse {
    message: string;
    statusCode: number;
    error: string;
}
export interface GenerateScaledOrderDataDto {
    chainId: number;
    YT: string;
    orderType: 0 | 1 | 2 | 3;
    token: string;
    maker: string;
    makingAmount: string;
    lowerImpliedApy: number;
    upperImpliedApy: number;
    orderCount: number;
    sizeDistribution: 'flat' | 'ascending' | 'descending';
    expiry: string;
}
export interface GenerateScaledOrderResponse {
    orders: GenerateLimitOrderDataResponse[];
}
export interface CreateLimitOrderDto {
    chainId: number;
    signature: string;
    salt: string;
    expiry: string;
    nonce: string;
    type: 0 | 1 | 2 | 3;
    token: string;
    yt: string;
    maker: string;
    receiver: string;
    makingAmount: string;
    lnImpliedRate: string;
    failSafeRate: string;
    permit: string;
}
export interface LimitOrderTakerResponse {
    order: LimitOrderResponse;
    makingAmount: string;
    netFromTaker: string;
    netToTaker: string;
}
export interface LimitOrdersTakerResponse {
    total: number;
    limit: number;
    skip: number;
    results: LimitOrderTakerResponse[];
}
export interface OrderBookV2EntryResponse {
    impliedApy: number;
    limitOrderSize: number;
    ammSize?: number;
}
export interface OrderBookV2Response {
    longYieldEntries: OrderBookV2EntryResponse[];
    shortYieldEntries: OrderBookV2EntryResponse[];
}
export interface GetAssetPricesCrossChainResponse {
    prices: Record<string, number>;
    total: number;
    skip: number;
    limit?: number | null;
}
export interface PriceOHLCVCSVResponse {
    total: number;
    currency: string;
    timeFrame: string;
    timestamp_start: number;
    timestamp_end: number;
    results: string;
}
export interface AssetPricesResponse {
    total: number;
    addresses: string[];
    pricesUsd: (number | null)[];
}
export interface NotionalVolumeResponse {
    timestamps: string[];
    volumes: number[];
    ammVolumes: number[];
    limitOrderVolumes: number[];
}
export interface OHLCVDataPoint {
    time: string;
    open: number;
    high: number;
    low: number;
    close: number;
    volume: number;
}
export interface PriceOHLCVResponse {
    limit: number;
    total: number;
    currency: string;
    timeFrame: string;
    timestamp_start?: string;
    timestamp_end?: string;
    results: OHLCVDataPoint[];
}
export interface AssetDataCrossChain {
    name: string;
    decimals: number;
    address: string;
    symbol: string;
    tags: string[];
    expiry: string;
    proIcon: string;
    chainId: number;
}
export interface GetAllAssetsCrossChainResponse {
    assets: AssetDataCrossChain[];
}
export interface AssetData {
    name: string;
    decimals: number;
    address: string;
    symbol: string;
    tags: string[];
    expiry: string;
    proIcon: string;
}
export interface GetAssetsResponse {
    assets: AssetData[];
}
export interface GetAssetPricesResponse {
    prices: Record<string, number>;
    total: number;
    skip: number;
    limit?: number | null;
}
export interface ValuationResponse {
    usd?: number | null;
    acc?: number | null;
}
export interface AssetResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    decimals: number;
    expiry?: string | null;
    accentColor?: string | null;
    price?: ValuationResponse | null;
    priceUpdatedAt?: string | null;
    name: string;
    baseType: string;
    types: string[];
    protocol?: string | null;
    underlyingPool?: string | null;
    proSymbol?: string | null;
    proIcon?: string | null;
    zappable?: boolean | null;
    simpleName: string;
    simpleSymbol: string;
    simpleIcon: string;
    proName: string;
}
export interface AssetsResponse {
    total: number;
    limit: number;
    skip: number;
    results: AssetResponse[];
}
export interface AssetCSVResponse {
    results: string;
}
export interface VersionResponse {
    major: number;
    minor: number;
    patch: number;
}
export interface TokenInfoResponse {
    chainId: number;
    address: string;
    decimals: number;
    name: string;
    symbol: string;
    logoURI: string;
    tags: string[];
    extensions: object;
}
export interface UniswapTokenListResponse {
    name: string;
    timestamp: string;
    version: VersionResponse;
    tokens: TokenInfoResponse[];
    tokenMap: Record<string, TokenInfoResponse>;
    keywords: string[];
    logoURI: string;
    tags: Record<string, TagDefinitionResponse>;
}
export interface SolanaTokenFileResponse {
    uri: string;
    type: string;
}
export interface SolanaTokenPropertiesResponse {
    files: SolanaTokenFileResponse[];
}
export interface SolanaTokenResponse {
    name: string;
    symbol: string;
    description: string;
    image: string;
    attributes: string[];
    properties: SolanaTokenPropertiesResponse;
}
export interface SyBasicResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    decimals: number;
    expiry?: string | null;
    accentColor?: string | null;
    price?: ValuationResponse | null;
    priceUpdatedAt?: string | null;
    name: string;
    baseType: string;
    types: string[];
    protocol?: string | null;
    underlyingPool?: string | null;
    proSymbol?: string | null;
    proIcon?: string | null;
    zappable?: boolean | null;
    simpleName: string;
    simpleSymbol: string;
    simpleIcon: string;
    proName: string;
    accountingAssetType: number;
    accountingAsset: string;
    underlyingAsset: string;
    rewardTokens: string[];
    inputTokens: string[];
    outputTokens: string[];
}
export interface WhitelistedSysResponse {
    results: SyBasicResponse[];
}
export interface SyResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    decimals: number;
    expiry?: string | null;
    accentColor?: string | null;
    price?: ValuationResponse | null;
    priceUpdatedAt?: string | null;
    name: string;
    baseType: string;
    types: string[];
    protocol?: string | null;
    underlyingPool?: string | null;
    proSymbol?: string | null;
    proIcon?: string | null;
    zappable?: boolean | null;
    simpleName: string;
    simpleSymbol: string;
    simpleIcon: string;
    proName: string;
    accountingAssetType: number;
    accountingAsset: AssetResponse;
    underlyingAsset: AssetResponse;
    rewardTokens: AssetResponse[];
    inputTokens: AssetResponse[];
    outputTokens: AssetResponse[];
}
export interface YieldRangeResponse {
    min: number;
    max: number;
}
export interface MarketDetailsV2Entity {
    liquidity: number;
    totalTvl: number;
    tradingVolume: number;
    underlyingApy: number;
    swapFeeApy: number;
    pendleApy: number;
    impliedApy: number;
    feeRate: number;
    yieldRange: YieldRangeResponse;
    aggregatedApy: number;
    maxBoostedApy: number;
    totalPt: number;
    totalSy: number;
    totalSupply: number;
    totalActiveSupply: number;
}
export interface MarketCrossChainData {
    name: string;
    address: string;
    expiry: string;
    pt: string;
    yt: string;
    sy: string;
    underlyingAsset: string;
    details: MarketDetailsV2Entity;
    isNew: boolean;
    isPrime: boolean;
    timestamp: string;
    lpWrapper?: string;
    categoryIds?: string[];
    chainId: number;
}
export interface GetMarketsCrossChainResponse {
    markets: MarketCrossChainData[];
}
export interface PointMetadataEntity {
    key: string;
    type: 'multiplier' | 'points-per-asset';
    pendleAsset: 'basic' | 'lp';
    externalDashboardURL: string;
    value: number;
    perDollarLp: boolean;
}
export interface MarketPointsEntity {
    id: string;
    points: PointMetadataEntity[];
}
export interface GetPointsMarketsResponse {
    markets: MarketPointsEntity[];
}
export interface MarketDetails {
    liquidity: number;
    pendleApy: number;
    impliedApy: number;
    feeRate: number;
    yieldRange: YieldRangeResponse;
    aggregatedApy: number;
    maxBoostedApy: number;
}
export interface MarketData {
    name: string;
    address: string;
    expiry: string;
    pt: string;
    yt: string;
    sy: string;
    underlyingAsset: string;
    details: MarketDetails;
    isNew: boolean;
    isPrime: boolean;
    timestamp: string;
    lpWrapper?: string;
    categoryIds?: string[];
}
export interface GetActiveMarketsResponse {
    markets: MarketData[];
}
export interface GetInactiveMarketsResponse {
    markets: MarketData[];
}
export interface MarketApyHistoriesCSVResponse {
    total: number;
    timestamp_start: number;
    timestamp_end: number;
    results: string;
}
export interface MarketExtendedInfoResponse {
    floatingPt: number;
    floatingSy: number;
    sySupplyCap?: number | null;
    syCurrentSupply?: number | null;
    pyUnit: string;
    ptEqualsPyUnit: boolean;
    underlyingAssetWorthMore?: string;
    nativeWithdrawalURL?: string;
    nativeDepositURL?: string;
    defaultMigratePool?: string;
    feeRate?: number;
    yieldRange?: YieldRangeResponse;
}
export interface MarketBasicMetadataResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    expiry: string;
    pt: AssetResponse;
    yt: AssetResponse;
    sy: AssetResponse;
    lp: AssetResponse;
    accountingAsset: AssetResponse;
    underlyingAsset: AssetResponse;
    basePricingAsset?: AssetResponse | null;
    protocol?: string | null;
    underlyingPool?: string | null;
    proSymbol?: string | null;
    proIcon?: string | null;
    assetRepresentation: string;
    isWhitelistedPro: boolean;
    isWhitelistedSimple: boolean;
    votable: boolean;
    isActive: boolean;
    isWhitelistedLimitOrder: boolean;
    accentColor?: string | null;
    totalPt?: number | null;
    totalSy?: number | null;
    totalLp?: number | null;
    liquidity?: ValuationResponse | null;
    tradingVolume?: ValuationResponse | null;
    underlyingInterestApy?: number | null;
    underlyingRewardApy?: number | null;
    underlyingApy?: number | null;
    impliedApy?: number | null;
    ytFloatingApy?: number | null;
    ptDiscount?: number | null;
    swapFeeApy?: number | null;
    pendleApy?: number | null;
    arbApy?: number | null;
    aggregatedApy?: number | null;
    maxBoostedApy?: number | null;
    lpRewardApy?: number | null;
    voterApy?: number | null;
    ytRoi?: number | null;
    ptRoi?: number | null;
    dataUpdatedAt?: string | null;
    categoryIds: string[];
    timestamp: string;
    whitelistedProAt?: string | null;
    scalarRoot: number;
    initialAnchor: number;
    extendedInfo: MarketExtendedInfoResponse;
    isFeatured?: boolean | null;
    isPopular?: boolean | null;
    tvlThresholdTimestamp?: string | null;
    isNew: boolean;
    name: string;
    simpleName: string;
    simpleSymbol: string;
    simpleIcon: string;
    proName: string;
    farmName: string;
    farmSymbol: string;
    farmSimpleName: string;
    farmSimpleSymbol: string;
    farmSimpleIcon: string;
    farmProName: string;
    farmProSymbol: string;
    farmProIcon: string;
}
export interface MarketsResponse {
    total: number;
    limit: number;
    skip: number;
    results: MarketBasicMetadataResponse[];
}
export interface CurrenyAmountEntity {
    currency: string;
    amount?: number | null;
}
export interface FeaturedMarketEntity {
    marketAddress: string;
    icon: string;
    tokenSymbol: string;
    symbol: string;
    accentColor: string;
    discountedPrice: CurrenyAmountEntity;
    fixedApy: number;
    currentPrice: CurrenyAmountEntity;
}
export interface FeaturedMarketsResponseEntity {
    total: number;
    limit: number;
    skip: number;
    results: FeaturedMarketEntity[];
}
export interface AssetBasicResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    decimals: number;
    expiry?: string | null;
    accentColor?: string | null;
    price?: ValuationResponse | null;
    priceUpdatedAt?: string | null;
    name: string;
}
export interface ApyBreakdownResponse {
    asset: AssetBasicResponse;
    absoluteApy: number;
    relativeApy: number;
    ytExclusive?: boolean | null;
    lpExclusive?: boolean | null;
    source?: 'CONTRACT' | 'EXTERNAL_REWARD' | 'PORTAL_INCENTIVE' | 'PENDLE_CO_BRIBE' | 'PLASMA_INCENTIVE' | null;
}
export interface EstimatedDailyPoolRewardResponse {
    asset: AssetBasicResponse;
    amount: number;
}
export interface MarketResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    expiry: string;
    pt: AssetResponse;
    yt: AssetResponse;
    sy: AssetResponse;
    lp: AssetResponse;
    accountingAsset: AssetResponse;
    underlyingAsset: AssetResponse;
    basePricingAsset?: AssetResponse | null;
    rewardTokens: AssetResponse[];
    inputTokens: AssetResponse[];
    outputTokens: AssetResponse[];
    protocol?: string | null;
    underlyingPool?: string | null;
    proSymbol?: string | null;
    proIcon?: string | null;
    assetRepresentation: string;
    isWhitelistedPro: boolean;
    isWhitelistedSimple: boolean;
    votable: boolean;
    isActive: boolean;
    isWhitelistedLimitOrder: boolean;
    accentColor?: string | null;
    totalPt?: number | null;
    totalSy?: number | null;
    totalLp?: number | null;
    totalActiveSupply?: number | null;
    liquidity?: ValuationResponse | null;
    tradingVolume?: ValuationResponse | null;
    underlyingInterestApy?: number | null;
    underlyingRewardApy?: number | null;
    underlyingRewardApyBreakdown?: ApyBreakdownResponse[] | null;
    underlyingApy?: number | null;
    impliedApy?: number | null;
    ytFloatingApy?: number | null;
    ptDiscount?: number | null;
    swapFeeApy?: number | null;
    pendleApy?: number | null;
    arbApy?: number | null;
    aggregatedApy?: number | null;
    maxBoostedApy?: number | null;
    lpRewardApy?: number | null;
    voterApy?: number | null;
    ytRoi?: number | null;
    ptRoi?: number | null;
    estimatedDailyPoolRewards?: EstimatedDailyPoolRewardResponse[] | null;
    dataUpdatedAt?: string | null;
    liquidityChange24h?: number | null;
    tradingVolumeChange24h?: number | null;
    underlyingInterestApyChange24h?: number | null;
    underlyingRewardApyChange24h?: number | null;
    underlyingApyChange24h?: number | null;
    impliedApyChange24h?: number | null;
    ytFloatingApyChange24h?: number | null;
    ptDiscountChange24h?: number | null;
    swapFeeApyChange24h?: number | null;
    pendleApyChange24h?: number | null;
    aggregatedApyChange24h?: number | null;
    lpRewardApyChange24h?: number | null;
    voterApyChange24h?: number | null;
    categoryIds: string[];
    timestamp: string;
    scalarRoot: number;
    initialAnchor: number;
    extendedInfo: MarketExtendedInfoResponse;
    isFeatured?: boolean | null;
    isPopular?: boolean | null;
    tvlThresholdTimestamp?: string | null;
    whitelistedProAt?: string | null;
    isNew: boolean;
    name: string;
    simpleName: string;
    simpleSymbol: string;
    simpleIcon: string;
    proName: string;
    farmName: string;
    farmSymbol: string;
    farmSimpleName: string;
    farmSimpleSymbol: string;
    farmSimpleIcon: string;
    farmProName: string;
    farmProSymbol: string;
    farmProIcon: string;
}
export interface MarketDataResponse {
    timestamp: string;
    liquidity: ValuationResponse;
    tradingVolume: ValuationResponse;
    totalTvl?: ValuationResponse | null;
    underlyingInterestApy: number;
    underlyingRewardApy: number;
    underlyingApy: number;
    impliedApy: number;
    ytFloatingApy: number;
    swapFeeApy: number;
    voterApy: number;
    ptDiscount: number;
    pendleApy: number;
    arbApy?: number;
    lpRewardApy: number;
    aggregatedApy: number;
    maxBoostedApy: number;
    estimatedDailyPoolRewards: EstimatedDailyPoolRewardResponse[];
    totalPt: number;
    totalSy: number;
    totalLp: number;
    totalActiveSupply: number;
    assetPriceUsd: number;
}
export interface MarketHistoryResponse {
    timestamp: string;
    liquidity: ValuationResponse;
    tradingVolume: ValuationResponse;
    totalTvl?: ValuationResponse | null;
    underlyingInterestApy: number;
    underlyingRewardApy: number;
    underlyingApy: number;
    impliedApy: number;
    ytFloatingApy: number;
    ptDiscount: number;
    swapFeeApy: number;
    pendleApy: number;
    aggregatedApy: number;
    lpRewardApy: number;
    voterApy: number;
    totalPt: number;
    totalSy: number;
    totalLp: number;
    totalActiveSupply: number;
}
export interface MarketHistoriesResponse {
    total: number;
    limit?: number;
    timestamp_start: string;
    timestamp_end?: string;
    results: MarketHistoryResponse[];
}
export interface MarketApyHistoryResponse {
    timestamp: string;
    underlyingApy: number;
    impliedApy: number;
}
export interface MarketApyHistoriesResponse {
    total: number;
    limit: number;
    timestamp_start: string;
    timestamp_end: string;
    results: MarketApyHistoryResponse[];
}
export interface GetMarketStatHistoryCSVResponse {
    total: number;
    timestamp_start: number;
    timestamp_end: number;
    results: string;
}
export interface MarketHistoricalDataPoint {
    timestamp: string;
    maxApy?: number;
    baseApy?: number;
    underlyingApy?: number;
    impliedApy?: number;
    tvl?: number;
    totalTvl?: number;
    underlyingInterestApy?: number;
    underlyingRewardApy?: number;
    ytFloatingApy?: number;
    swapFeeApy?: number;
    voterApr?: number;
    pendleApy?: number;
    lpRewardApy?: number;
    totalPt?: number;
    totalSy?: number;
    totalSupply?: number;
    ptPrice?: number;
    ytPrice?: number;
    syPrice?: number;
    lpPrice?: number;
    lastEpochVotes?: number;
    tradingVolume?: number;
    explicitSwapFee?: number;
    implicitSwapFee?: number;
    limitOrderFee?: number;
}
export interface MarketHistoricalDataResponse {
    total: number;
    timestamp_start: string;
    timestamp_end: string;
    results: MarketHistoricalDataPoint[];
}
export interface MarketHistoricalDataTableResponse {
    total: number;
    timestamp_start: number;
    timestamp_end: number;
    timestamp: number[];
    maxApy?: number[];
    baseApy?: number[];
    underlyingApy?: number[];
    impliedApy?: number[];
    tvl?: number[];
    totalTvl?: number[];
    underlyingInterestApy?: number[];
    underlyingRewardApy?: number[];
    ytFloatingApy?: number[];
    swapFeeApy?: number[];
    voterApr?: number[];
    pendleApy?: number[];
    lpRewardApy?: number[];
    totalPt?: number[];
    totalSy?: number[];
    totalSupply?: number[];
    ptPrice?: number[];
    ytPrice?: number[];
    syPrice?: number[];
    lpPrice?: number[];
    lastEpochVotes?: number[];
    explicitSwapFee?: number[];
    implicitSwapFee?: number[];
    limitOrderFee?: number[];
}
export interface MarketImpliedApyDataPoint {
    timestamp: number;
    impliedApy: number;
}
export interface MarketImpliedApyResponseEntity {
    total: number;
    timestamp_start?: number;
    timestamp_end?: number;
    results: MarketImpliedApyDataPoint[];
}
export interface MarketAssetsResponse {
    pt: AssetResponse;
    yt: AssetResponse;
    sy: AssetResponse;
    lp: AssetResponse;
    accountingAsset: AssetResponse;
    underlyingAsset: AssetResponse;
    basePricingAsset: AssetResponse;
    rewardTokens: AssetResponse[];
    inputTokens: AssetResponse[];
    outputTokens: AssetResponse[];
}
export interface MarketCategoryResponse {
    id: string;
    name: string;
}
export interface GetAllMarketCategoriesResponse {
    results: MarketCategoryResponse[];
}
export interface UtilizedProtocolResponse {
    id: string;
    url: string;
    name: string;
    imageUrl: string;
}
export interface GetAllUtilizedProtocolsResponse {
    results: UtilizedProtocolResponse[];
}
export interface VoteV2Response {
    votes: number;
    percentage: number;
}
export interface PoolV2Response {
    id: string;
    symbol: string;
    expiry: string;
    currentVoterApr?: number;
    lastEpochVoterApr?: number;
    currentSwapFee?: number;
    lastEpochSwapFee?: number;
    projectedVoterApr?: number;
    projectedVotes?: VoteV2Response | null;
    currentVotes?: VoteV2Response | null;
    expectedCap?: string;
    currentCap?: string;
}
export interface VePendleDataResponse {
    avgLockDuration: number;
    totalPendleLocked: number;
    vePendleSupply: number;
    totalProjectedVotes: number;
    totalCurrentVotes: number;
    pools: PoolV2Response[];
}
export interface PendleTokenSupplyResponse {
    timestamp: string;
    totalPendleCirculating: number;
    totalPendleLocked: number;
    totalPendleSupply: number;
}
export interface GetMonthlyRevenueResponse {
    revenues: number[];
    epochStartDates: string[];
    accumulatedRevenue: number;
}
export interface VePendleExtendedDataResponse {
    avgLockDuration: number;
    totalPendleLocked: number;
    vePendleSupply: number;
    totalProjectedVotes: number;
    totalCurrentVotes: number;
    pools: PoolV2Response[];
    tokenSupply?: PendleTokenSupplyResponse;
    monthlyRevenue?: GetMonthlyRevenueResponse;
}
export interface PoolResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    expiry: string;
    protocol?: string | null;
    underlyingPool?: string | null;
    voterApy: number;
    accentColor?: string | null;
    name: string;
    farmSimpleName: string;
    farmSimpleIcon: string;
    farmProName: string;
    farmProIcon: string;
}
export interface VoteResponse {
    pool: PoolResponse;
    votes: number;
    percentage: number;
}
export interface VoteSnapshotResponse {
    votes: VoteResponse[];
    totalPools: number;
    totalVotes: number;
    epoch: string;
}
export interface PoolVoterApyResponse {
    pool: PoolResponse;
    voterApy: number;
}
export interface PoolVoterApysResponse {
    results: PoolVoterApyResponse[];
    totalPools: number;
    timestamp: string;
}
export interface PoolVoterAprSwapFeeResponse {
    pool: PoolResponse;
    currentVoterApr: number;
    lastEpochVoterApr: number;
    currentSwapFee: number;
    lastEpochSwapFee: number;
    projectedVoterApr: number;
}
export interface PoolVoterAprsSwapFeesResponse {
    results: PoolVoterAprSwapFeeResponse[];
    totalPools: number;
    totalFee: number;
    timestamp: string;
}
export interface VoterApyChartDataPoint {
    time: string;
    voterApy: number;
}
export interface PoolVoterApyChart {
    values: VoterApyChartDataPoint[];
    pool: PoolResponse;
}
export interface VoterApyChartResponse {
    results: PoolVoterApyChart[];
}
export interface VePendleApyChartDataPoint {
    time: string;
    vePendleBaseApy: number;
    vePendleMaxApy: number;
}
export interface VePendleApyChartResponse {
    results: VePendleApyChartDataPoint[];
    timeFrame: string;
    timestamp_gte: string;
    timestamp_lte: string;
}
export interface VoteData {
    txHash: string;
    timestamp: string;
    poolChainId: number;
    poolAddress: string;
    user: string;
    weight: number;
    vePendleVote: number;
}
export interface GetHistoricalVotesResponse {
    data: VoteData[];
}
export interface MarketMetaData {
    id: string;
}
export interface TotalFeesWithTimestamp {
    time: string;
    totalFees: number;
}
export interface MarketTotalFeesData {
    market: MarketMetaData;
    values: TotalFeesWithTimestamp[];
}
export interface AllMarketTotalFeesResponse {
    results: MarketTotalFeesData[];
}
export interface GetOngoingVotesResponse {
    votes: VoteResponse[];
    totalPools: number;
    totalVotes: number;
}
export interface GetVePendleCapResponse {
    fee: object;
    currentCap: object;
    expectedCap: object;
}
export interface MetadataQueryDto {
    keys: string[];
}
export interface MetadataResponse {
    results: object;
    total: number;
}
export interface MetadataValuesResponse {
    values: (object | null)[];
}
export interface GetMetadataByTemplateResponse {
    keys: string[];
    values: object[];
}
export interface MarketTokensResponse {
    tokensMintSy: string[];
    tokensRedeemSy: string[];
    tokensIn: string[];
    tokensOut: string[];
}
export interface SupportedAggregator {
    name: string;
    computingUnit: number;
}
export interface SupportedAggregatorsResponse {
    aggregators: SupportedAggregator[];
}
export interface GetSpotSwappingPriceResponse {
    underlyingToken: string;
    underlyingTokenToPtRate: object | null;
    ptToUnderlyingTokenRate: object | null;
    underlyingTokenToYtRate: object | null;
    ytToUnderlyingTokenRate: object | null;
    impliedApy: number;
}
export interface TransactionDto {
    data: string;
    to: string;
    from: string;
    value: string;
}
export interface TokenAmountResponse {
    token: string;
    amount: string;
}
export interface PriceImpactBreakDownData {
    internalPriceImpact: number;
    externalPriceImpact: number;
}
export interface ImpliedApy {
    before: number;
    after: number;
}
export interface FeeUsd {
    usd: number;
}
export interface SwapData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
    impliedApy?: ImpliedApy;
    effectiveApy?: number;
    fee: FeeUsd;
}
export interface SwapResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: SwapData;
}
export interface AddLiquidityData {
    amountLpOut: string;
    amountYtOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
    impliedApy?: ImpliedApy;
    fee: FeeUsd;
}
export interface AddLiquidityResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: AddLiquidityData;
}
export interface RemoveLiquidityData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
    impliedApy?: ImpliedApy;
    fee: FeeUsd;
}
export interface RemoveLiquidityResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: RemoveLiquidityData;
}
export interface MintData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface MintResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: MintData;
}
export interface RedeemData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface RedeemResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: RedeemData;
}
export interface MintSyData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface MintSyResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: MintSyData;
}
export interface RedeemSyData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface RedeemSyResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: RedeemSyData;
}
export interface TransferLiquidityData {
    amountLpOut: string;
    amountYtOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
    fee: FeeUsd;
}
export interface ContractParamInfo {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
}
export interface ParamsBreakdown {
    selfCall1: ContractParamInfo;
    selfCall2?: ContractParamInfo;
    reflectCall: ContractParamInfo;
}
export interface TransferLiquidityResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: TransferLiquidityData;
    paramsBreakdown: ParamsBreakdown;
}
export interface RollOverPtData {
    amountPtOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
    effectiveApy?: number;
    fee: FeeUsd;
}
export interface RollOverPtResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: RollOverPtData;
    paramsBreakdown: ParamsBreakdown;
}
export interface AddLiquidityDualData {
    amountOut: string;
    amountTokenUsed: string;
    amountPtUsed: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface AddLiquidityDualResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: AddLiquidityDualData;
}
export interface RemoveLiquidityDualData {
    amountTokenOut: string;
    amountPtOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface RemoveLiquidityDualResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: RemoveLiquidityDualData;
}
export interface SdkResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
}
export interface PendleSwapInput {
    token: string;
    amount: string;
}
export interface PendleSwapDtoV2 {
    receiver?: string;
    inputs: PendleSwapInput[];
    tokenOut: string;
    slippage: number;
    aggregators?: string;
}
export interface PendleSwapData {
    amountOut: string;
    priceImpact: number;
    priceImpactBreakDown: PriceImpactBreakDownData;
}
export interface PendleSwapResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: PendleSwapData;
}
export interface RedeemInterestsAndRewardsResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
}
export interface ConvertData {
    aggregatorType: string;
    priceImpact: number;
    impliedApy?: ImpliedApy;
    priceImpactBreakDown: PriceImpactBreakDownData;
    effectiveApy?: number;
    paramsBreakdown?: ParamsBreakdown;
    fee?: FeeUsd;
}
export interface ConvertResponse {
    contractParamInfo: ContractParamInfo;
    tx: TransactionDto;
    outputs: TokenAmountResponse[];
    data: ConvertData;
}
export interface MultiRouteConvertResponse {
    action: 'swap' | 'add-liquidity' | 'remove-liquidity' | 'exit-market' | 'transfer-liquidity' | 'roll-over-pt' | 'add-liquidity-dual' | 'remove-liquidity-dual' | 'mint-py' | 'redeem-py' | 'mint-sy' | 'redeem-sy' | 'pendle-swap' | 'convert-lp-to-pt';
    inputs: TokenAmountResponse[];
    requiredApprovals?: TokenAmountResponse[];
    routes: ConvertResponse[];
    rewards?: TokenAmountResponse[];
}
export interface TokenAmountDto {
    token: string;
    amount: string;
}
export interface OKXCustomParamsDto {
    fromTokenReferrerWalletAddress?: string;
    toTokenReferrerWalletAddress?: string;
    feePercent?: number;
    positiveSlippagePercent?: number;
}
export interface ConvertV3Dto {
    receiver?: string;
    slippage: number;
    enableAggregator?: boolean;
    aggregators?: string[];
    inputs: TokenAmountDto[];
    outputs: string[];
    redeemRewards?: boolean;
    needScale?: boolean;
    additionalData?: string;
    useLimitOrder?: boolean;
    okxSwapParams?: OKXCustomParamsDto;
}
export interface SwapPtCrossChainData {
    netTokenOut: string;
    netPtIn: string;
}
export interface SwapPtCrossChainResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: SwapPtCrossChainData;
}
export interface SwapWithFixedPricePtAmmData {
    netTokenOut: string;
}
export interface SwapWithFixedPricePtAmmResponse {
    method: string;
    contractCallParamsName: string[];
    contractCallParams: any[][];
    tx: TransactionDto;
    tokenApprovals?: TokenAmountResponse[];
    data: SwapWithFixedPricePtAmmData;
}
export interface PtCrossChainMetadataResponse {
    pairedTokensOut: string[];
    ammAddress?: string;
}
export interface MarketBasicResponse {
    id: string;
    chainId: number;
    address: string;
    symbol: string;
    expiry: string;
    name: string;
}
export interface AssetAmountResponse {
    asset: AssetResponse;
    amount: number;
    price: ValuationResponse;
}
export interface TransactionResponse {
    id: string;
    chainId: number;
    txHash: string;
    blockNumber: number;
    timestamp: string;
    action: string;
    origin: string;
    market: MarketBasicResponse;
    inputs: AssetAmountResponse[];
    outputs: AssetAmountResponse[];
    user: string;
    valuation: ValuationResponse;
    implicitSwapFeeSy: number;
    explicitSwapFeeSy: number;
    impliedApy: number;
    assetPrices: object;
    gasUsed: number;
}
export interface TransactionsResponse {
    total: number;
    limit: number;
    skip: number;
    results: TransactionResponse[];
}
export interface NotionalV5 {
    pt: number;
}
export interface TransactionV5Response {
    id: string;
    market: string;
    timestamp: string;
    chainId: number;
    txHash: string;
    value: number;
    type: string;
    action: string;
    txOrigin?: string;
    impliedApy: number;
    notional?: NotionalV5;
}
export interface TransactionsV5Response {
    total: number;
    resumeToken?: string;
    limit: number;
    skip: number;
    results: TransactionV5Response[];
}
export interface TransactionsV4Response {
    total: number;
    limit: number;
    skip: number;
    results: string[];
    resumeToken?: string;
}
export interface TvlAndTradingVolumeResponseEntity {
    tvl: number;
    tradingVolume: number;
}
export interface GetDistinctUsersFromTokenEntity {
    users: string[];
}
export interface EulerUserResponse {
    user: string;
    subAccount: string;
    asset: string;
}
export interface MorphoUserResponse {
    user: string;
    marketId: string;
}
export interface SiloUserResponse {
    user: string;
    asset: string;
}
export interface MorphoConfigResponse {
    id: string;
    morphoAddress: string;
}
export interface WlpDistinctUsersResponse {
    wlpUsersTotal: number;
    eulerUsersTotal: number;
    morphoUsersTotal: number;
    siloUsersTotal: number;
    wlpUsers: string[];
    eulerUsers: EulerUserResponse[];
    morphoUsers: MorphoUserResponse[];
    siloUsers: SiloUserResponse[];
    wlpAddress: string;
    morphoConfigs: MorphoConfigResponse[];
}
export interface LiquidLockerPoolResponse {
    name: string;
    lpHolder: string;
    receiptToken: string;
    users: string[];
    errorMessage: string;
}
export interface LiquidLockerPoolsResponse {
    total: number;
    results: LiquidLockerPoolResponse[];
}
export interface WlpHolderMappingResponse {
    holder: string;
    asset: string;
    moneyMarket: string;
}
export interface GetAllRelatedInfoFromLpAndWlpResponse {
    distinctUsers: string[];
    liquidLockerPools: LiquidLockerPoolResponse[];
    wlpDistinctUsersResponse: WlpDistinctUsersResponse;
    wlpHolderMappings: WlpHolderMappingResponse[];
}
export interface MerkleRewardsResponse {
    accruedAmount: string;
    rewardBreakdowns: string[] | null;
    updatedAt: string;
}
export interface MerkleProofResponse {
    proof: string[];
    accruedAmount: string;
    updatedAt: string;
    verifyCallData?: string;
    merkleRoot: string;
}
export interface NotFoundResponse {
    message: string;
    statusCode: number;
}
export interface TokenProof {
    token: string;
    proof: string[];
    accruedAmount: string;
    verifyCallData?: string;
}
export interface MultiTokenMerkleProofResponse {
    proof: TokenProof[];
    merkleRoot: string;
    updatedAt: string;
    chainId: number;
    distributorAddress: string;
    campaignId: string;
}
export interface MerkleProofV2Response {
    total: number;
    results: MultiTokenMerkleProofResponse[];
}
export interface SyTokenOutRouteResponse {
    toSyAddress: string;
    defaultTokenOut: string;
}
export interface SyTokenOutRouteListResponse {
    tokenOutRoutes: SyTokenOutRouteResponse[];
}
export interface GetLiquidityTransferableMarketsResponse {
    marketAddresses: string[];
}
export interface CrossChainPtData {
    spokePt: string;
    hubPt: string;
    hubChainId: number;
}
export interface ChainIdSimplifiedData {
    chainId: number;
    sys: string[];
    markets: string[];
    pts: string[];
    yts: string[];
    crossPts: CrossChainPtData[];
}
export interface GetSimplifiedDataResponse {
    data: ChainIdSimplifiedData[];
}
export interface GetSafePendleAddressesResponse {
    sys: string[];
    pts: string[];
    yts: string[];
}
export interface ChainIdsResponse {
    chainIds: number[];
}
export interface ClaimTokenAmount {
    token: string;
    amount: string;
}
export interface Position {
    balance: string;
    activeBalance?: string;
    valuation: number;
    claimTokenAmounts?: ClaimTokenAmount[];
}
export interface CrossPtPosition {
    spokePt: string;
    balance: string;
}
export interface MarketPosition {
    marketId: string;
    pt: Position;
    yt: Position;
    lp: Position;
    crossPtPositions: CrossPtPosition[];
}
export interface SyPosition {
    syId: string;
    balance: string;
    claimTokenAmounts?: ClaimTokenAmount[];
}
export interface UserPositionsResponse {
    chainId: number;
    totalOpen: number;
    totalClosed: number;
    totalSy: number;
    openPositions: MarketPosition[];
    closedPositions: MarketPosition[];
    syPositions: SyPosition[];
    updatedAt: string;
    errorMessage?: string;
}
export interface UserPositionsCrossChainResponse {
    positions: UserPositionsResponse[];
}
export interface MerkleUserCampaignResponse {
    user: string;
    token: string;
    merkleRoot: string;
    chainId: number;
    assetId: string;
    amount: string;
    toTimestamp: string;
    fromTimestamp: string;
}
export interface MerkleClaimableRewardsResponse {
    claimableRewards: MerkleUserCampaignResponse[];
}
export interface MerkleClaimedRewardsResponse {
    claimedRewards: MerkleUserCampaignResponse[];
}
export interface SpokePtData {
    spokeChainId: number;
    spokeAddress: string;
}
export interface PtCrossChainData {
    hubPtChainId: number;
    hubPtAddress: string;
    spokePts: SpokePtData[];
}
export interface GetAllCrossPtsResponse {
    result: PtCrossChainData[];
}
export interface ValuationEntity {
    usd: number;
    asset: number;
    eth: number;
}
export interface SpendUnitData {
    unit: number;
    spent_v2: ValuationEntity;
}
export interface PriceAssetData {
    pt: number;
    yt: number;
    lp: number;
}
export interface PnLTransactionEntity {
    chainId: number;
    market: string;
    user: string;
    timestamp: string;
    action: 'addLiquidityDualTokenAndPt' | 'addLiquiditySinglePt' | 'addLiquiditySingleToken' | 'addLiquiditySingleTokenKeepYt' | 'removeLiquidityDualTokenAndPt' | 'removeLiquidityToPt' | 'removeLiquiditySingleToken' | 'mintPy' | 'redeemPy' | 'swapYtToPt' | 'swapPtToYt' | 'redeemYtRewards' | 'redeemYtYield' | 'redeemMarketRewards' | 'buyPt' | 'sellPt' | 'transferPtIn' | 'transferPtOut' | 'buyYt' | 'sellYt' | 'transferYtIn' | 'transferYtOut' | 'transferLpIn' | 'transferLpOut' | 'sellYtLimitOrder' | 'buyYtLimitOrder' | 'sellPtLimitOrder' | 'buyPtLimitOrder';
    ptData: SpendUnitData;
    ytData: SpendUnitData;
    lpData: SpendUnitData;
    priceInAsset: PriceAssetData;
    profit: ValuationEntity;
    txValueAsset: number;
    assetUsd: number;
    assetEth: number;
    ptExchangeRate: number;
    effectivePtExchangeRate?: number;
    ptExchangeRateAfter?: number;
    txHash?: string;
}
export interface TransactionsResponseEntity {
    total: number;
    results: PnLTransactionEntity[];
}
export interface BlockEntity {
    blockNumber: number;
    blockTimestamp: number;
}
export interface IntegrationAssetEntity {
    id: string;
    symbol: string;
    name: string;
    decimals: number;
}
export interface IntegrationAssetResponse {
    asset: IntegrationAssetEntity;
}
export interface PairEntity {
    id: string;
    dexKey: string;
    asset0Id: string;
    asset1Id: string;
}
export interface IntegrationPairResponse {
    pair: PairEntity;
}
export interface Reserves {
    asset0: string;
    asset1: string;
}
export interface SwapEvent {
    block: BlockEntity;
    txnId: string;
    txnIndex: number;
    eventIndex: number;
    maker: string;
    pairId: string;
    reserves: Reserves;
    eventType: 'swap' | 'join' | 'exit';
    asset0In: string;
    asset1In: string;
    asset0Out: string;
    asset1Out: string;
    priceNative: string;
}
export interface JoinExitEvent {
    block: BlockEntity;
    txnId: string;
    txnIndex: number;
    eventIndex: number;
    maker: string;
    pairId: string;
    reserves: Reserves;
    eventType: 'swap' | 'join' | 'exit';
    amount0: string;
    amount1: string;
}
export interface IntegrationEventResponse {
    events: (SwapEvent | JoinExitEvent)[];
}
export interface MerklRewardResponse {
    sumAmount: string;
    fromEpoch: number;
    toEpoch: number;
    hash: string;
    rewardToken: string;
    rewards: object;
}
export interface MerklDataResponse {
    tvl: string;
    apr: string;
    opportunityName?: string;
}
export interface MarketEmission {
    chainId: number;
    address: string;
    totalIncentive: number;
    tvlIncentive: number;
    feeIncentive: number;
    discretionaryIncentive: number;
    cobribingIncentive: number;
}
export interface GetPendleEmissionResponse {
    markets: MarketEmission[];
}
export interface TagDefinitionResponse {
    name: string;
    description: 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> {
    limitOrders: {
        limitOrdersControllerGetLimitOrders: (query?: {
            order_by?: string;
            skip?: number;
            limit?: number;
            chainId?: number;
            yt?: string;
            maker?: string;
            isActive?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersResponse, any>>;
        limitOrdersControllerGetAllLimitOrders: (query?: {
            chainId?: number;
            limit?: number;
            maker?: string;
            yt?: string;
            timestamp_start?: string;
            timestamp_end?: string;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersV2Response, any>>;
        limitOrdersControllerGetAllArchivedLimitOrders: (query?: {
            chainId?: number;
            limit?: number;
            maker?: string;
            yt?: string;
            timestamp_start?: string;
            timestamp_end?: string;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersV2Response, any>>;
        limitOrdersControllerFetchMakers: (query?: {
            chainId?: number;
            yt?: string;
            sortBy?: "sum_order_size" | "num_orders";
            sortOrder?: "asc" | "desc";
        }, params?: RequestParams) => Promise<AxiosResponse<MakersResponse, any>>;
        limitOrdersControllerGetMakerLimitOrder: (query: {
            skip?: number;
            limit?: number;
            chainId: number;
            maker: string;
            yt?: string;
            type?: 0 | 1 | 2 | 3;
            isActive?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersResponse, any>>;
        limitOrdersControllerCreateOrder: (data: CreateLimitOrderDto, params?: RequestParams) => Promise<AxiosResponse<LimitOrderResponse, any>>;
        limitOrdersControllerGenerateLimitOrderData: (data: GenerateLimitOrderDataDto, params?: RequestParams) => Promise<AxiosResponse<GenerateLimitOrderDataResponse, any>>;
        limitOrdersControllerGenerateScaledLimitOrderData: (data: GenerateScaledOrderDataDto, params?: RequestParams) => Promise<AxiosResponse<GenerateScaledOrderResponse, any>>;
        limitOrdersControllerGetTakerLimitOrders: (query: {
            skip?: number;
            limit?: number;
            chainId: number;
            yt: string;
            type: 0 | 1 | 2 | 3;
            sortBy?: "Implied Rate";
            sortOrder?: "asc" | "desc";
        }, params?: RequestParams) => Promise<AxiosResponse<LimitOrdersTakerResponse, any>>;
        limitOrdersControllerGetLimitOrderBookV2: (chainId: number, query: {
            limit?: number;
            precisionDecimal: number;
            market: string;
            includeAmm?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<OrderBookV2Response, any>>;
    };
    assets: {
        pricesCrossChainControllerGetAllAssetPricesByAddressesCrossChains: (query?: {
            ids?: string;
            chainId?: number;
            skip?: number;
            limit?: number;
            type?: PendleAssetType;
        }, params?: RequestParams) => Promise<AxiosResponse<GetAssetPricesCrossChainResponse, any>>;
        pricesControllerOhlcvV4: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<PriceOHLCVCSVResponse, any>>;
        pricesControllerNotionalVolumeByMarket: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<NotionalVolumeResponse, any>>;
        assetsCrossChainControllerGetPendleAssetsMetadata: (query?: {
            ids?: string;
            chainId?: number;
            skip?: number;
            limit?: number;
            type?: PendleAssetType;
        }, params?: RequestParams) => Promise<AxiosResponse<GetAllAssetsCrossChainResponse, any>>;
        assetsControllerGetAllAssets: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<GetAssetsResponse, any>>;
        assetsControllerGetAllAssetPricesByAddresses: (chainId: number, query?: {
            addresses?: string;
            skip?: number;
            limit?: number;
            type?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetAssetPricesResponse, any>>;
        assetsControllerGetAllPendleTokensInUniswapFormat: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<UniswapTokenListResponse, any>>;
        assetsControllerGetPendleTokenForSolana: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<SolanaTokenResponse, any>>;
    };
    assetsLegacy: {
        pricesControllerGetAllAssetPrices: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<AssetPricesResponse, any>>;
        pricesControllerGetAllAssetPricesByAddresses: (chainId: number, query?: {
            addresses?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AssetPricesResponse, any>>;
        pricesControllerVolumeByMarket: (chainId: number, address: string, query: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
            type: "pt" | "yt";
        }, params?: RequestParams) => Promise<AxiosResponse<PriceOHLCVCSVResponse, any>>;
        pricesControllerOhlcvV2: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<PriceOHLCVResponse, any>>;
        pricesControllerOhlcvV3: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<PriceOHLCVResponse, any>>;
        assetsControllerAssets: (chainId: number, query?: {
            order_by?: string;
            skip?: number;
            limit?: number;
            is_expired?: boolean;
            zappable?: boolean;
            type?: string;
            address?: string;
            q?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AssetsResponse, any>>;
        assetsControllerAllAssets: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<AssetResponse[], any>>;
        assetsControllerAllAssetsV2: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<AssetCSVResponse, any>>;
        assetsControllerAsset: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<AssetResponse, any>>;
        sysControllerWhitelistedSys: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<WhitelistedSysResponse, any>>;
        sysControllerAssetSy: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<SyResponse, any>>;
    };
    markets: {
        marketsCrossChainControllerGetAllMarkets: (query?: {
            isActive?: boolean;
            chainId?: number;
            ids?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetMarketsCrossChainResponse, any>>;
        marketsCrossChainControllerGetPointsMarkets: (query?: {
            isActive?: boolean;
            chainId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<GetPointsMarketsResponse, any>>;
        marketsControllerGetActiveMarkets: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<GetActiveMarketsResponse, any>>;
        marketsControllerGetInactiveMarkets: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<GetInactiveMarketsResponse, any>>;
        marketsControllerMarketDataV2: (chainId: number, address: string, query?: {
            timestamp?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketDataResponse, any>>;
        marketsControllerMarketHistoricalDataV2: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
            fields?: string;
            includeFeeBreakdown?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketHistoricalDataResponse, any>>;
        marketsControllerMarketApyHistoryV3: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketHistoricalDataTableResponse, any>>;
    };
    marketsLegacy: {
        marketsControllerMarketApyHistoryV2: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketApyHistoriesCSVResponse, any>>;
        marketsControllerMarkets: (chainId: number, query?: {
            order_by?: string;
            skip?: number;
            limit?: number;
            is_expired?: boolean;
            select?: string;
            pt?: string;
            yt?: string;
            sy?: string;
            q?: string;
            is_active?: boolean;
            categoryId?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketsResponse, any>>;
        marketsControllerGetFeaturedMarkets: (chainId: number, query?: {
            order_by?: string;
            skip?: number;
            limit?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<FeaturedMarketsResponseEntity, any>>;
        marketsControllerMarket: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<MarketResponse, any>>;
        marketsControllerMarketHistoryV2: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketHistoriesResponse, any>>;
        marketsControllerMarketApyHistory: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketApyHistoriesResponse, any>>;
        marketsControllerMarketStateHistory: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetMarketStatHistoryCSVResponse, any>>;
        marketsControllerMarketApyHistory1D: (chainId: number, address: string, query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketApyHistoriesCSVResponse, any>>;
        marketsControllerMarketImpliedApyChart: (chainId: number, address: string, query?: {
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MarketImpliedApyResponseEntity, any>>;
        marketsControllerMarketAssets: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<MarketAssetsResponse, any>>;
    };
    marketCategories: {
        marketCategoriesControllerFindAllMarketCategories: (params?: RequestParams) => Promise<AxiosResponse<GetAllMarketCategoriesResponse, any>>;
    };
    metadataLegacy: {
        utilizedProtocolsControllerFindAllUtilizedProtocols: (params?: RequestParams) => Promise<AxiosResponse<GetAllUtilizedProtocolsResponse, any>>;
        utilizedProtocolsControllerGetUtilizedProtocolsOfMarket: (chainId: number, address: string, params?: RequestParams) => Promise<AxiosResponse<UtilizedProtocolResponse[], any>>;
        metadataControllerGetValuesByKeys: (data: MetadataQueryDto, params?: RequestParams) => Promise<AxiosResponse<MetadataResponse, any>>;
        metadataControllerGetValuesByKeysV2ByPost: (data: MetadataQueryDto, params?: RequestParams) => Promise<AxiosResponse<MetadataResponse, any>>;
        metadataControllerGetValuesByKeysV2ByGet: (query: {
            keys: string[];
        }, params?: RequestParams) => Promise<AxiosResponse<MetadataValuesResponse, any>>;
        metadataControllerGetMetadataValuesByTemplate: (template: string, params?: RequestParams) => Promise<AxiosResponse<GetMetadataByTemplateResponse, any>>;
    };
    vePendle: {
        vePendleControllerVePendleData: (params?: RequestParams) => Promise<AxiosResponse<VePendleDataResponse, any>>;
        vePendleControllerVePendleExtendedData: (params?: RequestParams) => Promise<AxiosResponse<VePendleExtendedDataResponse, any>>;
        vePendleControllerVoteSnapshot: (query?: {
            epoch?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<VoteSnapshotResponse, any>>;
        vePendleControllerGetPoolVoterAprAndSwapFee: (query?: {
            order_by?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<PoolVoterAprsSwapFeesResponse, any>>;
        vePendleControllerVePendleApyChart: (query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_gte?: string;
            timestamp_lte?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<VePendleApyChartResponse, any>>;
        vePendleControllerAllMarketTotalFees: (query?: {
            timestamp_start?: string;
            timestamp_end?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AllMarketTotalFeesResponse, any>>;
        vePendleControllerOngoingVotes: (params?: RequestParams) => Promise<AxiosResponse<GetOngoingVotesResponse, any>>;
        vePendleControllerGetVePendleCap: (params?: RequestParams) => Promise<AxiosResponse<GetVePendleCapResponse, any>>;
        vePendleControllerGetMonthlyRevenue: (params?: RequestParams) => Promise<AxiosResponse<GetMonthlyRevenueResponse, any>>;
    };
    vePendleLegacy: {
        vePendleControllerPoolVoterApy: (query?: {
            order_by?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<PoolVoterApysResponse, any>>;
        vePendleControllerPoolMetadata: (params?: RequestParams) => Promise<AxiosResponse<PoolResponse[], any>>;
        vePendleControllerVoterApyChart: (query?: {
            time_frame?: "hour" | "day" | "week";
            timestamp_gte?: string;
            timestamp_lte?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<VoterApyChartResponse, any>>;
        vePendleControllerPendleTokenSupply: (params?: RequestParams) => Promise<AxiosResponse<PendleTokenSupplyResponse, any>>;
        vePendleControllerGetHistoricalVotes: (address: string, query?: {
            timestamp?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetHistoricalVotesResponse, any>>;
    };
    pendleLegacy: {
        pendleControllerPendleSupply: (params?: RequestParams) => Promise<AxiosResponse<void, any>>;
        pendleControllerPendleCirculatingSupply: (params?: RequestParams) => Promise<AxiosResponse<void, any>>;
    };
    sdk: {
        sdkControllerGetMarketTokens: (chainId: number, market: string, params?: RequestParams) => Promise<AxiosResponse<MarketTokensResponse, any>>;
        sdkControllerGetSupportedAggregators: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<SupportedAggregatorsResponse, any>>;
        sdkControllerGetMarketSpotSwappingPrice: (chainId: number, market: string, params?: RequestParams) => Promise<AxiosResponse<GetSpotSwappingPriceResponse, any>>;
        sdkControllerSwapV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            tokenIn: string;
            tokenOut: string;
            amountIn: string;
            additionalData?: string;
            needScale?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<SwapResponse, any>>;
        sdkControllerAddLiquidityV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            tokenIn: string;
            amountIn: string;
            zpi?: boolean;
            additionalData?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AddLiquidityResponse, any>>;
        sdkControllerRemoveLiquidityV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            amountIn: string;
            tokenOut: string;
            additionalData?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RemoveLiquidityResponse, any>>;
        sdkControllerMintV2: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            yt: string;
            tokenIn: string;
            amountIn: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MintResponse, any>>;
        sdkControllerRedeemV2: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            yt: string;
            amountIn: string;
            tokenOut: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RedeemResponse, any>>;
        sdkControllerMintSyV2: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            sy: string;
            tokenIn: string;
            amountIn: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MintSyResponse, any>>;
        sdkControllerRedeemSyV2: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            sy: string;
            amountIn: string;
            tokenOut: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RedeemSyResponse, any>>;
        sdkControllerTransferLiquidityV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            aggregators?: string;
            dstMarket: string;
            lpAmount: string;
            ptAmount: string;
            ytAmount: string;
            redeemRewards?: boolean;
            zpi?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<TransferLiquidityResponse, any>>;
        sdkControllerRollOverPtV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            aggregators?: string;
            dstMarket: string;
            ptAmount: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RollOverPtResponse, any>>;
        sdkControllerAddLiquidityDual: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            tokenIn: string;
            amountTokenIn: string;
            amountPtIn: string;
        }, params?: RequestParams) => Promise<AxiosResponse<AddLiquidityDualResponse, any>>;
        sdkControllerRemoveLiquidityDual: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            amountIn: string;
            tokenOut: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RemoveLiquidityDualResponse, any>>;
        sdkControllerCancelSingleLimitOrder: (chainId: number, query: {
            userAddress: string;
            salt: string;
            expiry: string;
            nonce: string;
            orderType: 0 | 1 | 2 | 3;
            token: string;
            YT: string;
            maker: string;
            receiver: string;
            makingAmount: string;
            lnImpliedRate: string;
            failSafeRate: string;
            permit: string;
        }, params?: RequestParams) => Promise<AxiosResponse<SdkResponse, any>>;
        sdkControllerCancelAllLimitOrders: (chainId: number, query: {
            userAddress: string;
        }, params?: RequestParams) => Promise<AxiosResponse<SdkResponse, any>>;
        sdkControllerPendleSwapV2: (chainId: number, data: PendleSwapDtoV2, params?: RequestParams) => Promise<AxiosResponse<PendleSwapResponse, any>>;
        sdkControllerExitMarketV2: (chainId: number, market: string, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            ptAmount: string;
            ytAmount: string;
            lpAmount: string;
            tokenOut: string;
        }, params?: RequestParams) => Promise<AxiosResponse<void, any>>;
        sdkControllerRedeemInterestsAndRewards: (chainId: number, query: {
            receiver: string;
            sys?: string;
            yts?: string;
            markets?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<RedeemInterestsAndRewardsResponse, any>>;
        sdkControllerConvert: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            tokensIn: string;
            amountsIn: string;
            tokensOut: string;
            redeemRewards?: boolean;
            needScale?: boolean;
            additionalData?: string;
            useLimitOrder?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<MultiRouteConvertResponse, any>>;
        sdkControllerConvertV3: (chainId: number, data: ConvertV3Dto, params?: RequestParams) => Promise<AxiosResponse<MultiRouteConvertResponse, any>>;
        sdkControllerSwapPtCrossChain: (chainId: number, query: {
            receiver?: string;
            pt: string;
            token: string;
            exactAmountType: "pt" | "token";
            exactAmount: string;
        }, params?: RequestParams) => Promise<AxiosResponse<SwapPtCrossChainResponse, any>>;
        sdkControllerSwapPtCrossChainV2: (chainId: number, query: {
            receiver?: string;
            slippage: number;
            enableAggregator?: boolean;
            aggregators?: string;
            pt: string;
            exactPtIn: string;
            tokenOut: string;
        }, params?: RequestParams) => Promise<AxiosResponse<SwapWithFixedPricePtAmmResponse, any>>;
        sdkControllerGetPtCrossChainMetadata: (chainId: number, pt: string, params?: RequestParams) => Promise<AxiosResponse<PtCrossChainMetadataResponse, any>>;
    };
    transactionsLegacy: {
        transactionsControllerTransactionsV3: (chainId: number, query: {
            market: string;
            skip?: number;
            limit?: number;
            action?: string;
            origin?: string;
            timestamp_start?: string;
            timestamp_end?: string;
            user?: string;
            minValue?: number;
            maxValue?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<TransactionsResponse, any>>;
        transactionsControllerTransaction: (chainId: number, id: string, params?: RequestParams) => Promise<AxiosResponse<TransactionResponse, any>>;
    };
    transactions: {
        transactionsControllerTransactionsV5: (chainId: number, address: string, query?: {
            type?: TransactionType;
            minValue?: number;
            txOrigin?: string;
            action?: TransactionAction;
            resumeToken?: string;
            limit?: number;
            skip?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<TransactionsV5Response, any>>;
        transactionsControllerTransactionsV4: (chainId: number, query?: {
            market?: string;
            skip?: number;
            limit?: number;
            action?: string;
            origin?: string;
            timestamp_start?: string;
            timestamp_end?: string;
            user?: string;
            minValue?: number;
            maxValue?: number;
            resumeToken?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<TransactionsV4Response, any>>;
        transactionsControllerGetTransactions: (query: {
            skip?: number;
            limit?: number;
            chainId?: number;
            user: string;
            market?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<TransactionsResponseEntity, any>>;
    };
    statisticsLegacy: {
        statisticsControllerGetTvlAndTradingVolume: (params?: RequestParams) => Promise<AxiosResponse<TvlAndTradingVolumeResponseEntity, any>>;
    };
    statistics: {
        statisticsControllerGetDistinctUserFromToken: (query: {
            token: string;
            chainId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<GetDistinctUsersFromTokenEntity, any>>;
        statisticsControllerGetWlpDistinctUsers: (query: {
            chainId: number;
            wlpAddress: string;
        }, params?: RequestParams) => Promise<AxiosResponse<WlpDistinctUsersResponse, any>>;
        statisticsControllerGetLiquidLockerPools: (query: {
            chainId: number;
            lpAddress: string;
        }, params?: RequestParams) => Promise<AxiosResponse<LiquidLockerPoolsResponse, any>>;
        statisticsControllerGetAllRelatedInfoFromLpAndWlp: (query: {
            chainId: number;
            marketAddress?: string;
        }, params?: RequestParams) => Promise<AxiosResponse<GetAllRelatedInfoFromLpAndWlpResponse, any>>;
    };
    merkleLegacy: {
        merkleControllerGetRewardsByAddress: (address: string, campaign: "vependle" | "arbitrum-grant" | "multi-token" | "external-rewards" | "vependle-usd", query?: {
            chainId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<MerkleRewardsResponse, any>>;
        merkleControllerGetProofByAddress: (address: string, campaign: "vependle" | "arbitrum-grant" | "multi-token" | "external-rewards" | "vependle-usd", query?: {
            generateVerifyData?: boolean;
            chainId?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<MerkleProofResponse, any>>;
    };
    merkle: {
        merkleControllerGetProofByAddressV2: (address: string, query?: {
            generateVerifyData?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<MerkleProofV2Response, any>>;
    };
    transferLiquidityLegacy: {
        transferLiquidityControllerGetDefaultTokenOutList: (chainId: number, fromSyAddress: string, params?: RequestParams) => Promise<AxiosResponse<SyTokenOutRouteListResponse, any>>;
        transferLiquidityControllerGetLiquidityTransferableMarkets: (chainId: number, marketAddress: string, params?: RequestParams) => Promise<AxiosResponse<GetLiquidityTransferableMarketsResponse, any>>;
    };
    querierLegacy: {
        querierControllerGetSimplifiedData: (query?: {
            isExpired?: boolean;
        }, params?: RequestParams) => Promise<AxiosResponse<GetSimplifiedDataResponse, any>>;
    };
    querier: {
        querierControllerGetSafePendleTokenAddresses: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<GetSafePendleAddressesResponse, any>>;
    };
    chains: {
        chainsControllerGetSupportedChainIds: (params?: RequestParams) => Promise<AxiosResponse<ChainIdsResponse, any>>;
    };
    dashboard: {
        dashboardControllerGetUserPositions: (user: string, query?: {
            filterUsd?: number;
        }, params?: RequestParams) => Promise<AxiosResponse<UserPositionsCrossChainResponse, any>>;
        dashboardControllerGetMerkleClaimableRewards: (user: string, params?: RequestParams) => Promise<AxiosResponse<MerkleClaimableRewardsResponse, any>>;
        dashboardControllerGetMerkleClaimedRewards: (user: string, params?: RequestParams) => Promise<AxiosResponse<MerkleClaimedRewardsResponse, any>>;
    };
    crossPt: {
        crossPtControllerGetAllCrossPt: (params?: RequestParams) => Promise<AxiosResponse<GetAllCrossPtsResponse, any>>;
    };
    integrations: {
        integrationsControllerGetLatestBlock: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<BlockEntity, any>>;
        integrationsControllerGetAsset: (chainId: number, query: {
            id: string;
        }, params?: RequestParams) => Promise<AxiosResponse<IntegrationAssetResponse, any>>;
        integrationsControllerGetPair: (chainId: number, query: {
            id: string;
        }, params?: RequestParams) => Promise<AxiosResponse<IntegrationPairResponse, any>>;
        integrationsControllerGetEvents: (chainId: number, query: {
            fromBlock: number;
            toBlock: number;
        }, params?: RequestParams) => Promise<AxiosResponse<IntegrationEventResponse, any>>;
    };
    incentiveRewards: {
        incentiveRewardsControllerGetMakerIncentiveDistribution: (chainId: number, query: {
            epochTimestamp: string;
        }, params?: RequestParams) => Promise<AxiosResponse<MerklRewardResponse, any>>;
        incentiveRewardsControllerGetMakerIncentiveData: (chainId: number, params?: RequestParams) => Promise<AxiosResponse<MerklDataResponse, any>>;
    };
    pendleEmission: {
        pendleEmissionControllerPendleEmission: (params?: RequestParams) => Promise<AxiosResponse<GetPendleEmissionResponse, any>>;
    };
}