import { EventEmitter } from 'events';

interface TokenInfo {
    name: string;
    symbol: string;
    mint: string;
    uri?: string;
    decimals: number;
    description?: string;
    image?: string;
    hasFileMetaData?: boolean;
    strictSocials?: {
        twitter?: string;
        telegram?: string;
        discord?: string;
        website?: string;
    };
    showName?: boolean;
    twitter?: string;
    telegram?: string;
    website?: string;
    discord?: string;
    createdOn?: string;
    creation?: {
        creator: string;
        created_tx: string;
        created_time: number;
    };
    [key: string]: any;
}
interface TokenSecurity {
    freezeAuthority: string | null;
    mintAuthority: string | null;
}
interface TokenPoolTxns {
    buys: number;
    sells: number;
    total: number;
    volume: number;
    volume24h: number;
}
interface TokenValuePair {
    quote: number;
    usd: number;
}
interface LaunchpadLiquidity$1 {
    amount: number;
    usd: number;
}
interface Launchpad$1 {
    name: string;
    url: string;
    logo: string;
    baseLiquidity: LaunchpadLiquidity$1;
    quoteLiquidity: LaunchpadLiquidity$1;
}
interface MeteoraCurveLiquidity$1 {
    base?: number;
    quote?: number;
    usd: number;
}
interface MeteoraCurve$1 {
    baseLiquidity: MeteoraCurveLiquidity$1;
    quoteLiquidity: MeteoraCurveLiquidity$1;
    fee: number;
    name?: string;
    url?: string;
    logo?: string;
}
interface RiskWallet {
    address: string;
    balance: number;
    percentage: number;
}
interface RiskCategory {
    count: number;
    totalBalance: number;
    totalPercentage: number;
    wallets: RiskWallet[];
}
interface BundlerWallet {
    wallet: string;
    initialBalance: number;
    initialPercentage: number;
    balance: number;
    percentage: number;
    bundleTime: number;
}
interface BundlersCategory {
    count: number;
    totalBalance: number;
    totalPercentage: number;
    totalInitialBalance: number;
    totalInitialPercentage: number;
    wallets: BundlerWallet[];
}
interface BundlersResponse {
    total: number;
    balance: number;
    percentage: number;
    initialBalance: number;
    initialPercentage: number;
    wallets: BundlerWallet[];
}
interface MultiTokensResponse {
    tokens: {
        [tokenAddress: string]: TokenDetailResponse;
    };
}
interface PoolInfo {
    poolId: string;
    liquidity: TokenValuePair;
    price: TokenValuePair;
    tokenSupply: number;
    lpBurn: number;
    tokenAddress: string;
    marketCap: TokenValuePair;
    market: string;
    quoteToken: string;
    decimals: number;
    security: TokenSecurity;
    lastUpdated: number;
    deployer?: string;
    txns?: TokenPoolTxns;
    curvePercentage?: number;
    curve?: string;
    createdAt?: number;
    bundleId?: string;
    launchpad?: Launchpad$1;
    meteoraCurve?: MeteoraCurve$1;
    raydium?: {
        baseLiquidity: number;
        quoteLiquidity: number;
    };
    heaven?: {
        baseLiquidity: number;
        quoteLiquidity: number;
        is_migrated: boolean;
        migrationTime?: number;
    };
    pumpfun?: {
        tokenProgram?: string;
        isMayhemMode?: boolean;
    };
    'pumpfun-amm'?: {
        tokenProgram?: string;
        isMayhemMode?: boolean;
    };
    /** Pool creation data - only present on new/graduated pool messages */
    creation?: {
        creator: string;
        created_tx: string;
        created_time: number;
    };
}
interface PriceChangeData {
    priceChangePercentage: number;
}
interface TokenEvents {
    "1m"?: PriceChangeData;
    "5m"?: PriceChangeData;
    "15m"?: PriceChangeData;
    "30m"?: PriceChangeData;
    "1h"?: PriceChangeData;
    "2h"?: PriceChangeData;
    "3h"?: PriceChangeData;
    "4h"?: PriceChangeData;
    "5h"?: PriceChangeData;
    "6h"?: PriceChangeData;
    "12h"?: PriceChangeData;
    "24h"?: PriceChangeData;
}
interface DevHolding {
    percentage: number;
    amount: number;
}
interface RiskFees {
    jito?: number;
    network?: number;
    bloom?: number;
    maestro?: number;
    soltradingbot?: number;
    bullx?: number;
    photon?: number;
    trojan?: number;
    padre?: number;
    nextblock?: number;
    totalTrading?: number;
    totalTips?: number;
    total?: number;
    [key: string]: number | undefined;
}
interface TokenRisk {
    snipers: RiskCategory;
    insiders: RiskCategory;
    bundlers: BundlersCategory;
    top10: number;
    dev: DevHolding;
    fees?: RiskFees;
    rugged: boolean;
    risks: TokenRiskFactor[];
    score: number;
    jupiterVerified?: boolean;
}
interface TokenRiskFactor {
    name: string;
    description: string;
    value?: string | number;
    level: "warning" | "danger";
    score: number;
}
interface TokenDetailResponse {
    token: TokenInfo;
    pools: PoolInfo[];
    events: TokenEvents;
    risk: TokenRisk;
    buys: number;
    sells: number;
    txns: number;
    holders?: number;
}
interface Holder {
    wallet: string;
    amount: number;
    value: TokenValuePair;
    percentage: number;
}
interface TopHolder$1 {
    address: string;
    amount: number;
    percentage: number;
    value: TokenValuePair;
}
/**
 * Flat per-token PnL returned in `/tokens/:tokenAddress/holders?enrich=walletPnl`.
 *
 * Distinct from the nested `PnlV2Position` shape: holder enrichment uses flat
 * field names (`buys`/`sells`, `totalBought`/`totalSold`, `avgBuy`/`avgSell`)
 * for backwards compatibility.
 */
interface EnrichedTokenPnl {
    realized: number | null;
    unrealized: number | null;
    total: number | null;
    invested: number | null;
    proceeds: number | null;
    buys: number;
    sells: number;
    totalTrades: number;
    roi: number | null;
    /** Current token balance (native units). */
    balance: number | null;
    /** Cost basis of remaining held tokens (USD). */
    costBasis: number | null;
    /** Current USD value of held tokens. */
    value: number | null;
    /** Current token price (USD). */
    price: number | null;
    /** Total tokens purchased (native units). */
    totalBought: number | null;
    /** Total tokens sold (native units). */
    totalSold: number | null;
    /** Average buy size (USD). */
    avgBuy: number | null;
    /** Average sell size (USD). */
    avgSell: number | null;
    /** Average cost per token (USD). */
    avgCost?: number | null;
    /** Unix ms. */
    firstBuy: number | null;
    /** Unix ms. */
    lastBuy: number | null;
    /** Unix ms. */
    firstSell: number | null;
    /** Unix ms. */
    lastSell: number | null;
    /** Unix ms. */
    firstTrade: number | null;
    /** Unix ms. */
    lastTrade: number | null;
    /** Hold duration in seconds. */
    holdTimeSecs: number | null;
}
interface TokenHoldersResponse {
    total: number;
    enrich?: string[];
    accounts: (Holder & {
        pnl?: {
            wallet?: PnlV2WalletLifetimePnl;
            token?: EnrichedTokenPnl;
        };
        identity?: PnlV2Identity | null;
    })[];
}
interface AthPrice {
    highest_price: number;
    highest_market_cap: number;
    timestamp: number;
    pool_id: string;
}
interface DeployerToken {
    name: string;
    symbol: string;
    mint: string;
    image?: string;
    decimals: number;
    hasSocials: boolean;
    poolAddress?: string;
    liquidityUsd: number;
    marketCapUsd: number;
    priceUsd: number;
    lpBurn: number;
    market: string;
    freezeAuthority: string | null;
    mintAuthority: string | null;
    createdAt: number;
    lastUpdated: number;
    buys: number;
    sells: number;
    totalTransactions: number;
}
interface DeployerTokensResponse<T = DeployerToken> {
    total: number;
    tokens: T[];
}
/**
 * Parameters for the deployer endpoint (/deployer/:wallet)
 */
interface DeployerParams {
    /** Page number (default: 1) */
    page?: number;
    /** Number of items per page (default: 250, max: 500, max: 100 when format=full) */
    limit?: number;
    /** Filter by market(s) - single value or array (e.g., 'raydium' or ['raydium', 'orca', 'pumpfun']) */
    market?: string | string[];
    /** Filter by launchpad(s) - single value or array (e.g., 'pumpfun' or ['pumpfun', 'boop']) */
    launchpad?: string | string[];
    /** Return full token objects (same shape as /tokens/:token). Max limit is capped at 100. */
    format?: 'full';
}
interface SearchParams {
    query?: string;
    symbol?: string;
    page?: number;
    limit?: number;
    cursor?: string;
    sortBy?: string;
    sortOrder?: string;
    showAllPools?: boolean;
    showPriceChanges?: boolean;
    minCreatedAt?: number;
    maxCreatedAt?: number;
    minLiquidity?: number;
    maxLiquidity?: number;
    minMarketCap?: number;
    maxMarketCap?: number;
    minVolume?: number;
    maxVolume?: number;
    volumeTimeframe?: string;
    minVolume_5m?: number;
    maxVolume_5m?: number;
    minVolume_15m?: number;
    maxVolume_15m?: number;
    minVolume_30m?: number;
    maxVolume_30m?: number;
    minVolume_1h?: number;
    maxVolume_1h?: number;
    minVolume_6h?: number;
    maxVolume_6h?: number;
    minVolume_12h?: number;
    maxVolume_12h?: number;
    minVolume_24h?: number;
    maxVolume_24h?: number;
    minBuys?: number;
    maxBuys?: number;
    minSells?: number;
    maxSells?: number;
    minTotalTransactions?: number;
    maxTotalTransactions?: number;
    minHolders?: number;
    maxHolders?: number;
    minTop10?: number;
    maxTop10?: number;
    minDev?: number;
    maxDev?: number;
    minInsiders?: number;
    maxInsiders?: number;
    minSnipers?: number;
    maxSnipers?: number;
    lpBurn?: number;
    /** Filter by market(s) - single value or array (e.g., 'raydium' or ['raydium', 'orca', 'pumpfun']) */
    market?: string | string[];
    freezeAuthority?: string;
    mintAuthority?: string;
    deployer?: string;
    creator?: string;
    status?: string;
    minCurvePercentage?: number;
    maxCurvePercentage?: number;
    twitter?: string;
    telegram?: string;
    discord?: string;
    website?: string;
    facebook?: string;
    instagram?: string;
    youtube?: string;
    reddit?: string;
    tiktok?: string;
    github?: string;
    minBundlers?: number;
    maxBundlers?: number;
    minBundlerPercentage?: number;
    maxBundlerPercentage?: number;
    minRiskScore?: number;
    maxRiskScore?: number;
    minFeesTotal?: number;
    maxFeesTotal?: number;
    minFeesTrading?: number;
    maxFeesTrading?: number;
    minFeesTips?: number;
    maxFeesTips?: number;
    hasImage?: boolean;
    image?: string;
    hasSocials?: boolean;
    /** When `true`, only tokens with at least one monitored community message. When `false`, only tokens with zero messages. */
    hasCoinCommunity?: boolean;
    /** Minimum live community message count (inclusive). */
    minCommunityMessages?: number;
    /** Maximum live community message count (inclusive). */
    maxCommunityMessages?: number;
    /** Filter by launchpad(s) - single value or array (e.g., 'pumpfun' or ['pumpfun', 'boop']) */
    launchpad?: string | string[];
    minGraduatedAt?: number;
    maxGraduatedAt?: number;
    /** Return full token objects (same shape as /tokens/:token). Max limit is capped at 100. */
    format?: 'full';
    [key: string]: string | number | boolean | string[] | undefined;
}
interface SearchResult {
    id: string;
    name: string;
    symbol: string;
    mint: string;
    image?: string;
    decimals: number;
    hasSocials: boolean;
    poolAddress: string;
    liquidityUsd: number;
    marketCapUsd: number;
    priceUsd: number;
    lpBurn: number;
    market: string;
    quoteToken: string;
    freezeAuthority: string | null;
    mintAuthority: string | null;
    deployer: string;
    status: string;
    createdAt: number;
    lastUpdated: number;
    holders: number;
    buys: number;
    sells: number;
    totalTransactions: number;
    volume: number;
    volume_5m: number;
    volume_15m: number;
    volume_30m: number;
    volume_1h: number;
    volume_6h: number;
    volume_12h: number;
    volume_24h: number;
    jupiter?: boolean;
    verified?: boolean;
    top10?: number;
    dev?: number;
    insiders?: number;
    snipers?: number;
    bundlers?: {
        count: number;
        balance: number;
        percentage: number;
    };
    riskScore?: number;
    socials?: {
        twitter?: string;
        telegram?: string;
        discord?: string;
        website?: string;
        facebook?: string;
        instagram?: string;
        youtube?: string;
        reddit?: string;
        tiktok?: string;
        github?: string;
    };
    fees?: {
        total?: number;
        totalTrading?: number;
        totalTips?: number;
    };
    tokenDetails?: {
        creator: string;
        tx: string;
        time: number;
    };
    launchpad?: {
        name: string;
        curvePercentage?: number;
    };
    graduatedAt?: number;
    /** Whether the token has monitored Coin Communities chat activity. */
    hasCoinCommunity?: boolean;
    /** Live community message count (messages observed since the feed monitor started). */
    communityMessages?: number;
    events?: {
        "1m"?: {
            priceChangePercentage: number;
        };
        "5m"?: {
            priceChangePercentage: number;
        };
        "15m"?: {
            priceChangePercentage: number;
        };
        "30m"?: {
            priceChangePercentage: number;
        };
        "1h"?: {
            priceChangePercentage: number;
        };
        "2h"?: {
            priceChangePercentage: number;
        };
        "3h"?: {
            priceChangePercentage: number;
        };
        "4h"?: {
            priceChangePercentage: number;
        };
        "5h"?: {
            priceChangePercentage: number;
        };
        "6h"?: {
            priceChangePercentage: number;
        };
        "12h"?: {
            priceChangePercentage: number;
        };
        "24h"?: {
            priceChangePercentage: number;
        };
    };
}
interface SearchResponse<T = SearchResult> {
    status: string;
    data: T[];
    total?: number;
    pages?: number;
    page?: number;
    cursor?: string;
    nextCursor?: string;
    hasMore?: boolean;
}
interface TokenOverview {
    latest: TokenDetailResponse[];
    graduating: TokenDetailResponse[];
    graduated: TokenDetailResponse[];
}
interface PriceData {
    price: number;
    liquidity: number;
    marketCap: number;
    lastUpdated: number;
}
interface PriceHistoryData {
    current: number;
    "3d"?: number;
    "5d"?: number;
    "7d"?: number;
    "14d"?: number;
    "30d"?: number;
}
interface PriceTimestampData {
    price: number;
    timestamp: number;
    timestamp_unix: number;
    pool: string;
}
interface PriceRangeData {
    token: string;
    price: {
        lowest: {
            price: number;
            time: number;
        };
        highest: {
            price: number;
            time: number;
        };
    };
}
interface PriceChange {
    timeframe: string;
    percentage: number;
}
interface MultiPriceResponse {
    [tokenAddress: string]: PriceData;
}
interface WalletTokenData {
    address: string;
    balance: number;
    value: number;
    price: TokenValuePair;
    marketCap: TokenValuePair;
    liquidity: TokenValuePair;
}
interface WalletBasicResponse {
    tokens: WalletTokenData[];
    total: number;
    totalSol: number;
}
interface TokenMetadata$1 {
    name: string;
    symbol: string;
    image?: string;
    decimals: number;
}
interface TradeTokenInfo {
    address: string;
    amount: number;
    token: TokenMetadata$1;
}
interface TradeTransaction {
    tx: string;
    from?: TradeTokenInfo;
    to?: TradeTokenInfo;
    amount?: number;
    priceUsd?: number;
    volume?: number;
    solVolume?: number;
    type?: string;
    wallet: string;
    time: number;
    program: string;
    pools?: string[];
    token?: {
        from: TradeTokenInfo;
        to: TradeTokenInfo;
    };
}
interface TradesResponse {
    trades: Trade[];
    nextCursor?: number;
    hasNextPage?: boolean;
}
interface WalletTradesResponse {
    trades: WalletTrade[];
    nextCursor?: number;
    hasNextPage?: boolean;
}
interface WalletTokenDetail {
    token: TokenInfo;
    pools?: PoolInfo[];
    events?: TokenEvents;
    risk?: TokenRisk;
    balance: number;
    value: number;
}
interface WalletResponse {
    tokens: WalletTokenDetail[];
    total: number;
    totalSol: number;
    timestamp: string;
}
interface OHLCVData {
    open: number;
    close: number;
    low: number;
    high: number;
    volume: number;
    time: number;
}
interface ChartResponse {
    oclhv: OHLCVData[];
}
interface HolderChartData {
    holders: number;
    time: number;
}
interface HoldersChartResponse {
    holders: HolderChartData[];
}
interface SnipersChartData {
    percentage: number;
    time: number;
}
interface SnipersChartResponse {
    snipers: SnipersChartData[];
}
interface InsidersChartData {
    percentage: number;
    time: number;
}
interface InsidersChartResponse {
    insiders: InsidersChartData[];
}
interface BundlersChartData {
    percentage: number;
    time: number;
}
interface BundlersChartResponse {
    bundlers: BundlersChartData[];
}
interface PnLData {
    holding: number;
    held: number;
    sold: number;
    realized: number;
    unrealized: number;
    total: number;
    total_sold: number;
    total_invested: number;
    average_buy_amount: number;
    current_value: number;
    cost_basis: number;
    sold_usd?: number;
    first_buy_time?: number;
    last_buy_time?: number;
    last_sell_time?: number;
    last_trade_time?: number;
    buy_transactions?: number;
    sell_transactions?: number;
    total_transactions?: number;
}
interface PnLSummary {
    realized: number;
    unrealized: number;
    total: number;
    totalInvested: number;
    averageBuyAmount: number;
    totalWins: number;
    totalLosses: number;
    winPercentage: number;
    lossPercentage: number;
    neutralPercentage?: number;
}
interface PnLResponse {
    tokens: {
        [tokenAddress: string]: PnLData;
    };
    summary: PnLSummary;
}
interface TokenPnLResponse extends PnLData {
}
interface FirstBuyTransaction {
    signature: string;
    amount: number;
    volume_usd: number;
    time: number;
}
interface FirstBuyerData {
    wallet: string;
    first_buy_time: number;
    first_buy: FirstBuyTransaction;
    first_sell_time: number | null;
    last_transaction_time: number;
    held: number;
    sold: number;
    sold_usd: number;
    holding: number;
    realized: number;
    unrealized: number;
    total: number;
    total_invested: number;
    buy_transactions: number;
    sell_transactions: number;
    total_transactions: number;
    average_buy_amount: number;
    average_sell_amount: number;
    current_value: number;
    cost_basis: number;
}
interface TopTrader {
    wallet: string;
    summary: PnLSummary;
}
interface TopTradersResponse {
    wallets: TopTrader[];
}
interface TokenStats {
    "1m"?: TimeframeStats;
    "5m"?: TimeframeStats;
    "15m"?: TimeframeStats;
    "30m"?: TimeframeStats;
    "1h"?: TimeframeStats;
    "4h"?: TimeframeStats;
    "24h"?: TimeframeStats;
}
interface TokenStatsTotal {
    buys: number;
    sells: number;
    total: number;
    volume: number;
}
interface WalletChartDataPoint {
    date: string;
    value: number;
    timestamp: number;
    pnlPercentage: number;
}
interface WalletChartPnLPeriod {
    value: number;
    percentage: number;
}
interface WalletChartResponse {
    chartData: WalletChartDataPoint[];
    pnl: {
        '24h': WalletChartPnLPeriod;
        '30d': WalletChartPnLPeriod;
    };
}
interface CreditsResponse {
    credits: number;
}
interface TradeMetadataToken {
    name: string;
    symbol: string;
    image?: string;
    decimals: number;
    amount: number;
    address: string;
    priceUsd: number;
    mint?: string;
    uri?: string;
    isMutable?: boolean;
    description?: string;
    tags?: string[];
    extensions?: {
        website?: string;
        twitter?: string;
        telegram?: string;
    };
    hasFileMetaData?: boolean;
    [key: string]: any;
}
interface TradeMetadata {
    from: TradeMetadataToken;
    to: TradeMetadataToken;
}
interface Trade {
    tx: string;
    amount: number;
    priceUsd: number;
    volume: number;
    volumeSol: number;
    type: "buy" | "sell";
    wallet: string;
    time: number;
    program: string;
    pools: string[];
    meta?: TradeMetadata;
}
interface WalletTrade {
    tx: string;
    from: {
        address: string;
        amount: number;
        token?: {
            name: string;
            symbol: string;
            image: string;
            decimals: number;
            price?: {
                usd: number;
            };
        };
        priceUsd: number;
    };
    to: {
        address: string;
        amount: number;
        token?: {
            name: string;
            symbol: string;
            image: string;
            decimals: number;
            price?: {
                usd: number;
            };
        };
        priceUsd: number;
    };
    price: {
        usd: number;
        sol?: string;
    };
    volume: {
        usd: number;
        sol?: number;
    };
    wallet: string;
    program: string;
    time: number;
}
interface EventsParams {
    /** Whether to decode the binary data into events array */
    decode?: boolean;
    /** Whether to process events into statistics */
    process?: boolean;
    /** Whether to process events asynchronously (for large datasets) */
    async?: boolean;
}
interface TimeframeStats {
    buyers: number;
    sellers: number;
    volume: {
        buys: number;
        sells: number;
        total: number;
    };
    transactions: number;
    buys: number;
    sells: number;
    wallets: number;
    price: number;
    priceChangePercentage: number;
}
interface TimeframeStats {
    buyers: number;
    sellers: number;
    volume: {
        buys: number;
        sells: number;
        total: number;
    };
    transactions: number;
    buys: number;
    sells: number;
    wallets: number;
    price: number;
    priceChangePercentage: number;
}
interface ProcessedStats {
    '1m'?: TimeframeStats;
    '5m'?: TimeframeStats;
    '15m'?: TimeframeStats;
    '30m'?: TimeframeStats;
    '1h'?: TimeframeStats;
    '2h'?: TimeframeStats;
    '3h'?: TimeframeStats;
    '4h'?: TimeframeStats;
    '5h'?: TimeframeStats;
    '6h'?: TimeframeStats;
    '12h'?: TimeframeStats;
    '24h'?: TimeframeStats;
}
interface ProcessedEvent {
    wallet: string;
    amount: number;
    priceUsd: number;
    volume: number;
    type: 'buy' | 'sell';
    time: number;
}
interface ProcessedEvent {
    wallet: string;
    amount: number;
    priceUsd: number;
    volume: number;
    type: 'buy' | 'sell';
    time: number;
}
interface SubscriptionResponse {
    credits: number;
    plan: string;
    next_billing_date: string;
    status: string;
}
interface WalletBalanceUpdate {
    wallet: string;
    token: string;
    amount: number;
}
type PnlMode = 'strict' | 'adjusted' | 'raw';
interface PnlV2Block {
    realized: number | null;
    realizedRaw?: number | null;
    unrealized: number | null;
    total: number | null;
}
interface PnlV2Pagination {
    hasMore: boolean;
    nextCursor: string | null;
    count: number;
    total: number;
    pnlMode?: PnlMode;
    enrich?: string[];
}
interface PnlV2IdentityBot {
    name: string | null;
    avatar: string | null;
}
interface PnlV2IdentityPool {
    program: string | null;
    poolAddress: string | null;
    tokenA?: string | null;
    tokenB?: string | null;
}
interface PnlV2IdentityDeveloper {
    token?: string | null;
    via?: string[];
    pools?: string[];
    creationTx?: string | null;
    createdAt?: number | null;
    tokens?: string[];
}
interface PnlV2IdentityHacker {
    label: string | null;
}
interface PnlV2IdentitySpamDusting {
    label: string | null;
}
interface PnlV2IdentityExchange {
    name: string | null;
}
/** Primary `.sol` domain from Ridge (Solscan-style domain label). */
interface PnlV2IdentitySns {
    domain: string;
}
interface PnlV2Identity {
    /**
     * Display name. For SNS-only wallets this is the primary domain (e.g. `solanatracker.sol`).
     * When a higher-priority label exists (KOL, exchange, bot, etc.), that label keeps `name`
     * and the domain is still available on `sns.domain`.
     */
    name?: string | null;
    twitter?: string | null;
    avatar?: string | null;
    /** Primary label type, e.g. `kol`, `sns`, `bot`, `developer`, `pool`, `exchange`. */
    type?: string | null;
    /** All resolved labels, e.g. `['kol', 'sns']`. */
    tags?: string[];
    platforms?: string[];
    /** Present when the wallet has a primary `.sol` domain (may coexist with other tags). */
    sns?: PnlV2IdentitySns;
    bot?: PnlV2IdentityBot;
    pool?: PnlV2IdentityPool;
    developer?: PnlV2IdentityDeveloper;
    hacker?: PnlV2IdentityHacker;
    spamDusting?: PnlV2IdentitySpamDusting;
    exchange?: PnlV2IdentityExchange;
}
interface PnlV2WalletLifetimePnl {
    realized: number | null;
    unrealized: number | null;
    total: number | null;
    invested: number | null;
    proceeds: number | null;
    totalTrades: number;
    tokensTraded: number;
}
interface PnlV2TokenScopedPnl {
    token: PnlV2Block;
    /**
     * Lifetime wallet PnL summary. Only populated when the underlying response
     * is enriched with wallet PnL data (always on for `/v2/pnl/tokens/...` endpoints,
     * opt-in for `/tokens/:token/holders?enrich=walletPnl`).
     */
    wallet?: PnlV2WalletLifetimePnl;
}
interface PnlV2PnlAdjustments {
    mode: PnlMode;
    invalidPnl: number | null;
    adjustedCorrection: number | null;
}
interface PnlV2TokenMeta {
    symbol: string | null;
    name: string | null;
    image?: string;
    decimals: number | null;
    price: number | null;
    snapshotPrice?: number | null;
    marketCap: number | null;
    liquidity: number | null;
    primaryMarket: string | null;
}
interface PnlV2WalletQueued {
    indexed: false;
    queued: true;
    message: string;
}
interface PnlV2Trader {
    wallet: string;
    pnl: PnlV2Block;
    invested: number | null;
    proceeds: number | null;
    openPositions: {
        cost: number | null;
        value: number | null;
    };
    counts: {
        buys: number;
        sells: number;
        trades: number;
        tokensTraded: number;
        tokensHeldEver: number;
    };
    averages: {
        buy: number | null;
        sell: number | null;
    };
    tokens: {
        profitable: number;
        losing: number;
        closed: number;
    };
    winRate: number | null;
    roi: number | null;
    timing: {
        firstTrade: number | null;
        lastTrade: number | null;
    };
    updatedAt: string | null;
}
interface PnlV2TraderWithIdentity extends PnlV2Trader {
    identity: PnlV2Identity | null;
}
interface PnlV2PeriodTrader {
    wallet: string;
    period: {
        realized: number | null;
        volume: number | null;
        tradingDays: number;
    };
    ending: {
        pnl: PnlV2Block;
    };
    lastSnapshotDate: string | null;
}
interface PnlV2PeriodTraderWithIdentity extends PnlV2PeriodTrader {
    identity: PnlV2Identity | null;
}
interface PnlV2DayTrader {
    wallet: string;
    day: {
        realized: number | null;
        volume: number | null;
        cost: number | null;
        buys: number;
        sells: number;
    };
    cumulative: {
        pnl: PnlV2Block;
        invested: number | null;
        proceeds: number | null;
    };
}
interface PnlV2DayTraderWithIdentity extends PnlV2DayTrader {
    identity: PnlV2Identity | null;
}
interface PnlV2Top90dTrader {
    wallet: string;
    period: {
        realized: number | null;
        realizedRaw?: number | null;
        volume: number | null;
        tradingDays: number;
        roi: number | null;
        days?: {
            profitable: number;
            losing: number;
            maxSinglePnl: number | null;
            winRate: number | null;
        };
    };
    pnlAdjustments?: PnlV2PnlAdjustments;
    ending: {
        pnl: {
            realized: number | null;
            total: number | null;
        };
    };
    invested: number | null;
    proceeds: number | null;
    counts: {
        buys: number;
        sells: number;
        trades: number;
        tokensTraded: number;
    };
    averages: {
        buy: number | null;
        sell: number | null;
    };
    tokens: {
        profitable: number;
        losing: number;
        closed: number;
    };
    winRate: number | null;
    timing: {
        firstTrade: number | null;
        lastTrade: number | null;
    };
    lastSnapshotDate: string | null;
    updatedAt: string | null;
    identity?: PnlV2Identity | null;
}
interface PnlV2Holder {
    wallet: string;
    pnl: PnlV2TokenScopedPnl;
    identity?: PnlV2Identity | null;
    /** Legacy current-position snapshot. Same values as `current` (kept for compatibility). */
    position: {
        balance: number | null;
        costBasis: number | null;
        value: number | null;
        price: number | null;
    };
    /** Legacy. Same as `volume.buyUsd` / `invested`. */
    buyUsd: number | null;
    /** Legacy. Same as `volume.sellUsd` / `proceeds`. */
    sellUsd: number | null;
    counts: {
        buys: number;
        sells: number;
        total: number;
    };
    roi: number | null;
    /** Total cost basis (USD spent buying). */
    invested: number | null;
    /** Total USD received from selling. */
    proceeds: number | null;
    volume: {
        tokensBought: number | null;
        tokensSold: number | null;
        buyUsd: number | null;
        sellUsd: number | null;
    };
    averages: {
        buy: number | null;
        sell: number | null;
    };
    current: {
        balance: number | null;
        costBasis: number | null;
        value: number | null;
        price: number | null;
        avgCost: number | null;
    };
    /** Trade timing. All values are unix ms except `holdTimeSecs` (seconds). */
    timing: {
        firstTrade: number | null;
        lastTrade: number | null;
        firstBuy: number | null;
        lastBuy: number | null;
        firstSell: number | null;
        lastSell: number | null;
        holdTimeSecs: number | null;
    };
}
interface PnlV2Summary {
    pnl: PnlV2Block;
    invested: number | null;
    proceeds: number | null;
    openPositions: {
        cost: number | null;
        value: number | null;
    };
    counts: {
        buys: number;
        sells: number;
        trades: number;
        tokensTraded: number;
        tokensHeldEver: number;
    };
    averages: {
        buy: number | null;
        sell: number | null;
    };
    roi: number | null;
    timing: {
        firstTrade: number | null;
        lastTrade: number | null;
        /** Average hold time in seconds across all positions with a first buy. */
        avgHoldTimeSecs?: number | null;
    };
}
interface PnlV2Position {
    token: string;
    pnl: PnlV2Block;
    invested: number | null;
    proceeds: number | null;
    roi: number | null;
    current: {
        balance: number | null;
        costBasis: number | null;
        value: number | null;
        price: number | null;
        avgCost: number | null;
    };
    volume: {
        tokensBought: number | null;
        tokensSold: number | null;
        buyUsd: number | null;
        sellUsd: number | null;
    };
    averages: {
        buy: number | null;
        sell: number | null;
    };
    counts: {
        buys: number;
        sells: number;
        total: number;
    };
    timing: {
        firstBuy: number | null;
        lastBuy: number | null;
        firstSell: number | null;
        lastSell: number | null;
        firstTrade: number | null;
        lastTrade: number | null;
        holdTimeSecs: number | null;
    };
    meta?: PnlV2TokenMeta;
    portfolioPercent?: number | null;
}
interface PnlV2PositionWithWallet extends PnlV2Position {
    wallet: string;
}
interface PnlV2Snapshot {
    date: string;
    cumulative: {
        pnl: PnlV2Block;
        cost: number | null;
        proceeds: number | null;
        openPositions: {
            cost: number | null;
            value: number | null;
        };
        counts: {
            buys: number;
            sells: number;
            tokensTraded: number;
        };
    };
    activity: {
        pnl: {
            realized: number | null;
        };
        counts: {
            buys: number;
            sells: number;
        };
        volume: {
            costUsd: number | null;
            total: number | null;
        };
        averages: {
            buy: number | null;
            sell: number | null;
            realizedPnl: number | null;
            holdTimeSecs: number | null;
        };
    };
}
interface PnlV2ChartPoint {
    date: string;
    time: number;
    pnl: {
        realized: number | null;
        total: number | null;
    };
    invested: number | null;
    proceeds: number | null;
    activity: {
        realizedPnl: number | null;
        buys: number;
        sells: number;
        volume: number | null;
        avgHoldTimeSecs: number | null;
    };
    counts: {
        buys: number;
        sells: number;
        tokensTraded: number;
    };
}
interface PnlV2KOLLeaderboardParams {
    sort?: 'total' | 'realized' | 'unrealized' | 'invested' | 'proceeds' | 'value' | 'trades' | 'tokens' | 'roi' | 'win_percentage' | 'last_trade';
    direction?: 'asc' | 'desc';
    limit?: number;
    cursor?: string;
}
interface PnlV2KOLPeriodParams {
    sort?: 'realized' | 'volume' | 'days' | 'ending_total';
    direction?: 'asc' | 'desc';
    limit?: number;
    cursor?: string;
    period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all';
    start?: string;
    end?: string;
}
interface PnlV2KOLCalendarParams {
    year?: number;
    month?: number;
}
interface PnlV2KOLByDateParams {
    date?: string;
}
interface PnlV2TopTradersParams {
    sort?: 'realized' | 'volume' | 'days' | 'roi' | 'win_percentage' | 'trades' | 'tokens';
    direction?: 'asc' | 'desc';
    limit?: number;
    cursor?: string;
    platform?: string;
    excludeArbitrage?: string;
    pnlMode?: PnlMode;
    days?: number;
    minTrades?: number;
    minInvested?: number;
    minDays?: number;
    minWinRate?: number;
    minRoi?: number;
    minClosedTokens?: number;
    maxSingleTokenPct?: number;
}
interface PnlV2TokenTradersParams {
    sort?: 'holding' | 'value' | 'pnl' | 'realized' | 'unrealized' | 'invested' | 'roi' | 'last_trade' | 'first_trade';
    direction?: 'asc' | 'desc';
    limit?: number;
    cursor?: string;
    platform?: string;
    excludeArbitrage?: string;
    excludeZeroBuys?: string;
    activeOnly?: string;
    minTrades?: number;
}
interface PnlV2TokenFirstBuyersParams {
    sort?: 'first_trade';
    direction?: 'asc';
    limit?: number;
    cursor?: string;
    platform?: string;
    excludeArbitrage?: string;
    excludeZeroBuys?: string;
    activeOnly?: string;
    minTrades?: number;
}
interface PnlV2WalletHistoryParams {
    period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all';
    start?: string;
    end?: string;
    limit?: number;
}
interface PnlV2WalletPerformanceParams {
    period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all';
    days?: number;
}
interface PnlV2WalletPositionsParams {
    sort?: 'last_trade' | 'pnl' | 'realized' | 'unrealized' | 'roi' | 'value' | 'holding' | 'invested' | 'cost' | 'proceeds' | 'buys' | 'sells';
    direction?: 'asc' | 'desc';
    cursor?: string;
    limit?: number;
    filter?: 'all' | 'holding' | 'active' | 'sold' | 'profitable' | 'losing';
    period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all';
    pnlMode?: PnlMode;
    tokens?: string;
    minValue?: number;
    maxValue?: number;
    minPnl?: number;
    maxPnl?: number;
    minInvested?: number;
    maxInvested?: number;
    minRoi?: number;
    maxRoi?: number;
    minTrades?: number;
    minHolding?: number;
    market?: string;
    minLiquidity?: number;
    minMarketCap?: number;
}
interface PnlV2WalletChartParams {
    time_from?: number;
    time_to?: number;
}
interface PnlV2WalletOverviewParams {
    pnlMode?: PnlMode;
}
interface PnlV2WalletTokenPositionParams {
    pnlMode?: PnlMode;
}
interface PnlV2BatchParams {
    pnlMode?: PnlMode;
}
interface PnlV2KOLLeaderboardResponse {
    traders: PnlV2TraderWithIdentity[];
    pagination: PnlV2Pagination;
}
interface PnlV2KOLPeriodResponse {
    traders: PnlV2PeriodTraderWithIdentity[];
    pagination: PnlV2Pagination;
}
interface PnlV2KOLCalendarDayData {
    realizedPnl: number | null;
    volume: number | null;
    buys: number;
    sells: number;
    traders: number;
}
interface PnlV2KOLCalendarResponse {
    year: number;
    month: number;
    days: {
        [day: string]: PnlV2KOLCalendarDayData;
    };
    summary: {
        tradingDays: number;
        positiveDays: number;
        negativeDays: number;
        totalRealizedPnl: number | null;
        totalVolume: number | null;
    };
}
interface PnlV2KOLByDateResponse {
    traders: PnlV2DayTraderWithIdentity[];
    summary: {
        totalRealizedPnl: number | null;
        totalVolume: number | null;
    };
    date: string;
}
interface PnlV2TopTradersResponse {
    traders: PnlV2Top90dTrader[];
    pagination: PnlV2Pagination;
}
interface PnlV2TokenTradersResponse {
    meta: PnlV2TokenMeta;
    traders: PnlV2Holder[];
    pagination: PnlV2Pagination;
}
interface PnlV2WalletTokenPositionResponse extends PnlV2Position {
    wallet?: string;
    identity?: PnlV2Identity | null;
    pnlMode?: PnlMode;
}
interface PnlV2WalletHistoryResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    days: PnlV2Snapshot[];
    summary: {
        days: {
            trading: number;
            positive: number;
            negative: number;
            breakEven: number;
        };
        totals: {
            realizedPnl: number | null;
            volume: number | null;
        };
        winRate: number | null;
        totalDays: number;
        deltas: {
            realized: number | null;
            total: number | null;
        } | null;
    };
}
interface PnlV2WalletPerformanceDay {
    date: string;
    realizedPnl: number | null;
    unrealizedPnl: number | null;
    totalPnl: number | null;
    volume: number | null;
    trades: number;
}
interface PnlV2WalletPerformanceResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    window: number;
    totals: {
        realizedPnl: number | null;
        volume: number | null;
        trades: number;
    };
    bestDay: {
        date: string;
        realizedPnl: number | null;
        volume: number | null;
        totalPnl: number | null;
        trades: number;
    } | null;
    worstDay: {
        date: string;
        realizedPnl: number | null;
        volume: number | null;
        totalPnl: number | null;
        trades: number;
    } | null;
    streaks: {
        positive: number | null;
        negative: number | null;
        currentPositive: number | null;
        currentNegative: number | null;
    };
    drawdown: {
        amount: number | null;
        percent: number | null;
    };
    days: PnlV2WalletPerformanceDay[];
    updatedAt: string | null;
}
interface PnlV2WalletHighlightsResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    counts: {
        positions: number;
        open: number;
        closed: number;
    };
    highlights: {
        biggestWinner: PnlV2Position | null;
        biggestLoser: PnlV2Position | null;
        biggestBag: PnlV2Position | null;
        mostProfitableClosed: PnlV2Position | null;
        fastestFlip: PnlV2Position | null;
        longestHold: PnlV2Position | null;
        mostActive: PnlV2Position | null;
    };
    updatedAt: string | null;
}
interface PnlV2WalletRiskResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    openPositions: {
        count: number;
        cost: number | null;
        value: number | null;
        profitableValue: number | null;
        profitableValuePercent: number | null;
    };
    concentration: {
        top1Percent: number | null;
        top5Percent: number | null;
        score: number | null;
    };
    pnlMix: {
        realized: number | null;
        unrealized: number | null;
        realizedPercent: number | null;
        unrealizedPercent: number | null;
    };
    largestPositions: PnlV2Position[];
    updatedAt: string | null;
}
interface PnlV2WalletPositionsResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    positions: PnlV2Position[];
    stats: {
        total: number;
        filtered: number;
        holding: number;
        sold: number;
        profitable: number;
        losing: number;
    };
    pagination: PnlV2Pagination;
}
interface PnlV2WalletChartResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    points: PnlV2ChartPoint[];
    summary: {
        days: {
            trading: number;
            positive: number;
            negative: number;
            breakEven: number;
        };
        totals: {
            realizedPnl: number | null;
            volume: number | null;
        };
        winRate: number | null;
        bestDay: {
            date: string;
            realizedPnl: number | null;
        } | null;
        worstDay: {
            date: string;
            realizedPnl: number | null;
        } | null;
        streaks: {
            positive: number;
            negative: number;
            currentPositive: number;
            currentNegative: number;
        };
        drawdown: {
            amount: number | null;
            percent: number | null;
        };
        averages: {
            dailyVolume: number | null;
            dailyRealizedPnl: number | null;
            holdTimeSecs: number | null;
        };
    };
    pagination: {
        count: number;
        hasMore: boolean;
        nextTimeTo: number | null;
    };
}
interface PnlV2WalletOverviewResponse {
    wallet?: string;
    identity?: PnlV2Identity | null;
    pnlMode?: PnlMode;
    summary: PnlV2Summary;
    analysis: {
        winRate: number | null;
        avgPnlPerAsset: number | null;
        avgBuyValue: number | null;
        tokens: {
            closed: number;
            winning: number;
            losing: number;
        };
        distribution: Array<{
            range: string;
            count: number;
            rate: number | null;
        }>;
    };
    stats: {
        total: number;
        holding: number;
        sold: number;
        profitable: number;
        losing: number;
    };
    tags: {
        isArbitrage: boolean;
        platforms: string[];
    };
    updatedAt: string | null;
}
interface PnlV2BatchWalletPositionsResponse {
    wallet: string;
    identity?: PnlV2Identity | null;
    pnlMode?: PnlMode;
    count: number;
    positions: PnlV2Position[];
    notFound: string[];
    invalid?: string[];
}
interface PnlV2BatchWalletSummary {
    wallet: string;
    identity?: PnlV2Identity | null;
    summary: PnlV2Summary;
    tags: {
        isArbitrage: boolean;
        platforms: string[];
    };
    updatedAt: string | number | null;
}
interface PnlV2BatchWalletSummariesResponse {
    count: number;
    wallets: PnlV2BatchWalletSummary[];
    notFound?: string[];
    invalid?: string[];
    truncated?: {
        requested: number;
        limit: number;
    };
}
interface PnlV2TokenScopedPositionWithWallet extends Omit<PnlV2Position, 'pnl'> {
    wallet: string;
    identity?: PnlV2Identity | null;
    pnl: PnlV2TokenScopedPnl;
}
interface PnlV2BatchTokenPositionsResponse {
    token: string;
    pnlMode?: PnlMode;
    count: number;
    positions: PnlV2TokenScopedPositionWithWallet[];
    notFound: string[];
    invalid?: string[];
}
interface PnlV2BatchPositionPairsResponse {
    pnlMode?: PnlMode;
    count: number;
    positions: (PnlV2PositionWithWallet & {
        identity?: PnlV2Identity | null;
    })[];
    notFound: Array<{
        wallet: string;
        token: string;
    }>;
    invalid?: Array<{
        wallet?: string;
        token?: string;
    }>;
}
interface ChartDataParams {
    /** Token address */
    tokenAddress: string;
    /** Pool address (only for pool-specific charts) */
    poolAddress?: string;
    /** Time interval (e.g., "1s", "1m", "1h", "1d") */
    type?: string;
    /** Start time (Unix timestamp in seconds) */
    timeFrom?: number;
    /** End time (Unix timestamp in seconds) */
    timeTo?: number;
    /** Return chart for market cap instead of pricing */
    marketCap?: boolean;
    /** Disable outlier removal if set to false (default: true) */
    removeOutliers?: boolean;
    /** Dynamically picks the main pool over time for consistent charts (default: true, only applies without pool) */
    dynamicPools?: boolean;
    /** Timezone for chart data - use "current" for auto-detection or specify timezone (e.g., "PST", "UTC", "America/New_York") */
    timezone?: string | 'current';
    /** Enable live cache for faster response times (default: false) */
    fastCache?: boolean;
    /** Currency for price data (default: "usd") */
    currency?: 'usd' | 'eur' | 'sol';
}
/**
 * Represents a holder in the paginated response with account address
 */
interface PaginatedHolder {
    wallet: string;
    account: string;
    amount: number;
    value: TokenValuePair;
    percentage: number;
}
/**
 * Response for paginated token holders endpoint
 */
interface PaginatedTokenHoldersResponse {
    total: number;
    accounts: PaginatedHolder[];
    cursor: string;
    hasMore: boolean;
    limit: number;
}
/** Status of a single DCA order. */
type DcaOrderStatus = 'active' | 'paused' | 'completed' | 'pending';
/** Status filter accepted by DCA list endpoints (adds `'all'`). */
type DcaOrderStatusFilter = DcaOrderStatus | 'all';
/** Trade direction relative to the wallet across its DCA orders. */
type DcaDirection = 'buying' | 'selling' | 'mixed';
/** Sort field accepted by DCA list endpoints. */
type DcaSort = 'volume' | 'deposited' | 'remaining' | 'progress' | 'recent' | 'created' | 'status';
/** A supported DCA program. */
interface DcaProgram {
    id: string;
    label: string;
    programId: string;
}
interface DcaProgramsResponse {
    programs: DcaProgram[];
}
/** Token metadata embedded on a DCA order. */
interface DcaToken {
    mint: string;
    symbol: string;
    name: string;
    decimals: number;
    image?: string | null;
    uri?: string | null;
    description?: string | null;
    twitter?: string | null;
    website?: string | null;
    hasFileMetaData?: boolean;
    /** Current USD price; null/omitted when unavailable. */
    priceUsd?: number | null;
}
/** Raw on-chain amounts (strings, base units). Keys depend on program. */
type DcaOrderRaw = Record<string, string>;
/** A single DCA (recurring) order. */
interface DcaOrder {
    program: string;
    programId: string;
    /** DCA account pubkey. */
    address: string;
    owner: string;
    status: DcaOrderStatus;
    direction: DcaDirection;
    /** Human readable pair, e.g. "USDC → SOL". */
    pair: string;
    input: DcaToken;
    output: DcaToken;
    deposited: number;
    depositedUsd?: number | null;
    used: number;
    usedUsd?: number | null;
    remaining: number;
    remainingUsd?: number | null;
    received: number;
    receivedUsd?: number | null;
    perCycle: number;
    perCycleUsd?: number | null;
    /** Cycle frequency, e.g. "1h". */
    frequency: string;
    progressPercent: number;
    volume: number;
    volumeUsd?: number | null;
    /** ISO 8601 timestamp. */
    createdAt: string;
    /** ISO 8601 timestamp; null when no further cycle is scheduled. */
    nextCycleAt: string | null;
    raw: DcaOrderRaw;
}
/** Status counts for a wallet's DCA orders. */
interface DcaSummary {
    total: number;
    active: number;
    paused: number;
    completed: number;
    pending: number;
}
/** Pagination block returned by paginated DCA endpoints. */
interface DcaPagination {
    limit: number;
    /** Cursor to pass as `cursor` for the next page; null when no more results. */
    nextCursor: string | null;
    hasMore: boolean;
    count: number;
    total: number;
}
/** Common query parameters for DCA list endpoints. */
interface DcaListParams {
    /** DCA program id (default `"jupiter"`). */
    program?: string;
    /** Alias for `program`. */
    dex?: string;
    /** Alias for `program`. */
    platform?: string;
    /**
     * Page size. Defaults differ by endpoint:
     * - wallet / wallet orders / pair: default `50`, max `100`
     * - token buyers / sellers / users: default `200`, max `1000`
     */
    limit?: number;
    /** Opaque cursor (the previous page's last order `address`). */
    cursor?: string;
    sort?: DcaSort;
    /** Alias for `sort`. */
    sortBy?: DcaSort;
    status?: DcaOrderStatusFilter;
}
/** Query parameters accepted by single-order/program endpoints. */
interface DcaProgramParams {
    /** DCA program id (default `"jupiter"`). */
    program?: string;
    /** Alias for `program`. */
    dex?: string;
    /** Alias for `program`. */
    platform?: string;
}
/** Standard error envelope returned by DCA endpoints on failure. */
interface DcaErrorResponse {
    error: {
        code: 'INVALID_WALLET' | 'INVALID_MINT' | 'INVALID_ORDER' | 'NOT_FOUND' | 'INVALID_SORT' | 'INVALID_STATUS' | 'INVALID_LIMIT' | 'INVALID_PROGRAM' | 'PROGRAM_PARAM_CONFLICT' | 'INVALID_CURSOR' | 'TIMEOUT' | 'SERVER_ERROR';
        message: string;
    };
}
interface DcaWalletResponse {
    wallet: string;
    summary: DcaSummary;
    orders: DcaOrder[];
    pagination: DcaPagination;
}
interface DcaOrdersListResponse {
    orders: DcaOrder[];
    pagination: DcaPagination;
}
interface DcaTokenFlowResponse {
    mint: string;
    buyers: {
        count: number;
        volumeUsd: number | null;
    };
    sellers: {
        count: number;
        volumeUsd: number | null;
    };
}
interface DcaTokenOrdersResponse {
    mint: string;
    orders: DcaOrder[];
    pagination: DcaPagination;
}
interface DcaTokenUser {
    wallet: string;
    orderCount: number;
    volumeUsd: number | null;
}
interface DcaTokenUsersResponse {
    mint: string;
    users: DcaTokenUser[];
}
interface DcaPairResponse {
    inputMint: string;
    outputMint: string;
    pair: string;
    orders: DcaOrder[];
    pagination: DcaPagination;
}
/** Map of mint address → USD price at event time. */
type DcaPricesMap = Record<string, number>;
/**
 * Order snapshot embedded on a DCA stream event.
 *
 * Position events carry the full {@link DcaOrder} shape; transaction events
 * (Filled, Deposit, etc.) often include only a subset of fields, so all
 * properties are typed as optional.
 */
type DcaOrderSnapshot = Partial<DcaOrder>;
interface DcaEventBase {
    program: string;
    programId: string;
    /** DCA account address. */
    address: string;
    owner: string;
    signature: string;
    slot: number;
    /** Unix ms. */
    timestamp: number;
    eventIndex: number;
    dcaKey: string;
    /** Snapshot of the order at event time. */
    order: DcaOrderSnapshot;
}
interface DcaOpenedEvent extends DcaEventBase {
    eventName: 'Opened';
    openInstruction: 'openDca' | 'openDcaV2';
    userKey: string;
    inputMint: string;
    outputMint: string;
    /** Raw deposited amount as base-units string. */
    inDeposited: string;
    /** Cycle frequency in seconds, as string. */
    cycleFrequency: string;
    /** Raw amount per cycle as base-units string. */
    inAmountPerCycle: string;
    /** Created at as unix seconds string. */
    createdAt: string;
    usd: {
        inDepositedUsd?: number;
        inAmountPerCycleUsd?: number;
    };
    prices: DcaPricesMap;
}
interface DcaFilledEvent extends DcaEventBase {
    eventName: 'Filled';
    userKey: string;
    inputMint: string;
    outputMint: string;
    inAmount: string;
    outAmount: string;
    feeMint: string;
    fee: string;
    fillInstruction: string;
    usd: {
        inAmountUsd?: number;
        outAmountUsd?: number;
        feeUsd?: number;
    };
    prices: DcaPricesMap;
}
interface DcaClosedEvent extends DcaEventBase {
    eventName: 'Closed';
    userKey: string;
    inputMint: string;
    outputMint: string;
    inDeposited: string;
    totalInWithdrawn: string;
    totalOutWithdrawn: string;
    unfilledAmount: string;
    userClosed: boolean;
    usd: {
        totalInWithdrawnUsd?: number;
        totalOutWithdrawnUsd?: number;
        unfilledAmountUsd?: number;
    };
    prices: DcaPricesMap;
}
interface DcaDepositEvent extends DcaEventBase {
    eventName: 'Deposit';
    amount: string;
    usd: {
        amountUsd?: number;
    };
}
interface DcaWithdrawEvent extends DcaEventBase {
    eventName: 'Withdraw';
    inAmount: string;
    outAmount: string;
    userWithdraw: boolean;
    usd: {
        inAmountUsd?: number;
        outAmountUsd?: number;
    };
}
interface DcaCollectedFeeEvent extends DcaEventBase {
    eventName: 'CollectedFee';
    userKey: string;
    mint: string;
    amount: string;
    usd: {
        amountUsd?: number;
    };
    prices: DcaPricesMap;
}
/** DCA account snapshot. No transaction signature; throttled per account. */
interface DcaPositionEvent {
    program: string;
    programId: string;
    /** DCA account pubkey (alias of `address`). */
    pubkey: string;
    address: string;
    owner: string;
    slot: number;
    /** Unix ms. */
    timestamp: number;
    /** Account write version. */
    writeVersion: number;
    order: DcaOrder;
}
/** Discriminated union over all DCA stream events. */
type DcaStreamEvent = DcaOpenedEvent | DcaFilledEvent | DcaClosedEvent | DcaDepositEvent | DcaWithdrawEvent | DcaCollectedFeeEvent | DcaPositionEvent;
/** Transaction events (everything except the position snapshot). */
type DcaTransactionEvent = Exclude<DcaStreamEvent, DcaPositionEvent>;

declare class DataApiError extends Error {
    status?: number | undefined;
    code?: string | undefined;
    details?: any;
    constructor(message: string, status?: number | undefined, code?: string | undefined, details?: any);
}
declare class RateLimitError extends DataApiError {
    retryAfter?: number | undefined;
    constructor(message: string, retryAfter?: number | undefined, details?: any);
}
declare class ValidationError extends DataApiError {
    constructor(message: string, details?: any);
}
/**
 * Config options for the Solana Tracker Data API
 */
interface DataApiConfig {
    /** Your API key from solanatracker.io */
    apiKey: string;
    /** Optional base URL override */
    baseUrl?: string;
}
/**
 * Parameters for token overview endpoint (/tokens/multi/all)
 */
interface TokenOverviewParams {
    /** Number of tokens per category (default: 100, max: 500) */
    limit?: number;
    /** Minimum curve percentage for graduating tokens (default: 40) */
    minCurve?: number;
    /** Minimum number of holders for graduating tokens (default: 20) */
    minHolders?: number;
    /** Maximum number of holders for graduating tokens */
    maxHolders?: number;
    /** Reduce spam by filtering out quick graduated tokens */
    reduceSpam?: boolean;
    minLiquidity?: number;
    maxLiquidity?: number;
    minMarketCap?: number;
    maxMarketCap?: number;
    markets?: string[];
    minRiskScore?: number;
    maxRiskScore?: number;
    rugged?: boolean;
}
/**
 * Parameters for graduated tokens endpoint (/tokens/multi/graduated)
 */
interface GraduatedTokensParams {
    /** Number of tokens to return (default: 100, max: 500) */
    limit?: number;
    /** Page number for pagination (default: 1) */
    page?: number;
    /** Reduce spam by filtering out quick graduated tokens */
    reduceSpam?: boolean;
    minLiquidity?: number;
    maxLiquidity?: number;
    minMarketCap?: number;
    maxMarketCap?: number;
    markets?: string[];
    minRiskScore?: number;
    maxRiskScore?: number;
    rugged?: boolean;
}
/**
 * Parameters for graduating tokens endpoint (/tokens/multi/graduating)
 */
interface GraduatingTokensParams {
    /** Number of tokens to return (default: 100, max: 500) */
    limit?: number;
    /** Minimum curve percentage (default: 40) */
    minCurve?: number;
    /** Maximum curve percentage (default: 100) */
    maxCurve?: number;
    /** Minimum number of holders (default: 20) */
    minHolders?: number;
    /** Maximum number of holders */
    maxHolders?: number;
    minLiquidity?: number;
    maxLiquidity?: number;
    minMarketCap?: number;
    maxMarketCap?: number;
    markets?: string[];
    minRiskScore?: number;
    maxRiskScore?: number;
    rugged?: boolean;
}
/**
 * Solana Tracker Data API client
 */
declare class Client {
    private apiKey;
    private baseUrl;
    /**
     * Creates a new instance of the Solana Tracker Data API client
     * @param config Configuration options including API key
     */
    constructor(config: DataApiConfig);
    /**
     * Makes a request to the API
     * @param endpoint The API endpoint
     * @param options Additional fetch options
     * @returns The API response
     */
    private request;
    /**
     * Validates a Solana public key
     * @param address The address to validate
     * @param paramName The parameter name for error messaging
     * @throws ValidationError if the address is invalid
     */
    private validatePublicKey;
    /**
     * Builds query string from parameters object
     * @param params Parameters object
     * @returns Query string
     */
    private buildQueryString;
    /**
     * Get comprehensive information about a specific token
     * @param tokenAddress The token's mint address
     * @returns Detailed token information
     */
    getTokenInfo(tokenAddress: string): Promise<TokenDetailResponse>;
    /**
     * Get token information by searching with a pool address
     * @param poolAddress The pool address
     * @returns Detailed token information
     */
    getTokenByPool(poolAddress: string): Promise<TokenDetailResponse>;
    /**
     * Get token holders information
     * @param tokenAddress The token's mint address
     * @returns Information about token holders
     */
    getTokenHolders(tokenAddress: string, enrich?: 'identity' | 'walletPnl' | 'identity,walletPnl' | 'all' | '*'): Promise<TokenHoldersResponse>;
    /**
     * Get token holders with pagination support
     * @param tokenAddress The token's mint address
     * @param limit Number of holders to return per page (default: 100, max: 100)
     * @param cursor Pagination cursor from previous response
     * @returns Paginated token holders information
     */
    getTokenHoldersPaginated(tokenAddress: string, limit?: number, cursor?: string): Promise<PaginatedTokenHoldersResponse>;
    /**
     * Get top 20 token holders
     * @param tokenAddress The token's mint address
     * @returns Top holders information
     */
    getTopHolders(tokenAddress: string): Promise<TopHolder$1[]>;
    /**
     * Get the all-time high price and market cap for a token
     * @param tokenAddress The token's mint address
     * @returns All-time high price and market cap data
     */
    getAthPrice(tokenAddress: string): Promise<AthPrice>;
    /**
     * Get bundler information for a token
     * @param tokenAddress The token's mint address
     * @returns Bundler wallet stats including top 500 bundler wallets
     */
    getTokenBundlers(tokenAddress: string): Promise<BundlersResponse>;
    /**
     * Get tokens created by a specific wallet with pagination
     * @param wallet The deployer wallet address
     * @param pageOrParams Page number (legacy) or DeployerParams object
     * @param limit Number of items per page when using legacy positional args
     * @returns List of tokens created by the deployer (TokenDetailResponse items when format=full)
     */
    getTokensByDeployer(wallet: string, params: DeployerParams & {
        format: 'full';
    }): Promise<DeployerTokensResponse<TokenDetailResponse>>;
    getTokensByDeployer(wallet: string, pageOrParams?: number | DeployerParams, limit?: number): Promise<DeployerTokensResponse>;
    /**
     * Search for tokens with flexible filtering options
     * @param params Search parameters and filters
     * @returns Search results (TokenDetailResponse items when format=full)
     */
    searchTokens(params: SearchParams & {
        format: 'full';
    }): Promise<SearchResponse<TokenDetailResponse>>;
    searchTokens(params: SearchParams): Promise<SearchResponse>;
    /**
     * Get the latest tokens
     * @param page Page number (1-10)
     * @returns List of latest tokens
     */
    getLatestTokens(page?: number): Promise<TokenDetailResponse[]>;
    /**
     * Get information about multiple tokens
     * @param tokenAddresses Array of token addresses
     * @returns Information about multiple tokens
     */
    getMultipleTokens(tokenAddresses: string[]): Promise<MultiTokensResponse>;
    /**
     * Get trending tokens
     * @param timeframe Optional timeframe for trending calculation
     * @returns List of trending tokens
     */
    getTrendingTokens(timeframe?: string): Promise<TokenDetailResponse[]>;
    /**
     * Get top performing tokens by price change percentage
     * @param timeframe Timeframe for performance calculation (5m, 15m, 30m, 1h, 6h, 12h, 24h)
     * @returns List of top performing tokens
     */
    getTopPerformers(timeframe: string): Promise<TokenDetailResponse[]>;
    /**
     * Get tokens sorted by volume
     * @param timeframe Optional timeframe for volume calculation
     * @returns List of tokens sorted by volume
     */
    getTokensByVolume(timeframe?: string): Promise<TokenDetailResponse[]>;
    /**
     * Get an overview of latest, graduating, and graduated tokens
     * @param limit Number of tokens per category (or params object)
     * @returns Token overview (Memescope / Pumpvision style)
     */
    getTokenOverview(limit?: number): Promise<TokenOverview>;
    getTokenOverview(params?: TokenOverviewParams): Promise<TokenOverview>;
    /**
     * Get graduated tokens
     * @param params Optional parameters including limit, page, and filters
     * @returns List of graduated tokens
     */
    getGraduatedTokens(): Promise<TokenDetailResponse[]>;
    getGraduatedTokens(params?: GraduatedTokensParams): Promise<TokenDetailResponse[]>;
    /**
     * Get graduating tokens
     * @param params Optional parameters including limit, curve percentages, holders, and filters
     * @returns List of graduating tokens
     */
    getGraduatingTokens(): Promise<TokenDetailResponse[]>;
    getGraduatingTokens(params?: GraduatingTokensParams): Promise<TokenDetailResponse[]>;
    /**
     * Get price information for a token
     * @param tokenAddress The token's mint address
     * @param priceChanges Include price change percentages
     * @returns Price data
     */
    getPrice(tokenAddress: string, priceChanges?: boolean): Promise<PriceData>;
    /**
     * Get historic price information for a token
     * @param tokenAddress The token's mint address
     * @returns Historic price data
     */
    getPriceHistory(tokenAddress: string): Promise<PriceHistoryData>;
    /**
     * Get price at a specific timestamp
     * @param tokenAddress The token's mint address
     * @param timestamp Unix timestamp
     * @returns Price at the specified timestamp
     */
    getPriceAtTimestamp(tokenAddress: string, timestamp: number): Promise<PriceTimestampData>;
    /**
     * Get lowest and highest price in a time range
     * @param tokenAddress The token's mint address
     * @param timeFrom Start time (unix timestamp)
     * @param timeTo End time (unix timestamp)
     * @returns Price range data
     */
    getPriceRange(tokenAddress: string, timeFrom: number, timeTo: number): Promise<PriceRangeData>;
    /**
     * Get price information for a token (POST method)
     * @param tokenAddress The token's mint address
     * @param priceChanges Include price change percentages
     * @returns Price data
     */
    postPrice(tokenAddress: string, priceChanges?: boolean): Promise<PriceData>;
    /**
     * Get price information for multiple tokens
     * @param tokenAddresses Array of token addresses
     * @param priceChanges Include price change percentages
     * @returns Price data for multiple tokens
     */
    getMultiplePrices(tokenAddresses: string[], priceChanges?: boolean): Promise<MultiPriceResponse>;
    /**
     * Get price information for multiple tokens (POST method)
     * @param tokenAddresses Array of token addresses
     * @param priceChanges Include price change percentages
     * @returns Price data for multiple tokens
     */
    postMultiplePrices(tokenAddresses: string[], priceChanges?: boolean): Promise<MultiPriceResponse>;
    /**
     * Get basic wallet information
     * @param owner Wallet address
     * @returns Basic wallet data
     */
    getWalletBasic(owner: string): Promise<WalletBasicResponse>;
    /**
     * Get all tokens in a wallet
     * @param owner Wallet address
     * @returns Detailed wallet data
     */
    getWallet(owner: string): Promise<WalletResponse>;
    /**
     * Get wallet tokens with pagination
     * @param owner Wallet address
     * @param page Page number
     * @returns Paginated wallet data
     */
    getWalletPage(owner: string, page: number): Promise<WalletResponse>;
    /**
   * Get wallet portfolio chart data with PnL information
   * @param wallet Wallet address
   * @returns Wallet chart data with historical values and PnL
   * @throws DataApiError if no data found for the wallet
   */
    getWalletChart(wallet: string): Promise<WalletChartResponse>;
    /**
     * Get wallet trades
     * @param owner Wallet address
     * @param cursor Pagination cursor
     * @param showMeta Include token metadata
     * @param parseJupiter Parse Jupiter swaps
     * @param hideArb Hide arbitrage transactions
     * @returns Wallet trades data
     */
    getWalletTrades(owner: string, cursor?: number, showMeta?: boolean, parseJupiter?: boolean, hideArb?: boolean): Promise<WalletTradesResponse>;
    /**
     * Get trades for a token
     * @param tokenAddress Token address
     * @param cursor Pagination cursor
     * @param showMeta Include token metadata
     * @param parseJupiter Parse Jupiter swaps
     * @param hideArb Hide arbitrage transactions
     * @returns Token trades data
     */
    getTokenTrades(tokenAddress: string, cursor?: number, showMeta?: boolean, parseJupiter?: boolean, hideArb?: boolean): Promise<TradesResponse>;
    /**
     * Get trades for a specific token and pool
     * @param tokenAddress Token address
     * @param poolAddress Pool address
     * @param cursor Pagination cursor
     * @param showMeta Include token metadata
     * @param parseJupiter Parse Jupiter swaps
     * @param hideArb Hide arbitrage transactions
     * @returns Pool-specific token trades data
     */
    getPoolTrades(tokenAddress: string, poolAddress: string, cursor?: number, showMeta?: boolean, parseJupiter?: boolean, hideArb?: boolean): Promise<TradesResponse>;
    /**
     * Get trades for a specific token, pool, and wallet
     * @param tokenAddress Token address
     * @param poolAddress Pool address
     * @param owner Wallet address
     * @param cursor Pagination cursor
     * @param showMeta Include token metadata
     * @param parseJupiter Parse Jupiter swaps
     * @param hideArb Hide arbitrage transactions
     * @returns User-specific pool trades data
     */
    getUserPoolTrades(tokenAddress: string, poolAddress: string, owner: string, cursor?: number, showMeta?: boolean, parseJupiter?: boolean, hideArb?: boolean): Promise<TradesResponse>;
    /**
     * Get trades for a specific token and wallet
     * @param tokenAddress Token address
     * @param owner Wallet address
     * @param cursor Pagination cursor
     * @param showMeta Include token metadata
     * @param parseJupiter Parse Jupiter swaps
     * @param hideArb Hide arbitrage transactions
     * @returns User-specific token trades data
     */
    getUserTokenTrades(tokenAddress: string, owner: string, cursor?: number, showMeta?: boolean, parseJupiter?: boolean, hideArb?: boolean): Promise<TradesResponse>;
    /**
    * Get OHLCV data for a token
    * @param params Chart parameters as an object or individual parameters
    * @returns OHLCV chart data
    */
    getChartData(params: ChartDataParams): Promise<ChartResponse>;
    getChartData(tokenAddress: string, type?: string, timeFrom?: number, timeTo?: number, marketCap?: boolean, removeOutliers?: boolean, dynamicPools?: boolean, timezone?: string | 'current', fastCache?: boolean, currency?: 'usd' | 'eur' | 'sol'): Promise<ChartResponse>;
    /**
     * Get OHLCV data for a specific token and pool
     * @param params Chart parameters as an object or individual parameters
     * @returns OHLCV chart data for a specific pool
     */
    getPoolChartData(params: ChartDataParams): Promise<ChartResponse>;
    getPoolChartData(tokenAddress: string, poolAddress: string, type?: string, timeFrom?: number, timeTo?: number, marketCap?: boolean, removeOutliers?: boolean, timezone?: string | 'current', fastCache?: boolean, currency?: 'usd' | 'eur' | 'sol'): Promise<ChartResponse>;
    /**
     * Get holder count chart data
     * @param tokenAddress Token address
     * @param type Time interval (e.g., "1s", "1m", "1h", "1d")
     * @param timeFrom Start time (Unix timestamp in seconds)
     * @param timeTo End time (Unix timestamp in seconds)
     * @returns Holder count chart data
     */
    getHoldersChart(tokenAddress: string, type?: string, timeFrom?: number, timeTo?: number): Promise<HoldersChartResponse>;
    /**
     * Get snipers percentage chart data
     * @param tokenAddress Token address
     * @param type Time interval (e.g., "1s", "1m", "1h", "1d")
     * @param timeFrom Start time (Unix timestamp in seconds)
     * @param timeTo End time (Unix timestamp in seconds)
     * @returns Snipers percentage chart data
     */
    getSnipersChart(tokenAddress: string, type?: string, timeFrom?: number, timeTo?: number): Promise<SnipersChartResponse>;
    /**
     * Get insiders percentage chart data
     * @param tokenAddress Token address
     * @param type Time interval (e.g., "1s", "1m", "1h", "1d")
     * @param timeFrom Start time (Unix timestamp in seconds)
     * @param timeTo End time (Unix timestamp in seconds)
     * @returns Insiders percentage chart data
     */
    getInsidersChart(tokenAddress: string, type?: string, timeFrom?: number, timeTo?: number): Promise<InsidersChartResponse>;
    /**
     * Get bundlers percentage chart data
     * @param tokenAddress Token address
     * @param type Time interval (e.g., "1s", "1m", "1h", "1d")
     * @param timeFrom Start time (Unix timestamp in seconds)
     * @param timeTo End time (Unix timestamp in seconds)
     * @returns Bundlers percentage chart data
     */
    getBundlersChart(tokenAddress: string, type?: string, timeFrom?: number, timeTo?: number): Promise<BundlersChartResponse>;
    /**
     * Get PnL data for all positions of a wallet
     * @param wallet Wallet address
     * @param showHistoricPnL Add PnL data for 1d, 7d and 30d intervals (BETA)
     * @param holdingCheck Additional check for current holding value
     * @param hideDetails Return only summary without data for each token
     * @returns Wallet PnL data
     */
    getWalletPnL(wallet: string, showHistoricPnL?: boolean, holdingCheck?: boolean, hideDetails?: boolean): Promise<PnLResponse>;
    /**
     * Get the first 100 buyers of a token with PnL data
     * @param tokenAddress Token address
     * @returns First buyers data with PnL
     */
    getFirstBuyers(tokenAddress: string): Promise<FirstBuyerData[]>;
    /**
   * Get PnL data for a specific token in a wallet
   * @param wallet Wallet address
   * @param tokenAddress Token address
   * @param holdingCheck Additional check for current holding value in wallet
   * @returns Token-specific PnL data
   */
    getTokenPnL(wallet: string, tokenAddress: string, holdingCheck?: boolean): Promise<TokenPnLResponse>;
    /**
     * Get the most profitable traders across all tokens
     * @param page Page number (optional)
     * @param expandPnL Include detailed PnL data for each token
     * @param sortBy Sort results by metric ("total" or "winPercentage")
     * @returns Top traders data
     */
    getTopTraders(page?: number, expandPnL?: boolean, sortBy?: 'total' | 'winPercentage'): Promise<TopTradersResponse>;
    /**
     * Get top 100 traders by PnL for a token
     * @param tokenAddress Token address
     * @returns Top traders for a specific token
     */
    getTokenTopTraders(tokenAddress: string): Promise<FirstBuyerData[]>;
    /**
     * Get detailed stats for a token over various time intervals
     * @param tokenAddress Token address
     * @returns Detailed token stats
     */
    getTokenStats(tokenAddress: string): Promise<TokenStats>;
    /**
     * Get detailed stats for a specific token and pool
     * @param tokenAddress Token address
     * @param poolAddress Pool address
     * @returns Detailed token-pool stats
     */
    getPoolStats(tokenAddress: string, poolAddress: string): Promise<TokenStats>;
    /**
   * Get current subscription information including credits, plan, and billing details
   * @returns Subscription information
   */
    getSubscription(): Promise<SubscriptionResponse>;
    /**
   * Get remaining API credits for the current API key
   * @returns Credits information
   */
    getCredits(): Promise<CreditsResponse>;
    /**
     * Get events data for a token (all pools)
     * NOTE: For non-live statistics, use getTokenStats() instead which is more efficient
     * @param tokenAddress The token's mint address
     * @returns Decoded events array
     */
    getEvents(tokenAddress: string): Promise<ProcessedEvent[]>;
    /**
     * Get events data for a specific token and pool
     * NOTE: For non-live statistics, use getPoolStats() instead which is more efficient
     * @param tokenAddress The token's mint address
     * @param poolAddress The pool's address
     * @returns Decoded events array
     */
    getPoolEvents(tokenAddress: string, poolAddress: string): Promise<ProcessedEvent[]>;
    getPnlV2KOLLeaderboard(params?: PnlV2KOLLeaderboardParams): Promise<PnlV2KOLLeaderboardResponse>;
    getPnlV2KOLPeriodLeaderboard(params?: PnlV2KOLPeriodParams): Promise<PnlV2KOLPeriodResponse>;
    getPnlV2KOLCalendar(params?: PnlV2KOLCalendarParams): Promise<PnlV2KOLCalendarResponse>;
    getPnlV2KOLByDate(params?: PnlV2KOLByDateParams): Promise<PnlV2KOLByDateResponse>;
    getPnlV2TopTraders(params?: PnlV2TopTradersParams): Promise<PnlV2TopTradersResponse>;
    getPnlV2TokenTraders(token: string, params?: PnlV2TokenTradersParams): Promise<PnlV2TokenTradersResponse>;
    getPnlV2TokenFirstBuyers(token: string, params?: PnlV2TokenFirstBuyersParams): Promise<PnlV2TokenTradersResponse>;
    getPnlV2WalletOverview(wallet: string, params?: PnlV2WalletOverviewParams): Promise<PnlV2WalletOverviewResponse | PnlV2WalletQueued>;
    getPnlV2WalletHistory(wallet: string, params?: PnlV2WalletHistoryParams): Promise<PnlV2WalletHistoryResponse | PnlV2WalletQueued>;
    getPnlV2WalletPerformance(wallet: string, params?: PnlV2WalletPerformanceParams): Promise<PnlV2WalletPerformanceResponse | PnlV2WalletQueued>;
    getPnlV2WalletTokenPosition(wallet: string, token: string, params?: PnlV2WalletTokenPositionParams): Promise<PnlV2WalletTokenPositionResponse | PnlV2WalletQueued>;
    getPnlV2WalletHighlights(wallet: string): Promise<PnlV2WalletHighlightsResponse | PnlV2WalletQueued>;
    getPnlV2WalletRisk(wallet: string): Promise<PnlV2WalletRiskResponse | PnlV2WalletQueued>;
    getPnlV2WalletPositions(wallet: string, params?: PnlV2WalletPositionsParams): Promise<PnlV2WalletPositionsResponse | PnlV2WalletQueued>;
    getPnlV2WalletChart(wallet: string, params?: PnlV2WalletChartParams): Promise<PnlV2WalletChartResponse | PnlV2WalletQueued>;
    /**
     * Batch fetch lifetime PnL summaries for up to 100 wallets in one request.
     * Duplicates are deduped server-side; if more than 100 unique wallets are sent,
     * the server truncates and returns `truncated: true` in the response.
     */
    batchPnlV2WalletSummaries(wallets: string[]): Promise<PnlV2BatchWalletSummariesResponse>;
    batchPnlV2WalletTokenPositions(wallet: string, tokens: string[], params?: PnlV2BatchParams): Promise<PnlV2BatchWalletPositionsResponse>;
    batchPnlV2TokenWalletPositions(token: string, wallets: string[], params?: PnlV2BatchParams): Promise<PnlV2BatchTokenPositionsResponse>;
    batchPnlV2PositionPairs(pairs: Array<{
        wallet: string;
        token: string;
    }>, params?: PnlV2BatchParams): Promise<PnlV2BatchPositionPairsResponse>;
    /** List supported DCA programs (currently `jupiter`). */
    getDcaPrograms(): Promise<DcaProgramsResponse>;
    /**
     * Get a wallet's DCA orders with status counts and pagination.
     * @param wallet Wallet pubkey
     * @param params Optional `program`, `limit`, `cursor`, `sort`, `status`
     */
    getDcaWallet(wallet: string, params?: DcaListParams): Promise<DcaWalletResponse>;
    /** Paginated DCA orders for a wallet (no status summary). */
    getDcaWalletOrders(wallet: string, params?: DcaListParams): Promise<DcaOrdersListResponse>;
    /** Fetch a single DCA order by its account pubkey. */
    getDcaOrder(address: string, params?: DcaProgramParams): Promise<DcaOrder>;
    /** Aggregate buyer/seller flow on a token across DCA orders. */
    getDcaTokenFlow(mint: string, params?: DcaListParams): Promise<DcaTokenFlowResponse>;
    /** DCA orders buying this token (token is the output mint). */
    getDcaTokenBuyers(mint: string, params?: DcaListParams): Promise<DcaTokenOrdersResponse>;
    /** DCA orders selling this token (token is the input mint). */
    getDcaTokenSellers(mint: string, params?: DcaListParams): Promise<DcaTokenOrdersResponse>;
    /** Top wallets by DCA activity on a token. */
    getDcaTokenUsers(mint: string, params?: {
        program?: string;
        limit?: number;
    }): Promise<DcaTokenUsersResponse>;
    /** DCA orders for a specific input → output trading pair. */
    getDcaPair(inputMint: string, outputMint: string, params?: DcaListParams): Promise<DcaPairResponse>;
}

/**
 * WebSocket polyfill for Node.js environments
 */
declare global {
    interface Window {
        WebSocket: typeof WebSocket;
    }
}

/**
 * Room types for the WebSocket data stream
 */
declare enum DatastreamRoom {
    LATEST = "latest",
    PRICE_BY_TOKEN = "price-by-token",
    PRICE_BY_POOL = "price",
    TOKEN_TRANSACTIONS = "transaction",
    WALLET_TRANSACTIONS = "wallet",
    GRADUATING = "graduating",
    GRADUATED = "graduated",
    CURVE_PERCENTAGE = "curve",
    METADATA = "metadata",
    HOLDERS = "holders",
    TOKEN_CHANGES = "token",
    POOL_CHANGES = "pool",
    SNIPERS = "sniper",
    INSIDERS = "insider",
    BUNDLERS = "bundlers",
    VOLUME_POOL = "volume:pool",
    VOLUME_TOKEN = "volume:token",
    PNL_WALLET = "pnl",
    PNL_WALLET_SUMMARY = "pnl:summary",
    DCA_JUPITER = "dca:jupiter",
    DCA_JUPITER_OPENED = "dca:jupiter:opened",
    DCA_JUPITER_FILLED = "dca:jupiter:filled",
    DCA_JUPITER_CLOSED = "dca:jupiter:closed",
    DCA_JUPITER_DEPOSIT = "dca:jupiter:deposit",
    DCA_JUPITER_WITHDRAW = "dca:jupiter:withdraw",
    DCA_JUPITER_COLLECTED_FEE = "dca:jupiter:collected_fee",
    DCA_JUPITER_POSITION = "dca:jupiter:position"
}
/**
 * Configuration for the Datastream client
 */
interface DatastreamConfig {
    /**
     * WebSocket URL for the data stream found on your Dashboard.
     */
    wsUrl: string;
    /**
     * Whether to automatically reconnect on disconnect
     * @default true
     */
    autoReconnect?: boolean;
    /**
     * Initial reconnect delay in milliseconds
     * @default 2500
     */
    reconnectDelay?: number;
    /**
     * Maximum reconnect delay in milliseconds
     * @default 4500
     */
    reconnectDelayMax?: number;
    /**
     * Randomization factor for reconnect delay
     * @default 0.5
     */
    randomizationFactor?: number;
    /**
     * Whether to run WebSocket connections in a Web Worker
     * @default false
     */
    useWorker?: boolean;
    /**
     * Custom worker script URL (optional)
     * If not provided, will use inline worker
     */
    workerUrl?: string;
}
interface SubscribeResponse<T = any> {
    room: string;
    /**
     * Register a listener for this subscription
     * @param callback Function to handle incoming data
     * @returns Object with unsubscribe method
     */
    on(callback: (data: T) => void): {
        unsubscribe: () => void;
    };
}
/**
 * Token subscription methods interface
 */
interface TokenSubscriptionMethods {
    /**
     * Subscribe to all pool updates for this token (default)
     */
    on(callback: (data: PoolUpdate) => void): {
        unsubscribe: () => void;
    };
    room: string;
    /**
     * Subscribe to all pool updates for this token
     */
    all(): SubscribeResponse<PoolUpdate>;
    /**
     * Subscribe to primary pool updates for this token
     */
    primary(): SubscribeResponse<PoolUpdate>;
    /**
    * Subscribe to dev/creator related events for this token
    */
    dev: DevSubscriptionMethods;
    /**
    * Subscribe to top 10 holders updates for this token
    */
    top10(): SubscribeResponse<Top10HoldersUpdate>;
    /**
    * Subscribe to platform and network fees for this token
    */
    fees(): SubscribeResponse<FeesUpdate>;
}
/**
 * Wallet balance subscription methods interface
 */
interface WalletBalanceSubscriptionMethods {
    /**
     * Subscribe to all balance updates for the wallet
     */
    balance(): SubscribeResponse<WalletBalanceUpdate>;
    /**
     * Subscribe to specific token balance updates for the wallet
     */
    tokenBalance(tokenAddress: string): SubscribeResponse<WalletBalanceUpdate>;
}
/**
 * Dev-related subscription methods interface
 */
interface DevSubscriptionMethods {
    /**
     * Subscribe to developer/creator holding updates for the token
     */
    holding(): SubscribeResponse<DevHoldingUpdate>;
}
/**
 * Subscription methods for the Datastream client
 */
declare class SubscriptionMethods {
    private ds;
    price: PriceSubscriptions;
    tx: TransactionSubscriptions;
    stats: StatsSubscriptions;
    volume: VolumeSubscriptions;
    pnl: PnlSubscriptions;
    dca: DcaSubscriptions;
    constructor(datastream: Datastream);
    /**
     * Subscribe to latest tokens and pools
     */
    latest(): SubscribeResponse<TokenDetailWebsocket>;
    /**
     * Subscribe to graduating tokens
     * @param marketCapThresholdSOL Optional market cap threshold in SOL
     */
    graduating(marketCapThresholdSOL?: number): SubscribeResponse<TokenDetailWebsocket>;
    /**
     * Subscribe to tokens reaching a specific curve percentage for a market
     * @param market The market type: 'launchpad', 'pumpfun', 'boop', or 'meteora-curve'
     * @param percentage The curve percentage threshold (e.g., 30, 50, 75)
     * @returns Subscription response with curve percentage updates
     */
    curvePercentage(market: 'launchpad' | 'pumpfun' | 'boop' | 'meteora-curve', percentage: number): SubscribeResponse<CurvePercentageUpdate>;
    /**
     * Subscribe to graduated tokens
     */
    graduated(): SubscribeResponse<TokenDetailWebsocket>;
    /**
     * Subscribe to token metadata updates
     * @param tokenAddress The token address
     */
    metadata(tokenAddress: string): SubscribeResponse<TokenMetadata>;
    /**
     * Subscribe to holder count updates for a token
     * @param tokenAddress The token address
     */
    holders(tokenAddress: string): SubscribeResponse<HolderUpdate>;
    /**
     * Subscribe to token-related events (all pools, primary pool, dev events, or top holders)
     *
     * @example
     * // For all pool updates:
     * datastream.subscribe.token('address').all().on(callback)
     * // Or using shorthand:
     * datastream.subscribe.token('address').on(callback)
     *
     * // For primary pool updates only:
     * datastream.subscribe.token('address').primary().on(callback)
     *
     * // For dev holding updates:
     * datastream.subscribe.token('address').dev.holding().on(callback)
     *
     * // For top 10 holders updates:
     * datastream.subscribe.token('address').top10().on(callback)
     *
     * @param tokenAddress The token address
     */
    token(tokenAddress: string): TokenSubscriptionMethods;
    /**
     * Subscribe to pool changes
     * @param poolId The pool address
     */
    pool(poolId: string): SubscribeResponse<PoolUpdate>;
    /**
     * Subscribe to sniper updates for a token
     * @param tokenAddress The token address
     */
    snipers(tokenAddress: string): SubscribeResponse<SniperInsiderUpdate>;
    /**
     * Subscribe to insider updates for a token
     * @param tokenAddress The token address
     */
    insiders(tokenAddress: string): SubscribeResponse<SniperInsiderUpdate>;
    /**
     * Subscribe to bundler updates for a token
     * @param tokenAddress The token address
     */
    bundlers(tokenAddress: string): SubscribeResponse<BundlerUpdate>;
    /**
     * Subscribe to wallet balance updates
     *
     * @example
     * // For all balance updates:
     * datastream.subscribe.wallet('address').balance().on(callback)
     *
     * // For specific token balance:
     * datastream.subscribe.wallet('address').tokenBalance('token').on(callback)
     *
     * @param walletAddress The wallet address
     */
    wallet(walletAddress: string): WalletBalanceSubscriptionMethods;
}
/**
 * Stats-related subscription methods
 */
declare class StatsSubscriptions {
    private ds;
    total: StatsTotalSubscriptions;
    constructor(datastream: Datastream);
    /**
     * Subscribe to live stats updates for a token across all timeframes
     * @param tokenAddress The token address
     * @returns Subscription response with stats updates
     */
    token(tokenAddress: string): SubscribeResponse<TokenStats>;
    /**
     * Subscribe to live stats updates for a specific pool across all timeframes
     * @param poolId The pool address
     * @returns Subscription response with stats updates
     */
    pool(poolId: string): SubscribeResponse<TokenStats>;
}
/**
 * Total stats room subscription methods
 */
declare class StatsTotalSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /**
     * Subscribe to total stats updates for a token
     * Room: stats:token:{tokenAddress}:total
     *
     * Note: this room emits the stats object directly.
     */
    token(tokenAddress: string): SubscribeResponse<TokenStatsTotal>;
    /**
     * Subscribe to total stats updates for a pool
     * Room: stats:pool:{poolId}:total
     *
     * Note: this room emits the stats object directly.
     */
    pool(poolId: string): SubscribeResponse<TokenStatsTotal>;
}
/**
 * Volume-related subscription methods
 */
declare class VolumeSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /**
     * Subscribe to USD volume aggregated per pool (flushed every ~50ms)
     * Room: volume:pool:{poolAddress}
     */
    pool(poolAddress: string): SubscribeResponse<VolumePoolUpdate>;
    /**
     * Subscribe to USD volume aggregated per token (cross-pool deduplicated, flushed every ~50ms)
     * Room: volume:token:{tokenAddress}
     */
    token(tokenAddress: string): SubscribeResponse<VolumeTokenUpdate>;
}
/**
 * PnL-related subscription methods
 */
declare class PnlSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /**
     * Subscribe to trade and balance updates for a specific wallet+token position
     * Room: pnl:{walletAddress}:{tokenAddress}
     */
    position(walletAddress: string, tokenAddress: string): SubscribeResponse<PnlPositionUpdate>;
    /**
     * Subscribe to trade and balance updates for all token positions in a wallet
     * Room: pnl:{walletAddress}
     */
    wallet(walletAddress: string): SubscribeResponse<PnlPositionUpdate>;
    /**
     * Subscribe to aggregated wallet summary updates
     * Room: pnl:{walletAddress}:summary
     */
    summary(walletAddress: string): SubscribeResponse<PnlWalletUpdate>;
}
/**
 * Jupiter DCA (recurring orders) subscription methods.
 *
 * Each DCA event is delivered to the global room (`dca:jupiter`), the matching
 * event-type room (e.g. `dca:jupiter:filled`), and any scoped rooms that apply
 * (token buyers/sellers, wallet, or specific DCA address).
 */
declare class DcaSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /** All Jupiter DCA events (transactions and position snapshots). */
    all(): SubscribeResponse<DcaStreamEvent>;
    /** New DCA opened events. */
    opened(): SubscribeResponse<DcaOpenedEvent>;
    /** Cycle fill events. */
    filled(): SubscribeResponse<DcaFilledEvent>;
    /** DCA closed events. */
    closed(): SubscribeResponse<DcaClosedEvent>;
    /** Deposit events. */
    deposit(): SubscribeResponse<DcaDepositEvent>;
    /** Withdraw events. */
    withdraw(): SubscribeResponse<DcaWithdrawEvent>;
    /** Fee collection events. */
    collectedFee(): SubscribeResponse<DcaCollectedFeeEvent>;
    /** Live DCA account snapshots (no transaction signature). */
    position(): SubscribeResponse<DcaPositionEvent>;
    /**
     * All DCA events for a given token (input or output).
     * Returns helpers `.buyers()` and `.sellers()` to scope to direction.
     */
    token(mint: string): {
        buyers(): SubscribeResponse<DcaStreamEvent>;
        sellers(): SubscribeResponse<DcaStreamEvent>;
    };
    /** All DCA events for a wallet owner. */
    wallet(walletAddress: string): SubscribeResponse<DcaStreamEvent>;
    /** All DCA events for a specific DCA account address. */
    order(dcaAddress: string): SubscribeResponse<DcaStreamEvent>;
}
declare class PriceSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /**
     * Subscribe to aggregated price updates for a token across all pools
     * Provides median, average, min, max prices and top pools by liquidity
     * @param tokenAddress The token address
     */
    aggregated(tokenAddress: string): SubscribeResponse<AggregatedPriceUpdate>;
    /**
     * @deprecated Use aggregated() instead for better price data across all pools
     * Subscribe to price updates for a token's primary/largest pool
     * @param tokenAddress The token address
     */
    token(tokenAddress: string): SubscribeResponse<PriceUpdate>;
    /**
     * Subscribe to all price updates for a token across all pools
     * @param tokenAddress The token address
     */
    allPoolsForToken(tokenAddress: string): SubscribeResponse<PriceUpdate>;
    /**
     * Subscribe to price updates for a specific pool
     * @param poolId The pool address
     */
    pool(poolId: string): SubscribeResponse<PriceUpdate>;
}
/**
 * Wallet transaction subscription methods interface (under .tx namespace)
 */
interface WalletTransactionSubscriptionMethods {
    /**
     * Subscribe to wallet transactions (default)
     */
    on(callback: (data: WalletTransaction) => void): {
        unsubscribe: () => void;
    };
    room: string;
    /**
     * Explicitly subscribe to wallet transactions
     */
    transactions(): SubscribeResponse<WalletTransaction>;
    /**
     * @deprecated Use datastream.subscribe.wallet('address').balance() instead
     * This method will be removed in a future version
     */
    balance(): SubscribeResponse<WalletBalanceUpdate>;
    /**
     * @deprecated Use datastream.subscribe.wallet('address').tokenBalance('token') instead
     * This method will be removed in a future version
     */
    tokenBalance(tokenAddress: string): SubscribeResponse<WalletBalanceUpdate>;
}
/**
 * Transaction-related subscription methods
 */
declare class TransactionSubscriptions {
    private ds;
    constructor(datastream: Datastream);
    /**
     * Subscribe to transactions for a token across all pools
     * @param tokenAddress The token address
     */
    token(tokenAddress: string): SubscribeResponse<TokenTransaction>;
    /**
     * Subscribe to transactions for a specific token and pool
     * @param tokenAddress The token address
     * @param poolId The pool address
     */
    pool(tokenAddress: string, poolId: string): SubscribeResponse<TokenTransaction>;
    /**
     * Subscribe to wallet transactions
     *
     * @example
     * // Subscribe to wallet transactions (default):
     * datastream.subscribe.tx.wallet('address').on(callback)
     *
     * // Subscribe to wallet transactions (explicit):
     * datastream.subscribe.tx.wallet('address').transactions().on(callback)
     *
     * @param walletAddress The wallet address
     */
    wallet(walletAddress: string): WalletTransactionSubscriptionMethods;
}
/**
 * WebSocket service for real-time data streaming from Solana Tracker
 */
declare class Datastream extends EventEmitter {
    subscribe: SubscriptionMethods;
    private wsUrl;
    private socket;
    private transactionSocket;
    private reconnectAttempts;
    private reconnectDelay;
    private reconnectDelayMax;
    private randomizationFactor;
    private subscribedRooms;
    private transactions;
    private autoReconnect;
    private isConnecting;
    private useWorker;
    private worker;
    private workerUrl?;
    /**
     * Creates a new Datastream client for real-time Solana Tracker data
     * @param config Configuration options
     */
    constructor(config: DatastreamConfig);
    /**
     * Connects to the WebSocket server
     * @returns Promise that resolves when connected
     */
    connect(): Promise<void>;
    /**
     * Connects using Web Worker
     * @returns Promise that resolves when connected
     */
    private connectWithWorker;
    /**
     * Sets up worker event listeners
     */
    private setupWorkerListeners;
    /**
     * Handles messages from worker
     */
    private handleWorkerMessage;
    private getWorkerCode;
    /**
     * Creates a WebSocket connection
     * @param type Socket type ('main' or 'transaction')
     * @returns Promise that resolves when connected
     */
    private createSocket;
    /**
     * Sets up WebSocket event listeners
     * @param socket The WebSocket connection
     * @param type Socket type ('main' or 'transaction')
     */
    private setupSocketListeners;
    /**
     * Disconnects from the WebSocket server
     */
    disconnect(): void;
    /**
     * Handles reconnection to the WebSocket server
     */
    private reconnect;
    /**
     * Subscribes to a data room
     * @param room The room name to join
     * @returns Response with room name and on() method for listening
     * @internal Used by SubscriptionMethods
     */
    _subscribe<T = any>(room: string): SubscribeResponse<T>;
    on(event: string | symbol, listener: (...args: any[]) => void): this;
    once(event: string | symbol, listener: (...args: any[]) => void): this;
    off(event: string | symbol, listener: (...args: any[]) => void): this;
    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
    removeAllListeners(event?: string | symbol): this;
    listeners(event: string | symbol): Function[];
    /**
     * Unsubscribes from a data room
     * @param room The room name to leave
     * @returns Reference to this instance for chaining
     */
    unsubscribe(room: string): Datastream;
    /**
     * Resubscribes to all previously subscribed rooms after reconnection
     */
    private resubscribeToRooms;
    /**
     * Get the current connection status
     * @returns True if connected, false otherwise
     */
    isConnected(): boolean;
}
interface TokenDetailWebsocket {
    token: TokenInfo;
    pools: PoolInfo[];
    events: TokenEvents;
    risk: TokenRisk;
}
interface CurvePercentageUpdate {
    token: TokenInfo;
    pools: PoolInfo[];
    events: TokenEvents;
    risk: TokenRisk;
}
interface TokenTransaction {
    tx: string;
    amount: number;
    priceUsd: number;
    volume: number;
    solVolume: number;
    type: 'buy' | 'sell';
    wallet: string;
    time: number;
    program: string;
    token: {
        from: {
            name: string;
            symbol: string;
            image?: string;
            decimals: number;
            amount: number;
            address: string;
            price?: {
                usd: number;
            };
            marketCap?: {
                usd: number;
            };
            [key: string]: any;
        };
        to: {
            name: string;
            symbol: string;
            image?: string;
            decimals: number;
            amount: number;
            address: string;
            price?: {
                usd: number;
            };
            marketCap?: {
                usd: number;
            };
            [key: string]: any;
        };
    };
}
interface PriceUpdate {
    price: number;
    price_quote: number;
    pool: string;
    token: string;
    time: number;
}
interface LaunchpadLiquidity {
    amount: number;
    usd: number;
}
interface Launchpad {
    name: string;
    url: string;
    logo: string;
    baseLiquidity: LaunchpadLiquidity;
    quoteLiquidity: LaunchpadLiquidity;
}
interface MeteoraCurveLiquidity {
    base?: number;
    quote?: number;
    usd: number;
}
interface MeteoraCurve {
    baseLiquidity: MeteoraCurveLiquidity;
    quoteLiquidity: MeteoraCurveLiquidity;
    fee: number;
    name?: string;
    url?: string;
    logo?: string;
}
interface PoolUpdate {
    liquidity: {
        quote: number;
        usd: number;
    };
    price: {
        quote: number;
        usd: number;
    };
    tokenSupply: number;
    lpBurn: number;
    tokenAddress: string;
    marketCap: {
        quote: number;
        usd: number;
    };
    decimals: number;
    security: {
        freezeAuthority: string | null;
        mintAuthority: string | null;
    };
    quoteToken: string;
    market: string;
    deployer?: string;
    lastUpdated: number;
    createdAt?: number;
    poolId: string;
    curvePercentage?: number;
    curve?: string;
    txns?: {
        buys: number;
        total: number;
        volume: number;
        sells: number;
        volume24h: number;
    };
    bundleId?: string;
    launchpad?: Launchpad;
    meteoraCurve?: MeteoraCurve;
    raydium?: {
        baseLiquidity: number;
        quoteLiquidity: number;
    };
    heaven?: {
        baseLiquidity: number;
        quoteLiquidity: number;
        is_migrated: boolean;
        migrationTime?: number;
    };
}
interface HolderUpdate {
    total: number;
}
interface WalletTransaction {
    tx: string;
    type: 'buy' | 'sell';
    wallet: string;
    time: number;
    price: {
        quote: number;
        usd: number;
    };
    volume: {
        usd: number;
        sol: number;
    };
    program: string;
    pools: string[];
    from: {
        address: string;
        amount: number;
        token: {
            name: string;
            symbol: string;
            image?: string;
            decimals: number;
            amount: number;
            address: string;
            price?: {
                usd: number;
            };
            marketCap?: {
                usd: number;
            };
            [key: string]: any;
        };
    };
    to: {
        address: string;
        amount: number;
        token: {
            name: string;
            symbol: string;
            image?: string;
            decimals: number;
            amount: number;
            address: string;
            price?: {
                usd: number;
            };
            marketCap?: {
                usd: number;
            };
            [key: string]: any;
        };
    };
}
interface TokenMetadata {
    name: string;
    symbol: string;
    mint: string;
    uri?: string;
    decimals: number;
    hasFileMetaData?: boolean;
    createdOn?: string;
    description?: string;
    image?: string;
    showName?: boolean;
    twitter?: string;
    telegram?: string;
    website?: string;
    strictSocials?: {
        twitter?: string;
        telegram?: string;
        website?: string;
    };
}
interface SniperInsiderUpdate {
    wallet: string;
    amount: string;
    tokenAmount: number;
    percentage: number;
    previousAmount: number;
    previousPercentage: number;
    totalSniperPercentage: number;
    totalInsiderPercentage: number;
}
interface DevHoldingUpdate {
    token: string;
    creator: string;
    amount: string;
    percentage: number;
    previousPercentage: number;
    timestamp: number;
}
/**
 * Individual holder information in top 10
 */
interface TopHolder {
    address: string;
    amount: string;
    percentage: number;
}
/**
 * Top 10 holders update data
 */
interface Top10HoldersUpdate {
    token: string;
    holders: TopHolder[];
    totalPercentage: number;
    previousPercentage: number | null;
    timestamp: number;
}
interface Fees {
    photon?: number;
    bloom?: number;
    bullx?: number;
    axiom?: number;
    vector?: number;
    jito?: number;
    '0slot'?: number;
    'helius-sender'?: number;
    nextblock?: number;
    trojan?: number;
    soltradingbot?: number;
    maestro?: number;
    padre?: number;
    network?: number;
    totalTrading: number;
    totalTips: number;
    total: number;
    [key: string]: number | undefined;
}
interface TransactionFees {
    photon?: number;
    bloom?: number;
    bullx?: number;
    axiom?: number;
    vector?: number;
    jito?: number;
    '0slot'?: number;
    'helius-sender'?: number;
    nextblock?: number;
    trojan?: number;
    soltradingbot?: number;
    maestro?: number;
    padre?: number;
    network?: number;
    [key: string]: number | undefined;
}
interface FeesUpdate {
    total: Fees;
    fees: TransactionFees;
    tx: string;
    time: number;
}
interface AggregatedPriceUpdate {
    token: string;
    timestamp: number;
    price: number;
    pool: string;
    aggregated: {
        median: number;
        average: number;
        min: number;
        max: number;
        poolCount: number;
    };
    topPools: Array<{
        poolId: string;
        price: number;
        liquidity: number;
        market: string;
    }>;
}
interface VolumePoolUpdate {
    pool: string;
    token: string;
    volume: number;
    txCount: number;
    timestamp: number;
}
interface VolumeTokenUpdate {
    token: string;
    volume: number;
    txCount: number;
    timestamp: number;
}
/**
 * Real-time bundler wallet update data
 */
interface BundlerUpdate {
    /** Bundler wallet address */
    wallet: string;
    /** Raw token amount as string */
    amount: string;
    /** Current token amount held */
    tokenAmount: number;
    /** Previous token amount held */
    previousAmount: number;
    /** Amount bought by this bundler */
    boughtAmount: number;
    /** Percentage of supply bought by this bundler */
    boughtPercentage: number;
    /** Current percentage of total supply */
    percentage: number;
    /** Previous percentage of total supply */
    previousPercentage: number;
    /** Total percentage held by all bundlers for this token */
    totalBundlerPercentage: number;
}
interface PnlTradeUpdate {
    type: 'tradeUpdate';
    wallet: string;
    token: string;
    averageBuyAmountUsd: number | null;
    averageSellAmountUsd: number | null;
    avgCostPerToken: number | null;
    buyCount: number;
    currentBalance: number | null;
    currentPrice: number | null;
    currentValue: number | null;
    firstBuyTime: number | null;
    firstTradeTime: number | null;
    holdingCostBasis: number | null;
    lastBuyTime: number | null;
    lastTradeTime: number | null;
    proceeds: number | null;
    realizedPnl: number | null;
    sellCount: number;
    soldCostBasis: number | null;
    totalBought: number | null;
    totalBuyUsd: number | null;
    totalSellUsd: number | null;
    totalSold: number | null;
    totalTransactions: number;
    unrealizedPnl: number | null;
}
interface PnlBalanceUpdate {
    type: 'balanceUpdate';
    wallet: string;
    token: string;
    avgCostPerToken: number | null;
    currentBalance: number | null;
    currentPrice: number | null;
    currentValue: number | null;
    holdingCostBasis: number | null;
    unrealizedPnl: number | null;
}
interface PnlPriceUpdate {
    type: 'priceUpdate';
    wallet: string;
    token: string;
    currentBalance: number | null;
    currentPrice: number | null;
    currentValue: number | null;
    holdingCostBasis: number | null;
    unrealizedPnl: number | null;
}
type PnlPositionUpdate = PnlTradeUpdate | PnlBalanceUpdate | PnlPriceUpdate;
interface PnlWalletPosition {
    token: string;
    avgCostPerToken: number | null;
    currentBalance: number | null;
    currentPrice: number | null;
    currentValue: number | null;
    holdingCostBasis: number | null;
    unrealizedPnl: number | null;
}
interface PnlWalletUpdate {
    averages: {
        buy: number | null;
        sell: number | null;
    };
    counts: {
        buys: number;
        sells: number;
        tokensHeldEver: number;
        tokensTraded: number;
        trades: number;
    };
    invested: number | null;
    openPositions: {
        cost: number | null;
        value: number | null;
    };
    pnl: {
        realized: number | null;
        total: number | null;
        unrealized: number | null;
    };
    proceeds: number | null;
    roi: number | null;
    timing: {
        firstTrade: number | null;
        lastTrade: number | null;
    };
}

/**
 * Decode binary data into events array
 * @param binaryData The binary data to decode
 * @returns Array of decoded events
 */
declare function decodeBinaryEvents(binaryData: ArrayBuffer | Uint8Array): ProcessedEvent[];
/**
 * Process events synchronously
 * @param binaryData Binary data or decoded events array
 * @returns Processed statistics by timeframe
 */
declare function processEvents(binaryData: ArrayBuffer | Uint8Array | ProcessedEvent[]): ProcessedStats;
/**
 * Process events asynchronously in chunks
 * @param binaryData Binary data or decoded events array
 * @param onProgress Optional progress callback
 * @returns Processed statistics by timeframe
 */
declare function processEventsAsync(binaryData: ArrayBuffer | Uint8Array | ProcessedEvent[], onProgress?: (progress: number) => void): Promise<ProcessedStats>;

export { type AthPrice, type BundlerUpdate, type BundlerWallet, type BundlersCategory, type BundlersChartData, type BundlersChartResponse, type BundlersResponse, type ChartDataParams, type ChartResponse, Client, type CreditsResponse, type DataApiConfig, DataApiError, Datastream, type DatastreamConfig, DatastreamRoom, type DcaClosedEvent, type DcaCollectedFeeEvent, type DcaDepositEvent, type DcaDirection, type DcaErrorResponse, type DcaFilledEvent, type DcaListParams, type DcaOpenedEvent, type DcaOrder, type DcaOrderRaw, type DcaOrderSnapshot, type DcaOrderStatus, type DcaOrderStatusFilter, type DcaOrdersListResponse, type DcaPagination, type DcaPairResponse, type DcaPositionEvent, type DcaPricesMap, type DcaProgram, type DcaProgramParams, type DcaProgramsResponse, type DcaSort, type DcaStreamEvent, type DcaSummary, type DcaToken, type DcaTokenFlowResponse, type DcaTokenOrdersResponse, type DcaTokenUser, type DcaTokenUsersResponse, type DcaTransactionEvent, type DcaWalletResponse, type DcaWithdrawEvent, type DeployerParams, type DeployerToken, type DeployerTokensResponse, type DevHolding, type EnrichedTokenPnl, type EventsParams, type FirstBuyTransaction, type FirstBuyerData, type Holder, type HolderChartData, type HolderUpdate, type HoldersChartResponse, type InsidersChartData, type InsidersChartResponse, type Launchpad$1 as Launchpad, type LaunchpadLiquidity$1 as LaunchpadLiquidity, type MeteoraCurve$1 as MeteoraCurve, type MeteoraCurveLiquidity$1 as MeteoraCurveLiquidity, type MultiPriceResponse, type MultiTokensResponse, type OHLCVData, type PaginatedHolder, type PaginatedTokenHoldersResponse, type PnLData, type PnLResponse, type PnLSummary, type PnlBalanceUpdate, type PnlMode, type PnlPositionUpdate, type PnlPriceUpdate, type PnlTradeUpdate, type PnlV2BatchParams, type PnlV2BatchPositionPairsResponse, type PnlV2BatchTokenPositionsResponse, type PnlV2BatchWalletPositionsResponse, type PnlV2BatchWalletSummariesResponse, type PnlV2BatchWalletSummary, type PnlV2Block, type PnlV2ChartPoint, type PnlV2DayTrader, type PnlV2DayTraderWithIdentity, type PnlV2Holder, type PnlV2Identity, type PnlV2IdentityBot, type PnlV2IdentityDeveloper, type PnlV2IdentityExchange, type PnlV2IdentityHacker, type PnlV2IdentityPool, type PnlV2IdentitySns, type PnlV2IdentitySpamDusting, type PnlV2KOLByDateParams, type PnlV2KOLByDateResponse, type PnlV2KOLCalendarDayData, type PnlV2KOLCalendarParams, type PnlV2KOLCalendarResponse, type PnlV2KOLLeaderboardParams, type PnlV2KOLLeaderboardResponse, type PnlV2KOLPeriodParams, type PnlV2KOLPeriodResponse, type PnlV2Pagination, type PnlV2PeriodTrader, type PnlV2PeriodTraderWithIdentity, type PnlV2PnlAdjustments, type PnlV2Position, type PnlV2PositionWithWallet, type PnlV2Snapshot, type PnlV2Summary, type PnlV2TokenFirstBuyersParams, type PnlV2TokenMeta, type PnlV2TokenScopedPnl, type PnlV2TokenScopedPositionWithWallet, type PnlV2TokenTradersParams, type PnlV2TokenTradersResponse, type PnlV2Top90dTrader, type PnlV2TopTradersParams, type PnlV2TopTradersResponse, type PnlV2Trader, type PnlV2TraderWithIdentity, type PnlV2WalletChartParams, type PnlV2WalletChartResponse, type PnlV2WalletHighlightsResponse, type PnlV2WalletHistoryParams, type PnlV2WalletHistoryResponse, type PnlV2WalletLifetimePnl, type PnlV2WalletOverviewParams, type PnlV2WalletOverviewResponse, type PnlV2WalletPerformanceDay, type PnlV2WalletPerformanceParams, type PnlV2WalletPerformanceResponse, type PnlV2WalletPositionsParams, type PnlV2WalletPositionsResponse, type PnlV2WalletQueued, type PnlV2WalletRiskResponse, type PnlV2WalletTokenPositionParams, type PnlV2WalletTokenPositionResponse, type PnlWalletPosition, type PnlWalletUpdate, type PoolInfo, type PoolUpdate, type PriceChange, type PriceChangeData, type PriceData, type PriceHistoryData, type PriceRangeData, type PriceTimestampData, type PriceUpdate, type ProcessedEvent, type ProcessedStats, RateLimitError, type RiskCategory, type RiskFees, type RiskWallet, type SearchParams, type SearchResponse, type SearchResult, type SnipersChartData, type SnipersChartResponse, type SubscriptionResponse, type TimeframeStats, type TokenDetailResponse, type TokenEvents, type TokenHoldersResponse, type TokenInfo, type TokenMetadata, type TokenOverview, type TokenPnLResponse, type TokenPoolTxns, type TokenRisk, type TokenRiskFactor, type TokenSecurity, type TokenStats, type TokenStatsTotal, type TokenTransaction, type TokenValuePair, type TopHolder$1 as TopHolder, type TopTrader, type TopTradersResponse, type Trade, type TradeMetadata, type TradeMetadataToken, type TradeTokenInfo, type TradeTransaction, type TradesResponse, ValidationError, type VolumePoolUpdate, type VolumeTokenUpdate, type WalletBalanceUpdate, type WalletBasicResponse, type WalletChartDataPoint, type WalletChartPnLPeriod, type WalletChartResponse, type WalletResponse, type WalletTokenData, type WalletTokenDetail, type WalletTrade, type WalletTradesResponse, type WalletTransaction, decodeBinaryEvents, processEvents, processEventsAsync };