@pulsight-xyz/sdk 0.1.0

package/dist/generated/types.gen.d.ts

@@ -0,0 +1,3337 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+export type InternalAdaptersPrimaryHttpHandlerDashboardStats = {
+    aggregate_sim_pnl_sol?: number;
+    backtested_trades?: number;
+    best_run?: InternalAdaptersPrimaryHttpHandlerBestRunRef;
+    running_backtests?: number;
+    strategies_with_runs?: number;
+    total_strategies?: number;
+};
+export type InternalAdaptersPrimaryHttpHandlerPaginatedPnls = {
+    items?: Array<PulsightInternalCoreDomainTraderPnl>;
+    limit?: number;
+    offset?: number;
+    total?: number;
+};
+export type InternalAdaptersPrimaryHttpHandlerStrategyListItem = {
+    record?: PulsightInternalCoreDomainStrategyRecord;
+    stats?: InternalAdaptersPrimaryHttpHandlerStrategyStats;
+};
+export type InternalAdaptersPrimaryHttpHandlerStrategyStats = {
+    draft?: boolean;
+    /**
+     * EquityPoints is the cumulative-P&L curve across the most
+     * recent ≤20 `done` runs, ordered ascending by finished_at.
+     * Each element is the running sum of `summary.total_pnl_sol`
+     * through that run, so a frontend <polyline> over these points
+     * renders the dashboard sparkline directly.
+     */
+    equity_points?: Array<number>;
+    last_run_at?: string;
+    last_run_pnl_sol?: number;
+    last_run_status?: string;
+    last_run_trades?: number;
+    last_run_win_rate_pct?: number;
+    total_runs?: number;
+};
+export type InternalAdaptersPrimaryHttpHandlerTraderExportRequest = {
+    columns?: Array<string>;
+    direction?: string;
+    filters?: {
+        [key: string]: unknown;
+    };
+    format?: string;
+    sort_by?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerApiKeyRenameRequest = {
+    name?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerBacktestSettingsResponse = {
+    max_tick_budget?: number;
+};
+export type InternalAdaptersPrimaryHttpHandlerBestRunRef = {
+    backtest_id?: string;
+    pnl_sol?: number;
+    strategy_id?: string;
+    strategy_name?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerErrorResponse = {
+    error?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerServiceLoyaltyRow = {
+    share_pct?: number;
+    swap_count?: number;
+    tip_service?: string;
+    tip_sum_lamports?: number;
+};
+export type InternalAdaptersPrimaryHttpHandlerSnapshotResponse = {
+    rows?: Array<InternalAdaptersPrimaryHttpHandlerSnapshotRow>;
+    window?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerSnapshotRow = {
+    avg_buys_per_token?: number;
+    avg_hold_secs?: number;
+    avg_reactivity_secs?: number;
+    /**
+     * lamports
+     */
+    avg_rp_30d?: number;
+    /**
+     * lamports
+     */
+    avg_rp_7d?: number;
+    avg_sells_per_token?: number;
+    holding_pnl_lamports?: number;
+    med_buys_per_token?: number;
+    med_hold_secs?: number;
+    med_reactivity_secs?: number;
+    /**
+     * lamports
+     */
+    med_rp_30d?: number;
+    /**
+     * lamports
+     */
+    med_rp_7d?: number;
+    med_sells_per_token?: number;
+    oldest_trade_at?: string;
+    pnl_distribution?: Array<number>;
+    /**
+     * lamports per day
+     */
+    pnl_sparkline_7d?: Array<number>;
+    tags?: Array<string>;
+    /**
+     * lifetime mints created
+     */
+    tokens_created?: number;
+    /**
+     * subset that graduated
+     */
+    tokens_graduated?: number;
+    trader?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerStrategyCreateRequest = {
+    /**
+     * Config carries the visual node-graph DSL. Tagged `def` on the
+     * wire to match the frontend contract (pulsight/new-front/src/
+     * api/client.ts sends `{name, description, def}`); the Go field
+     * keeps its existing name so callers don't have to churn.
+     */
+    def?: PulsightInternalCoreDomainStrategyStrategyDef;
+    description?: string;
+    name?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerStrategyUpdateRequest = {
+    /**
+     * Config carries the visual node-graph DSL. Tagged `def` on the
+     * wire to match the frontend contract (pulsight/new-front/src/
+     * api/client.ts sends `{name, description, def}`); the Go field
+     * keeps its existing name so callers don't have to churn.
+     */
+    def?: PulsightInternalCoreDomainStrategyStrategyDef;
+    description?: string;
+    name?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerSwapEventRow = {
+    amount_in?: number;
+    amount_out?: number;
+    arb_pnl_lamports?: number;
+    dex?: string;
+    fee?: number;
+    is_arb?: boolean;
+    is_buy?: boolean;
+    mint?: string;
+    pool?: string;
+    priority_fee_lamports?: number;
+    quote_mint?: string;
+    realized_profit?: number;
+    signature?: string;
+    sold_more_than_bought?: boolean;
+    sold_without_buy?: boolean;
+    tip_lamports?: number;
+    tip_service?: string;
+    trader?: string;
+    ts?: number;
+    /**
+     * null — not in Pulsight SwapRow
+     */
+    virtual_sol?: number;
+    /**
+     * null — not in Pulsight SwapRow
+     */
+    virtual_token?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerTokensRow = {
+    buy_tx_count?: number;
+    cost_basis_lamports?: string;
+    first_buy_ts?: string;
+    holding_pnl_lamports?: number;
+    last_active_ts?: string;
+    mint?: string;
+    mint_decimals?: number;
+    mint_logo_uri?: string;
+    mint_name?: string;
+    mint_symbol?: string;
+    realized_profit?: number;
+    sell_tx_count?: number;
+    token_balance?: string;
+    total_fees?: number;
+    total_invested?: number;
+    trader?: string;
+    updated_at?: string;
+};
+export type InternalAdaptersPrimaryHttpHandlerTraderTipStatsResponse = {
+    exec_premium?: number;
+    priority_fee_sum?: number;
+    swap_count?: number;
+    tip_aggression_ratio?: number;
+    tip_avg_lamports?: number;
+    tip_count?: number;
+    tip_sum_lamports?: number;
+    trader?: string;
+    volume_in_sum?: number;
+    window?: string;
+};
+export type PulsightInternalCoreDomainAggregatorBondingCurveState = {
+    /**
+     * True iff mint_migrations carries any graduation row for this mint.
+     */
+    graduated?: boolean;
+    /**
+     * Destination dex of the graduation; nil when not graduated.
+     */
+    graduation_target_dex?: string;
+    /**
+     * Launchpad slug — pumpfun_amm | raydium_launchpad | meteora_dbc.
+     */
+    launchpad?: string;
+    /**
+     * Curve progress 0..=100. nil for Raydium Launchpad / Meteora DBC
+     * (per-pool config not persisted); always set for PumpFun.
+     */
+    progress_pct?: number;
+    /**
+     * Most recent observed virtual_sol (= dex_swaps.quote_reserves)
+     * snapshot on the launchpad dex, in lamports. 0 for pre-feature
+     * graduations with no curve swap on file.
+     */
+    virtual_sol_lamports?: number;
+    /**
+     * Most recent observed virtual_token (NUMERIC → decimal string for
+     * JSON safety). "0" when no curve swap is on file.
+     */
+    virtual_token?: string;
+};
+export type PulsightInternalCoreDomainAggregatorCreatedMintRow = {
+    decimals?: number;
+    /**
+     * FirstSeenTS proxies "created at" — the create-tx and first buy land in
+     * the same flush window. nil for fixture-only edge cases.
+     */
+    first_seen_ts?: string;
+    /**
+     * Graduated is true iff the mint has any `mint_migrations` row.
+     */
+    graduated?: boolean;
+    /**
+     * GraduationTargetDex is the most-recent migration's to_dex; nil when not
+     * graduated.
+     */
+    graduation_target_dex?: string;
+    logo_uri?: string;
+    mint?: string;
+    name?: string;
+    symbol?: string;
+};
+export type PulsightInternalCoreDomainAggregatorDevHoldings = {
+    /**
+     * Creator's raw token balance (NUMERIC → decimal string).
+     */
+    balance_raw?: string;
+    /**
+     * Creator wallet (mirrors MintRow.Creator).
+     */
+    creator?: string;
+    /**
+     * Percentage of supply held by the creator, 0..=100.
+     */
+    percent_of_supply?: number;
+    /**
+     * Mint's on-chain total supply (same encoding).
+     */
+    supply_raw?: string;
+};
+export type PulsightInternalCoreDomainAggregatorGlobalTipStats = {
+    p50_tip_lamports?: number;
+    p90_tip_lamports?: number;
+    priority_fee_sum?: number;
+    swap_count?: number;
+    tip_avg_lamports?: number;
+    tip_count?: number;
+    tip_sum_lamports?: number;
+    /**
+     * TippedFraction is tip_count / swap_count over the window (0..1).
+     */
+    tipped_fraction?: number;
+    window?: string;
+};
+export type PulsightInternalCoreDomainAggregatorHeatmapResponse = {
+    bucket?: string;
+    horizon_hours?: number;
+    points?: Array<PulsightInternalCoreDomainAggregatorTipHeatmapPoint>;
+};
+export type PulsightInternalCoreDomainAggregatorJitoEfficiencyRow = {
+    efficiency_score?: number;
+    tip_swaps?: number;
+    total_tip_sum?: number;
+    total_volume_in?: number;
+    trader?: string;
+};
+export type PulsightInternalCoreDomainAggregatorLpEvent = {
+    base_amount?: string;
+    base_mint?: string;
+    dex?: string;
+    ix_index?: number;
+    /**
+     * LpMint is the LP-token mint; "" when unknown.
+     */
+    lp_mint?: string;
+    lp_token_amount?: string;
+    /**
+     * Op ∈ {add, remove, burn}.
+     */
+    op?: string;
+    pool?: string;
+    quote_amount?: string;
+    quote_mint?: string;
+    signature?: string;
+    signer?: string;
+    slot?: number;
+    timestamp?: string;
+};
+export type PulsightInternalCoreDomainAggregatorMatPoint = {
+    bucket_ts?: number;
+    ma_1h?: number;
+    ma_5m?: number;
+    tip_avg?: number;
+};
+export type PulsightInternalCoreDomainAggregatorMevTipSharePoint = {
+    bucket_ts?: number;
+    share_pct?: number;
+    tipped_volume_lamports?: number;
+    total_volume_lamports?: number;
+};
+export type PulsightInternalCoreDomainAggregatorMintMarket = {
+    dex?: string;
+    last_swap_ts?: string;
+    pool?: string;
+    sol_volume_lamports?: number;
+    sol_volume_share?: number;
+    swap_count?: number;
+};
+export type PulsightInternalCoreDomainAggregatorMintMigration = {
+    destination_pool?: string;
+    from_dex?: string;
+    mint?: string;
+    slot?: number;
+    /**
+     * Source ∈ {"observed","inferred"} (CHECK constraint).
+     */
+    source?: string;
+    timestamp?: string;
+    to_dex?: string;
+};
+export type PulsightInternalCoreDomainAggregatorMintRow = {
+    authorities_observed_at?: string;
+    /**
+     * ── CA mint-catalog enrichment (ported from mint_catalog.rs::find /
+     * list_active). bonding_curve + dev_holdings populate on BOTH
+     * /api/mints (list) and /api/mints/:pubkey (detail); supply +
+     * authorities populate on the detail path only (nil on list rows).
+     * All pointer + omitempty so list rows stay lean. The frontend's
+     * CurveBadge/DevPill already render bonding_curve/dev_holdings.
+     */
+    bonding_curve?: PulsightInternalCoreDomainAggregatorBondingCurveState;
+    /**
+     * BuyCount/SellCount: buy- vs sell-side swap counts over the `?hours`
+     * activity window (countIf(is_buy)). Populated on the list path; 0 on
+     * the detail path.
+     */
+    buy_count?: number;
+    creator?: string;
+    decimals?: number;
+    dev_holdings?: PulsightInternalCoreDomainAggregatorDevHoldings;
+    fetch_status?: string;
+    first_seen_ts?: string;
+    freeze_authority?: string;
+    /**
+     * IsMayhemMode flags a Pump.fun "Mayhem"-mode token (its trades route
+     * through the Mayhem custody program). Populated on BOTH list and detail
+     * from the mint_mayhem table; omitted when false.
+     */
+    is_mayhem_mode?: boolean;
+    last_trade_ts?: string;
+    logo_uri?: string;
+    markets_count?: number;
+    /**
+     * MetadataURI/FetchStatus are detail-only identity fields the
+     * frontend's TokenIdentityCard renders (off-chain JSON link + enrich
+     * status). nil on list rows.
+     */
+    metadata_uri?: string;
+    mint?: string;
+    /**
+     * MintAuthority/FreezeAuthority: non-nil = active authority pubkey;
+     * nil with AuthoritiesObservedAt set = renounced; nil with
+     * AuthoritiesObservedAt nil = unknown (not yet observed).
+     */
+    mint_authority?: string;
+    name?: string;
+    sell_count?: number;
+    /**
+     * Windowed stats bundle keyed by window. Reuses the same
+     * MintStatsByWindow struct that GET /api/mints/:pubkey/stats
+     * returns so the frontend's ActiveMint.stats path consumes both
+     * endpoints identically.
+     *
+     * /api/mints/:pubkey/stats (FindStatsBundle) populates all four
+     * windows in one round-trip.
+     *
+     * /api/mints (ListActive) currently populates ONLY the active
+     * window's bucket — the other three windows in the per-row
+     * MintStatsByWindow stay zero-valued. The frontend's
+     * `m.stats?.[window]?.…` chain renders `—` on null, so this is
+     * safe; an N-row × 4-window fan-out would mean 3× more LATERAL
+     * joins per page and the UI only ever shows one window at a time
+     * (window switch refetches the page). If a future surface needs
+     * all four windows in the list response, extend ListActive to
+     * match FindStatsBundle's four-LATERAL pattern.
+     */
+    stats?: PulsightInternalCoreDomainAggregatorMintStatsByWindow;
+    /**
+     * Supply is the on-chain total supply (NUMERIC → decimal string);
+     * nil until the enricher has decoded the mint account.
+     */
+    supply?: string;
+    /**
+     * Window-bound activity aggregates over the `?hours` lookback,
+     * derived from hourly_mint_trader_activity + hourly_mint_pool_activity.
+     * All non-pointer because GROUP BY in the LATERAL produces a row even
+     * for zero swaps (we go through the activity gate first, so anything
+     * returned has at least one). SwapCount, TraderCount and MarketsCount
+     * default to 0 if the LATERAL came up empty; the frontend's `formatNum`
+     * renders 0 cleanly.
+     */
+    swap_count?: number;
+    symbol?: string;
+    trader_count?: number;
+};
+export type PulsightInternalCoreDomainAggregatorMintStatsByWindow = {
+    '1h'?: PulsightInternalCoreDomainAggregatorMintWindowStats;
+    '1m'?: PulsightInternalCoreDomainAggregatorMintWindowStats;
+    '24h'?: PulsightInternalCoreDomainAggregatorMintWindowStats;
+    '5m'?: PulsightInternalCoreDomainAggregatorMintWindowStats;
+};
+export type PulsightInternalCoreDomainAggregatorMintTraderRow = {
+    buy_tx_count?: number;
+    cost_basis_lamports?: string;
+    first_buy_ts?: string;
+    holding_pnl_lamports?: number;
+    last_active_ts?: string;
+    realized_profit?: number;
+    sell_tx_count?: number;
+    token_balance?: string;
+    total_fees?: number;
+    total_invested?: number;
+    trader?: string;
+};
+export type PulsightInternalCoreDomainAggregatorMintWindowStats = {
+    buy_swap_count?: number;
+    /**
+     * SOL spent buying, in lamports.
+     */
+    buy_volume_sol?: number;
+    /**
+     * buy_volume_sol - sell_volume_sol, in lamports.
+     */
+    net_buy_sol?: number;
+    /**
+     * Most recent virtual_sol (pool size) observed in the window, in lamports.
+     */
+    pool_sol?: number;
+    /**
+     * (close - open) / open × 100 over the window.
+     */
+    price_change_pct?: number;
+    sell_swap_count?: number;
+    /**
+     * SOL received from sells, in lamports.
+     */
+    sell_volume_sol?: number;
+    swap_count?: number;
+    /**
+     * Total SOL traded (buy + sell), in lamports.
+     */
+    volume_sol?: number;
+};
+export type PulsightInternalCoreDomainAggregatorMintWindowStatsBundle = {
+    as_of?: string;
+    mint?: string;
+    stats?: PulsightInternalCoreDomainAggregatorMintStatsByWindow;
+};
+export type PulsightInternalCoreDomainAggregatorOhlcvCandle = {
+    bucket?: string;
+    buy_volume_sol?: number;
+    c?: number;
+    h?: number;
+    l?: number;
+    mint?: string;
+    o?: number;
+    pool_sol?: number;
+    sell_volume_sol?: number;
+    swap_count?: number;
+    token_volume?: number;
+};
+export type PulsightInternalCoreDomainAggregatorSafetyEvent = {
+    /**
+     * AccountTarget is the affected token account; set for freeze/thaw.
+     */
+    account_target?: string;
+    /**
+     * Amount is a decimal token-amount string; set for burn/mint_to.
+     */
+    amount?: string;
+    /**
+     * AuthorityType ∈ {mint, freeze, account_owner, close_account};
+     * set only for kind=authority_change.
+     */
+    authority_type?: string;
+    ix_index?: number;
+    /**
+     * Kind ∈ {burn, mint_to, freeze, thaw, authority_change}.
+     */
+    kind?: string;
+    mint?: string;
+    /**
+     * NewAuthority is the new authority pubkey (nil = revoked / empty);
+     * set only for kind=authority_change.
+     */
+    new_authority?: string;
+    signature?: string;
+    signer?: string;
+    slot?: number;
+    timestamp?: string;
+};
+export type PulsightInternalCoreDomainAggregatorServiceDominanceRow = {
+    share_pct?: number;
+    tip_service?: string;
+    tip_sum_lamports?: number;
+    tipped_count?: number;
+};
+export type PulsightInternalCoreDomainAggregatorTimeframe = '1s' | '5s' | '15s' | '30s' | '1m' | '5m' | '15m' | '30m';
+export type PulsightInternalCoreDomainAggregatorTipHeatmapPoint = {
+    /**
+     * unix epoch seconds at bucket start
+     */
+    bucket_ts?: number;
+    median_tip_lamports?: number;
+    p90_tip_lamports?: number;
+    tipped_count?: number;
+};
+export type PulsightInternalCoreDomainAggregatorTipPriorityRatioPoint = {
+    bucket_ts?: number;
+    priority_fee_sum?: number;
+    ratio?: number;
+    tip_sum_lamports?: number;
+};
+export type PulsightInternalCoreDomainAggregatorTraderBehavioralStats = {
+    active_hours_count?: number;
+    avg_buy_count_per_token?: number;
+    avg_holding_time_secs?: number;
+    avg_reactivity_secs?: number;
+    avg_sell_count_per_token?: number;
+    median_buy_count_per_token?: number;
+    median_holding_time_secs?: number;
+    median_reactivity_secs?: number;
+    median_sell_count_per_token?: number;
+    oldest_trade_at?: string;
+    profit_per_trade_lamports?: number;
+    pubkey?: string;
+    rebalancing_ratio?: number;
+    total_volume_lamports?: number;
+    window?: PulsightInternalCoreDomainAggregatorWindow;
+};
+export type PulsightInternalCoreDomainAggregatorTraderPeriodStatsRow = {
+    /**
+     * ArbTxRatio is the fraction (0..1) of the window's swaps that were
+     * arbitrage txs (is_arb). 0 when the window has no swaps.
+     */
+    arb_tx_ratio?: number;
+    buy_amount_lamports?: number;
+    buy_sell_ratio?: number;
+    /**
+     * DidntBuySells / SoldGtBoughtSells count the window's uncovered
+     * sells: countIf(sold_without_buy) and countIf(sold_more_than_bought)
+     * over `swaps`. Replaces the retired phantom proceeds split (CA
+     * migration 000018_remove_phantom_tracking).
+     */
+    didnt_buy_sells?: number;
+    loss_profit?: number;
+    loss_sells?: number;
+    realized_profit?: number;
+    sell_amount_lamports?: number;
+    sold_gt_bought_sells?: number;
+    swap_count?: number;
+    token_num?: number;
+    /**
+     * Count fields are int64, not int: periodStatsOne casts them with
+     * toInt64() in SQL, and clickhouse-go scans an Int64 column only into
+     * *int64 (it rejects *int with code-typed "try using *int64"). JSON
+     * serialisation is identical either way.
+     */
+    total_buys?: number;
+    total_fees?: number;
+    total_sells?: number;
+    trader?: string;
+    win_profit?: number;
+    win_sells?: number;
+    window_label?: string;
+    winrate?: number;
+};
+export type PulsightInternalCoreDomainAggregatorWindow = '1d' | '7d' | '30d' | 'all';
+export type PulsightInternalCoreDomainApikeyKey = {
+    created_at?: string;
+    expires_at?: string;
+    id?: string;
+    last_used_at?: string;
+    name?: string;
+    prefix?: string;
+    revoked_at?: string;
+    scopes?: Array<PulsightInternalCoreDomainApikeyScope>;
+    user_id?: string;
+};
+export type PulsightInternalCoreDomainApikeyScope = 'data:read' | 'backtest:run' | 'strategy:read' | 'strategy:write';
+export type PulsightInternalCoreDomainCreditPool = 'api';
+export type PulsightInternalCoreDomainCreditReason = 'grant' | 'consume' | 'refund' | 'adjust' | 'referral_bonus';
+export type PulsightInternalCoreDomainCreditTransaction = {
+    created_at?: string;
+    delta?: number;
+    id?: string;
+    pool?: PulsightInternalCoreDomainCreditPool;
+    reason?: PulsightInternalCoreDomainCreditReason;
+    ref?: string;
+    user_id?: string;
+};
+export type PulsightInternalCoreDomainStrategyComparisonOp = 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
+export type PulsightInternalCoreDomainStrategyEdge = {
+    from?: string;
+    port?: PulsightInternalCoreDomainStrategyEdgePort;
+    to?: string;
+};
+export type PulsightInternalCoreDomainStrategyEdgePort = 'default' | 'cond' | 'then' | 'else';
+export type PulsightInternalCoreDomainStrategyEventKind = 'freeze_renounced' | 'mint_renounced' | 'lp_burned' | 'dev_sold';
+export type PulsightInternalCoreDomainStrategyGlobalConstraints = {
+    max_buy_sol?: number;
+    /**
+     * MaxBuysPerOpenPosition is the max number of buys (initial open + adds)
+     * allowed within ONE open position. 0 ⇒ 1 — the historical single-buy-
+     * per-position behaviour; read it through EffectiveMaxBuysPerOpenPosition.
+     * Raise it above 1 to enable DCA / pyramiding.
+     */
+    max_buys_per_open_position?: number;
+    max_buys_per_token_per_hour?: number;
+    max_buys_per_token_per_minute?: number;
+    /**
+     * MaxPositionExposureSol caps the cumulative cost basis (SOL spent) of a
+     * single open position. 0 ⇒ unlimited. An add that would push the open
+     * position's exposure over this cap is skipped.
+     */
+    max_position_exposure_sol?: number;
+    min_buy_sol?: number;
+};
+export type PulsightInternalCoreDomainStrategyNode = {
+    id?: string;
+    kind?: PulsightInternalCoreDomainStrategyNodeKind;
+    label?: string;
+};
+export type PulsightInternalCoreDomainStrategyNodeKind = {
+    [key: string]: unknown;
+};
+export type PulsightInternalCoreDomainStrategyRecord = {
+    created_at?: string;
+    /**
+     * Config is the visual node-graph DSL. JSON-serialised as `def`
+     * to match the frontend contract (pulsight/new-front/src/api/
+     * types.ts::StrategyRecord.def). The DB column is still `config`
+     * — only the wire field name differs. Renaming the Go field would
+     * churn the StrategyStore + service signatures without benefit.
+     */
+    def?: PulsightInternalCoreDomainStrategyStrategyDef;
+    deleted_at?: string;
+    description?: string;
+    id?: string;
+    name?: string;
+    updated_at?: string;
+    user_id?: string;
+};
+export type PulsightInternalCoreDomainStrategyStrategyDef = {
+    constraints?: PulsightInternalCoreDomainStrategyGlobalConstraints;
+    entry?: PulsightInternalCoreDomainStrategySubGraph;
+    exit?: PulsightInternalCoreDomainStrategySubGraph;
+};
+export type PulsightInternalCoreDomainStrategySubGraph = {
+    edges?: Array<PulsightInternalCoreDomainStrategyEdge>;
+    nodes?: Array<PulsightInternalCoreDomainStrategyNode>;
+};
+export type PulsightInternalCoreDomainStrategyVenueId = 'solana' | 'hyperliquid' | 'polymarket';
+export type PulsightInternalCoreDomainSubscriptionSubscriptionTier = 'free' | 'tier1' | 'tier2' | 'tier3' | 'enterprise';
+export type PulsightInternalCoreDomainTraderDailyProfit = {
+    buy_amount_usd?: number;
+    created_at?: string;
+    date?: string;
+    id?: string;
+    loss_profit?: number;
+    loss_sells?: number;
+    sell_amount_usd?: number;
+    total_buys?: number;
+    total_profit?: number;
+    total_sells?: number;
+    trader_id?: string;
+    win_profit?: number;
+    win_sells?: number;
+};
+export type PulsightInternalCoreDomainTraderFilter = {
+    created_at?: string;
+    filters?: {
+        [key: string]: unknown;
+    };
+    id?: string;
+    is_default?: boolean;
+    name?: string;
+    updated_at?: string;
+    user_id?: string;
+};
+export type PulsightInternalCoreDomainTraderPnl = {
+    /**
+     * Position
+     */
+    balance?: number;
+    /**
+     * Activity
+     */
+    buy_tx_count?: number;
+    created_at?: string;
+    id?: string;
+    last_active_timestamp?: number;
+    /**
+     * Timing
+     */
+    open_timestamp?: number;
+    realized_profit?: number;
+    sell_tx_count?: number;
+    start_holding_at?: number;
+    /**
+     * Token info
+     */
+    token_address?: string;
+    token_logo?: string;
+    token_name?: string;
+    token_price?: number;
+    token_symbol?: string;
+    total_profit?: number;
+    total_profit_pnl?: number;
+    trader_id?: string;
+    unrealized_profit?: number;
+    updated_at?: string;
+    usd_value?: number;
+};
+export type PulsightInternalCoreDomainTraderTag = {
+    created_at?: string;
+    description?: string;
+    id?: string;
+    name?: string;
+    source?: PulsightInternalCoreDomainTraderTagSource;
+};
+export type PulsightInternalCoreDomainTraderTagSource = 'computed' | 'manual' | 'aggregator';
+export type PulsightInternalCoreDomainTraderTrader = {
+    active_hours_count?: number;
+    arb_tx_ratio_30d?: number;
+    arb_tx_ratio_7d?: number;
+    avatar?: string;
+    /**
+     * Per-token buy/sell counts
+     */
+    avg_buy_count_per_token?: number;
+    /**
+     * First-buy reactivity (seconds after token launch)
+     */
+    avg_first_buy_reactivity?: number;
+    /**
+     * Holding time (seconds)
+     */
+    avg_holding_time?: number;
+    avg_realized_profit_30d?: number;
+    /**
+     * Realized profit per-mint averages / medians. UNIT: lamports
+     * (frontend FormattedSol divides by 1e9 on display).
+     */
+    avg_realized_profit_7d?: number;
+    avg_sell_count_per_token?: number;
+    buy_30d?: number;
+    buy_7d?: number;
+    buy_sell_ratio_30d?: number;
+    /**
+     * Computed ratios
+     */
+    buy_sell_ratio_7d?: number;
+    buy_size_cv?: number;
+    /**
+     * "sol" | "eth"
+     */
+    chain?: string;
+    created_at?: string;
+    daily_profits?: Array<PulsightInternalCoreDomainTraderDailyProfit>;
+    didnt_buy_sells_30d?: number;
+    /**
+     * Uncovered-sell counters for the window (CA migration 000018):
+     * sells with no observed buy of the mint / sells exceeding the
+     * observed bought balance.
+     */
+    didnt_buy_sells_7d?: number;
+    dust_tx_ratio?: number;
+    id?: string;
+    is_favorite?: boolean;
+    /**
+     * Activity
+     */
+    last_active_timestamp?: number;
+    median_buy_count_per_token?: number;
+    median_first_buy_reactivity?: number;
+    median_holding_time?: number;
+    median_realized_profit_30d?: number;
+    median_realized_profit_7d?: number;
+    median_sell_count_per_token?: number;
+    mm_score?: number;
+    /**
+     * Identifiers / social
+     */
+    name?: string;
+    oldest_trade_at?: number;
+    pnl_0x2x_num_30d?: number;
+    /**
+     * 0x to 2x
+     */
+    pnl_0x2x_num_7d?: number;
+    pnl_2x5x_num_30d?: number;
+    /**
+     * 2x to 5x
+     */
+    pnl_2x5x_num_7d?: number;
+    pnl_gt5x_num_30d?: number;
+    /**
+     * > 5x
+     */
+    pnl_gt5x_num_7d?: number;
+    /**
+     * PnL distribution buckets — 30d
+     */
+    pnl_lt_nd5_num_30d?: number;
+    /**
+     * PnL distribution buckets — 7d
+     */
+    pnl_lt_nd5_num_7d?: number;
+    pnl_nd50x_num_30d?: number;
+    /**
+     * -5x to 0x
+     */
+    pnl_nd50x_num_7d?: number;
+    pnls?: Array<PulsightInternalCoreDomainTraderPnl>;
+    profit_per_trade?: number;
+    realized_profit?: number;
+    /**
+     * 30-day period
+     */
+    realized_profit_30d?: number;
+    /**
+     * 7-day period. UNIT for realized_profit_*: lamports.
+     */
+    realized_profit_7d?: number;
+    realized_profit_pnl_30d?: number;
+    realized_profit_pnl_7d?: number;
+    rebalancing_ratio?: number;
+    risk_level?: string;
+    /**
+     * Risk assessment
+     */
+    risk_score?: number;
+    sell_30d?: number;
+    sell_7d?: number;
+    /**
+     * Balances. UNIT: lamports (BIGINT, held as *float64 for wire
+     * compatibility). The field name says "Sol" for historical reasons;
+     * the wire convention is lamports because the frontend's
+     * FormattedSol component divides by 1e9 itself.
+     */
+    sol_balance?: number;
+    sold_gt_bought_sells_30d?: number;
+    sold_gt_bought_sells_7d?: number;
+    /**
+     * Relations (loaded on demand)
+     */
+    tags?: Array<PulsightInternalCoreDomainTraderTag>;
+    token_num_30d?: number;
+    token_num_7d?: number;
+    /**
+     * Profit stats (all-time). UNIT: lamports (see SolBalance note).
+     */
+    total_profit?: number;
+    total_profit_30d?: number;
+    total_profit_7d?: number;
+    total_profit_pnl_30d?: number;
+    total_profit_pnl_7d?: number;
+    total_value?: number;
+    total_volume_usd?: number;
+    trade_interval_cv?: number;
+    /**
+     * Market-maker detection
+     */
+    trade_interval_mean?: number;
+    twitter_username?: string;
+    unrealized_profit?: number;
+    unrealized_profit_30d?: number;
+    unrealized_profit_7d?: number;
+    unrealized_profit_pnl_30d?: number;
+    unrealized_profit_pnl_7d?: number;
+    updated_at?: string;
+    wallet_address?: string;
+    winrate_30d?: number;
+    winrate_7d?: number;
+};
+export type PulsightInternalCorePortsInputApiKeyCreateRequest = {
+    expires_at?: string;
+    name?: string;
+    scopes?: Array<PulsightInternalCoreDomainApikeyScope>;
+};
+export type PulsightInternalCorePortsInputCreatedApiKey = {
+    key?: PulsightInternalCoreDomainApikeyKey;
+    plaintext?: string;
+};
+export type PulsightInternalCorePortsInputFilterCreateRequest = {
+    filters?: Array<number>;
+    is_default?: boolean;
+    name?: string;
+};
+export type PulsightInternalCorePortsInputFilterUpdateRequest = {
+    filters?: Array<number>;
+    is_default?: boolean;
+    name?: string;
+};
+export type PulsightInternalCorePortsInputPlanLimitsRead = {
+    can_use_tag_event_filters?: boolean;
+    can_view_full_data?: boolean;
+    max_filters?: number;
+    max_webhooks?: number;
+};
+export type PulsightInternalCorePortsInputSubscriptionInfo = {
+    expires_at?: string;
+    interval?: string;
+    is_active?: boolean;
+    /**
+     * Label/PriceUSD/Interval describe a bespoke ENTERPRISE plan; populated
+     * only for an active TierEnterprise user (from their custom entitlement)
+     * so the plan page can render the negotiated plan instead of a tier card.
+     */
+    label?: string;
+    limits?: PulsightInternalCorePortsInputPlanLimitsRead;
+    price_usd?: number;
+    provider?: string;
+    started_at?: string;
+    status?: string;
+    tier?: PulsightInternalCoreDomainSubscriptionSubscriptionTier;
+    usage?: PulsightInternalCorePortsInputUsageCounts;
+};
+export type PulsightInternalCorePortsInputUsageCounts = {
+    filters?: number;
+    webhooks?: number;
+};
+export type PulsightInternalCorePortsInputUserPoolCredits = {
+    /**
+     * tier grant per cycle (the limit)
+     */
+    allowance?: number;
+    /**
+     * total remaining = cycle balance + gift
+     */
+    balance?: number;
+    /**
+     * Gifted is the persistent admin-gift reserve still available. It is
+     * spent down before the cycle allowance and survives tier changes.
+     * Cycle tier balance remaining = Balance − Gifted.
+     */
+    gifted?: number;
+    period_end?: string;
+    period_start?: string;
+    pool?: PulsightInternalCoreDomainCreditPool;
+    /**
+     * Used is the real consumption this cycle (positive), summed from the
+     * ledger — not allowance−balance, which breaks once credits are gifted.
+     */
+    used?: number;
+};
+export type PulsightInternalCoreUsecasesBacktestBacktestPosition = {
+    cost_basis_sol?: number;
+    exit_value_sol?: number;
+    /**
+     * FinalPriceSol is the last candle mid (SOL/token), for reference next to
+     * the discounted exit value.
+     */
+    final_price_sol?: number;
+    mint?: string;
+    /**
+     * PoolState flags the exit liquidity used to value the position:
+     * "ok" (priced into a live pool), "drained" (pool empty → unrealizable,
+     * ~total loss), or "unknown" (no pool snapshot → valued at raw mid).
+     */
+    pool_state?: string;
+    remaining_tokens?: number;
+    unrealized_pnl_sol?: number;
+};
+export type PulsightInternalCoreUsecasesBacktestBacktestRecord = {
+    created_at?: string;
+    error?: string;
+    finished_at?: string;
+    id?: string;
+    progress_note?: string;
+    progress_pct?: number;
+    scope?: PulsightInternalCoreUsecasesBacktestTokenScope;
+    started_at?: string;
+    starting_balance_sol?: number;
+    status?: PulsightInternalCoreUsecasesBacktestBacktestStatus;
+    strategy_id?: string;
+    strategy_snapshot?: PulsightInternalCoreDomainStrategyStrategyDef;
+    summary?: PulsightInternalCoreUsecasesBacktestBacktestSummary;
+    target_trader?: string;
+    time_from?: string;
+    time_to?: string;
+    timeframe?: PulsightInternalCoreDomainAggregatorTimeframe;
+    user_id?: string;
+};
+export type PulsightInternalCoreUsecasesBacktestBacktestRequest = {
+    scope?: PulsightInternalCoreUsecasesBacktestTokenScope;
+    starting_balance_sol?: number;
+    strategy_id?: string;
+    time_range?: PulsightInternalCoreUsecasesBacktestTimeRange;
+    timeframe?: PulsightInternalCoreDomainAggregatorTimeframe;
+    /**
+     * Venue selects the trading venue / chain for the run. Empty ⇒ solana
+     * (back-compat). The runner gates chain-specific strategy nodes against
+     * the venue's capabilities via StrategyDef.ValidateForVenue.
+     */
+    venue?: PulsightInternalCoreDomainStrategyVenueId;
+};
+export type PulsightInternalCoreUsecasesBacktestBacktestStatus = 'pending' | 'running' | 'done' | 'failed' | 'cancelled';
+export type PulsightInternalCoreUsecasesBacktestBacktestSummary = {
+    ending_balance_sol?: number;
+    fees_paid_sol?: number;
+    /**
+     * HeldPositions is every mint still open at run end — the bags the
+     * strategy never sold, valued at their liquidity-aware exit (see
+     * BacktestPosition). Their UnrealizedPnlSol sums into UnrealizedPnlSol
+     * above. Empty when the strategy closed everything (all "Sold all").
+     * Additive JSONB field — pre-existing rows decode as nil.
+     */
+    held_positions?: Array<PulsightInternalCoreUsecasesBacktestBacktestPosition>;
+    losses?: number;
+    max_drawdown_sol?: number;
+    /**
+     * Price-impact rollups, in percent of mid. "Our*" averages over every
+     * simulated trade that had a pool snapshot; "Target*" averages over the
+     * copy trades that mirrored a target swap 1:1 (same timestamp). Zero when
+     * no trade contributed (e.g. an indicator-only strategy, or a run with no
+     * pool data). Additive JSONB fields — pre-existing rows decode as 0.
+     */
+    our_avg_price_impact_pct?: number;
+    our_median_price_impact_pct?: number;
+    realized_pnl_sol?: number;
+    roi_pct?: number;
+    /**
+     * SimulationAssumptions is free-text notes about which real-world
+     * cost components the simulator did NOT model (route hops, MEV,
+     * partial fills, pre-trade gas estimation, etc.). Rendered
+     * prominently on the result page so users don't read "won 4.2 SOL"
+     * too literally.
+     */
+    simulation_assumptions?: Array<string>;
+    starting_balance_sol?: number;
+    target_avg_price_impact_pct?: number;
+    target_median_price_impact_pct?: number;
+    tips_paid_sol?: number;
+    total_pnl_sol?: number;
+    trades?: number;
+    unrealized_pnl_sol?: number;
+    wins?: number;
+};
+export type PulsightInternalCoreUsecasesBacktestBacktestTrade = {
+    backtest_id?: string;
+    fee_sol?: number;
+    idx?: number;
+    mint?: string;
+    pool_sol_at_trigger?: number;
+    /**
+     * PriceImpactPct is OUR own price impact on this fill, as a percent of the
+     * mid price (size / pool_sol, the constant-product average-fill premium).
+     * Nil when the engine had no pool snapshot at the tick (impact unknown →
+     * pricing degraded to slippage-only). A buy moves price up, a sell down;
+     * the magnitude is recorded either way.
+     */
+    price_impact_pct?: number;
+    price_per_token?: number;
+    realized_pnl_sol?: number;
+    side?: PulsightInternalCoreUsecasesBacktestSide;
+    sol_amount?: number;
+    source?: PulsightInternalCoreUsecasesBacktestTradeSource;
+    /**
+     * TargetPriceImpactPct is the MIRRORED trader's own price impact on the
+     * swap we copied — set only on copy trades that executed at the same
+     * timestamp as the target (a true 1:1 mirror), where the target's move is
+     * folded into our fill price. Nil for emit trades and delayed copies.
+     */
+    target_price_impact_pct?: number;
+    tip_sol?: number;
+    token_amount?: number;
+    triggering_swap_sig?: string;
+    ts?: string;
+};
+export type PulsightInternalCoreUsecasesBacktestEventPredicate = {
+    event?: PulsightInternalCoreDomainStrategyEventKind;
+    negate?: boolean;
+};
+export type PulsightInternalCoreUsecasesBacktestMetricPredicate = {
+    metric?: PulsightInternalCoreUsecasesBacktestSelectionMetric;
+    op?: PulsightInternalCoreDomainStrategyComparisonOp;
+    value?: number;
+    /**
+     * Window — optional trailing window ending at the selection `to`. Ignored
+     * for liquidity_sol (always the latest reserve).
+     */
+    window?: PulsightInternalCoreUsecasesBacktestSelectionMetricWindow;
+};
+export type PulsightInternalCoreUsecasesBacktestPreviewMarker = {
+    pool_sol_at_trigger?: number;
+    /**
+     * Price is the pessimistic execution price (slippage applied) so
+     * the marker lines up with what a real run would have recorded.
+     */
+    price?: number;
+    side?: PulsightInternalCoreUsecasesBacktestSide;
+    source?: PulsightInternalCoreUsecasesBacktestTradeSource;
+    /**
+     * TS is epoch seconds.
+     */
+    ts?: number;
+};
+export type PulsightInternalCoreUsecasesBacktestPreviewRequest = {
+    def?: PulsightInternalCoreDomainStrategyStrategyDef;
+    mint?: string;
+    time_range?: PulsightInternalCoreUsecasesBacktestTimeRange;
+    timeframe?: PulsightInternalCoreDomainAggregatorTimeframe;
+};
+export type PulsightInternalCoreUsecasesBacktestPreviewResponse = {
+    markers?: Array<PulsightInternalCoreUsecasesBacktestPreviewMarker>;
+    simulation_assumptions?: Array<string>;
+};
+export type PulsightInternalCoreUsecasesBacktestSelectionFilter = {
+    events?: Array<PulsightInternalCoreUsecasesBacktestEventPredicate>;
+    metrics?: Array<PulsightInternalCoreUsecasesBacktestMetricPredicate>;
+};
+export type PulsightInternalCoreUsecasesBacktestSelectionMetric = 'liquidity_sol' | 'volume_sol' | 'price_change_pct' | 'swap_count';
+export type PulsightInternalCoreUsecasesBacktestSelectionMetricWindow = '5m' | '30m' | '1h' | '6h' | '12h';
+export type PulsightInternalCoreUsecasesBacktestSide = 'buy' | 'sell';
+export type PulsightInternalCoreUsecasesBacktestTimeRange = {
+    from?: string;
+    to?: string;
+};
+export type PulsightInternalCoreUsecasesBacktestTokenScope = {
+    exclude?: PulsightInternalCoreUsecasesBacktestSelectionFilter;
+    include?: PulsightInternalCoreUsecasesBacktestSelectionFilter;
+    kind?: PulsightInternalCoreUsecasesBacktestTokenScopeKind;
+    /**
+     * MirrorsTraded + TraderTraded + Standalone (cap on selected mints).
+     */
+    max_mints?: number;
+    /**
+     * SingleMint
+     */
+    mint?: string;
+    /**
+     * Mints
+     */
+    mints?: Array<string>;
+    /**
+     * TraderTraded only.
+     */
+    trader?: string;
+    /**
+     * Standalone only — the point-in-time selection window + the
+     * include / exclude ("unselect") predicate filters.
+     */
+    window?: PulsightInternalCoreUsecasesBacktestTimeRange;
+};
+export type PulsightInternalCoreUsecasesBacktestTokenScopeKind = 'single_mint' | 'mints' | 'mirrors_traded' | 'standalone' | 'trader_traded';
+export type PulsightInternalCoreUsecasesBacktestTradeSource = 'copy_buy' | 'copy_sell' | 'emit_buy' | 'emit_sell';
+export type PulsightInternalCoreUsecasesTraderDailyProfitEntry = {
+    date?: string;
+    total_profit?: number;
+};
+export type PulsightInternalCoreUsecasesTraderDailyProfitListItem = {
+    buy_amount_usd?: number;
+    created_at?: string;
+    date?: string;
+    id?: string;
+    loss_profit?: number;
+    loss_sells?: number;
+    sell_amount_usd?: number;
+    total_buys?: number;
+    total_profit?: number;
+    total_sells?: number;
+    trader_id?: string;
+    win_profit?: number;
+    win_sells?: number;
+};
+export type PulsightInternalCoreUsecasesTraderDailyProfitsResult = {
+    items?: Array<PulsightInternalCoreUsecasesTraderDailyProfitListItem>;
+    limit?: number;
+    offset?: number;
+    total?: number;
+};
+export type PulsightInternalCoreUsecasesTraderPnlSeriesPoint = {
+    day?: string;
+    profit?: number;
+};
+export type PulsightInternalCoreUsecasesTraderPnlSeriesResult = {
+    points?: Array<PulsightInternalCoreUsecasesTraderPnlSeriesPoint>;
+    window?: string;
+};
+export type PulsightInternalCoreUsecasesTraderTraderListItem = {
+    active_hours_count?: number;
+    arb_tx_ratio_30d?: number;
+    arb_tx_ratio_7d?: number;
+    avg_buy_count_per_token?: number;
+    avg_first_buy_reactivity?: number;
+    avg_holding_time?: number;
+    avg_realized_profit_30d?: number;
+    avg_realized_profit_7d?: number;
+    avg_sell_count_per_token?: number;
+    behavioral_30d?: PulsightInternalCoreDomainAggregatorTraderBehavioralStats;
+    /**
+     * Behavioral7d / Behavioral30d are the two rows the
+     * "Behavioural" panel toggles between (7d and 30d are the only
+     * supported windows). nil → panel renders its empty state for that
+     * window.
+     */
+    behavioral_7d?: PulsightInternalCoreDomainAggregatorTraderBehavioralStats;
+    buy_30d?: number;
+    buy_7d?: number;
+    buy_sell_ratio_30d?: number;
+    buy_sell_ratio_7d?: number;
+    buy_size_cv?: number;
+    chain?: string;
+    created_at?: string;
+    daily_profit_30d?: Array<PulsightInternalCoreUsecasesTraderDailyProfitEntry>;
+    daily_profit_7d?: Array<PulsightInternalCoreUsecasesTraderDailyProfitEntry>;
+    didnt_buy_sells_30d?: number;
+    /**
+     * Uncovered-sell counters (CA migration 000018): sells with no
+     * observed buy of the mint / sells exceeding the observed bought
+     * balance, scoped to the window.
+     */
+    didnt_buy_sells_7d?: number;
+    dust_tx_ratio?: number;
+    has_avatar?: boolean;
+    /**
+     * HoldingPnlLamports is the wallet's current unrealised PnL across
+     * all open positions, in lamports. Nil when CA has no live price
+     * quote for any of the held mints.
+     */
+    holding_pnl_lamports?: number;
+    id?: string;
+    is_favorite?: boolean;
+    last_active_timestamp?: number;
+    median_buy_count_per_token?: number;
+    median_first_buy_reactivity?: number;
+    median_holding_time?: number;
+    median_realized_profit_30d?: number;
+    median_realized_profit_7d?: number;
+    median_sell_count_per_token?: number;
+    mm_score?: number;
+    name?: string;
+    oldest_trade_at?: number;
+    /**
+     * Periods is one row per canonical UTC-aligned window (1d, 7d, 30d,
+     * all) from CA's `trader_period_stats_for`. Drives the
+     * "Calendar-based UTC windows" panel on the trader-detail page.
+     */
+    periods?: Array<PulsightInternalCoreDomainAggregatorTraderPeriodStatsRow>;
+    pnl_0x_2x_num_30d?: number;
+    pnl_0x_2x_num_7d?: number;
+    pnl_2x_5x_num_30d?: number;
+    pnl_2x_5x_num_7d?: number;
+    /**
+     * PnlDistribution is the 5-bucket realised-PnL distribution for
+     * the request window: [<-50%, -50–0%, 0–2×, 2–5×, >5×]. Nil when
+     * the snapshot wasn't inlined.
+     */
+    pnl_distribution?: Array<number>;
+    pnl_gt_5x_num_30d?: number;
+    pnl_gt_5x_num_7d?: number;
+    pnl_lt_nd5_num_30d?: number;
+    pnl_lt_nd5_num_7d?: number;
+    pnl_nd5_0x_num_30d?: number;
+    pnl_nd5_0x_num_7d?: number;
+    /**
+     * PnlSparkline7d is the 7-day realised-PnL series, oldest first,
+     * expressed in lamports per day on the wire (matches CA's BIGINT
+     * storage and the FormattedSol contract elsewhere). Nil when the
+     * snapshot wasn't inlined.
+     */
+    pnl_sparkline_7d?: Array<number>;
+    profit_per_trade?: number;
+    realized_profit?: number;
+    realized_profit_30d?: number;
+    realized_profit_7d?: number;
+    realized_profit_pnl_30d?: number;
+    realized_profit_pnl_7d?: number;
+    rebalancing_ratio?: number;
+    risk_level?: string;
+    risk_score?: number;
+    sell_30d?: number;
+    sell_7d?: number;
+    sol_balance?: number;
+    sold_gt_bought_sells_30d?: number;
+    sold_gt_bought_sells_7d?: number;
+    tags?: Array<string>;
+    token_num_30d?: number;
+    token_num_7d?: number;
+    /**
+     * TokensCreated / TokensGraduated are the wallet's lifetime
+     * creator-token counts (distinct mints created, and the subset that
+     * graduated). Inlined from the folded snapshot; nil when the snapshot
+     * wasn't inlined. Mirror the creator_tokens_* leaderboard filters.
+     */
+    tokens_created?: number;
+    tokens_graduated?: number;
+    total_profit?: number;
+    total_profit_30d?: number;
+    total_profit_7d?: number;
+    total_profit_pnl_30d?: number;
+    total_profit_pnl_7d?: number;
+    total_value?: number;
+    total_volume_usd?: number;
+    trade_interval_cv?: number;
+    trade_interval_mean?: number;
+    twitter_username?: string;
+    unrealized_profit?: number;
+    unrealized_profit_30d?: number;
+    unrealized_profit_7d?: number;
+    unrealized_profit_pnl_30d?: number;
+    unrealized_profit_pnl_7d?: number;
+    updated_at?: string;
+    wallet_address?: string;
+    winrate_30d?: number;
+    winrate_7d?: number;
+};
+export type PulsightInternalCoreUsecasesTraderTraderListResult = {
+    items?: Array<PulsightInternalCoreUsecasesTraderTraderListItem>;
+    limit?: number;
+    next_cursor_pubkey?: string;
+    next_cursor_value?: number;
+    offset?: number;
+    total?: number;
+};
+export type GetBacktestsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Strategy ID (when called via /api/backtests)
+         */
+        strategy_id?: string;
+    };
+    url: '/api/backtests';
+};
+export type GetBacktestsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetBacktestsError = GetBacktestsErrors[keyof GetBacktestsErrors];
+export type GetBacktestsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreUsecasesBacktestBacktestRecord>;
+};
+export type GetBacktestsResponse = GetBacktestsResponses[keyof GetBacktestsResponses];
+export type PostBacktestsData = {
+    /**
+     * Backtest request
+     */
+    body: PulsightInternalCoreUsecasesBacktestBacktestRequest;
+    path?: never;
+    query?: never;
+    url: '/api/backtests';
+};
+export type PostBacktestsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostBacktestsError = PostBacktestsErrors[keyof PostBacktestsErrors];
+export type PostBacktestsResponses = {
+    /**
+     * Accepted
+     */
+    202: PulsightInternalCoreUsecasesBacktestBacktestRecord;
+};
+export type PostBacktestsResponse = PostBacktestsResponses[keyof PostBacktestsResponses];
+export type GetBacktestsLimitsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/backtests/limits';
+};
+export type GetBacktestsLimitsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetBacktestsLimitsError = GetBacktestsLimitsErrors[keyof GetBacktestsLimitsErrors];
+export type GetBacktestsLimitsResponses = {
+    /**
+     * OK
+     */
+    200: InternalAdaptersPrimaryHttpHandlerBacktestSettingsResponse;
+};
+export type GetBacktestsLimitsResponse = GetBacktestsLimitsResponses[keyof GetBacktestsLimitsResponses];
+export type DeleteBacktestsByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Backtest ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/backtests/{id}';
+};
+export type DeleteBacktestsByIdResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteBacktestsByIdResponse = DeleteBacktestsByIdResponses[keyof DeleteBacktestsByIdResponses];
+export type GetBacktestsByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Backtest ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/backtests/{id}';
+};
+export type GetBacktestsByIdErrors = {
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetBacktestsByIdError = GetBacktestsByIdErrors[keyof GetBacktestsByIdErrors];
+export type GetBacktestsByIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesBacktestBacktestRecord;
+};
+export type GetBacktestsByIdResponse = GetBacktestsByIdResponses[keyof GetBacktestsByIdResponses];
+export type GetBacktestsByIdTradesData = {
+    body?: never;
+    path: {
+        /**
+         * Backtest ID
+         */
+        id: string;
+    };
+    query?: {
+        /**
+         * Page size (default 200, max 2000)
+         */
+        limit?: number;
+        /**
+         * Page offset (default 0)
+         */
+        offset?: number;
+    };
+    url: '/api/backtests/{id}/trades';
+};
+export type GetBacktestsByIdTradesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetBacktestsByIdTradesError = GetBacktestsByIdTradesErrors[keyof GetBacktestsByIdTradesErrors];
+export type GetBacktestsByIdTradesResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreUsecasesBacktestBacktestTrade>;
+};
+export type GetBacktestsByIdTradesResponse = GetBacktestsByIdTradesResponses[keyof GetBacktestsByIdTradesResponses];
+export type GetHealthData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/health';
+};
+export type GetHealthErrors = {
+    /**
+     * Service Unavailable
+     */
+    503: {
+        [key: string]: unknown;
+    };
+};
+export type GetHealthError = GetHealthErrors[keyof GetHealthErrors];
+export type GetHealthResponses = {
+    /**
+     * OK
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+export type GetHealthResponse = GetHealthResponses[keyof GetHealthResponses];
+export type GetMeApiKeysData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/me/api-keys';
+};
+export type GetMeApiKeysErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMeApiKeysError = GetMeApiKeysErrors[keyof GetMeApiKeysErrors];
+export type GetMeApiKeysResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainApikeyKey>;
+};
+export type GetMeApiKeysResponse = GetMeApiKeysResponses[keyof GetMeApiKeysResponses];
+export type PostMeApiKeysData = {
+    /**
+     * Key name, scopes, optional expiry
+     */
+    body: PulsightInternalCorePortsInputApiKeyCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/api/me/api-keys';
+};
+export type PostMeApiKeysErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * api key limit reached for the tier
+     */
+    403: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostMeApiKeysError = PostMeApiKeysErrors[keyof PostMeApiKeysErrors];
+export type PostMeApiKeysResponses = {
+    /**
+     * Created
+     */
+    201: PulsightInternalCorePortsInputCreatedApiKey;
+};
+export type PostMeApiKeysResponse = PostMeApiKeysResponses[keyof PostMeApiKeysResponses];
+export type DeleteMeApiKeysByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Key ID (UUID)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/me/api-keys/{id}';
+};
+export type DeleteMeApiKeysByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type DeleteMeApiKeysByIdError = DeleteMeApiKeysByIdErrors[keyof DeleteMeApiKeysByIdErrors];
+export type DeleteMeApiKeysByIdResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteMeApiKeysByIdResponse = DeleteMeApiKeysByIdResponses[keyof DeleteMeApiKeysByIdResponses];
+export type PatchMeApiKeysByIdData = {
+    /**
+     * New name
+     */
+    body: InternalAdaptersPrimaryHttpHandlerApiKeyRenameRequest;
+    path: {
+        /**
+         * Key ID (UUID)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/me/api-keys/{id}';
+};
+export type PatchMeApiKeysByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PatchMeApiKeysByIdError = PatchMeApiKeysByIdErrors[keyof PatchMeApiKeysByIdErrors];
+export type PatchMeApiKeysByIdResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type PatchMeApiKeysByIdResponse = PatchMeApiKeysByIdResponses[keyof PatchMeApiKeysByIdResponses];
+export type GetMeCreditsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/me/credits';
+};
+export type GetMeCreditsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMeCreditsError = GetMeCreditsErrors[keyof GetMeCreditsErrors];
+export type GetMeCreditsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCorePortsInputUserPoolCredits>;
+};
+export type GetMeCreditsResponse = GetMeCreditsResponses[keyof GetMeCreditsResponses];
+export type GetMeCreditsLedgerData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Max entries to return (default 50, max 200)
+         */
+        limit?: number;
+    };
+    url: '/api/me/credits/ledger';
+};
+export type GetMeCreditsLedgerErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMeCreditsLedgerError = GetMeCreditsLedgerErrors[keyof GetMeCreditsLedgerErrors];
+export type GetMeCreditsLedgerResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainCreditTransaction>;
+};
+export type GetMeCreditsLedgerResponse = GetMeCreditsLedgerResponses[keyof GetMeCreditsLedgerResponses];
+export type GetMintsData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Window (1m|5m|1h|24h)
+         */
+        window: string;
+        /**
+         * Mint pubkey prefix or case-insensitive symbol/name substring (lifts the default liquidity floor)
+         */
+        search?: string;
+        /**
+         * trades|traders|recent|volume (others fall back to swap_count)
+         */
+        sort?: string;
+        /**
+         * Restrict to mints traded on any of these DEXes (repeatable)
+         */
+        dex?: Array<string>;
+        /**
+         * Activity-gate lookback hours (1..168, default 24)
+         */
+        hours?: number;
+        /**
+         * Min window pool quote-reserves (liquidity), WSOL lamports. Omitted ⇒ a default ~1 SOL floor hides dust on untargeted browse; pass 0 to disable, or any value to override.
+         */
+        min_pool_sol?: number;
+        /**
+         * Max rows (default 50, max 500)
+         */
+        limit?: number;
+        /**
+         * Pagination offset
+         */
+        offset?: number;
+    };
+    url: '/api/mints';
+};
+export type GetMintsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * CREDIT_EXHAUSTED — api credit pool empty (only when credit enforcement is enabled)
+     */
+    402: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsError = GetMintsErrors[keyof GetMintsErrors];
+export type GetMintsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMintRow>;
+};
+export type GetMintsResponse = GetMintsResponses[keyof GetMintsResponses];
+export type GetMintsByPubkeyData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: never;
+    url: '/api/mints/{pubkey}';
+};
+export type GetMintsByPubkeyErrors = {
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyError = GetMintsByPubkeyErrors[keyof GetMintsByPubkeyErrors];
+export type GetMintsByPubkeyResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainAggregatorMintRow;
+};
+export type GetMintsByPubkeyResponse = GetMintsByPubkeyResponses[keyof GetMintsByPubkeyResponses];
+export type GetMintsByPubkeyLpEventsData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: {
+        /**
+         * Filter by op (add|remove|burn)
+         */
+        op?: string;
+        /**
+         * Max rows (default 50, max 200)
+         */
+        limit?: number;
+    };
+    url: '/api/mints/{pubkey}/lp-events';
+};
+export type GetMintsByPubkeyLpEventsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyLpEventsError = GetMintsByPubkeyLpEventsErrors[keyof GetMintsByPubkeyLpEventsErrors];
+export type GetMintsByPubkeyLpEventsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorLpEvent>;
+};
+export type GetMintsByPubkeyLpEventsResponse = GetMintsByPubkeyLpEventsResponses[keyof GetMintsByPubkeyLpEventsResponses];
+export type GetMintsByPubkeyMarketsData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: {
+        /**
+         * Window (1m|5m|1h|24h|all, default 24h)
+         */
+        window?: string;
+    };
+    url: '/api/mints/{pubkey}/markets';
+};
+export type GetMintsByPubkeyMarketsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyMarketsError = GetMintsByPubkeyMarketsErrors[keyof GetMintsByPubkeyMarketsErrors];
+export type GetMintsByPubkeyMarketsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMintMarket>;
+};
+export type GetMintsByPubkeyMarketsResponse = GetMintsByPubkeyMarketsResponses[keyof GetMintsByPubkeyMarketsResponses];
+export type GetMintsByPubkeyMigrationsData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: never;
+    url: '/api/mints/{pubkey}/migrations';
+};
+export type GetMintsByPubkeyMigrationsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyMigrationsError = GetMintsByPubkeyMigrationsErrors[keyof GetMintsByPubkeyMigrationsErrors];
+export type GetMintsByPubkeyMigrationsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMintMigration>;
+};
+export type GetMintsByPubkeyMigrationsResponse = GetMintsByPubkeyMigrationsResponses[keyof GetMintsByPubkeyMigrationsResponses];
+export type GetMintsByPubkeySafetyEventsData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: {
+        /**
+         * Filter by kind (burn|mint_to|freeze|thaw|authority_change)
+         */
+        kind?: string;
+        /**
+         * Max rows (default 50, max 500)
+         */
+        limit?: number;
+    };
+    url: '/api/mints/{pubkey}/safety-events';
+};
+export type GetMintsByPubkeySafetyEventsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeySafetyEventsError = GetMintsByPubkeySafetyEventsErrors[keyof GetMintsByPubkeySafetyEventsErrors];
+export type GetMintsByPubkeySafetyEventsResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorSafetyEvent>;
+};
+export type GetMintsByPubkeySafetyEventsResponse = GetMintsByPubkeySafetyEventsResponses[keyof GetMintsByPubkeySafetyEventsResponses];
+export type GetMintsByPubkeyStatsData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: never;
+    url: '/api/mints/{pubkey}/stats';
+};
+export type GetMintsByPubkeyStatsErrors = {
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyStatsError = GetMintsByPubkeyStatsErrors[keyof GetMintsByPubkeyStatsErrors];
+export type GetMintsByPubkeyStatsResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainAggregatorMintWindowStatsBundle;
+};
+export type GetMintsByPubkeyStatsResponse = GetMintsByPubkeyStatsResponses[keyof GetMintsByPubkeyStatsResponses];
+export type GetMintsByPubkeyTopHoldersData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: {
+        /**
+         * Sort key (balance|holding_pnl|recent, default balance)
+         */
+        sort?: string;
+        /**
+         * Max rows (default 50, max 500)
+         */
+        limit?: number;
+        /**
+         * Page offset (default 0)
+         */
+        offset?: number;
+    };
+    url: '/api/mints/{pubkey}/top-holders';
+};
+export type GetMintsByPubkeyTopHoldersErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyTopHoldersError = GetMintsByPubkeyTopHoldersErrors[keyof GetMintsByPubkeyTopHoldersErrors];
+export type GetMintsByPubkeyTopHoldersResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMintTraderRow>;
+};
+export type GetMintsByPubkeyTopHoldersResponse = GetMintsByPubkeyTopHoldersResponses[keyof GetMintsByPubkeyTopHoldersResponses];
+export type GetMintsByPubkeyTopTradersData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+    };
+    query?: {
+        /**
+         * Sort key (pnl|volume|swaps|recent, default pnl)
+         */
+        sort?: string;
+        /**
+         * Max rows (default 50, max 500)
+         */
+        limit?: number;
+        /**
+         * Page offset (default 0)
+         */
+        offset?: number;
+    };
+    url: '/api/mints/{pubkey}/top-traders';
+};
+export type GetMintsByPubkeyTopTradersErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyTopTradersError = GetMintsByPubkeyTopTradersErrors[keyof GetMintsByPubkeyTopTradersErrors];
+export type GetMintsByPubkeyTopTradersResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMintTraderRow>;
+};
+export type GetMintsByPubkeyTopTradersResponse = GetMintsByPubkeyTopTradersResponses[keyof GetMintsByPubkeyTopTradersResponses];
+export type GetMintsByPubkeyTradersByTraderData = {
+    body?: never;
+    path: {
+        /**
+         * Mint pubkey
+         */
+        pubkey: string;
+        /**
+         * Trader wallet pubkey
+         */
+        trader: string;
+    };
+    query?: never;
+    url: '/api/mints/{pubkey}/traders/{trader}';
+};
+export type GetMintsByPubkeyTradersByTraderErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetMintsByPubkeyTradersByTraderError = GetMintsByPubkeyTradersByTraderErrors[keyof GetMintsByPubkeyTradersByTraderErrors];
+export type GetMintsByPubkeyTradersByTraderResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainAggregatorMintTraderRow;
+};
+export type GetMintsByPubkeyTradersByTraderResponse = GetMintsByPubkeyTradersByTraderResponses[keyof GetMintsByPubkeyTradersByTraderResponses];
+export type GetOhlcvData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Mint pubkey
+         */
+        mint: string;
+        /**
+         * Timeframe (e.g. 1m, 5m, 1h)
+         */
+        tf: string;
+        /**
+         * Market (pool pubkey) to chart; defaults to the most active pool
+         */
+        pool?: string;
+        /**
+         * Price denomination (native|sol|usd; default native)
+         */
+        quote?: string;
+        /**
+         * Start of window (RFC3339)
+         */
+        from?: string;
+        /**
+         * End of window (RFC3339, exclusive)
+         */
+        to?: string;
+    };
+    url: '/api/ohlcv';
+};
+export type GetOhlcvErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * CREDIT_EXHAUSTED — api credit pool empty (only when credit enforcement is enabled)
+     */
+    402: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetOhlcvError = GetOhlcvErrors[keyof GetOhlcvErrors];
+export type GetOhlcvResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorOhlcvCandle>;
+};
+export type GetOhlcvResponse = GetOhlcvResponses[keyof GetOhlcvResponses];
+export type GetStrategiesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Max rows (default 200, max 1000)
+         */
+        limit?: number;
+        /**
+         * Row offset (default 0)
+         */
+        offset?: number;
+    };
+    url: '/api/strategies';
+};
+export type GetStrategiesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetStrategiesError = GetStrategiesErrors[keyof GetStrategiesErrors];
+export type GetStrategiesResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainStrategyRecord>;
+};
+export type GetStrategiesResponse = GetStrategiesResponses[keyof GetStrategiesResponses];
+export type PostStrategiesData = {
+    /**
+     * Strategy config
+     */
+    body: InternalAdaptersPrimaryHttpHandlerStrategyCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/api/strategies';
+};
+export type PostStrategiesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostStrategiesError = PostStrategiesErrors[keyof PostStrategiesErrors];
+export type PostStrategiesResponses = {
+    /**
+     * Created
+     */
+    201: PulsightInternalCoreDomainStrategyRecord;
+};
+export type PostStrategiesResponse = PostStrategiesResponses[keyof PostStrategiesResponses];
+export type GetStrategiesDashboardData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/strategies/dashboard';
+};
+export type GetStrategiesDashboardErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetStrategiesDashboardError = GetStrategiesDashboardErrors[keyof GetStrategiesDashboardErrors];
+export type GetStrategiesDashboardResponses = {
+    /**
+     * OK
+     */
+    200: InternalAdaptersPrimaryHttpHandlerDashboardStats;
+};
+export type GetStrategiesDashboardResponse = GetStrategiesDashboardResponses[keyof GetStrategiesDashboardResponses];
+export type PostStrategiesPreviewData = {
+    /**
+     * Preview request
+     */
+    body: PulsightInternalCoreUsecasesBacktestPreviewRequest;
+    path?: never;
+    query?: never;
+    url: '/api/strategies/preview';
+};
+export type PostStrategiesPreviewErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostStrategiesPreviewError = PostStrategiesPreviewErrors[keyof PostStrategiesPreviewErrors];
+export type PostStrategiesPreviewResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesBacktestPreviewResponse;
+};
+export type PostStrategiesPreviewResponse = PostStrategiesPreviewResponses[keyof PostStrategiesPreviewResponses];
+export type GetStrategiesWithStatsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Max rows
+         */
+        limit?: number;
+        /**
+         * Row offset
+         */
+        offset?: number;
+    };
+    url: '/api/strategies/with-stats';
+};
+export type GetStrategiesWithStatsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetStrategiesWithStatsError = GetStrategiesWithStatsErrors[keyof GetStrategiesWithStatsErrors];
+export type GetStrategiesWithStatsResponses = {
+    /**
+     * OK
+     */
+    200: Array<InternalAdaptersPrimaryHttpHandlerStrategyListItem>;
+};
+export type GetStrategiesWithStatsResponse = GetStrategiesWithStatsResponses[keyof GetStrategiesWithStatsResponses];
+export type DeleteStrategiesByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Strategy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/strategies/{id}';
+};
+export type DeleteStrategiesByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type DeleteStrategiesByIdError = DeleteStrategiesByIdErrors[keyof DeleteStrategiesByIdErrors];
+export type DeleteStrategiesByIdResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteStrategiesByIdResponse = DeleteStrategiesByIdResponses[keyof DeleteStrategiesByIdResponses];
+export type GetStrategiesByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Strategy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/strategies/{id}';
+};
+export type GetStrategiesByIdErrors = {
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetStrategiesByIdError = GetStrategiesByIdErrors[keyof GetStrategiesByIdErrors];
+export type GetStrategiesByIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainStrategyRecord;
+};
+export type GetStrategiesByIdResponse = GetStrategiesByIdResponses[keyof GetStrategiesByIdResponses];
+export type PutStrategiesByIdData = {
+    /**
+     * Strategy def
+     */
+    body: InternalAdaptersPrimaryHttpHandlerStrategyUpdateRequest;
+    path: {
+        /**
+         * Strategy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/strategies/{id}';
+};
+export type PutStrategiesByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PutStrategiesByIdError = PutStrategiesByIdErrors[keyof PutStrategiesByIdErrors];
+export type PutStrategiesByIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainStrategyRecord;
+};
+export type PutStrategiesByIdResponse = PutStrategiesByIdResponses[keyof PutStrategiesByIdResponses];
+export type GetSubscriptionsMeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/subscriptions/me';
+};
+export type GetSubscriptionsMeErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetSubscriptionsMeError = GetSubscriptionsMeErrors[keyof GetSubscriptionsMeErrors];
+export type GetSubscriptionsMeResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCorePortsInputSubscriptionInfo;
+};
+export type GetSubscriptionsMeResponse = GetSubscriptionsMeResponses[keyof GetSubscriptionsMeResponses];
+export type GetSwapsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Mint pubkey (optional; combinable with trader)
+         */
+        mint?: string;
+        /**
+         * Trader pubkey; repeatable or comma-separated (optional; combinable with mint)
+         */
+        trader?: string;
+        /**
+         * Market (pool pubkey) to scope swaps to (optional)
+         */
+        pool?: string;
+        /**
+         * Start of window (RFC3339)
+         */
+        from?: string;
+        /**
+         * End of window (RFC3339, exclusive)
+         */
+        to?: string;
+        /**
+         * Start of window (Unix epoch seconds)
+         */
+        from_ts?: number;
+        /**
+         * End of window (Unix epoch seconds, exclusive)
+         */
+        to_ts?: number;
+        /**
+         * Cursor: return the latest swaps strictly before this Unix epoch timestamp (no lower bound)
+         */
+        before_ts?: number;
+        /**
+         * Max rows (default 100, max 1000)
+         */
+        limit?: number;
+    };
+    url: '/api/swaps';
+};
+export type GetSwapsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * CREDIT_EXHAUSTED — api credit pool empty (only when credit enforcement is enabled)
+     */
+    402: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetSwapsError = GetSwapsErrors[keyof GetSwapsErrors];
+export type GetSwapsResponses = {
+    /**
+     * OK
+     */
+    200: Array<InternalAdaptersPrimaryHttpHandlerSwapEventRow>;
+};
+export type GetSwapsResponse = GetSwapsResponses[keyof GetSwapsResponses];
+export type GetTipsGlobalData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/tips/global';
+};
+export type GetTipsGlobalErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsGlobalError = GetTipsGlobalErrors[keyof GetTipsGlobalErrors];
+export type GetTipsGlobalResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainAggregatorGlobalTipStats;
+};
+export type GetTipsGlobalResponse = GetTipsGlobalResponses[keyof GetTipsGlobalResponses];
+export type GetTipsHeatmapData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Bucket (1m|5m|10m)
+         */
+        bucket?: string;
+        /**
+         * Horizon hours (1..24)
+         */
+        horizon_hours?: number;
+    };
+    url: '/api/tips/heatmap';
+};
+export type GetTipsHeatmapErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsHeatmapError = GetTipsHeatmapErrors[keyof GetTipsHeatmapErrors];
+export type GetTipsHeatmapResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainAggregatorHeatmapResponse;
+};
+export type GetTipsHeatmapResponse = GetTipsHeatmapResponses[keyof GetTipsHeatmapResponses];
+export type GetTipsLeaderboardJitoEfficiencyData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+        /**
+         * Row cap (1..200, default 50)
+         */
+        limit?: number;
+    };
+    url: '/api/tips/leaderboard/jito-efficiency';
+};
+export type GetTipsLeaderboardJitoEfficiencyErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsLeaderboardJitoEfficiencyError = GetTipsLeaderboardJitoEfficiencyErrors[keyof GetTipsLeaderboardJitoEfficiencyErrors];
+export type GetTipsLeaderboardJitoEfficiencyResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorJitoEfficiencyRow>;
+};
+export type GetTipsLeaderboardJitoEfficiencyResponse = GetTipsLeaderboardJitoEfficiencyResponses[keyof GetTipsLeaderboardJitoEfficiencyResponses];
+export type GetTipsMatData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/tips/mat';
+};
+export type GetTipsMatErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsMatError = GetTipsMatErrors[keyof GetTipsMatErrors];
+export type GetTipsMatResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMatPoint>;
+};
+export type GetTipsMatResponse = GetTipsMatResponses[keyof GetTipsMatResponses];
+export type GetTipsMevShareData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/tips/mev-share';
+};
+export type GetTipsMevShareErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsMevShareError = GetTipsMevShareErrors[keyof GetTipsMevShareErrors];
+export type GetTipsMevShareResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorMevTipSharePoint>;
+};
+export type GetTipsMevShareResponse = GetTipsMevShareResponses[keyof GetTipsMevShareResponses];
+export type GetTipsPriorityRatioData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/tips/priority-ratio';
+};
+export type GetTipsPriorityRatioErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsPriorityRatioError = GetTipsPriorityRatioErrors[keyof GetTipsPriorityRatioErrors];
+export type GetTipsPriorityRatioResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorTipPriorityRatioPoint>;
+};
+export type GetTipsPriorityRatioResponse = GetTipsPriorityRatioResponses[keyof GetTipsPriorityRatioResponses];
+export type GetTipsServicesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Window (30m|1h|12h|1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/tips/services';
+};
+export type GetTipsServicesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTipsServicesError = GetTipsServicesErrors[keyof GetTipsServicesErrors];
+export type GetTipsServicesResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorServiceDominanceRow>;
+};
+export type GetTipsServicesResponse = GetTipsServicesResponses[keyof GetTipsServicesResponses];
+export type GetTraderFiltersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/trader-filters/';
+};
+export type GetTraderFiltersErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTraderFiltersError = GetTraderFiltersErrors[keyof GetTraderFiltersErrors];
+export type GetTraderFiltersResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainTraderFilter>;
+};
+export type GetTraderFiltersResponse = GetTraderFiltersResponses[keyof GetTraderFiltersResponses];
+export type PostTraderFiltersData = {
+    /**
+     * Filter preset details
+     */
+    body: PulsightInternalCorePortsInputFilterCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/api/trader-filters/';
+};
+export type PostTraderFiltersErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Forbidden
+     */
+    403: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostTraderFiltersError = PostTraderFiltersErrors[keyof PostTraderFiltersErrors];
+export type PostTraderFiltersResponses = {
+    /**
+     * Created
+     */
+    201: PulsightInternalCoreDomainTraderFilter;
+};
+export type PostTraderFiltersResponse = PostTraderFiltersResponses[keyof PostTraderFiltersResponses];
+export type DeleteTraderFiltersByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Filter preset ID (UUID)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/trader-filters/{id}';
+};
+export type DeleteTraderFiltersByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type DeleteTraderFiltersByIdError = DeleteTraderFiltersByIdErrors[keyof DeleteTraderFiltersByIdErrors];
+export type DeleteTraderFiltersByIdResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteTraderFiltersByIdResponse = DeleteTraderFiltersByIdResponses[keyof DeleteTraderFiltersByIdResponses];
+export type GetTraderFiltersByIdData = {
+    body?: never;
+    path: {
+        /**
+         * Filter preset ID (UUID)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/trader-filters/{id}';
+};
+export type GetTraderFiltersByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTraderFiltersByIdError = GetTraderFiltersByIdErrors[keyof GetTraderFiltersByIdErrors];
+export type GetTraderFiltersByIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainTraderFilter;
+};
+export type GetTraderFiltersByIdResponse = GetTraderFiltersByIdResponses[keyof GetTraderFiltersByIdResponses];
+export type PutTraderFiltersByIdData = {
+    /**
+     * Updated filter preset
+     */
+    body: PulsightInternalCorePortsInputFilterUpdateRequest;
+    path: {
+        /**
+         * Filter preset ID (UUID)
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/trader-filters/{id}';
+};
+export type PutTraderFiltersByIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PutTraderFiltersByIdError = PutTraderFiltersByIdErrors[keyof PutTraderFiltersByIdErrors];
+export type PutTraderFiltersByIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreDomainTraderFilter;
+};
+export type PutTraderFiltersByIdResponse = PutTraderFiltersByIdResponses[keyof PutTraderFiltersByIdResponses];
+export type GetTradersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Limit
+         */
+        limit?: number;
+        /**
+         * Offset
+         */
+        offset?: number;
+        /**
+         * Sort By field
+         */
+        sort_by?: string;
+        /**
+         * Sort Direction
+         */
+        direction?: string;
+        /**
+         * Restrict to the caller's favorited traders (authenticated only)
+         */
+        favorites_only?: boolean;
+    };
+    url: '/api/traders';
+};
+export type GetTradersErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * CREDIT_EXHAUSTED — api credit pool empty (only when credit enforcement is enabled)
+     */
+    402: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersError = GetTradersErrors[keyof GetTradersErrors];
+export type GetTradersResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesTraderTraderListResult;
+};
+export type GetTradersResponse = GetTradersResponses[keyof GetTradersResponses];
+export type GetTradersByIdByTraderIdData = {
+    body?: never;
+    path: {
+        /**
+         * Trader ID
+         */
+        traderID: string;
+    };
+    query?: never;
+    url: '/api/traders/by-id/{traderID}';
+};
+export type GetTradersByIdByTraderIdErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByIdByTraderIdError = GetTradersByIdByTraderIdErrors[keyof GetTradersByIdByTraderIdErrors];
+export type GetTradersByIdByTraderIdResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesTraderTraderListItem;
+};
+export type GetTradersByIdByTraderIdResponse = GetTradersByIdByTraderIdResponses[keyof GetTradersByIdByTraderIdResponses];
+export type GetTradersByWalletByWalletAddressData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet Address
+         */
+        walletAddress: string;
+    };
+    query?: never;
+    url: '/api/traders/by-wallet/{walletAddress}';
+};
+export type GetTradersByWalletByWalletAddressErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletByWalletAddressError = GetTradersByWalletByWalletAddressErrors[keyof GetTradersByWalletByWalletAddressErrors];
+export type GetTradersByWalletByWalletAddressResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesTraderTraderListItem;
+};
+export type GetTradersByWalletByWalletAddressResponse = GetTradersByWalletByWalletAddressResponses[keyof GetTradersByWalletByWalletAddressResponses];
+export type PostTradersExportData = {
+    /**
+     * Export Filter Details
+     */
+    body: InternalAdaptersPrimaryHttpHandlerTraderExportRequest;
+    path?: never;
+    query?: never;
+    url: '/api/traders/export';
+};
+export type PostTradersExportErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * CREDIT_EXHAUSTED — api credit pool empty (only when credit enforcement is enabled)
+     */
+    402: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type PostTradersExportError = PostTradersExportErrors[keyof PostTradersExportErrors];
+export type PostTradersExportResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainTraderTrader>;
+};
+export type PostTradersExportResponse = PostTradersExportResponses[keyof PostTradersExportResponses];
+export type GetTradersSearchData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Search query
+         */
+        q?: string;
+        /**
+         * Blockchain filter — only 'sol' is accepted post roadmap subtask 2.6 (BSC removed). Empty defaults to 'sol'.
+         */
+        chain?: string;
+        /**
+         * Limit
+         */
+        limit?: number;
+    };
+    url: '/api/traders/search';
+};
+export type GetTradersSearchErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersSearchError = GetTradersSearchErrors[keyof GetTradersSearchErrors];
+export type GetTradersSearchResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainTraderTrader>;
+};
+export type GetTradersSearchResponse = GetTradersSearchResponses[keyof GetTradersSearchResponses];
+export type GetTradersSnapshotData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Comma-separated wallet addresses
+         */
+        traders: string;
+        /**
+         * Window label (7d|30d)
+         */
+        window?: string;
+    };
+    url: '/api/traders/snapshot';
+};
+export type GetTradersSnapshotErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersSnapshotError = GetTradersSnapshotErrors[keyof GetTradersSnapshotErrors];
+export type GetTradersSnapshotResponses = {
+    /**
+     * OK
+     */
+    200: InternalAdaptersPrimaryHttpHandlerSnapshotResponse;
+};
+export type GetTradersSnapshotResponse = GetTradersSnapshotResponses[keyof GetTradersSnapshotResponses];
+export type GetTradersByTraderIdDailyProfitsData = {
+    body?: never;
+    path: {
+        /**
+         * Trader ID
+         */
+        traderID: string;
+    };
+    query?: {
+        /**
+         * Limit (1..200)
+         */
+        limit?: number;
+        /**
+         * Offset
+         */
+        offset?: number;
+        /**
+         * Inclusive lower bound, YYYY-MM-DD
+         */
+        from_date?: string;
+        /**
+         * Inclusive upper bound, YYYY-MM-DD
+         */
+        to_date?: string;
+        /**
+         * Sort column
+         */
+        sort_by?: string;
+        /**
+         * asc | desc
+         */
+        direction?: string;
+    };
+    url: '/api/traders/{traderID}/daily-profits';
+};
+export type GetTradersByTraderIdDailyProfitsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByTraderIdDailyProfitsError = GetTradersByTraderIdDailyProfitsErrors[keyof GetTradersByTraderIdDailyProfitsErrors];
+export type GetTradersByTraderIdDailyProfitsResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesTraderDailyProfitsResult;
+};
+export type GetTradersByTraderIdDailyProfitsResponse = GetTradersByTraderIdDailyProfitsResponses[keyof GetTradersByTraderIdDailyProfitsResponses];
+export type GetTradersByTraderIdPnlsData = {
+    body?: never;
+    path: {
+        /**
+         * Trader ID
+         */
+        traderID: string;
+    };
+    query?: {
+        /**
+         * Search by token address or symbol
+         */
+        token_search?: string;
+        /**
+         * Limit
+         */
+        limit?: number;
+        /**
+         * Offset
+         */
+        offset?: number;
+        /**
+         * Sort By field
+         */
+        sort_by?: string;
+        /**
+         * Sort Direction
+         */
+        direction?: string;
+    };
+    url: '/api/traders/{traderID}/pnls';
+};
+export type GetTradersByTraderIdPnlsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByTraderIdPnlsError = GetTradersByTraderIdPnlsErrors[keyof GetTradersByTraderIdPnlsErrors];
+export type GetTradersByTraderIdPnlsResponses = {
+    /**
+     * OK
+     */
+    200: InternalAdaptersPrimaryHttpHandlerPaginatedPnls;
+};
+export type GetTradersByTraderIdPnlsResponse = GetTradersByTraderIdPnlsResponses[keyof GetTradersByTraderIdPnlsResponses];
+export type GetTradersByWalletAddressCreatedTokensData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet Address
+         */
+        walletAddress: string;
+    };
+    query?: {
+        /**
+         * Max rows (default 100, max 500)
+         */
+        limit?: number;
+        /**
+         * Page offset
+         */
+        offset?: number;
+    };
+    url: '/api/traders/{walletAddress}/created-tokens';
+};
+export type GetTradersByWalletAddressCreatedTokensErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletAddressCreatedTokensError = GetTradersByWalletAddressCreatedTokensErrors[keyof GetTradersByWalletAddressCreatedTokensErrors];
+export type GetTradersByWalletAddressCreatedTokensResponses = {
+    /**
+     * OK
+     */
+    200: Array<PulsightInternalCoreDomainAggregatorCreatedMintRow>;
+};
+export type GetTradersByWalletAddressCreatedTokensResponse = GetTradersByWalletAddressCreatedTokensResponses[keyof GetTradersByWalletAddressCreatedTokensResponses];
+export type GetTradersByWalletAddressPnlSeriesData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet Address
+         */
+        walletAddress: string;
+    };
+    query?: {
+        /**
+         * Time window
+         */
+        window?: '1d' | '7d' | '30d' | 'all';
+    };
+    url: '/api/traders/{walletAddress}/pnl-series';
+};
+export type GetTradersByWalletAddressPnlSeriesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletAddressPnlSeriesError = GetTradersByWalletAddressPnlSeriesErrors[keyof GetTradersByWalletAddressPnlSeriesErrors];
+export type GetTradersByWalletAddressPnlSeriesResponses = {
+    /**
+     * OK
+     */
+    200: PulsightInternalCoreUsecasesTraderPnlSeriesResult;
+};
+export type GetTradersByWalletAddressPnlSeriesResponse = GetTradersByWalletAddressPnlSeriesResponses[keyof GetTradersByWalletAddressPnlSeriesResponses];
+export type GetTradersByWalletAddressTipsData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet address
+         */
+        walletAddress: string;
+    };
+    query?: {
+        /**
+         * Window (1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/traders/{walletAddress}/tips';
+};
+export type GetTradersByWalletAddressTipsErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletAddressTipsError = GetTradersByWalletAddressTipsErrors[keyof GetTradersByWalletAddressTipsErrors];
+export type GetTradersByWalletAddressTipsResponses = {
+    /**
+     * OK
+     */
+    200: InternalAdaptersPrimaryHttpHandlerTraderTipStatsResponse;
+};
+export type GetTradersByWalletAddressTipsResponse = GetTradersByWalletAddressTipsResponses[keyof GetTradersByWalletAddressTipsResponses];
+export type GetTradersByWalletAddressTipsServicesData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet address
+         */
+        walletAddress: string;
+    };
+    query?: {
+        /**
+         * Window (1d|7d|30d|all)
+         */
+        window?: string;
+    };
+    url: '/api/traders/{walletAddress}/tips/services';
+};
+export type GetTradersByWalletAddressTipsServicesErrors = {
+    /**
+     * Bad Request
+     */
+    400: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletAddressTipsServicesError = GetTradersByWalletAddressTipsServicesErrors[keyof GetTradersByWalletAddressTipsServicesErrors];
+export type GetTradersByWalletAddressTipsServicesResponses = {
+    /**
+     * OK
+     */
+    200: Array<InternalAdaptersPrimaryHttpHandlerServiceLoyaltyRow>;
+};
+export type GetTradersByWalletAddressTipsServicesResponse = GetTradersByWalletAddressTipsServicesResponses[keyof GetTradersByWalletAddressTipsServicesResponses];
+export type GetTradersByWalletAddressTokensData = {
+    body?: never;
+    path: {
+        /**
+         * Wallet address
+         */
+        walletAddress: string;
+    };
+    query?: {
+        /**
+         * Sort key (profit|invested|balance|recent)
+         */
+        sort?: string;
+        /**
+         * Limit
+         */
+        limit?: number;
+        /**
+         * Offset
+         */
+        offset?: number;
+    };
+    url: '/api/traders/{walletAddress}/tokens';
+};
+export type GetTradersByWalletAddressTokensErrors = {
+    /**
+     * Unauthorized
+     */
+    401: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+    /**
+     * Not Found
+     */
+    404: InternalAdaptersPrimaryHttpHandlerErrorResponse;
+};
+export type GetTradersByWalletAddressTokensError = GetTradersByWalletAddressTokensErrors[keyof GetTradersByWalletAddressTokensErrors];
+export type GetTradersByWalletAddressTokensResponses = {
+    /**
+     * OK
+     */
+    200: Array<InternalAdaptersPrimaryHttpHandlerTokensRow>;
+};
+export type GetTradersByWalletAddressTokensResponse = GetTradersByWalletAddressTokensResponses[keyof GetTradersByWalletAddressTokensResponses];
+//# sourceMappingURL=types.gen.d.ts.map