import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
import { TimestampedValue, TokenType } from "../v1/types_pb.js";
import { ProtocolVersion, Token as Token$1 } from "../v1/poolTypes_pb.js";
/**
 * @generated from enum data.v2.TokensOrderBy
 */
export declare enum TokensOrderBy {
    /**
     * @generated from enum value: TOKENS_ORDER_BY_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_TVL = 1;
     */
    TVL = 1,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_1H = 2;
     */
    VOLUME_1H = 2,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_1D = 3;
     */
    VOLUME_1D = 3,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_7D = 4;
     */
    VOLUME_7D = 4,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_30D = 5;
     */
    VOLUME_30D = 5,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_1Y = 6;
     */
    VOLUME_1Y = 6,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_VOLUME_ALL = 7;
     */
    VOLUME_ALL = 7,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_FDV = 8;
     */
    FDV = 8,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_PRICE_CHANGE_1H = 9;
     */
    PRICE_CHANGE_1H = 9,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_PRICE_CHANGE_1D = 10;
     */
    PRICE_CHANGE_1D = 10,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_MARKET_CAP = 11;
     */
    MARKET_CAP = 11,
    /**
     * @generated from enum value: TOKENS_ORDER_BY_PRICE = 12;
     */
    PRICE = 12
}
/**
 * The fiat currencies the legacy GraphQL convert resolver accepts
 * (ETH/MATIC intentionally unrepresentable) plus later additions (SEK).
 * "Fiat" prefix avoids collision with the SDK's Currency (token) type.
 *
 * @generated from enum data.v2.FiatCurrency
 */
export declare enum FiatCurrency {
    /**
     * @generated from enum value: FIAT_CURRENCY_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: FIAT_CURRENCY_ARS = 1;
     */
    ARS = 1,
    /**
     * @generated from enum value: FIAT_CURRENCY_AUD = 2;
     */
    AUD = 2,
    /**
     * @generated from enum value: FIAT_CURRENCY_BRL = 3;
     */
    BRL = 3,
    /**
     * @generated from enum value: FIAT_CURRENCY_CAD = 4;
     */
    CAD = 4,
    /**
     * @generated from enum value: FIAT_CURRENCY_CNY = 5;
     */
    CNY = 5,
    /**
     * @generated from enum value: FIAT_CURRENCY_COP = 6;
     */
    COP = 6,
    /**
     * @generated from enum value: FIAT_CURRENCY_EUR = 7;
     */
    EUR = 7,
    /**
     * @generated from enum value: FIAT_CURRENCY_GBP = 8;
     */
    GBP = 8,
    /**
     * @generated from enum value: FIAT_CURRENCY_HKD = 9;
     */
    HKD = 9,
    /**
     * @generated from enum value: FIAT_CURRENCY_IDR = 10;
     */
    IDR = 10,
    /**
     * @generated from enum value: FIAT_CURRENCY_INR = 11;
     */
    INR = 11,
    /**
     * @generated from enum value: FIAT_CURRENCY_JPY = 12;
     */
    JPY = 12,
    /**
     * @generated from enum value: FIAT_CURRENCY_KRW = 13;
     */
    KRW = 13,
    /**
     * @generated from enum value: FIAT_CURRENCY_MXN = 14;
     */
    MXN = 14,
    /**
     * @generated from enum value: FIAT_CURRENCY_NGN = 15;
     */
    NGN = 15,
    /**
     * @generated from enum value: FIAT_CURRENCY_NZD = 16;
     */
    NZD = 16,
    /**
     * @generated from enum value: FIAT_CURRENCY_PKR = 17;
     */
    PKR = 17,
    /**
     * @generated from enum value: FIAT_CURRENCY_RUB = 18;
     */
    RUB = 18,
    /**
     * @generated from enum value: FIAT_CURRENCY_SGD = 19;
     */
    SGD = 19,
    /**
     * @generated from enum value: FIAT_CURRENCY_THB = 20;
     */
    THB = 20,
    /**
     * @generated from enum value: FIAT_CURRENCY_TRY = 21;
     */
    TRY = 21,
    /**
     * @generated from enum value: FIAT_CURRENCY_UAH = 22;
     */
    UAH = 22,
    /**
     * @generated from enum value: FIAT_CURRENCY_USD = 23;
     */
    USD = 23,
    /**
     * @generated from enum value: FIAT_CURRENCY_VND = 24;
     */
    VND = 24,
    /**
     * @generated from enum value: FIAT_CURRENCY_SEK = 25;
     */
    SEK = 25
}
/**
 * Client-chosen candle width for the ranged (TradingView) OHLC mode. Served
 * from token_price_history via the ClickHouse OHLC path. 1s (trades-derived)
 * is intentionally omitted for now.
 *
 * @generated from enum data.v2.OhlcResolution
 */
export declare enum OhlcResolution {
    /**
     * @generated from enum value: OHLC_RESOLUTION_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: OHLC_RESOLUTION_ONE_MINUTE = 1;
     */
    ONE_MINUTE = 1,
    /**
     * @generated from enum value: OHLC_RESOLUTION_FIVE_MINUTE = 2;
     */
    FIVE_MINUTE = 2,
    /**
     * @generated from enum value: OHLC_RESOLUTION_ONE_HOUR = 3;
     */
    ONE_HOUR = 3,
    /**
     * @generated from enum value: OHLC_RESOLUTION_FOUR_HOUR = 4;
     */
    FOUR_HOUR = 4,
    /**
     * @generated from enum value: OHLC_RESOLUTION_ONE_DAY = 5;
     */
    ONE_DAY = 5
}
/**
 * Time window for windowed token-market stats; FIVE_MINUTE is intentionally omitted.
 *
 * @generated from enum data.v2.HistoryDuration
 */
export declare enum HistoryDuration {
    /**
     * server defaults to DAY
     *
     * @generated from enum value: HISTORY_DURATION_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: HISTORY_DURATION_HOUR = 1;
     */
    HOUR = 1,
    /**
     * @generated from enum value: HISTORY_DURATION_DAY = 2;
     */
    DAY = 2,
    /**
     * @generated from enum value: HISTORY_DURATION_WEEK = 3;
     */
    WEEK = 3,
    /**
     * @generated from enum value: HISTORY_DURATION_MONTH = 4;
     */
    MONTH = 4,
    /**
     * @generated from enum value: HISTORY_DURATION_YEAR = 5;
     */
    YEAR = 5,
    /**
     * @generated from enum value: HISTORY_DURATION_MAX = 6;
     */
    MAX = 6
}
/**
 * @generated from enum data.v2.PoolsOrderBy
 */
export declare enum PoolsOrderBy {
    /**
     * @generated from enum value: POOLS_ORDER_BY_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * default
     *
     * @generated from enum value: POOLS_ORDER_BY_TVL = 1;
     */
    TVL = 1,
    /**
     * @generated from enum value: POOLS_ORDER_BY_VOLUME_1D = 2;
     */
    VOLUME_1D = 2,
    /**
     * @generated from enum value: POOLS_ORDER_BY_VOLUME_30D = 3;
     */
    VOLUME_30D = 3,
    /**
     * ranks on total_apr (fee apr + live reward apr); fee apr alone when incentive data is unavailable
     *
     * @generated from enum value: POOLS_ORDER_BY_APR = 4;
     */
    APR = 4,
    /**
     * volume_1d / tvl; capital-efficiency proxy
     *
     * @generated from enum value: POOLS_ORDER_BY_VOLUME_1D_TVL_RATIO = 5;
     */
    VOLUME_1D_TVL_RATIO = 5
}
/**
 * @generated from enum data.v2.PoolTokenLogicalOperator
 */
export declare enum PoolTokenLogicalOperator {
    /**
     * treated as OR
     *
     * @generated from enum value: POOL_TOKEN_LOGICAL_OPERATOR_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: POOL_TOKEN_LOGICAL_OPERATOR_OR = 1;
     */
    OR = 1,
    /**
     * invalid with more than 2 tokens
     *
     * @generated from enum value: POOL_TOKEN_LOGICAL_OPERATOR_AND = 2;
     */
    AND = 2
}
/**
 * @generated from enum data.v2.TransactionEventType
 */
export declare enum TransactionEventType {
    /**
     * @generated from enum value: TRANSACTION_EVENT_TYPE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: TRANSACTION_EVENT_TYPE_SWAP = 1;
     */
    SWAP = 1,
    /**
     * mint / positive modify_liquidity
     *
     * @generated from enum value: TRANSACTION_EVENT_TYPE_ADD = 2;
     */
    ADD = 2,
    /**
     * burn / negative modify_liquidity
     *
     * @generated from enum value: TRANSACTION_EVENT_TYPE_REMOVE = 3;
     */
    REMOVE = 3
}
/**
 * Sort field for ListLaunches; UNSPECIFIED defaults to LAUNCHED_AT (newest first).
 *
 * @generated from enum data.v2.LaunchesOrderBy
 */
export declare enum LaunchesOrderBy {
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_LAUNCHED_AT = 1;
     */
    LAUNCHED_AT = 1,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_VOLUME_1D = 2;
     */
    VOLUME_1D = 2,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_TVL = 3;
     */
    TVL = 3,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1H = 4;
     */
    PRICE_CHANGE_1H = 4,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1D = 5;
     */
    PRICE_CHANGE_1D = 5,
    /**
     * Trending: launches with recent buy-side momentum. Candidates are tokens
     * with buy activity in the trailing hour REGARDLESS of launch age; gated
     * (non-negative 1h price change, minimum FDV, minimum distinct 1h buyers)
     * and scored by volume/buyer acceleration vs the preceding hours, with the
     * remainder of the page backfilled by 24h volume so the module never
     * renders empty. Needs no LaunchListFilter.window — any window filter is
     * ignored under this sort.
     *
     * @generated from enum value: LAUNCHES_ORDER_BY_TRENDING = 6;
     */
    TRENDING = 6,
    /**
     * Fully-diluted valuation, descending by default. Served from the RANKED
     * launch_tokens read (the live attribution scan has no FDV engine), which
     * every non-LAUNCHED_AT sort already routes to. Unlike TRENDING, a
     * LaunchListFilter.window IS applied under this sort: the launch-age floor
     * reaches both arms, so FDV + LAST_24H ranks by FDV among launches inside
     * that window rather than across all launches.
     *
     * @generated from enum value: LAUNCHES_ORDER_BY_FDV = 7;
     */
    FDV = 7
}
/**
 * Launch-recency window for ListLaunches. UNSPECIFIED applies no window (all
 * launches); LAST_24H / LAST_1H keep only launches whose launched_at is within
 * the trailing 24 hours / 1 hour respectively.
 *
 * @generated from enum data.v2.LaunchWindow
 */
export declare enum LaunchWindow {
    /**
     * @generated from enum value: LAUNCH_WINDOW_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: LAUNCH_WINDOW_LAST_24H = 1;
     */
    LAST_24H = 1,
    /**
     * @generated from enum value: LAUNCH_WINDOW_LAST_1H = 2;
     */
    LAST_1H = 2
}
/**
 * The trade's direction from the trader's perspective: BUY = the trader
 * received the requested token, SELL = the trader gave it up. UNSPECIFIED
 * when the direction can't be derived (zero/unknown amount).
 *
 * @generated from enum data.v2.TradeSide
 */
export declare enum TradeSide {
    /**
     * @generated from enum value: TRADE_SIDE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: TRADE_SIDE_BUY = 1;
     */
    BUY = 1,
    /**
     * @generated from enum value: TRADE_SIDE_SELL = 2;
     */
    SELL = 2
}
/**
 * Volume, TVL, FDV, market-cap, and price-change stats for a ranked token.
 * All values are USD-denominated.
 * All fields are populated from Clickhouse aggregations.
 *
 * @generated from message data.v2.TokenRankStats
 */
export declare class TokenRankStats extends Message<TokenRankStats> {
    /**
     * @generated from field: optional double volume_1h = 1;
     */
    volume1h?: number;
    /**
     * @generated from field: optional double volume_1d = 2;
     */
    volume1d?: number;
    /**
     * @generated from field: optional double volume_7d = 3;
     */
    volume7d?: number;
    /**
     * @generated from field: optional double volume_30d = 4;
     */
    volume30d?: number;
    /**
     * @generated from field: optional double volume_1y = 5;
     */
    volume1y?: number;
    /**
     * @generated from field: optional double volume_all = 6;
     */
    volumeAll?: number;
    /**
     * @generated from field: optional double tvl = 7;
     */
    tvl?: number;
    /**
     * @generated from field: optional double fdv = 8;
     */
    fdv?: number;
    /**
     * Not additive across a multichain group's members: the canonical chain's
     * value (mainnet, else lowest chain_id) — the same member the TDP's
     * headline % change is computed from.
     *
     * @generated from field: optional double price_change_1h = 9;
     */
    priceChange1h?: number;
    /**
     * @generated from field: optional double price_change_1d = 10;
     */
    priceChange1d?: number;
    /**
     * USD spot price of the canonical chain member (mainnet, else lowest
     * chain_id; current_token_prices). Populated only on PRICE-ordered
     * requests; it is exactly the ranked value.
     *
     * @generated from field: optional double price = 11;
     */
    price?: number;
    /**
     * price * circulating supply (chain_token_stats.market_cap_usd). Like fdv,
     * not additive across a multichain group's members: the canonical chain's
     * value. Unset where the pipeline has no circulating-supply source, and
     * unset for Solana (no Codex source wired here).
     *
     * @generated from field: optional double market_cap = 12;
     */
    marketCap?: number;
    constructor(data?: PartialMessage<TokenRankStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenRankStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenRankStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenRankStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenRankStats;
    static equals(a: TokenRankStats | PlainMessage<TokenRankStats> | undefined, b: TokenRankStats | PlainMessage<TokenRankStats> | undefined): boolean;
}
/**
 * Sort field and direction for ListTokens.
 *
 * @generated from message data.v2.TokensSort
 */
export declare class TokensSort extends Message<TokensSort> {
    /**
     * default: TOKENS_ORDER_BY_VOLUME_1D
     *
     * @generated from field: optional data.v2.TokensOrderBy order_by = 1;
     */
    orderBy?: TokensOrderBy;
    /**
     * default false (highest first)
     *
     * @generated from field: optional bool ascending = 2;
     */
    ascending?: boolean;
    constructor(data?: PartialMessage<TokensSort>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokensSort";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokensSort;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokensSort;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokensSort;
    static equals(a: TokensSort | PlainMessage<TokensSort> | undefined, b: TokensSort | PlainMessage<TokensSort> | undefined): boolean;
}
/**
 * Server-side filters applied before ranking and pagination.
 *
 * @generated from message data.v2.TokenListFilter
 */
export declare class TokenListFilter extends Message<TokenListFilter> {
    /**
     * Default false (spam excluded): drops tokens affirmatively flagged — a
     * non-Benign Blockaid verdict, blocklisted, or URL-spam; unscanned tokens
     * pass. Independent of apply_top_level_filters: true alone means "show
     * spam but keep the quality gates".
     *
     * @generated from field: optional bool include_spam = 1;
     */
    includeSpam?: boolean;
    /**
     * @generated from field: optional double min_volume_1d_usd = 2;
     */
    minVolume1dUsd?: number;
    /**
     * @generated from field: optional double min_tvl_usd = 3;
     */
    minTvlUsd?: number;
    /**
     * @generated from field: optional bool apply_top_level_filters = 4;
     */
    applyTopLevelFilters?: boolean;
    /**
     * Currently ignored (may be honored in the future): ListTokens always
     * drops tokenized real-world assets — ListRwas / ListRwaTokens serve them
     * instead. An asset is dropped if any of its chain deployments is known to
     * be an RWA; assets not yet classified are kept. EVM only — Solana RWAs
     * are not yet flagged.
     *
     * @generated from field: optional bool exclude_rwas = 5;
     */
    excludeRwas?: boolean;
    /**
     * Serve only members of these categories: OR within this list, AND with
     * the other filter fields.
     *
     * @generated from field: repeated string category_ids = 6;
     */
    categoryIds: string[];
    /**
     * Explore-search filter: free text prefix-matched (case-insensitive,
     * normalized: trimmed, whitespace collapsed, capped at 100 chars) against
     * token name and symbol — or, for a "0x"-prefixed query, against the
     * token address. Narrows the listing; sort, quality gates, and pagination
     * keep their ordinary meanings (filter-the-feed, not relevance search —
     * the Search endpoint serves that). A multichain token matches when any
     * of its per-chain members matches. Empty/whitespace = no filter.
     *
     * @generated from field: optional string search_query = 7;
     */
    searchQuery?: string;
    constructor(data?: PartialMessage<TokenListFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenListFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenListFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenListFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenListFilter;
    static equals(a: TokenListFilter | PlainMessage<TokenListFilter> | undefined, b: TokenListFilter | PlainMessage<TokenListFilter> | undefined): boolean;
}
/**
 * @generated from message data.v2.FiatAmount
 */
export declare class FiatAmount extends Message<FiatAmount> {
    /**
     * @generated from field: data.v2.FiatCurrency currency = 1;
     */
    currency: FiatCurrency;
    /**
     * @generated from field: double value = 2;
     */
    value: number;
    constructor(data?: PartialMessage<FiatAmount>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.FiatAmount";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FiatAmount;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FiatAmount;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FiatAmount;
    static equals(a: FiatAmount | PlainMessage<FiatAmount> | undefined, b: FiatAmount | PlainMessage<FiatAmount> | undefined): boolean;
}
/**
 * Per-chain volume breakdown within a RankedMultichainToken.
 *
 * @generated from message data.v2.ChainTokenRankStats
 */
export declare class ChainTokenRankStats extends Message<ChainTokenRankStats> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: data.v2.TokenRankStats stats = 2;
     */
    stats?: TokenRankStats;
    constructor(data?: PartialMessage<ChainTokenRankStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ChainTokenRankStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChainTokenRankStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChainTokenRankStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChainTokenRankStats;
    static equals(a: ChainTokenRankStats | PlainMessage<ChainTokenRankStats> | undefined, b: ChainTokenRankStats | PlainMessage<ChainTokenRankStats> | undefined): boolean;
}
/**
 * Returned by ListTokens — wraps a MultichainToken with its ranking stats.
 *
 * @generated from message data.v2.RankedMultichainToken
 */
export declare class RankedMultichainToken extends Message<RankedMultichainToken> {
    /**
     * @generated from field: data.v2.MultichainToken multichain_token = 1;
     */
    multichainToken?: MultichainToken;
    /**
     * @generated from field: data.v2.TokenRankStats stats = 2;
     */
    stats?: TokenRankStats;
    /**
     * @generated from field: repeated data.v2.ChainTokenRankStats chain_stats = 3;
     */
    chainStats: ChainTokenRankStats[];
    /**
     * USD price sparkline over sparkline_duration, from the same chain member
     * as price_change. <=20 points, oldest first; timestamps are synthesized,
     * not observed. Empty when no series is available.
     *
     * @generated from field: repeated data.v1.TimestampedValue sparkline = 4;
     */
    sparkline: TimestampedValue[];
    constructor(data?: PartialMessage<RankedMultichainToken>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.RankedMultichainToken";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RankedMultichainToken;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RankedMultichainToken;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RankedMultichainToken;
    static equals(a: RankedMultichainToken | PlainMessage<RankedMultichainToken> | undefined, b: RankedMultichainToken | PlainMessage<RankedMultichainToken> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenPriceData
 */
export declare class TokenPriceData extends Message<TokenPriceData> {
    /**
     * @generated from field: optional double spot_usd = 1;
     */
    spotUsd?: number;
    /**
     * @generated from field: optional double percent_change_1d = 2;
     */
    percentChange1d?: number;
    /**
     * @generated from field: optional double percent_change_1h = 3;
     */
    percentChange1h?: number;
    /**
     * USD price ~24h ago — the anchor percent_change_1d is measured against.
     * When set, percent_change_1d is computed at serve time from spot_usd
     * against this anchor (live numerator, 1d-cron-refreshed denominator);
     * unset when the stats pipeline has not resolved an anchor yet.
     *
     * @generated from field: optional double price_24h_ago_usd = 4;
     */
    price24hAgoUsd?: number;
    constructor(data?: PartialMessage<TokenPriceData>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenPriceData";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenPriceData;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenPriceData;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenPriceData;
    static equals(a: TokenPriceData | PlainMessage<TokenPriceData> | undefined, b: TokenPriceData | PlainMessage<TokenPriceData> | undefined): boolean;
}
/**
 * Live on-chain market stats for a single token, USD-denominated.
 * Live on-chain market stats, shared by the single-chain (TokenMarket) and
 * multichain (MultichainTokenMarket) views. In the multichain case TVL and
 * volume are summed across chains and 52-week high/low come from the canonical
 * chain; in the single-chain case all values are for that one token.
 *
 * @generated from message data.v2.TokenMarketStats
 */
export declare class TokenMarketStats extends Message<TokenMarketStats> {
    /**
     * @generated from field: optional double total_value_locked_usd = 1;
     */
    totalValueLockedUsd?: number;
    /**
     * price * circulating supply. NULL for EVM until CONS-2571's write path
     * populates chain_token_stats.market_cap_usd; unset for Solana (no Codex
     * source wired here).
     *
     * @generated from field: optional double market_cap_usd = 2;
     */
    marketCapUsd?: number;
    /**
     * price * total supply. Same NULL/unset rules as market_cap_usd.
     *
     * @generated from field: optional double fully_diluted_valuation_usd = 3;
     */
    fullyDilutedValuationUsd?: number;
    /**
     * @generated from field: optional double price_high_52w_usd = 4;
     */
    priceHigh52wUsd?: number;
    /**
     * @generated from field: optional double price_low_52w_usd = 5;
     */
    priceLow52wUsd?: number;
    /**
     * over volume_duration
     *
     * @generated from field: optional double volume_usd = 6;
     */
    volumeUsd?: number;
    /**
     * echoes the requested duration (UNSPECIFIED → DAY)
     *
     * @generated from field: data.v2.HistoryDuration volume_duration = 7;
     */
    volumeDuration: HistoryDuration;
    constructor(data?: PartialMessage<TokenMarketStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenMarketStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenMarketStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenMarketStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenMarketStats;
    static equals(a: TokenMarketStats | PlainMessage<TokenMarketStats> | undefined, b: TokenMarketStats | PlainMessage<TokenMarketStats> | undefined): boolean;
}
/**
 * Single-chain market view of one token.
 *
 * @generated from message data.v2.TokenMarket
 */
export declare class TokenMarket extends Message<TokenMarket> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * @generated from field: data.v2.TokenMarketStats stats = 3;
     */
    stats?: TokenMarketStats;
    constructor(data?: PartialMessage<TokenMarket>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenMarket";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenMarket;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenMarket;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenMarket;
    static equals(a: TokenMarket | PlainMessage<TokenMarket> | undefined, b: TokenMarket | PlainMessage<TokenMarket> | undefined): boolean;
}
/**
 * Cross-chain market view of one logical asset (a bridged token aggregated
 * across the chains it lives on), keyed by multichain_id. The per-chain address
 * map is available from GetTokens / GetTokensMultiChain.
 *
 * @generated from message data.v2.MultichainTokenMarket
 */
export declare class MultichainTokenMarket extends Message<MultichainTokenMarket> {
    /**
     * @generated from field: string multichain_id = 1;
     */
    multichainId: string;
    /**
     * @generated from field: data.v2.TokenMarketStats stats = 2;
     */
    stats?: TokenMarketStats;
    constructor(data?: PartialMessage<MultichainTokenMarket>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.MultichainTokenMarket";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultichainTokenMarket;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultichainTokenMarket;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultichainTokenMarket;
    static equals(a: MultichainTokenMarket | PlainMessage<MultichainTokenMarket> | undefined, b: MultichainTokenMarket | PlainMessage<MultichainTokenMarket> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenSafety
 */
export declare class TokenSafety extends Message<TokenSafety> {
    /**
     * @generated from field: bool is_spam = 1;
     */
    isSpam: boolean;
    /**
     * @generated from field: bool is_verified = 2;
     */
    isVerified: boolean;
    /**
     * @generated from field: bool is_blocked = 3;
     */
    isBlocked: boolean;
    /**
     * @generated from field: optional string verdict = 4;
     */
    verdict?: string;
    /**
     * @generated from field: repeated string features = 5;
     */
    features: string[];
    constructor(data?: PartialMessage<TokenSafety>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenSafety";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenSafety;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenSafety;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenSafety;
    static equals(a: TokenSafety | PlainMessage<TokenSafety> | undefined, b: TokenSafety | PlainMessage<TokenSafety> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenFees
 */
export declare class TokenFees extends Message<TokenFees> {
    /**
     * @generated from field: optional double buy_fee = 1;
     */
    buyFee?: number;
    /**
     * @generated from field: optional double sell_fee = 2;
     */
    sellFee?: number;
    /**
     * @generated from field: optional double transfer_fee = 3;
     */
    transferFee?: number;
    constructor(data?: PartialMessage<TokenFees>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenFees";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenFees;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenFees;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenFees;
    static equals(a: TokenFees | PlainMessage<TokenFees> | undefined, b: TokenFees | PlainMessage<TokenFees> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenProject
 */
export declare class TokenProject extends Message<TokenProject> {
    /**
     * @generated from field: optional string description = 1;
     */
    description?: string;
    /**
     * Translations of `description`, keyed by BCP-47 locale tag. Keys served
     * today: en-US, es-ES, fr-FR, ja-JP, pt-PT, zh-Hans, zh-Hant. A locale is
     * absent (never an empty string) when no translation exists; the map is
     * empty when the token has no description or the request is `external`.
     *
     * @generated from field: map<string, string> description_translations = 5;
     */
    descriptionTranslations: {
        [key: string]: string;
    };
    /**
     * @generated from field: optional string homepage_url = 2;
     */
    homepageUrl?: string;
    /**
     * @generated from field: optional string twitter_name = 3;
     */
    twitterName?: string;
    /**
     * @generated from field: optional string logo_url = 4;
     */
    logoUrl?: string;
    constructor(data?: PartialMessage<TokenProject>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenProject";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenProject;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenProject;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenProject;
    static equals(a: TokenProject | PlainMessage<TokenProject> | undefined, b: TokenProject | PlainMessage<TokenProject> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenMultichain
 */
export declare class TokenMultichain extends Message<TokenMultichain> {
    /**
     * @generated from field: string id = 1;
     */
    id: string;
    /**
     * @generated from field: map<string, string> addresses = 2;
     */
    addresses: {
        [key: string]: string;
    };
    constructor(data?: PartialMessage<TokenMultichain>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenMultichain";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenMultichain;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenMultichain;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenMultichain;
    static equals(a: TokenMultichain | PlainMessage<TokenMultichain> | undefined, b: TokenMultichain | PlainMessage<TokenMultichain> | undefined): boolean;
}
/**
 * Issuer of a tokenized real-world asset; absent = not an RWA or issuer unknown.
 *
 * @generated from message data.v2.TokenIssuerInfo
 */
export declare class TokenIssuerInfo extends Message<TokenIssuerInfo> {
    /**
     * @generated from field: string id = 1;
     */
    id: string;
    /**
     * @generated from field: string display_name = 2;
     */
    displayName: string;
    /**
     * @generated from field: string logo_url = 3;
     */
    logoUrl: string;
    constructor(data?: PartialMessage<TokenIssuerInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenIssuerInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenIssuerInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenIssuerInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenIssuerInfo;
    static equals(a: TokenIssuerInfo | PlainMessage<TokenIssuerInfo> | undefined, b: TokenIssuerInfo | PlainMessage<TokenIssuerInfo> | undefined): boolean;
}
/**
 * @generated from message data.v2.MultichainToken
 */
export declare class MultichainToken extends Message<MultichainToken> {
    /**
     * Canonicalizer group id; empty for a single-chain (ungrouped) token, except
     * in Search results, which carry the token's own id as a row key.
     * GetTokenMultiChain resolves grouped ids only.
     *
     * @generated from field: string multichain_id = 1;
     */
    multichainId: string;
    /**
     * @generated from field: map<string, string> addresses = 2;
     */
    addresses: {
        [key: string]: string;
    };
    /**
     * @generated from field: string symbol = 3;
     */
    symbol: string;
    /**
     * @generated from field: uint32 decimals = 4;
     */
    decimals: number;
    /**
     * @generated from field: string name = 5;
     */
    name: string;
    /**
     * @generated from field: data.v1.TokenType type = 6;
     */
    type: TokenType;
    /**
     * @generated from field: data.v2.TokenPriceData price = 7;
     */
    price?: TokenPriceData;
    /**
     * @generated from field: data.v2.TokenSafety safety = 8;
     */
    safety?: TokenSafety;
    /**
     * @generated from field: data.v2.TokenFees fees = 9;
     */
    fees?: TokenFees;
    /**
     * @generated from field: data.v2.TokenProject project = 10;
     */
    project?: TokenProject;
    /**
     * USD, price * total supply. NULL for EVM until CONS-2571's write path
     * populates chain_token_stats.fdv_usd. Populated for Solana via Codex.
     *
     * @generated from field: optional double fdv = 11;
     */
    fdv?: number;
    /**
     * Ordered by display precedence: the first id is the preferred tag.
     *
     * @generated from field: repeated string category_ids = 12;
     */
    categoryIds: string[];
    /**
     * @generated from field: optional data.v2.TokenIssuerInfo issuer = 13;
     */
    issuer?: TokenIssuerInfo;
    constructor(data?: PartialMessage<MultichainToken>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.MultichainToken";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultichainToken;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultichainToken;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultichainToken;
    static equals(a: MultichainToken | PlainMessage<MultichainToken> | undefined, b: MultichainToken | PlainMessage<MultichainToken> | undefined): boolean;
}
/**
 * @generated from message data.v2.PoolsSort
 */
export declare class PoolsSort extends Message<PoolsSort> {
    /**
     * default: POOLS_ORDER_BY_TVL
     *
     * @generated from field: optional data.v2.PoolsOrderBy order_by = 1;
     */
    orderBy?: PoolsOrderBy;
    /**
     * default false (highest first)
     *
     * @generated from field: optional bool ascending = 2;
     */
    ascending?: boolean;
    constructor(data?: PartialMessage<PoolsSort>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolsSort";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolsSort;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolsSort;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolsSort;
    static equals(a: PoolsSort | PlainMessage<PoolsSort> | undefined, b: PoolsSort | PlainMessage<PoolsSort> | undefined): boolean;
}
/**
 * A pool's boosted APR in one reward token: the sum of that token's live
 * campaign APRs on the pool, in percent, on top of the pool's fee APR. Ended
 * campaigns are excluded — they accrue no yield.
 *
 * Deliberately carries no campaign detail (windows, allocations, distributed
 * amounts): only the pool details page renders that, and it reads
 * GetPoolRewards. Keeping it off this message keeps the per-row payload small
 * enough to repeat across a page of pools.
 *
 * @generated from message data.v2.PoolTokenBoost
 */
export declare class PoolTokenBoost extends Message<PoolTokenBoost> {
    /**
     * @generated from field: pools.v1.Token token = 1;
     */
    token?: Token$1;
    /**
     * @generated from field: double apr = 2;
     */
    apr: number;
    constructor(data?: PartialMessage<PoolTokenBoost>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolTokenBoost";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolTokenBoost;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolTokenBoost;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolTokenBoost;
    static equals(a: PoolTokenBoost | PlainMessage<PoolTokenBoost> | undefined, b: PoolTokenBoost | PlainMessage<PoolTokenBoost> | undefined): boolean;
}
/**
 * Ranking stats for a pool.
 * apr = annualised fee revenue / TVL.
 * reward_apr = Merkl incentive yield (not a valid sort key).
 * total_apr = apr + reward_apr treating null as 0; only null if both are null.
 *
 * @generated from message data.v2.PoolRankStats
 */
export declare class PoolRankStats extends Message<PoolRankStats> {
    /**
     * @generated from field: optional double tvl = 1;
     */
    tvl?: number;
    /**
     * @generated from field: optional double volume_1d = 2;
     */
    volume1d?: number;
    /**
     * @generated from field: optional double volume_30d = 3;
     */
    volume30d?: number;
    /**
     * @generated from field: optional double apr = 4;
     */
    apr?: number;
    /**
     * @generated from field: optional double reward_apr = 5;
     */
    rewardApr?: number;
    /**
     * @generated from field: optional double total_apr = 6;
     */
    totalApr?: number;
    /**
     * volume_1d / tvl; null if tvl is zero
     *
     * @generated from field: optional double volume_1d_tvl_ratio = 7;
     */
    volume1dTvlRatio?: number;
    /**
     * What reward_apr is paid in, per reward token — so a client can denominate
     * a boost ("+2.1% in UNI") instead of rendering a bare number under a
     * guessed symbol. reward_apr stays the cross-token sum and is derived from
     * these, so reward_apr == sum(token_boosts[].apr) always holds.
     *
     * Empty when the pool runs no live campaign, and empty when the incentive
     * lookup degraded — in which case reward_apr is unset too. Never one
     * without the other: a boost nobody can denominate is worse than no boost.
     *
     * @generated from field: repeated data.v2.PoolTokenBoost token_boosts = 8;
     */
    tokenBoosts: PoolTokenBoost[];
    constructor(data?: PartialMessage<PoolRankStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolRankStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolRankStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolRankStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolRankStats;
    static equals(a: PoolRankStats | PlainMessage<PoolRankStats> | undefined, b: PoolRankStats | PlainMessage<PoolRankStats> | undefined): boolean;
}
/**
 * A pool's protocol identity, token pair, and current on-chain state (state
 * fields are mirrored from the chain verbatim). No derived stats
 * (TVL/volume/APR) — those live on RankedPool.
 *
 * @generated from message data.v2.Pool
 */
export declare class Pool extends Message<Pool> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * checksummed pool address (V4: pool id hash)
     *
     * @generated from field: string pool_id = 2;
     */
    poolId: string;
    /**
     * @generated from field: data.v2.Token token0 = 3;
     */
    token0?: Token;
    /**
     * @generated from field: data.v2.Token token1 = 4;
     */
    token1?: Token;
    /**
     * @generated from field: pools.v1.ProtocolVersion protocol_version = 5;
     */
    protocolVersion: ProtocolVersion;
    /**
     * @generated from field: optional int32 tick_spacing = 6;
     */
    tickSpacing?: number;
    /**
     * The pool key's own fee in pips, always served: the V4 DYNAMIC_FEE_FLAG
     * sentinel (0x800000) for a dynamic-fee pool — the literal PoolKey.fee, which
     * is what hashing a v4 pool id needs — and the fixed 3000 for V2. Read
     * is_dynamic_fee, not this, to decide whether a pool has a fixed rate.
     *
     * @generated from field: optional uint32 fee_tier = 7;
     */
    feeTier?: number;
    /**
     * true for V4 pools with dynamic fees
     *
     * @generated from field: bool is_dynamic_fee = 8;
     */
    isDynamicFee: boolean;
    /**
     * V4 only
     *
     * @generated from field: optional string hook_address = 9;
     */
    hookAddress?: string;
    /**
     * V3/V4 only; absent when no state row is indexed yet
     *
     * @generated from field: optional int32 current_tick = 10;
     */
    currentTick?: number;
    /**
     * uint160 as decimal string; V3/V4 only
     *
     * @generated from field: optional string sqrt_price_x96 = 11;
     */
    sqrtPriceX96?: string;
    /**
     * uint128 as decimal string; V3/V4 only
     *
     * @generated from field: optional string liquidity = 12;
     */
    liquidity?: string;
    /**
     * Protocol fee (pips): additive on top of the LP fee for V4, a carve-out
     * of the fee tier for V2/V3. Unset when unavailable.
     *
     * @generated from field: optional uint32 protocol_fee = 13;
     */
    protocolFee?: number;
    /**
     * Effective (all-in) fee (pips): V4 fee_tier + protocol_fee; V2/V3 the fee
     * tier. Unset when protocol_fee is unavailable (incl. V4 dynamic-fee).
     *
     * @generated from field: optional uint32 effective_fee = 14;
     */
    effectiveFee?: number;
    constructor(data?: PartialMessage<Pool>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.Pool";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Pool;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Pool;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Pool;
    static equals(a: Pool | PlainMessage<Pool> | undefined, b: Pool | PlainMessage<Pool> | undefined): boolean;
}
/**
 * @generated from message data.v2.PoolTokenFilter
 */
export declare class PoolTokenFilter extends Message<PoolTokenFilter> {
    /**
     * checksummed EVM addresses
     *
     * @generated from field: repeated string tokens = 1;
     */
    tokens: string[];
    /**
     * @generated from field: data.v2.PoolTokenLogicalOperator logical_operator = 2;
     */
    logicalOperator: PoolTokenLogicalOperator;
    constructor(data?: PartialMessage<PoolTokenFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolTokenFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolTokenFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolTokenFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolTokenFilter;
    static equals(a: PoolTokenFilter | PlainMessage<PoolTokenFilter> | undefined, b: PoolTokenFilter | PlainMessage<PoolTokenFilter> | undefined): boolean;
}
/**
 * @generated from message data.v2.PoolStatRangeFilter
 */
export declare class PoolStatRangeFilter extends Message<PoolStatRangeFilter> {
    /**
     * @generated from field: optional double min = 1;
     */
    min?: number;
    /**
     * @generated from field: optional double max = 2;
     */
    max?: number;
    constructor(data?: PartialMessage<PoolStatRangeFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolStatRangeFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolStatRangeFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolStatRangeFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolStatRangeFilter;
    static equals(a: PoolStatRangeFilter | PlainMessage<PoolStatRangeFilter> | undefined, b: PoolStatRangeFilter | PlainMessage<PoolStatRangeFilter> | undefined): boolean;
}
/**
 * @generated from message data.v2.PoolStatsFilter
 */
export declare class PoolStatsFilter extends Message<PoolStatsFilter> {
    /**
     * @generated from field: optional data.v2.PoolStatRangeFilter tvl = 1;
     */
    tvl?: PoolStatRangeFilter;
    /**
     * @generated from field: optional data.v2.PoolStatRangeFilter apr = 2;
     */
    apr?: PoolStatRangeFilter;
    /**
     * @generated from field: optional data.v2.PoolStatRangeFilter volume_1d = 3;
     */
    volume1d?: PoolStatRangeFilter;
    /**
     * @generated from field: optional data.v2.PoolStatRangeFilter volume_30d = 4;
     */
    volume30d?: PoolStatRangeFilter;
    constructor(data?: PartialMessage<PoolStatsFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolStatsFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolStatsFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolStatsFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolStatsFilter;
    static equals(a: PoolStatsFilter | PlainMessage<PoolStatsFilter> | undefined, b: PoolStatsFilter | PlainMessage<PoolStatsFilter> | undefined): boolean;
}
/**
 * Server-side filters applied before ranking and pagination.
 *
 * @generated from message data.v2.PoolListFilter
 */
export declare class PoolListFilter extends Message<PoolListFilter> {
    /**
     * if empty, all protocol versions
     *
     * @generated from field: repeated pools.v1.ProtocolVersion protocol_versions = 1;
     */
    protocolVersions: ProtocolVersion[];
    /**
     * Default false (spam excluded): drops pools where either token is
     * affirmatively flagged — a non-Benign Blockaid verdict, blocklisted, or
     * URL-spam; unscanned tokens pass (ListTokens' exact safety rule).
     * Independent of apply_top_level_filters.
     *
     * @generated from field: optional bool include_spam = 2;
     */
    includeSpam?: boolean;
    /**
     * @generated from field: optional data.v2.PoolTokenFilter token_filter = 3;
     */
    tokenFilter?: PoolTokenFilter;
    /**
     * @generated from field: optional data.v2.PoolStatsFilter stats_filter = 4;
     */
    statsFilter?: PoolStatsFilter;
    /**
     * e.g. [500, 3000, 10000]; never matches V2 pools
     *
     * @generated from field: repeated uint32 fee_tiers = 5;
     */
    feeTiers: number[];
    /**
     * exact match; never matches V2 pools
     *
     * @generated from field: optional int32 tick_spacing = 6;
     */
    tickSpacing?: number;
    /**
     * V4 hook address; the zero address matches hookless V4 pools; never matches V2/V3 pools
     *
     * @generated from field: optional string hooks = 7;
     */
    hooks?: string;
    /**
     * Curated-feed quality gates, default true (the pools translation of
     * ListTokens' bundle, CONS-2542). Applied uniformly to every request
     * shape; scoped flows (exact-pool lookups, fee-tier discovery) that need
     * complete listings must send false explicitly. Gates: wash trading (1D
     * volume must not exceed 10,000x the pool's TVL; fails open on missing
     * values), valuation trust (both tokens priced with confidence >= 0.005,
     * ListTokens' exact rule; fails closed on a missing price), and discovery
     * (each token native, on a token list, or confidence >= 0.2 WITH 1D token
     * volume in ListTokens' discovery band [10K, 30M] — its exact
     * on-list-or-earned-trust rule), balance (the pool's claimed TVL
     * must be backed on both sides: side-valuation ratio at or above the
     * protocol-stats 1:500 rule; unknown fails open), and a TVL floor
     * (pool TVL >= $1,000 on ranked explore feeds, >= $1 on token-scoped
     * requests — the dust stratum where fossilized stats live; unknown
     * fails open).
     *
     * @generated from field: optional bool apply_top_level_filters = 8;
     */
    applyTopLevelFilters?: boolean;
    /**
     * Restrict the listing to pools running a live allowlisted LP-incentive
     * campaign (Merkl). The campaign set is the row source; everything else —
     * spam, the quality gates above, attribute filters, sort, pagination —
     * behaves exactly as it does without this flag, so a caller wanting every
     * rewarded pool regardless of size sends include_spam true and
     * apply_top_level_filters false alongside it. Never matches V2 pools:
     * Merkl campaign types don't target them.
     *
     * @generated from field: optional bool rewards_only = 9;
     */
    rewardsOnly?: boolean;
    /**
     * Explore-search filter: free text matched against the pool's tokens
     * (case-insensitive, normalized as in TokenListFilter.search_query). A
     * plain term prefix-matches either token's symbol or name; a "/" splits
     * the query into two halves, each prefix-matching one side's symbol (both
     * orientations; an empty half matches anything, so "usdc/" = all USDC
     * pools); a "0x"-prefixed query prefix-matches the token addresses or the
     * pool identifier instead. Narrows the listing; sort, gates, floors, and
     * pagination keep their ordinary meanings. Empty/whitespace = no filter.
     *
     * @generated from field: optional string search_query = 10;
     */
    searchQuery?: string;
    constructor(data?: PartialMessage<PoolListFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PoolListFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PoolListFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PoolListFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolListFilter;
    static equals(a: PoolListFilter | PlainMessage<PoolListFilter> | undefined, b: PoolListFilter | PlainMessage<PoolListFilter> | undefined): boolean;
}
/**
 * Returned by ListPools — wraps a Pool with its ranking stats.
 *
 * @generated from message data.v2.RankedPool
 */
export declare class RankedPool extends Message<RankedPool> {
    /**
     * @generated from field: data.v2.Pool pool = 1;
     */
    pool?: Pool;
    /**
     * @generated from field: data.v2.PoolRankStats stats = 2;
     */
    stats?: PoolRankStats;
    constructor(data?: PartialMessage<RankedPool>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.RankedPool";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RankedPool;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RankedPool;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RankedPool;
    static equals(a: RankedPool | PlainMessage<RankedPool> | undefined, b: RankedPool | PlainMessage<RankedPool> | undefined): boolean;
}
/**
 * One token side of a pool event. amount is signed, pool-perspective:
 * positive = the token entered the pool (sold / deposited), negative = it
 * left the pool (bought / withdrawn) — same convention as the GraphQL
 * transactions resolvers. amount_usd = |amount| * price; 0 when price or
 * decimals are unavailable.
 *
 * @generated from message data.v2.TransactionTokenSide
 */
export declare class TransactionTokenSide extends Message<TransactionTokenSide> {
    /**
     * @generated from field: data.v2.Token token = 1;
     */
    token?: Token;
    /**
     * decimal-adjusted signed amount, full precision; absent when decimals unavailable
     *
     * @generated from field: optional string amount = 2;
     */
    amount?: string;
    /**
     * @generated from field: double amount_usd = 3;
     */
    amountUsd: number;
    constructor(data?: PartialMessage<TransactionTokenSide>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TransactionTokenSide";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransactionTokenSide;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransactionTokenSide;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransactionTokenSide;
    static equals(a: TransactionTokenSide | PlainMessage<TransactionTokenSide> | undefined, b: TransactionTokenSide | PlainMessage<TransactionTokenSide> | undefined): boolean;
}
/**
 * A single on-chain event from the global protocol feed.
 *
 * @generated from message data.v2.UniswapTransaction
 */
export declare class UniswapTransaction extends Message<UniswapTransaction> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string tx_hash = 2;
     */
    txHash: string;
    /**
     * Unix epoch milliseconds
     *
     * @generated from field: int64 timestamp_ms = 3;
     */
    timestampMs: bigint;
    /**
     * @generated from field: data.v2.TransactionEventType event_type = 4;
     */
    eventType: TransactionEventType;
    /**
     * @generated from field: pools.v1.ProtocolVersion protocol_version = 5;
     */
    protocolVersion: ProtocolVersion;
    /**
     * pool address (V2/V3) or pool_id (V4)
     *
     * @generated from field: string pool_id = 6;
     */
    poolId: string;
    /**
     * @generated from field: data.v2.TransactionTokenSide token0 = 7;
     */
    token0?: TransactionTokenSide;
    /**
     * @generated from field: data.v2.TransactionTokenSide token1 = 8;
     */
    token1?: TransactionTokenSide;
    /**
     * swap = avg of both sides; add/remove = sum
     *
     * @generated from field: double amount_usd = 9;
     */
    amountUsd: number;
    /**
     * checksummed EVM address (tx_from)
     *
     * @generated from field: string wallet_address = 10;
     */
    walletAddress: string;
    constructor(data?: PartialMessage<UniswapTransaction>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.UniswapTransaction";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UniswapTransaction;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UniswapTransaction;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UniswapTransaction;
    static equals(a: UniswapTransaction | PlainMessage<UniswapTransaction> | undefined, b: UniswapTransaction | PlainMessage<UniswapTransaction> | undefined): boolean;
}
/**
 * @generated from message data.v2.Token
 */
export declare class Token extends Message<Token> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * @generated from field: string symbol = 3;
     */
    symbol: string;
    /**
     * @generated from field: uint32 decimals = 4;
     */
    decimals: number;
    /**
     * @generated from field: string name = 5;
     */
    name: string;
    /**
     * @generated from field: data.v1.TokenType type = 6;
     */
    type: TokenType;
    /**
     * @generated from field: data.v2.TokenPriceData price = 7;
     */
    price?: TokenPriceData;
    /**
     * @generated from field: data.v2.TokenSafety safety = 8;
     */
    safety?: TokenSafety;
    /**
     * @generated from field: data.v2.TokenFees fees = 9;
     */
    fees?: TokenFees;
    /**
     * @generated from field: data.v2.TokenProject project = 10;
     */
    project?: TokenProject;
    /**
     * @generated from field: optional data.v2.TokenMultichain multichain = 11;
     */
    multichain?: TokenMultichain;
    /**
     * USD, price * total supply. NULL for EVM until CONS-2571's write path
     * populates chain_token_stats.fdv_usd. Populated for Solana via Codex.
     *
     * @generated from field: optional double fdv = 12;
     */
    fdv?: number;
    /**
     * Ordered by display precedence: the first id is the preferred tag.
     *
     * @generated from field: repeated string category_ids = 13;
     */
    categoryIds: string[];
    /**
     * @generated from field: optional data.v2.TokenIssuerInfo issuer = 14;
     */
    issuer?: TokenIssuerInfo;
    constructor(data?: PartialMessage<Token>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.Token";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Token;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Token;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Token;
    static equals(a: Token | PlainMessage<Token> | undefined, b: Token | PlainMessage<Token> | undefined): boolean;
}
/**
 * A token launchpad known to the Launches surface (see the data-api
 * launchpad registry). A launchpad is the launching FRONTEND users see; id is
 * the stable slug used in launchpad_id filters.
 *
 * @generated from message data.v2.Launchpad
 */
export declare class Launchpad extends Message<Launchpad> {
    /**
     * @generated from field: string id = 1;
     */
    id: string;
    /**
     * @generated from field: string name = 2;
     */
    name: string;
    /**
     * @generated from field: optional string logo_url = 3;
     */
    logoUrl?: string;
    /**
     * Underlying shared launch protocol (e.g. "doppler") when the frontend
     * launches through contracts it doesn't own. Unset for self-contained
     * launchpads; several frontends can share one protocol value.
     *
     * @generated from field: optional string protocol = 4;
     */
    protocol?: string;
    constructor(data?: PartialMessage<Launchpad>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.Launchpad";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launchpad;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launchpad;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launchpad;
    static equals(a: Launchpad | PlainMessage<Launchpad> | undefined, b: Launchpad | PlainMessage<Launchpad> | undefined): boolean;
}
/**
 * Optional filters for ListLaunches. When a window is set and sort_by is
 * UNSPECIFIED the server sorts by 24h volume (VOLUME_1D).
 *
 * @generated from message data.v2.LaunchListFilter
 */
export declare class LaunchListFilter extends Message<LaunchListFilter> {
    /**
     * @generated from field: data.v2.LaunchWindow window = 1;
     */
    window: LaunchWindow;
    constructor(data?: PartialMessage<LaunchListFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchListFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchListFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchListFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchListFilter;
    static equals(a: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined, b: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined): boolean;
}
/**
 * The launched token's identity and display metadata.
 *
 * @generated from message data.v2.LaunchToken
 */
export declare class LaunchToken extends Message<LaunchToken> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * @generated from field: string symbol = 3;
     */
    symbol: string;
    /**
     * @generated from field: string name = 4;
     */
    name: string;
    /**
     * @generated from field: optional string logo_url = 5;
     */
    logoUrl?: string;
    /**
     * Safety classification from Aurora canonical_tokens — the same source and
     * shape GetToken serves (safety.is_blocked carries the compliance
     * blocklist). Unset when the token has no canonical row yet (fresh
     * launches lag ingestion) or the read failed: treat as not blocked.
     *
     * @generated from field: data.v2.TokenSafety safety = 6;
     */
    safety?: TokenSafety;
    constructor(data?: PartialMessage<LaunchToken>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchToken";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchToken;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchToken;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchToken;
    static equals(a: LaunchToken | PlainMessage<LaunchToken> | undefined, b: LaunchToken | PlainMessage<LaunchToken> | undefined): boolean;
}
/**
 * Live USD stats for a launch's pool/token. Each field is unset when its
 * source has no data yet (fresh launches lag the stats pipelines).
 *
 * @generated from message data.v2.LaunchStats
 */
export declare class LaunchStats extends Message<LaunchStats> {
    /**
     * @generated from field: optional double volume_24h_usd = 1;
     */
    volume24hUsd?: number;
    /**
     * @generated from field: optional double tvl_usd = 2;
     */
    tvlUsd?: number;
    /**
     * @generated from field: optional double price_usd = 3;
     */
    priceUsd?: number;
    /**
     * price x total supply; unset where no supply source
     *
     * @generated from field: optional double fdv_usd = 4;
     */
    fdvUsd?: number;
    /**
     * @generated from field: optional double price_change_percent_1h = 5;
     */
    priceChangePercent1h?: number;
    /**
     * @generated from field: optional double price_change_percent_24h = 6;
     */
    priceChangePercent24h?: number;
    /**
     * USD price sparkline over the trailing 24h, oldest first. Same shape as
     * RankedMultichainToken.sparkline (Aurora-side timestamps are synthesized;
     * CCA points are observed). Empty when no series is available.
     *
     * @generated from field: repeated data.v1.TimestampedValue sparkline = 7;
     */
    sparkline: TimestampedValue[];
    /**
     * price_usd in ETH terms, derived at serve time as price_usd divided by
     * the chain's native-ETH USD rate. Only set on chains whose native
     * currency is ETH; unset when either price is unavailable.
     *
     * @generated from field: optional double price_eth = 8;
     */
    priceEth?: number;
    /**
     * USD price ~24h ago — the anchor price_change_percent_24h is measured
     * against. When set, price_change_percent_24h is computed at serve time
     * from the live current price against this anchor; unset when the stats
     * pipeline has not resolved an anchor yet.
     *
     * @generated from field: optional double price_24h_ago_usd = 9;
     */
    price24hAgoUsd?: number;
    constructor(data?: PartialMessage<LaunchStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchStats;
    static equals(a: LaunchStats | PlainMessage<LaunchStats> | undefined, b: LaunchStats | PlainMessage<LaunchStats> | undefined): boolean;
}
/**
 * One token launch: the earliest pool a (token, launchpad) pair created.
 *
 * @generated from message data.v2.Launch
 */
export declare class Launch extends Message<Launch> {
    /**
     * @generated from field: string launchpad_id = 1;
     */
    launchpadId: string;
    /**
     * @generated from field: data.v2.LaunchToken token = 2;
     */
    token?: LaunchToken;
    /**
     * v4 pool id for hook-attributed and direct launches; CCA pool key hash
     * once the auction has migrated to a pool, empty before then.
     *
     * @generated from field: string pool_id = 3;
     */
    poolId: string;
    /**
     * @generated from field: optional string hooks_address = 4;
     */
    hooksAddress?: string;
    /**
     * unix seconds
     *
     * @generated from field: int64 launched_at = 5;
     */
    launchedAt: bigint;
    /**
     * @generated from field: data.v2.LaunchStats stats = 6;
     */
    stats?: LaunchStats;
    /**
     * CCA + direct-launch launches: true once the launch graduated. CCA:
     * auction migrated into its pool (on-chain fact). Direct launches
     * (launchpad "uniswap-bonding-curve") have NO on-chain graduation — the
     * pool is a vanilla v4 pool from block one — so this is currently always
     * false for them; a serving-side FDV-threshold graduation rule may set it
     * later. Unset for other hook-attributed launches, which are pools
     * already.
     *
     * @generated from field: optional bool graduated = 7;
     */
    graduated?: boolean;
    /**
     * CCA launches only, pre-graduation: bid volume as a percent of the
     * required raise, clamped to [0, 100]. Unset once graduated, when the
     * auction has no required raise, and for hook-attributed launches.
     *
     * @generated from field: optional double auction_fill_pct = 8;
     */
    auctionFillPct?: number;
    /**
     * CCA launches only, pre-graduation: the auction's end block number
     * (bigint as string). Clients estimate calendar time from blocks, like the
     * v1 auction start_block/end_block. Unset once graduated.
     *
     * @generated from field: optional string auction_end_block = 9;
     */
    auctionEndBlock?: string;
    /**
     * CCA launches only: distinct wallets that have placed bids in the auction
     * (all bids, including withdrawn/exited — historical participation, so it
     * stays set after graduation). Unset for hook-attributed launches, which
     * have no auction. int32 matches the v1 auction total_bid_count.
     *
     * @generated from field: optional int32 bidder_count = 10;
     */
    bidderCount?: number;
    /**
     * Direct-launch overlay (see BondingCurveInfo), set only for launches of
     * the Uniswap direct-launch launchpad ("uniswap-bonding-curve").
     *
     * @generated from field: optional data.v2.BondingCurveInfo bonding_curve = 11;
     */
    bondingCurve?: BondingCurveInfo;
    /**
     * Launchpad token metadata (12-15), joined from launched_tokens — present
     * only for launches whose token was created via the Uniswap token factory
     * (CCA and bonding-curve launches); other launchpads' tokens have no row
     * and serve unset. Verification gating mirrors v1 GetAuction
     * (AuctionsBL.enrichWithLaunchpadMetadata): the description is on-chain
     * creator text at the same trust level as name/symbol, served ungated.
     *
     * @generated from field: optional string token_description = 12;
     */
    tokenDescription?: string;
    /**
     * The launch tx's from address (launched_tokens.creator_wallet),
     * EIP-55 checksummed. Public on-chain data, served ungated.
     *
     * @generated from field: optional string creator_address = 13;
     */
    creatorAddress?: string;
    /**
     * Creator-declared project website. Served only once website verification
     * passes; verification is deferred today (status stays 'pending', same
     * rule that keeps the token mirror's homepageUrl null), so this stays
     * unset until that ships.
     *
     * @generated from field: optional string website_url = 14;
     */
    websiteUrl?: string;
    /**
     * X handle, only when its inline-at-ingest Ed25519 verification passed.
     *
     * @generated from field: optional string x_handle = 15;
     */
    xHandle?: string;
    /**
     * Bonding-curve launches only (16-17): distinct wallets (swap tx senders)
     * that bought the launch token on its curve pool — all-time and trailing
     * hour. Served from ClickHouse v4 swaps; absent (never 0) when the stats
     * source fails or for non-curve launches, so clients can tell degraded
     * from a real zero.
     *
     * @generated from field: optional int32 unique_buyer_count = 16;
     */
    uniqueBuyerCount?: number;
    /**
     * @generated from field: optional int32 buyers_last_1h = 17;
     */
    buyersLast1h?: number;
    /**
     * Exact on-chain holder count of the launch token, computed at query time
     * over the raw launch-transfers feed (ClickHouse, reorg-excluded):
     * addresses with a positive net balance, contracts included, burn sinks
     * like 0x…dEaD included while they hold a balance — raw Etherscan-style
     * semantics. Present only for tokens created via the Uniswap token
     * factory (CCA + bonding-curve launches, whose transfers the feed
     * whitelists); absent — never 0 — while the token has no ingested
     * transfers or when the enrichment fails.
     *
     * @generated from field: optional int32 holder_count = 18;
     */
    holderCount?: number;
    /**
     * Cumulative burned amount of the launch token, split by burn sink and
     * computed from the same transfer feed. Raw uint256 base units as decimal
     * strings; total burned = burned_to_zero + burned_to_dead. Because burn
     * addresses never spend, a holders-excluding-burn count is
     * client-derivable as holder_count - (burned_to_dead > 0 ? 1 : 0). Same
     * presence rule as holder_count (absent without ingested transfers), but
     * once the token has transfers a genuine "0" is served.
     *
     * @generated from field: optional string burned_to_zero = 19;
     */
    burnedToZero?: string;
    /**
     * @generated from field: optional string burned_to_dead = 20;
     */
    burnedToDead?: string;
    /**
     * CCA launches only, pre-graduation (same lifecycle as auction_end_block):
     * wall-clock time of the auction's end block in unix seconds, computed
     * server-side (LP-1300) — the exact block timestamp once the end block is
     * mined, otherwise an estimate from a per-chain block-time model. Unset
     * once graduated, when the source data is unavailable, and for
     * hook-attributed launches.
     *
     * @generated from field: optional int64 auction_end_time = 21;
     */
    auctionEndTime?: bigint;
    /**
     * X profile image URL of the verified launcher account, captured from the
     * launch's signed x-verification claims. Same gate as x_handle: served only
     * when the inline-at-ingest Ed25519 verification passed. Unset for launches
     * that predate claim capture (backfill pending) or carry no avatar.
     *
     * @generated from field: optional string x_profile_image_url = 22;
     */
    xProfileImageUrl?: string;
    /**
     * Whether the launcher's X account was verified (blue check) when captured.
     * Tri-state via presence: unset = unknown (pre-feature launch, not yet
     * backfilled), false = X reported not verified, true = verified. Same
     * x_handle_status gate as x_handle / x_profile_image_url.
     *
     * @generated from field: optional bool x_verified = 23;
     */
    xVerified?: boolean;
    /**
     * Home-card trade tape: the launch token's most recent swaps, newest
     * first, capped at the last 5 within the trailing 24h — same rows (and
     * message) GetTokenTrades serves, aggregated across all the token's pools
     * on its chain. Served from a short-TTL cache refreshed off the request
     * path, so entries can lag live trades by the cache TTL (~30s) and a
     * cold cache serves an empty list — clients treat empty as "no recent
     * activity known", not an error. Pre-graduation CCA launches have no
     * swaps by construction (bids are not trades) — the auction tape is
     * AuctionWithStats.recent_bids on ListTopAuctions.
     *
     * @generated from field: repeated data.v2.TokenTrade recent_trades = 24;
     */
    recentTrades: TokenTrade[];
    /**
     * Badges earned by the launch's token (LP badges), one per badge type,
     * highest tier only, canonical order. Empty until the token has earned
     * any (badges are awarded at ingest and by a slow tier cron, so the
     * common row serves an empty list).
     *
     * @generated from field: repeated data.v2.LaunchBadge badges = 25;
     */
    badges: LaunchBadge[];
    constructor(data?: PartialMessage<Launch>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.Launch";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launch;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launch;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launch;
    static equals(a: Launch | PlainMessage<Launch> | undefined, b: Launch | PlainMessage<Launch> | undefined): boolean;
}
/**
 * One badge earned by a launch's token. type/tier are deliberately plain
 * strings, NOT enums: the client contract pins the lowercase ids on the
 * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
 *
 * @generated from message data.v2.LaunchBadge
 */
export declare class LaunchBadge extends Message<LaunchBadge> {
    /**
     * "original" | "frontrunner" | "volume" | "holders" | "badger".
     *
     * @generated from field: string type = 1;
     */
    type: string;
    /**
     * Tier id, present only for the tiered types — volume: "5m" | "10m" |
     * "50m"; holders: "100" | "1k" | "10k". Unset for untiered types.
     *
     * @generated from field: optional string tier = 2;
     */
    tier?: string;
    /**
     * When the badge was earned (proto-JSON serializes this as an ISO-8601
     * string, which is the client contract). Exact on-chain launch time for
     * frontrunner; observation time for original and for tier crossings,
     * which are only known to have happened by the pass that spots them.
     *
     * @generated from field: google.protobuf.Timestamp earned_at = 3;
     */
    earnedAt?: Timestamp;
    /**
     * Rarity: percentage (0-100) of eligible tokens that hold this badge
     * TYPE (any tier), for the client's rarity-tag hover. The denominator is
     * every factory-launched token (the launched_tokens registry). Served
     * from a short-TTL cached aggregate; unset when the aggregate is
     * unavailable — clients hide the rarity detail rather than showing 0.
     *
     * @generated from field: optional double holder_percentage = 4;
     */
    holderPercentage?: number;
    constructor(data?: PartialMessage<LaunchBadge>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchBadge";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchBadge;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchBadge;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchBadge;
    static equals(a: LaunchBadge | PlainMessage<LaunchBadge> | undefined, b: LaunchBadge | PlainMessage<LaunchBadge> | undefined): boolean;
}
/**
 * One row of a launch token's holder list (GetLaunchHolders).
 *
 * @generated from message data.v2.LaunchHolder
 */
export declare class LaunchHolder extends Message<LaunchHolder> {
    /**
     * EIP-55 checksummed, so clients can equality-match against
     * Launch.creator_address and well-known addresses (LP, burn sinks).
     *
     * @generated from field: string address = 1;
     */
    address: string;
    /**
     * Net balance, raw base units as a decimal string. For the synthetic
     * zero-address burn row this is the cumulative amount burned to 0x0.
     *
     * @generated from field: string balance = 2;
     */
    balance: string;
    /**
     * balance as a percent of minted_supply, in [0, 100].
     *
     * @generated from field: double supply_pct = 3;
     */
    supplyPct: number;
    /**
     * True for burn-sink rows (the zero address and 0x…dEaD). Burn rows are
     * served in the list (burned tokens stay visible) but excluded from
     * top10_supply_pct; the synthetic zero-address row is also excluded from
     * holder_count (0x…dEaD counts, matching Launch.holder_count).
     *
     * @generated from field: bool is_burn_address = 4;
     */
    isBurnAddress: boolean;
    /**
     * True for the launch pool's custody row — the chain's v4 PoolManager
     * singleton, which holds the pool's token-side balance (the LP NFT sits
     * in the FeeSplitter, the ERC-20 supply does not). Served in the list so
     * clients can label it, but excluded from top10_supply_pct like burn rows
     * (the pool is the market, not a dumpable holder); it stays inside
     * holder_count.
     *
     * @generated from field: bool is_pool_address = 5;
     */
    isPoolAddress: boolean;
    constructor(data?: PartialMessage<LaunchHolder>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchHolder";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchHolder;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchHolder;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchHolder;
    static equals(a: LaunchHolder | PlainMessage<LaunchHolder> | undefined, b: LaunchHolder | PlainMessage<LaunchHolder> | undefined): boolean;
}
/**
 * Overlay for launches of the Uniswap direct-launch launchpad (launchpad_id
 * "uniswap-bonding-curve", kept for client compatibility). The current
 * launcher generation (DirectLaunchStrategy, LP-1289) is hookless with NO
 * on-chain graduation lifecycle: launch pools are vanilla v4 pools from
 * block one, and "graduation" is a serving/frontend concept (an FDV
 * threshold), not a contract event. Fields 1-5 and 7-9 belong to the
 * never-launched bonding-curve hook generation and are no longer set for
 * new launches; they are kept so the message shape stays wire-compatible.
 *
 * @generated from message data.v2.BondingCurveInfo
 */
export declare class BondingCurveInfo extends Message<BondingCurveInfo> {
    /**
     * Legacy bonding-curve-hook fields (1-5, 7-9): never set for direct-launch
     * (hookless) launches — there is no curve and no on-chain graduation.
     *
     * @generated from field: optional string graduation_sqrt_price_x96 = 1;
     */
    graduationSqrtPriceX96?: string;
    /**
     * @generated from field: optional int32 curve_tick_lower = 2;
     */
    curveTickLower?: number;
    /**
     * @generated from field: optional int32 curve_tick_upper = 3;
     */
    curveTickUpper?: number;
    /**
     * @generated from field: optional string curve_supply = 4;
     */
    curveSupply?: string;
    /**
     * @generated from field: optional string reserve_supply = 5;
     */
    reserveSupply?: string;
    /**
     * @generated from field: optional string graduated_tx_hash = 7;
     */
    graduatedTxHash?: string;
    /**
     * @generated from field: optional double curve_progress_pct = 8;
     */
    curveProgressPct?: number;
    /**
     * @generated from field: optional int64 graduated_at = 9;
     */
    graduatedAt?: bigint;
    /**
     * The launch's fee beneficiary, EIP-55 checksummed: the CURRENT holder of
     * the launch's BeneficiaryVault NFT, i.e. the address receiving the
     * creator share of the launch pool's trading fees. Freely chosen at
     * launch time by whoever built the launch transaction — a payee, NOT
     * proven authorship (see Launch.creator_address for the launch tx
     * sender) — and it MOVES with later NFT transfers. Unset while ingestion
     * of the vault events lags the launch, or when the position is
     * unregistered.
     *
     * @generated from field: optional string fee_beneficiary = 10;
     */
    feeBeneficiary?: string;
    constructor(data?: PartialMessage<BondingCurveInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.BondingCurveInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BondingCurveInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BondingCurveInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BondingCurveInfo;
    static equals(a: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined, b: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined): boolean;
}
/**
 * One swap involving the requested token, returned by GetTokenTrades.
 *
 * @generated from message data.v2.TokenTrade
 */
export declare class TokenTrade extends Message<TokenTrade> {
    /**
     * @generated from field: string tx_hash = 1;
     */
    txHash: string;
    /**
     * @generated from field: data.v2.TradeSide side = 2;
     */
    side: TradeSide;
    /**
     * The transaction's from-address (the EOA that signed it), not the router
     * contract that forwarded the swap to the pool.
     *
     * @generated from field: string wallet = 3;
     */
    wallet: string;
    /**
     * Whole-swap USD value at trade time; unset when no USD price is known.
     *
     * @generated from field: optional double amount_usd = 4;
     */
    amountUsd?: number;
    /**
     * Absolute amount of the requested token traded, decimal string in token
     * units (decimals applied). Empty when the token's decimals are unknown.
     *
     * @generated from field: string token_amount = 5;
     */
    tokenAmount: string;
    /**
     * USD price of the requested token at trade time; unset when unknown.
     *
     * @generated from field: optional double price_usd = 6;
     */
    priceUsd?: number;
    /**
     * @generated from field: google.protobuf.Timestamp timestamp = 7;
     */
    timestamp?: Timestamp;
    constructor(data?: PartialMessage<TokenTrade>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenTrade";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenTrade;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenTrade;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenTrade;
    static equals(a: TokenTrade | PlainMessage<TokenTrade> | undefined, b: TokenTrade | PlainMessage<TokenTrade> | undefined): boolean;
}
/**
 * @generated from message data.v2.NftImage
 */
export declare class NftImage extends Message<NftImage> {
    /**
     * @generated from field: string url = 1;
     */
    url: string;
    /**
     * FE reads image.dimensions for grid aspect ratio; may be null from Alchemy
     *
     * @generated from field: optional uint32 width = 2;
     */
    width?: number;
    /**
     * @generated from field: optional uint32 height = 3;
     */
    height?: number;
    constructor(data?: PartialMessage<NftImage>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.NftImage";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NftImage;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NftImage;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NftImage;
    static equals(a: NftImage | PlainMessage<NftImage> | undefined, b: NftImage | PlainMessage<NftImage> | undefined): boolean;
}
/**
 * @generated from message data.v2.Nft
 */
export declare class Nft extends Message<Nft> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * checksummed
     *
     * @generated from field: string contract_address = 2;
     */
    contractAddress: string;
    /**
     * @generated from field: string token_id = 3;
     */
    tokenId: string;
    /**
     * @generated from field: string name = 4;
     */
    name: string;
    /**
     * @generated from field: string description = 5;
     */
    description: string;
    /**
     * @generated from field: data.v2.NftImage image = 6;
     */
    image?: NftImage;
    /**
     * @generated from field: data.v2.NftImage thumbnail = 7;
     */
    thumbnail?: NftImage;
    /**
     * Spam flag: Alchemy spam signals + Blockaid verdict + heuristics. Malicious
     * NFTs are filtered out server-side (not represented here).
     *
     * @generated from field: bool is_spam = 8;
     */
    isSpam: boolean;
    /**
     * @generated from field: string collection_name = 9;
     */
    collectionName: string;
    constructor(data?: PartialMessage<Nft>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.Nft";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Nft;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Nft;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Nft;
    static equals(a: Nft | PlainMessage<Nft> | undefined, b: Nft | PlainMessage<Nft> | undefined): boolean;
}