import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
import { FiatAmount, FiatCurrency, HistoryDuration, Launch, LaunchesOrderBy, LaunchHolder, LaunchListFilter, Launchpad, MultichainToken, MultichainTokenMarket, Nft, OhlcResolution, PoolListFilter, PoolsSort, RankedMultichainToken, RankedPool, Token, TokenListFilter, TokenMarket, TokenRankStats, TokensSort, TokenTrade, TransactionEventType, UniswapTransaction } from "./types_pb.js";
import { PageRequest, PageResponse } from "./common_pb.js";
import { EarnPosition, EarnVault } from "./earn_pb.js";
import { TimestampedValue } from "../v1/types_pb.js";
import { RankedCategory, TimeSeriesPoint } from "./categories_pb.js";
import { RankedTokenGroup, TokenGroup, TokenGroupListFilter } from "./tokenGroups_pb.js";
import { ProtocolVersion } from "../v1/poolTypes_pb.js";
/**
 * @generated from enum data.v2.ActivityStatsWindow
 */
export declare enum ActivityStatsWindow {
    /**
     * @generated from enum value: ACTIVITY_STATS_WINDOW_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_5M = 1;
     */
    LAST_5M = 1,
    /**
     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_1H = 2;
     */
    LAST_1H = 2,
    /**
     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_6H = 3;
     */
    LAST_6H = 3,
    /**
     * @generated from enum value: ACTIVITY_STATS_WINDOW_LAST_24H = 4;
     */
    LAST_24H = 4,
    /**
     * Anchored at launch creation; for graduated CCA launches, at graduation
     * (the auction's migration into its pool).
     *
     * @generated from enum value: ACTIVITY_STATS_WINDOW_SINCE_LAUNCH = 5;
     */
    SINCE_LAUNCH = 5
}
/**
 * @generated from message data.v2.GetTokenMarketsRequest
 */
export declare class GetTokenMarketsRequest extends Message<GetTokenMarketsRequest> {
    /**
     * max 100
     *
     * @generated from field: repeated data.v2.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    /**
     * volume_usd window for all tokens; UNSPECIFIED defaults to DAY
     *
     * @generated from field: data.v2.HistoryDuration duration = 2;
     */
    duration: HistoryDuration;
    constructor(data?: PartialMessage<GetTokenMarketsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMarketsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMarketsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMarketsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMarketsRequest;
    static equals(a: GetTokenMarketsRequest | PlainMessage<GetTokenMarketsRequest> | undefined, b: GetTokenMarketsRequest | PlainMessage<GetTokenMarketsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenMarketsResponse
 */
export declare class GetTokenMarketsResponse extends Message<GetTokenMarketsResponse> {
    /**
     * @generated from field: repeated data.v2.TokenMarket markets = 1;
     */
    markets: TokenMarket[];
    constructor(data?: PartialMessage<GetTokenMarketsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMarketsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMarketsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMarketsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMarketsResponse;
    static equals(a: GetTokenMarketsResponse | PlainMessage<GetTokenMarketsResponse> | undefined, b: GetTokenMarketsResponse | PlainMessage<GetTokenMarketsResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenMarketsMultiChainRequest
 */
export declare class GetTokenMarketsMultiChainRequest extends Message<GetTokenMarketsMultiChainRequest> {
    /**
     * @generated from oneof data.v2.GetTokenMarketsMultiChainRequest.identifier
     */
    identifier: {
        /**
         * @generated from field: data.v2.MultichainIdList multichain_ids = 1;
         */
        value: MultichainIdList;
        case: "multichainIds";
    } | {
        /**
         * @generated from field: data.v2.TokenIdentifierList tokens = 2;
         */
        value: TokenIdentifierList;
        case: "tokens";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * volume_usd window for all assets; UNSPECIFIED defaults to DAY
     *
     * @generated from field: data.v2.HistoryDuration duration = 3;
     */
    duration: HistoryDuration;
    /**
     * Aggregate volume_usd and TVL over only these chains. Empty = all chains in
     * the asset's group. 52w price high/low is unaffected (always read from the
     * asset's canonical chain, like the OHLC/price charts). EVM-only, matching
     * the rest of the markets endpoints.
     *
     * @generated from field: repeated uint32 chain_ids = 4;
     */
    chainIds: number[];
    constructor(data?: PartialMessage<GetTokenMarketsMultiChainRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMarketsMultiChainRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMarketsMultiChainRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMarketsMultiChainRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMarketsMultiChainRequest;
    static equals(a: GetTokenMarketsMultiChainRequest | PlainMessage<GetTokenMarketsMultiChainRequest> | undefined, b: GetTokenMarketsMultiChainRequest | PlainMessage<GetTokenMarketsMultiChainRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenMarketsMultiChainResponse
 */
export declare class GetTokenMarketsMultiChainResponse extends Message<GetTokenMarketsMultiChainResponse> {
    /**
     * @generated from field: repeated data.v2.MultichainTokenMarket markets = 1;
     */
    markets: MultichainTokenMarket[];
    constructor(data?: PartialMessage<GetTokenMarketsMultiChainResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMarketsMultiChainResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMarketsMultiChainResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMarketsMultiChainResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMarketsMultiChainResponse;
    static equals(a: GetTokenMarketsMultiChainResponse | PlainMessage<GetTokenMarketsMultiChainResponse> | undefined, b: GetTokenMarketsMultiChainResponse | PlainMessage<GetTokenMarketsMultiChainResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryOHLCRequest
 */
export declare class GetTokenHistoryOHLCRequest extends Message<GetTokenHistoryOHLCRequest> {
    /**
     * @generated from oneof data.v2.GetTokenHistoryOHLCRequest.target
     */
    target: {
        /**
         * @generated from field: data.v2.TokenIdentifier single_chain = 1;
         */
        value: TokenIdentifier;
        case: "singleChain";
    } | {
        /**
         * @generated from field: data.v2.MultichainTarget multichain = 2;
         */
        value: MultichainTarget;
        case: "multichain";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * Chart time range. UNSPECIFIED defaults to DAY;
     *
     * @generated from field: data.v2.HistoryDuration duration = 3;
     */
    duration: HistoryDuration;
    /**
     * Ranged (TradingView) mode: when resolution is set (non-UNSPECIFIED) the
     * series covers [start_time, end_time || now] at the given candle width and
     * duration is ignored. start_time is required in this mode; end_time defaults
     * to now. single_chain (EVM) only. Mirrors GetTokenHistoryPrice.start_time.
     *
     * @generated from field: optional google.protobuf.Timestamp start_time = 4;
     */
    startTime?: Timestamp;
    /**
     * @generated from field: optional google.protobuf.Timestamp end_time = 5;
     */
    endTime?: Timestamp;
    /**
     * @generated from field: optional data.v2.OhlcResolution resolution = 6;
     */
    resolution?: OhlcResolution;
    constructor(data?: PartialMessage<GetTokenHistoryOHLCRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryOHLCRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryOHLCRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryOHLCRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryOHLCRequest;
    static equals(a: GetTokenHistoryOHLCRequest | PlainMessage<GetTokenHistoryOHLCRequest> | undefined, b: GetTokenHistoryOHLCRequest | PlainMessage<GetTokenHistoryOHLCRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.MultichainTarget
 */
export declare class MultichainTarget extends Message<MultichainTarget> {
    /**
     * @generated from oneof data.v2.MultichainTarget.identifier
     */
    identifier: {
        /**
         * canonical chain's candles (mainnet -> else lowest chainId)
         *
         * @generated from field: data.v2.TokenIdentifier token = 1;
         */
        value: TokenIdentifier;
        case: "token";
    } | {
        /**
         * @generated from field: string multichain_id = 2;
         */
        value: string;
        case: "multichainId";
    } | {
        case: undefined;
        value?: undefined;
    };
    constructor(data?: PartialMessage<MultichainTarget>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.MultichainTarget";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultichainTarget;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultichainTarget;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultichainTarget;
    static equals(a: MultichainTarget | PlainMessage<MultichainTarget> | undefined, b: MultichainTarget | PlainMessage<MultichainTarget> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryOHLCResponse
 */
export declare class GetTokenHistoryOHLCResponse extends Message<GetTokenHistoryOHLCResponse> {
    /**
     * @generated from field: repeated data.v2.OhlcCandle candles = 1;
     */
    candles: OhlcCandle[];
    constructor(data?: PartialMessage<GetTokenHistoryOHLCResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryOHLCResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryOHLCResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryOHLCResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryOHLCResponse;
    static equals(a: GetTokenHistoryOHLCResponse | PlainMessage<GetTokenHistoryOHLCResponse> | undefined, b: GetTokenHistoryOHLCResponse | PlainMessage<GetTokenHistoryOHLCResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.OhlcCandle
 */
export declare class OhlcCandle extends Message<OhlcCandle> {
    /**
     * unix seconds, bucket start (inclusive)
     *
     * @generated from field: int64 timestamp = 1;
     */
    timestamp: bigint;
    /**
     * @generated from field: double open_usd = 2;
     */
    openUsd: number;
    /**
     * @generated from field: double high_usd = 3;
     */
    highUsd: number;
    /**
     * @generated from field: double low_usd = 4;
     */
    lowUsd: number;
    /**
     * @generated from field: double close_usd = 5;
     */
    closeUsd: number;
    constructor(data?: PartialMessage<OhlcCandle>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.OhlcCandle";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OhlcCandle;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OhlcCandle;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OhlcCandle;
    static equals(a: OhlcCandle | PlainMessage<OhlcCandle> | undefined, b: OhlcCandle | PlainMessage<OhlcCandle> | undefined): boolean;
}
/**
 * Swap-volume history for a token's chart. single_chain is that chain's volume;
 * multichain SUMS volume across the asset's chains (volume is additive, unlike
 * OHLC price which reads one canonical chain).
 *
 * @generated from message data.v2.GetTokenHistoryVolumeRequest
 */
export declare class GetTokenHistoryVolumeRequest extends Message<GetTokenHistoryVolumeRequest> {
    /**
     * @generated from oneof data.v2.GetTokenHistoryVolumeRequest.target
     */
    target: {
        /**
         * @generated from field: data.v2.TokenIdentifier single_chain = 1;
         */
        value: TokenIdentifier;
        case: "singleChain";
    } | {
        /**
         * @generated from field: data.v2.MultichainTarget multichain = 2;
         */
        value: MultichainTarget;
        case: "multichain";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * UNSPECIFIED -> DAY
     *
     * @generated from field: data.v2.HistoryDuration duration = 3;
     */
    duration: HistoryDuration;
    /**
     * Multichain filter: aggregate only these chains. Empty = all chains in the
     * asset's group. Ignored for the single_chain target. Solana volume is
     * included only when its chain id appears here (or the filter is empty).
     *
     * @generated from field: repeated uint32 chain_ids = 4;
     */
    chainIds: number[];
    /**
     * Ranged (TradingView) mode: when resolution is set (non-UNSPECIFIED) the
     * series covers [start_time, end_time || now] at the given bucket width and
     * duration is ignored. start_time is required in this mode; end_time defaults
     * to now. single_chain (EVM) only. Mirrors GetTokenHistoryOHLC's ranged mode
     * so volume buckets align with that endpoint's candles for any window.
     *
     * @generated from field: optional google.protobuf.Timestamp start_time = 5;
     */
    startTime?: Timestamp;
    /**
     * @generated from field: optional google.protobuf.Timestamp end_time = 6;
     */
    endTime?: Timestamp;
    /**
     * @generated from field: optional data.v2.OhlcResolution resolution = 7;
     */
    resolution?: OhlcResolution;
    constructor(data?: PartialMessage<GetTokenHistoryVolumeRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryVolumeRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryVolumeRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryVolumeRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryVolumeRequest;
    static equals(a: GetTokenHistoryVolumeRequest | PlainMessage<GetTokenHistoryVolumeRequest> | undefined, b: GetTokenHistoryVolumeRequest | PlainMessage<GetTokenHistoryVolumeRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryVolumeResponse
 */
export declare class GetTokenHistoryVolumeResponse extends Message<GetTokenHistoryVolumeResponse> {
    /**
     * ascending time order
     *
     * @generated from field: repeated data.v2.VolumeBucket buckets = 1;
     */
    buckets: VolumeBucket[];
    constructor(data?: PartialMessage<GetTokenHistoryVolumeResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryVolumeResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryVolumeResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryVolumeResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryVolumeResponse;
    static equals(a: GetTokenHistoryVolumeResponse | PlainMessage<GetTokenHistoryVolumeResponse> | undefined, b: GetTokenHistoryVolumeResponse | PlainMessage<GetTokenHistoryVolumeResponse> | undefined): boolean;
}
/**
 * One swap-volume bucket, labeled by its bucket-start time.
 *
 * @generated from message data.v2.VolumeBucket
 */
export declare class VolumeBucket extends Message<VolumeBucket> {
    /**
     * unix seconds, bucket start (inclusive)
     *
     * @generated from field: int64 timestamp = 1;
     */
    timestamp: bigint;
    /**
     * unset when no swap in the bucket had a known USD price
     *
     * @generated from field: optional double volume_usd = 2;
     */
    volumeUsd?: number;
    constructor(data?: PartialMessage<VolumeBucket>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.VolumeBucket";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VolumeBucket;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VolumeBucket;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VolumeBucket;
    static equals(a: VolumeBucket | PlainMessage<VolumeBucket> | undefined, b: VolumeBucket | PlainMessage<VolumeBucket> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryPriceRequest
 */
export declare class GetTokenHistoryPriceRequest extends Message<GetTokenHistoryPriceRequest> {
    /**
     * @generated from oneof data.v2.GetTokenHistoryPriceRequest.target
     */
    target: {
        /**
         * @generated from field: data.v2.TokenIdentifier single_chain = 1;
         */
        value: TokenIdentifier;
        case: "singleChain";
    } | {
        /**
         * canonical chain, not a sum
         *
         * @generated from field: data.v2.MultichainTarget multichain = 2;
         */
        value: MultichainTarget;
        case: "multichain";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * UNSPECIFIED -> DAY
     *
     * @generated from field: data.v2.HistoryDuration duration = 3;
     */
    duration: HistoryDuration;
    /**
     * Anchored mode: when set, the series covers [start_time, now] instead of a
     * trailing duration window (duration is ignored). The server picks the
     * bucket width — the finest available (1 min) for short ranges, scaled up so
     * the series stays under ~400 points for long ones. single_chain (EVM) only.
     *
     * @generated from field: optional google.protobuf.Timestamp start_time = 4;
     */
    startTime?: Timestamp;
    constructor(data?: PartialMessage<GetTokenHistoryPriceRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryPriceRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryPriceRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryPriceRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryPriceRequest;
    static equals(a: GetTokenHistoryPriceRequest | PlainMessage<GetTokenHistoryPriceRequest> | undefined, b: GetTokenHistoryPriceRequest | PlainMessage<GetTokenHistoryPriceRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryPriceResponse
 */
export declare class GetTokenHistoryPriceResponse extends Message<GetTokenHistoryPriceResponse> {
    /**
     * @generated from field: repeated data.v2.PricePoint points = 1;
     */
    points: PricePoint[];
    constructor(data?: PartialMessage<GetTokenHistoryPriceResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryPriceResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryPriceResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryPriceResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryPriceResponse;
    static equals(a: GetTokenHistoryPriceResponse | PlainMessage<GetTokenHistoryPriceResponse> | undefined, b: GetTokenHistoryPriceResponse | PlainMessage<GetTokenHistoryPriceResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.PricePoint
 */
export declare class PricePoint extends Message<PricePoint> {
    /**
     * unix seconds, bucket start
     *
     * @generated from field: int64 timestamp = 1;
     */
    timestamp: bigint;
    /**
     * @generated from field: double price_usd = 2;
     */
    priceUsd: number;
    constructor(data?: PartialMessage<PricePoint>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.PricePoint";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PricePoint;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PricePoint;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PricePoint;
    static equals(a: PricePoint | PlainMessage<PricePoint> | undefined, b: PricePoint | PlainMessage<PricePoint> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryTVLRequest
 */
export declare class GetTokenHistoryTVLRequest extends Message<GetTokenHistoryTVLRequest> {
    /**
     * @generated from oneof data.v2.GetTokenHistoryTVLRequest.target
     */
    target: {
        /**
         * @generated from field: data.v2.TokenIdentifier single_chain = 1;
         */
        value: TokenIdentifier;
        case: "singleChain";
    } | {
        /**
         * SUMs TVL across the asset's chains
         *
         * @generated from field: data.v2.MultichainTarget multichain = 2;
         */
        value: MultichainTarget;
        case: "multichain";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * UNSPECIFIED -> DAY
     *
     * @generated from field: data.v2.HistoryDuration duration = 3;
     */
    duration: HistoryDuration;
    /**
     * Multichain filter: aggregate only these chains. Empty = all chains in the
     * asset's group. Ignored for the single_chain target. Solana TVL is
     * included only when its chain id appears here (or the filter is empty).
     *
     * @generated from field: repeated uint32 chain_ids = 4;
     */
    chainIds: number[];
    constructor(data?: PartialMessage<GetTokenHistoryTVLRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryTVLRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryTVLRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryTVLRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryTVLRequest;
    static equals(a: GetTokenHistoryTVLRequest | PlainMessage<GetTokenHistoryTVLRequest> | undefined, b: GetTokenHistoryTVLRequest | PlainMessage<GetTokenHistoryTVLRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenHistoryTVLResponse
 */
export declare class GetTokenHistoryTVLResponse extends Message<GetTokenHistoryTVLResponse> {
    /**
     * @generated from field: repeated data.v2.TvlPoint points = 1;
     */
    points: TvlPoint[];
    constructor(data?: PartialMessage<GetTokenHistoryTVLResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenHistoryTVLResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenHistoryTVLResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenHistoryTVLResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenHistoryTVLResponse;
    static equals(a: GetTokenHistoryTVLResponse | PlainMessage<GetTokenHistoryTVLResponse> | undefined, b: GetTokenHistoryTVLResponse | PlainMessage<GetTokenHistoryTVLResponse> | undefined): boolean;
}
/**
 * Newest-first swap feed for a token, aggregated across ALL its pools
 * (v2/v3/v4) on the chain. Non-swap events (mints/burns/liquidity) are
 * excluded. Lookback is capped at 3 months. EVM-only.
 *
 * @generated from message data.v2.GetTokenTradesRequest
 */
export declare class GetTokenTradesRequest extends Message<GetTokenTradesRequest> {
    /**
     * @generated from field: data.v2.TokenIdentifier token = 1;
     */
    token?: TokenIdentifier;
    /**
     * page_size (default 25, max 100) + page_token
     *
     * @generated from field: optional data.v2.PageRequest page = 2;
     */
    page?: PageRequest;
    /**
     * Restrict the feed to one trader: matches the trade's wallet (the tx
     * sender, not the router). Any casing accepted. Omitted = all traders.
     * page_token carries only a keyset position, not this filter — the client
     * must resend the same wallet on every page; omitting or changing it
     * resumes from that position under different filter semantics.
     *
     * @generated from field: optional string wallet = 3;
     */
    wallet?: string;
    /**
     * Minimum trade size: keep only trades whose amount_usd is >= this
     * threshold. Trades with no known USD amount are excluded when set (they
     * cannot be proven to clear the bar). Omitted or 0 = no filtering; negative
     * or non-finite values are rejected. Applied before the page cut, so a page
     * holds up to page_size MATCHING trades — but the server bounds how far it
     * scans per request, so a page may come back short of page_size while
     * next_page_token is still set; presence of next_page_token, not page
     * fullness, signals more data under this filter. Deep scans also terminate
     * after a bounded total: once a walk has scanned a server-defined number of
     * rows (currently 5,000) the server stops issuing next_page_token and the
     * feed ends early. Like wallet, page_token carries only the walk position —
     * the client must resend the same min_amount_usd on every page.
     *
     * @generated from field: optional double min_amount_usd = 4;
     */
    minAmountUsd?: number;
    constructor(data?: PartialMessage<GetTokenTradesRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenTradesRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTradesRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTradesRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTradesRequest;
    static equals(a: GetTokenTradesRequest | PlainMessage<GetTokenTradesRequest> | undefined, b: GetTokenTradesRequest | PlainMessage<GetTokenTradesRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenTradesResponse
 */
export declare class GetTokenTradesResponse extends Message<GetTokenTradesResponse> {
    /**
     * @generated from field: repeated data.v2.TokenTrade trades = 1;
     */
    trades: TokenTrade[];
    /**
     * next_page_token absent on last page
     *
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<GetTokenTradesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenTradesResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTradesResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTradesResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTradesResponse;
    static equals(a: GetTokenTradesResponse | PlainMessage<GetTokenTradesResponse> | undefined, b: GetTokenTradesResponse | PlainMessage<GetTokenTradesResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.TvlPoint
 */
export declare class TvlPoint extends Message<TvlPoint> {
    /**
     * unix seconds, bucket start
     *
     * @generated from field: int64 timestamp = 1;
     */
    timestamp: bigint;
    /**
     * unset when no constituent had a known USD price
     *
     * @generated from field: optional double tvl_usd = 2;
     */
    tvlUsd?: number;
    constructor(data?: PartialMessage<TvlPoint>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TvlPoint";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TvlPoint;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TvlPoint;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TvlPoint;
    static equals(a: TvlPoint | PlainMessage<TvlPoint> | undefined, b: TvlPoint | PlainMessage<TvlPoint> | undefined): boolean;
}
/**
 * 1:1 REST port of the legacy GraphQL `convert` query. Cross-currency pairs
 * (e.g. EUR -> JPY) are computed from the same USD-base rates snapshot.
 * Same-currency requests echo the amount back unchanged. Rates may be up to
 * ~5-10min old by design (5min cache + provider's 5min update cycle); on
 * upstream failure the server serves the last good snapshot rather than erroring.
 *
 * @generated from message data.v2.ConvertFiatRequest
 */
export declare class ConvertFiatRequest extends Message<ConvertFiatRequest> {
    /**
     * required
     *
     * @generated from field: data.v2.FiatAmount from_amount = 1;
     */
    fromAmount?: FiatAmount;
    /**
     * required
     *
     * @generated from field: data.v2.FiatCurrency to_currency = 2;
     */
    toCurrency: FiatCurrency;
    constructor(data?: PartialMessage<ConvertFiatRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ConvertFiatRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConvertFiatRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConvertFiatRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConvertFiatRequest;
    static equals(a: ConvertFiatRequest | PlainMessage<ConvertFiatRequest> | undefined, b: ConvertFiatRequest | PlainMessage<ConvertFiatRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ConvertFiatResponse
 */
export declare class ConvertFiatResponse extends Message<ConvertFiatResponse> {
    /**
     * from_amount.value x rate, in to_currency
     *
     * @generated from field: data.v2.FiatAmount converted_amount = 1;
     */
    convertedAmount?: FiatAmount;
    constructor(data?: PartialMessage<ConvertFiatResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ConvertFiatResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConvertFiatResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConvertFiatResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConvertFiatResponse;
    static equals(a: ConvertFiatResponse | PlainMessage<ConvertFiatResponse> | undefined, b: ConvertFiatResponse | PlainMessage<ConvertFiatResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenRequest
 */
export declare class GetTokenRequest extends Message<GetTokenRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * External-consumer request (public API proxy): fields whose upstream
     * data source is internal-only are omitted (served as null/empty), and
     * Solana tokens are not served (SVM lookups return NotFound).
     *
     * @generated from field: bool external = 3;
     */
    external: boolean;
    constructor(data?: PartialMessage<GetTokenRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenRequest;
    static equals(a: GetTokenRequest | PlainMessage<GetTokenRequest> | undefined, b: GetTokenRequest | PlainMessage<GetTokenRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenResponse
 */
export declare class GetTokenResponse extends Message<GetTokenResponse> {
    /**
     * @generated from field: data.v2.Token token = 1;
     */
    token?: Token;
    constructor(data?: PartialMessage<GetTokenResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenResponse;
    static equals(a: GetTokenResponse | PlainMessage<GetTokenResponse> | undefined, b: GetTokenResponse | PlainMessage<GetTokenResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenIdentifier
 */
export declare class TokenIdentifier extends Message<TokenIdentifier> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    constructor(data?: PartialMessage<TokenIdentifier>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenIdentifier";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenIdentifier;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenIdentifier;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenIdentifier;
    static equals(a: TokenIdentifier | PlainMessage<TokenIdentifier> | undefined, b: TokenIdentifier | PlainMessage<TokenIdentifier> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokensRequest
 */
export declare class GetTokensRequest extends Message<GetTokensRequest> {
    /**
     * @generated from field: repeated data.v2.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    /**
     * External-consumer request: internally-sourced fields are omitted and
     * SVM identifiers resolve nothing (see GetTokenRequest.external).
     *
     * @generated from field: bool external = 2;
     */
    external: boolean;
    constructor(data?: PartialMessage<GetTokensRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokensRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokensRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokensRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokensRequest;
    static equals(a: GetTokensRequest | PlainMessage<GetTokensRequest> | undefined, b: GetTokensRequest | PlainMessage<GetTokensRequest> | undefined): boolean;
}
/**
 * Best-effort response: tokens are returned for each requested identifier that
 * was found. If some identifiers are not found, the response will contain fewer
 * tokens than requested. Callers should match response tokens back to their
 * request by (chain_id, address) to determine which were not found.
 *
 * @generated from message data.v2.GetTokensResponse
 */
export declare class GetTokensResponse extends Message<GetTokensResponse> {
    /**
     * @generated from field: repeated data.v2.Token tokens = 1;
     */
    tokens: Token[];
    constructor(data?: PartialMessage<GetTokensResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokensResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokensResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokensResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokensResponse;
    static equals(a: GetTokensResponse | PlainMessage<GetTokensResponse> | undefined, b: GetTokensResponse | PlainMessage<GetTokensResponse> | undefined): boolean;
}
/**
 * Single-token sibling of GetTokensMultiChain: same canonical-group resolution,
 * but a missing token is a not_found error instead of a silent omission.
 *
 * @generated from message data.v2.GetTokenMultiChainRequest
 */
export declare class GetTokenMultiChainRequest extends Message<GetTokenMultiChainRequest> {
    /**
     * @generated from oneof data.v2.GetTokenMultiChainRequest.identifier
     */
    identifier: {
        /**
         * @generated from field: string multichain_id = 1;
         */
        value: string;
        case: "multichainId";
    } | {
        /**
         * any (chain_id, address) in the group resolves to the same canonical result
         *
         * @generated from field: data.v2.TokenIdentifier token = 2;
         */
        value: TokenIdentifier;
        case: "token";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * override canonical chain selection; mainnet -> lowest chainId if omitted
     *
     * @generated from field: optional uint32 canonical_chain_id = 3;
     */
    canonicalChainId?: number;
    /**
     * External-consumer request: internally-sourced fields are omitted and SVM
     * group members are not served (see GetTokenRequest.external).
     *
     * @generated from field: bool external = 4;
     */
    external: boolean;
    constructor(data?: PartialMessage<GetTokenMultiChainRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMultiChainRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMultiChainRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMultiChainRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMultiChainRequest;
    static equals(a: GetTokenMultiChainRequest | PlainMessage<GetTokenMultiChainRequest> | undefined, b: GetTokenMultiChainRequest | PlainMessage<GetTokenMultiChainRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenMultiChainResponse
 */
export declare class GetTokenMultiChainResponse extends Message<GetTokenMultiChainResponse> {
    /**
     * @generated from field: data.v2.MultichainToken token = 1;
     */
    token?: MultichainToken;
    constructor(data?: PartialMessage<GetTokenMultiChainResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenMultiChainResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenMultiChainResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenMultiChainResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenMultiChainResponse;
    static equals(a: GetTokenMultiChainResponse | PlainMessage<GetTokenMultiChainResponse> | undefined, b: GetTokenMultiChainResponse | PlainMessage<GetTokenMultiChainResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokensMultiChainRequest
 */
export declare class GetTokensMultiChainRequest extends Message<GetTokensMultiChainRequest> {
    /**
     * @generated from oneof data.v2.GetTokensMultiChainRequest.identifier
     */
    identifier: {
        /**
         * @generated from field: data.v2.MultichainIdList multichain_ids = 1;
         */
        value: MultichainIdList;
        case: "multichainIds";
    } | {
        /**
         * @generated from field: data.v2.TokenIdentifierList tokens = 2;
         */
        value: TokenIdentifierList;
        case: "tokens";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * @generated from field: optional uint32 canonical_chain_id = 3;
     */
    canonicalChainId?: number;
    /**
     * External-consumer request: internally-sourced fields are omitted and SVM
     * group members are not served (see GetTokenRequest.external).
     *
     * @generated from field: bool external = 4;
     */
    external: boolean;
    constructor(data?: PartialMessage<GetTokensMultiChainRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokensMultiChainRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokensMultiChainRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokensMultiChainRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokensMultiChainRequest;
    static equals(a: GetTokensMultiChainRequest | PlainMessage<GetTokensMultiChainRequest> | undefined, b: GetTokensMultiChainRequest | PlainMessage<GetTokensMultiChainRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.MultichainIdList
 */
export declare class MultichainIdList extends Message<MultichainIdList> {
    /**
     * max 100
     *
     * @generated from field: repeated string ids = 1;
     */
    ids: string[];
    constructor(data?: PartialMessage<MultichainIdList>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.MultichainIdList";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultichainIdList;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultichainIdList;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultichainIdList;
    static equals(a: MultichainIdList | PlainMessage<MultichainIdList> | undefined, b: MultichainIdList | PlainMessage<MultichainIdList> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenIdentifierList
 */
export declare class TokenIdentifierList extends Message<TokenIdentifierList> {
    /**
     * max 100
     *
     * @generated from field: repeated data.v2.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    constructor(data?: PartialMessage<TokenIdentifierList>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenIdentifierList";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenIdentifierList;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenIdentifierList;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenIdentifierList;
    static equals(a: TokenIdentifierList | PlainMessage<TokenIdentifierList> | undefined, b: TokenIdentifierList | PlainMessage<TokenIdentifierList> | undefined): boolean;
}
/**
 * Best-effort response: one MultichainToken per distinct multichain identity.
 * addresses is always populated. Tokens not found are silently omitted.
 *
 * @generated from message data.v2.GetTokensMultiChainResponse
 */
export declare class GetTokensMultiChainResponse extends Message<GetTokensMultiChainResponse> {
    /**
     * @generated from field: repeated data.v2.MultichainToken tokens = 1;
     */
    tokens: MultichainToken[];
    constructor(data?: PartialMessage<GetTokensMultiChainResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokensMultiChainResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokensMultiChainResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokensMultiChainResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokensMultiChainResponse;
    static equals(a: GetTokensMultiChainResponse | PlainMessage<GetTokensMultiChainResponse> | undefined, b: GetTokensMultiChainResponse | PlainMessage<GetTokensMultiChainResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListEarnVaultsRequest
 */
export declare class ListEarnVaultsRequest extends Message<ListEarnVaultsRequest> {
    /**
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * @generated from field: optional uint32 page_size = 2;
     */
    pageSize?: number;
    /**
     * @generated from field: optional string page_token = 3;
     */
    pageToken?: string;
    constructor(data?: PartialMessage<ListEarnVaultsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListEarnVaultsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListEarnVaultsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListEarnVaultsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListEarnVaultsRequest;
    static equals(a: ListEarnVaultsRequest | PlainMessage<ListEarnVaultsRequest> | undefined, b: ListEarnVaultsRequest | PlainMessage<ListEarnVaultsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListEarnVaultsResponse
 */
export declare class ListEarnVaultsResponse extends Message<ListEarnVaultsResponse> {
    /**
     * @generated from field: repeated data.v2.EarnVault vaults = 1;
     */
    vaults: EarnVault[];
    /**
     * @generated from field: optional string next_page_token = 2;
     */
    nextPageToken?: string;
    constructor(data?: PartialMessage<ListEarnVaultsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListEarnVaultsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListEarnVaultsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListEarnVaultsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListEarnVaultsResponse;
    static equals(a: ListEarnVaultsResponse | PlainMessage<ListEarnVaultsResponse> | undefined, b: ListEarnVaultsResponse | PlainMessage<ListEarnVaultsResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListEarnPositionsRequest
 */
export declare class ListEarnPositionsRequest extends Message<ListEarnPositionsRequest> {
    /**
     * @generated from field: string wallet_address = 1;
     */
    walletAddress: string;
    /**
     * @generated from field: repeated uint32 chain_ids = 2;
     */
    chainIds: number[];
    /**
     * @generated from field: optional uint32 page_size = 3;
     */
    pageSize?: number;
    /**
     * @generated from field: optional string page_token = 4;
     */
    pageToken?: string;
    constructor(data?: PartialMessage<ListEarnPositionsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListEarnPositionsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListEarnPositionsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListEarnPositionsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListEarnPositionsRequest;
    static equals(a: ListEarnPositionsRequest | PlainMessage<ListEarnPositionsRequest> | undefined, b: ListEarnPositionsRequest | PlainMessage<ListEarnPositionsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListEarnPositionsResponse
 */
export declare class ListEarnPositionsResponse extends Message<ListEarnPositionsResponse> {
    /**
     * @generated from field: repeated data.v2.EarnPosition positions = 1;
     */
    positions: EarnPosition[];
    /**
     * @generated from field: optional string next_page_token = 2;
     */
    nextPageToken?: string;
    constructor(data?: PartialMessage<ListEarnPositionsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListEarnPositionsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListEarnPositionsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListEarnPositionsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListEarnPositionsResponse;
    static equals(a: ListEarnPositionsResponse | PlainMessage<ListEarnPositionsResponse> | undefined, b: ListEarnPositionsResponse | PlainMessage<ListEarnPositionsResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetEarnPositionRequest
 */
export declare class GetEarnPositionRequest extends Message<GetEarnPositionRequest> {
    /**
     * @generated from field: string wallet_address = 1;
     */
    walletAddress: string;
    /**
     * @generated from field: string vault_address = 2;
     */
    vaultAddress: string;
    /**
     * @generated from field: uint32 chain_id = 3;
     */
    chainId: number;
    constructor(data?: PartialMessage<GetEarnPositionRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetEarnPositionRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetEarnPositionRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetEarnPositionRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetEarnPositionRequest;
    static equals(a: GetEarnPositionRequest | PlainMessage<GetEarnPositionRequest> | undefined, b: GetEarnPositionRequest | PlainMessage<GetEarnPositionRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetEarnPositionResponse
 */
export declare class GetEarnPositionResponse extends Message<GetEarnPositionResponse> {
    /**
     * @generated from field: data.v2.EarnPosition position = 1;
     */
    position?: EarnPosition;
    constructor(data?: PartialMessage<GetEarnPositionResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetEarnPositionResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetEarnPositionResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetEarnPositionResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetEarnPositionResponse;
    static equals(a: GetEarnPositionResponse | PlainMessage<GetEarnPositionResponse> | undefined, b: GetEarnPositionResponse | PlainMessage<GetEarnPositionResponse> | undefined): boolean;
}
/**
 * The launchpad registry, for building launchpad filters/labels client-side.
 *
 * @generated from message data.v2.ListLaunchpadsRequest
 */
export declare class ListLaunchpadsRequest extends Message<ListLaunchpadsRequest> {
    constructor(data?: PartialMessage<ListLaunchpadsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListLaunchpadsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchpadsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchpadsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchpadsRequest;
    static equals(a: ListLaunchpadsRequest | PlainMessage<ListLaunchpadsRequest> | undefined, b: ListLaunchpadsRequest | PlainMessage<ListLaunchpadsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListLaunchpadsResponse
 */
export declare class ListLaunchpadsResponse extends Message<ListLaunchpadsResponse> {
    /**
     * @generated from field: repeated data.v2.Launchpad launchpads = 1;
     */
    launchpads: Launchpad[];
    constructor(data?: PartialMessage<ListLaunchpadsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListLaunchpadsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchpadsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchpadsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchpadsResponse;
    static equals(a: ListLaunchpadsResponse | PlainMessage<ListLaunchpadsResponse> | undefined, b: ListLaunchpadsResponse | PlainMessage<ListLaunchpadsResponse> | undefined): boolean;
}
/**
 * Token launches aggregated across launchpads, newest first by default
 * (searched requests default to FDV instead — see sort_by and query). One
 * entry per (token, launchpad) — the earliest pool wins when a launchpad
 * creates several pools for the same token.
 *
 * @generated from message data.v2.ListLaunchesRequest
 */
export declare class ListLaunchesRequest extends Message<ListLaunchesRequest> {
    /**
     * Deprecated: use launchpad_ids. When both are set they are unioned.
     *
     * @generated from field: optional string launchpad_id = 1 [deprecated = true];
     * @deprecated
     */
    launchpadId?: string;
    /**
     * empty = all supported chains
     *
     * @generated from field: repeated uint32 chain_ids = 2;
     */
    chainIds: number[];
    /**
     * UNSPECIFIED resolves server-side: with a window -> VOLUME_1D, else with
     * a query -> FDV descending (largest matches first, with the first page
     * led by a small newest-first block of matches launched in the trailing
     * hour so a just-launched token stays findable by its creator), else
     * LAUNCHED_AT (newest first). An explicit value always wins.
     *
     * @generated from field: data.v2.LaunchesOrderBy sort_by = 3;
     */
    sortBy: LaunchesOrderBy;
    /**
     * @generated from field: optional data.v2.PageRequest page = 4;
     */
    page?: PageRequest;
    /**
     * Launchpads to serve. Empty = the server-side default scope (the
     * listable set plus uniswap-cca), so clients don't have to pre-scope with
     * ListLaunchpads. The Uniswap brand spans two ids behind one "Uniswap"
     * filter — uniswap-bonding-curve (instant launches) and uniswap-cca (CCA
     * crowd-launch auctions) — so an explicit filter naming either id expands
     * to the full brand set (both ids); there is no mechanism-scoped opt-out.
     * If a consumer ever needs one, the expansion moves client-side (the
     * filter chip sends both ids itself).
     *
     * @generated from field: repeated string launchpad_ids = 5;
     */
    launchpadIds: string[];
    /**
     * launch-recency window
     *
     * @generated from field: optional data.v2.LaunchListFilter filter = 6;
     */
    filter?: LaunchListFilter;
    /**
     * Sort direction for sort_by; false (default) = descending (highest first).
     * Null/empty metric rows sort last in both directions.
     *
     * @generated from field: optional bool ascending = 7;
     */
    ascending?: boolean;
    /**
     * Launchpad search: keep only launches whose token name OR
     * symbol starts with this string, compared case-insensitively (prefix
     * match only — no fuzzy/substring matching). LIKE metacharacters in the
     * query are treated literally. An EXPLICIT sort_by/ascending orders the
     * filtered results exactly as it does the unfiltered list; with sort_by
     * UNSPECIFIED a searched request ranks by FDV descending (see sort_by) so
     * the launch a name is actually looking for outranks whatever launched
     * since. Whitespace-only queries are treated as absent; input is trimmed,
     * whitespace-collapsed, and capped at 100 characters server-side.
     *
     * @generated from field: optional string query = 8;
     */
    query?: string;
    /**
     * "My launches": keep only launches created by this wallet — the same
     * address served as Launch.creator_address (launched_tokens.creator_wallet,
     * the launch tx's from address). Any case is accepted; the server
     * EIP-55-checksums it before comparing, and rejects a non-address with
     * INVALID_ARGUMENT. Empty/absent applies no filter.
     *
     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
     * auctions + uniswap-bonding-curve instant launches). Third-party-launchpad
     * launches are served from a materialized table with no creator column and
     * are dropped from a creator-filtered read — they carry no
     * Launch.creator_address today either, so nothing filterable is lost.
     *
     * Not supported with sort_by = TRENDING: that ranking is built from a
     * candidate scan with no creator column, so the combination is rejected
     * rather than served unfiltered or silently re-sorted.
     *
     * @generated from field: optional string creator_address = 9;
     */
    creatorAddress?: string;
    /**
     * "Linked X": keep only launches that serve Launch.x_handle — i.e. whose
     * creator-declared X handle passed its inline-at-ingest Ed25519
     * verification (launched_tokens.x_handle_status = 'passed' with a
     * non-empty handle). Exactly the rows the response decorates with
     * x_handle, but filtered IN the ranked query before pagination, so the
     * result is the top launches with a linked X across ALL launches — not a
     * client-side pass over one pre-cut page. False/absent applies no filter.
     *
     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
     * auctions + uniswap-bonding-curve instant launches): x_handle is only
     * ever attested for factory launches, so third-party-launchpad launches —
     * which never serve x_handle — are dropped from a filtered read and
     * nothing filterable is lost.
     *
     * Not supported with sort_by = TRENDING: that ranking is built from a
     * candidate scan with no X-handle column, so the combination is rejected
     * with INVALID_ARGUMENT rather than served unfiltered or silently
     * re-sorted. Composes with every other sort, VOLUME_1D included.
     *
     * @generated from field: optional bool linked_x_only = 10;
     */
    linkedXOnly?: boolean;
    /**
     * Launch lookup by token: keep only launches of these token addresses.
     * Any casing is accepted (the server EIP-55-checksums and dedupes before
     * comparing); a non-address entry fails the request with INVALID_ARGUMENT.
     * Empty/absent applies no filter. At most 100 entries.
     *
     * Built for token pages resolving a launch by address — e.g. an instant
     * launch that has aged off the newest-100 feed window — so it composes
     * with launchpad_ids/chain_ids and serves the same row shape and stats
     * sources as the unfiltered feed.
     *
     * Coverage is the Uniswap launchpads only (uniswap-cca crowd-launch
     * auctions + uniswap-bonding-curve instant launches): neither
     * third-party-launchpad read can express a token predicate, so that arm
     * is dropped from a token-filtered read rather than served unfiltered.
     * Not supported with sort_by = TRENDING (rejected), same contract as
     * creator_address.
     *
     * CCA rows additionally inherit the crowd-launch feed's
     * `is_quick_launch = true` gate; an unclassified or institutional
     * auction will not match.
     *
     * @generated from field: repeated string token_addresses = 11;
     */
    tokenAddresses: string[];
    /**
     * "Fees paid to me": keep only launches whose CURRENT fee beneficiary is
     * this address — the holder of the launch's BeneficiaryVault NFT, as
     * served on BondingCurve.fee_beneficiary. Any case accepted; a non-address
     * fails with INVALID_ARGUMENT. Empty/absent applies no filter.
     *
     * Separate from creator_address, not OR'd with it: the beneficiary is a
     * payee that moves with the NFT, the creator is the immutable launch-tx
     * sender. Callers wanting both issue both reads.
     *
     * Coverage is uniswap-bonding-curve ONLY — a uniswap-cca launch mints its
     * vault NFT lazily from the creator's later claim, so it has no
     * launch-anchored beneficiary and serves no fee_beneficiary. Rejected with
     * sort_by = TRENDING, same contract as creator_address.
     *
     * @generated from field: optional string fee_beneficiary = 12;
     */
    feeBeneficiary?: string;
    constructor(data?: PartialMessage<ListLaunchesRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListLaunchesRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchesRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchesRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchesRequest;
    static equals(a: ListLaunchesRequest | PlainMessage<ListLaunchesRequest> | undefined, b: ListLaunchesRequest | PlainMessage<ListLaunchesRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListLaunchesResponse
 */
export declare class ListLaunchesResponse extends Message<ListLaunchesResponse> {
    /**
     * @generated from field: repeated data.v2.Launch launches = 1;
     */
    launches: Launch[];
    /**
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListLaunchesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListLaunchesResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListLaunchesResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListLaunchesResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListLaunchesResponse;
    static equals(a: ListLaunchesResponse | PlainMessage<ListLaunchesResponse> | undefined, b: ListLaunchesResponse | PlainMessage<ListLaunchesResponse> | undefined): boolean;
}
/**
 * Holder data for ONE launch token (the TDP Holders module), computed at
 * query time over the raw launch-transfers feed (ClickHouse,
 * reorg-excluded) behind a short SWR cache. Only tokens created via the
 * Uniswap token factory (CCA + bonding-curve launches) have transfer rows.
 *
 * @generated from message data.v2.GetLaunchHoldersRequest
 */
export declare class GetLaunchHoldersRequest extends Message<GetLaunchHoldersRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    constructor(data?: PartialMessage<GetLaunchHoldersRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchHoldersRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchHoldersRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchHoldersRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchHoldersRequest;
    static equals(a: GetLaunchHoldersRequest | PlainMessage<GetLaunchHoldersRequest> | undefined, b: GetLaunchHoldersRequest | PlainMessage<GetLaunchHoldersRequest> | undefined): boolean;
}
/**
 * Server-computed per-window trade activity for a launch token (LP-1294):
 * every window in one response, so the TDP Volume module's 5s poll is a
 * single call instead of a client-side walk of GetTokenTrades. EVM-only.
 * Served for tokens launched via the Uniswap token factory (CCA and
 * bonding-curve launches); other tokens are a not_found error.
 * CCA launches pre-graduation serve all-zero windows: bids are not trades,
 * and the token does not swap until the auction migrates into its pool.
 *
 * @generated from message data.v2.GetLaunchActivityStatsRequest
 */
export declare class GetLaunchActivityStatsRequest extends Message<GetLaunchActivityStatsRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    constructor(data?: PartialMessage<GetLaunchActivityStatsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchActivityStatsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchActivityStatsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsRequest;
    static equals(a: GetLaunchActivityStatsRequest | PlainMessage<GetLaunchActivityStatsRequest> | undefined, b: GetLaunchActivityStatsRequest | PlainMessage<GetLaunchActivityStatsRequest> | undefined): boolean;
}
/**
 * Absence contract mirrors the Launch holder fields: when the token has no
 * ingested transfers (non-factory token, ingestion lag, or every row
 * reorged out) holders is empty and every optional field is unset, never a
 * fake 0, so clients can tell no-data from a real zero. Upstream failures
 * fail the RPC instead of serving empty.
 *
 * @generated from message data.v2.GetLaunchHoldersResponse
 */
export declare class GetLaunchHoldersResponse extends Message<GetLaunchHoldersResponse> {
    /**
     * Top-100 holders by balance, descending. Raw Etherscan-style rows over
     * net transfer balances, INCLUDING burned tokens: the 0x…dEaD burn sink
     * appears while it holds a balance, and cumulative burns to the zero
     * address appear as a synthetic zero-address row — so held + burned rows
     * sum to minted_supply. Burn rows are flagged (is_burn_address); clients
     * that want them out filter the flag.
     *
     * @generated from field: repeated data.v2.LaunchHolder holders = 1;
     */
    holders: LaunchHolder[];
    /**
     * Exact holder count, same semantics as Launch.holder_count (addresses
     * with a positive net balance; burn sinks like 0x…dEaD included while
     * they hold a balance, the zero address never). The synthetic zero-address
     * burn row is never counted.
     *
     * @generated from field: optional int32 holder_count = 2;
     */
    holderCount?: number;
    /**
     * holder_count minus the count as of 24h ago (signed).
     *
     * @generated from field: optional int32 holder_count_change_24h = 3;
     */
    holderCountChange24h?: number;
    /**
     * Trailing 7-day holder-count trend for the stat sparkline: one point per
     * UTC-now-anchored 24h mark, oldest first, last point = holder_count now.
     *
     * @generated from field: repeated data.v1.TimestampedValue holder_count_trend = 4;
     */
    holderCountTrend: TimestampedValue[];
    /**
     * Share of minted_supply held by the top 10 holder rows that are neither
     * burn sinks nor the pool's custody row (LaunchHolder.is_pool_address),
     * percent in [0, 100]. Burned tokens can never concentrate and the pool
     * is the market itself, so both are excluded here (unlike the rows above).
     *
     * @generated from field: optional double top10_supply_pct = 5;
     */
    top10SupplyPct?: number;
    /**
     * Cumulative value ever minted, raw base units as a decimal string — the
     * denominator of every supply_pct in this response. Burn-inclusive by
     * construction: holder balances + burned rows sum to it. On-chain
     * totalSupply-style circulating figures are client-derivable as
     * minted_supply - burned_to_zero.
     *
     * @generated from field: optional string minted_supply = 6;
     */
    mintedSupply?: string;
    /**
     * Same definitions as Launch.burned_to_zero / burned_to_dead.
     *
     * @generated from field: optional string burned_to_zero = 7;
     */
    burnedToZero?: string;
    /**
     * @generated from field: optional string burned_to_dead = 8;
     */
    burnedToDead?: string;
    constructor(data?: PartialMessage<GetLaunchHoldersResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchHoldersResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchHoldersResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchHoldersResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchHoldersResponse;
    static equals(a: GetLaunchHoldersResponse | PlainMessage<GetLaunchHoldersResponse> | undefined, b: GetLaunchHoldersResponse | PlainMessage<GetLaunchHoldersResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetLaunchActivityStatsResponse
 */
export declare class GetLaunchActivityStatsResponse extends Message<GetLaunchActivityStatsResponse> {
    /**
     * One entry per window, always all five, in enum order.
     *
     * @generated from field: repeated data.v2.LaunchActivityStatsWindow windows = 1;
     */
    windows: LaunchActivityStatsWindow[];
    constructor(data?: PartialMessage<GetLaunchActivityStatsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchActivityStatsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchActivityStatsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchActivityStatsResponse;
    static equals(a: GetLaunchActivityStatsResponse | PlainMessage<GetLaunchActivityStatsResponse> | undefined, b: GetLaunchActivityStatsResponse | PlainMessage<GetLaunchActivityStatsResponse> | undefined): boolean;
}
/**
 * Trade activity over one trailing window, split by direction from the
 * trader's perspective. Unique counts are per trading wallet (the tx
 * from-address, not the router) and are HLL-approximate (<1% error). USD
 * volume values each swap at its ASOF token price; swaps with no known
 * price contribute to counts but not to USD volume.
 *
 * @generated from message data.v2.LaunchActivityStatsWindow
 */
export declare class LaunchActivityStatsWindow extends Message<LaunchActivityStatsWindow> {
    /**
     * @generated from field: data.v2.ActivityStatsWindow window = 1;
     */
    window: ActivityStatsWindow;
    /**
     * @generated from field: int32 buy_count = 2;
     */
    buyCount: number;
    /**
     * @generated from field: int32 sell_count = 3;
     */
    sellCount: number;
    /**
     * @generated from field: double buy_volume_usd = 4;
     */
    buyVolumeUsd: number;
    /**
     * @generated from field: double sell_volume_usd = 5;
     */
    sellVolumeUsd: number;
    /**
     * @generated from field: int32 unique_buyers = 6;
     */
    uniqueBuyers: number;
    /**
     * @generated from field: int32 unique_sellers = 7;
     */
    uniqueSellers: number;
    constructor(data?: PartialMessage<LaunchActivityStatsWindow>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchActivityStatsWindow";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchActivityStatsWindow;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchActivityStatsWindow;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchActivityStatsWindow;
    static equals(a: LaunchActivityStatsWindow | PlainMessage<LaunchActivityStatsWindow> | undefined, b: LaunchActivityStatsWindow | PlainMessage<LaunchActivityStatsWindow> | undefined): boolean;
}
/**
 * Per-wallet CCA auction claim aggregates for a launch token (LP-1296):
 * the cost-basis seed for Top Traders PnL. Serves CCA launches ONLY —
 * tokens launched via a Uniswap CCA auction; bonding-curve launches and
 * non-factory tokens are a not_found error (curve tokens have no claims:
 * their cost basis is the swap history alone). EVM-only.
 *
 * @generated from message data.v2.GetLaunchClaimsRequest
 */
export declare class GetLaunchClaimsRequest extends Message<GetLaunchClaimsRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    constructor(data?: PartialMessage<GetLaunchClaimsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchClaimsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchClaimsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchClaimsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchClaimsRequest;
    static equals(a: GetLaunchClaimsRequest | PlainMessage<GetLaunchClaimsRequest> | undefined, b: GetLaunchClaimsRequest | PlainMessage<GetLaunchClaimsRequest> | undefined): boolean;
}
/**
 * One wallet's aggregate acquisition through the auction, folded across all
 * of the wallet's bids (multiple bids per wallet are summed). Sourced from
 * indexed bid terminal events, so bids exited post-auction with a partial
 * fill are included — economically those tokens are auction acquisitions
 * even when no explicit claim transaction exists.
 *
 * The client derives the wallet's TRUE unit cost as
 * currency_spent / tokens_received. In a time-weighted CCA, bidders do NOT
 * all pay the final clearing price (early accumulation is cheaper), so
 * never seed cost basis from the auction-level clearing price when these
 * rows are available.
 *
 * @generated from message data.v2.LaunchClaim
 */
export declare class LaunchClaim extends Message<LaunchClaim> {
    /**
     * EIP-55 checksummed wallet address.
     *
     * @generated from field: string wallet = 1;
     */
    wallet: string;
    /**
     * Total launch tokens the wallet received from the auction, raw uint256
     * decimal string in token base units.
     *
     * @generated from field: string tokens_received = 2;
     */
    tokensReceived: string;
    /**
     * What the wallet actually spent, NET of refunds, as a raw uint256
     * decimal string in the auction's raise-currency base units (see
     * GetAuction for the currency): sum over the wallet's terminal bids of
     * (bid amount - exit refund).
     *
     * @generated from field: string currency_spent = 3;
     */
    currencySpent: string;
    /**
     * Number of the wallet's bids folded into this row (bids claimed or
     * exited with a nonzero fill).
     *
     * @generated from field: int32 claim_count = 4;
     */
    claimCount: number;
    /**
     * True when every bid the wallet placed on this auction has reached a
     * terminal state (claimed or exited); false while any bid is still
     * pending, i.e. tokens_received may still grow.
     *
     * @generated from field: bool fully_claimed = 5;
     */
    fullyClaimed: boolean;
    constructor(data?: PartialMessage<LaunchClaim>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchClaim";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchClaim;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchClaim;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchClaim;
    static equals(a: LaunchClaim | PlainMessage<LaunchClaim> | undefined, b: LaunchClaim | PlainMessage<LaunchClaim> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetLaunchClaimsResponse
 */
export declare class GetLaunchClaimsResponse extends Message<GetLaunchClaimsResponse> {
    /**
     * One row per claiming wallet, ordered tokens_received DESC (wallet ASC
     * tiebreak); empty when the auction has no terminal bids yet. Servers
     * cap the list to the top wallets under that ordering (currently 1000),
     * so the rows are the complete claimer set for any auction below the
     * cap; total_claimed and unique_claimers ALWAYS cover every claimer,
     * not just the returned rows.
     *
     * @generated from field: repeated data.v2.LaunchClaim claims = 1;
     */
    claims: LaunchClaim[];
    /**
     * Total launch tokens received across ALL claiming wallets (the full
     * population, even when claims is capped), raw uint256 decimal string
     * in token base units.
     *
     * @generated from field: string total_claimed = 2;
     */
    totalClaimed: string;
    /**
     * Number of distinct claiming wallets in the full population (may
     * exceed the number of rows in claims when the cap applies).
     *
     * @generated from field: int32 unique_claimers = 3;
     */
    uniqueClaimers: number;
    constructor(data?: PartialMessage<GetLaunchClaimsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchClaimsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchClaimsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchClaimsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchClaimsResponse;
    static equals(a: GetLaunchClaimsResponse | PlainMessage<GetLaunchClaimsResponse> | undefined, b: GetLaunchClaimsResponse | PlainMessage<GetLaunchClaimsResponse> | undefined): boolean;
}
/**
 * Creator-fee metrics for ONE Instant Launch token (LP-1332): the numbers
 * behind the portfolio Fees panel — fees accumulated for the creator,
 * claimable now, claimed to date, and auto-compounded back into the launch
 * position. Computed from indexed FeeSplitter FeesCollected and claim
 * recipient Claimed events with the launcher SDK's fee math, so the amounts
 * match the on-chain per-position attribution exactly (per-collect
 * multiply-before-divide flooring). Instant Launch tokens only: a token with
 * neither indexed fee events nor a resolvable launch (CCA launches,
 * non-factory tokens) is a not_found error. EVM-only.
 *
 * @generated from message data.v2.GetLaunchCreatorFeesRequest
 */
export declare class GetLaunchCreatorFeesRequest extends Message<GetLaunchCreatorFeesRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * The launched token's address (any casing).
     *
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    constructor(data?: PartialMessage<GetLaunchCreatorFeesRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchCreatorFeesRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesRequest;
    static equals(a: GetLaunchCreatorFeesRequest | PlainMessage<GetLaunchCreatorFeesRequest> | undefined, b: GetLaunchCreatorFeesRequest | PlainMessage<GetLaunchCreatorFeesRequest> | undefined): boolean;
}
/**
 * A native + launch-token amount pair, raw uint256 base units as decimal
 * strings: native_amount in wei (the launch pool's currency0),
 * token_amount in launch-token base units (currency1).
 *
 * @generated from message data.v2.LaunchCreatorFeeAmounts
 */
export declare class LaunchCreatorFeeAmounts extends Message<LaunchCreatorFeeAmounts> {
    /**
     * @generated from field: string native_amount = 1;
     */
    nativeAmount: string;
    /**
     * @generated from field: string token_amount = 2;
     */
    tokenAmount: string;
    constructor(data?: PartialMessage<LaunchCreatorFeeAmounts>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.LaunchCreatorFeeAmounts";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchCreatorFeeAmounts;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchCreatorFeeAmounts;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchCreatorFeeAmounts;
    static equals(a: LaunchCreatorFeeAmounts | PlainMessage<LaunchCreatorFeeAmounts> | undefined, b: LaunchCreatorFeeAmounts | PlainMessage<LaunchCreatorFeeAmounts> | undefined): boolean;
}
/**
 * The creator's own fee position — the ONLY amounts that belong to the
 * creator. Grouped in their own message so no caller can read a
 * protocol-custodied figure as part of the creator's total (see
 * auto_compounded below). All three are POSITION-lifetime: the vault NFT is
 * transferable, so they span every holder the position has had, not just the
 * current beneficiary. When the launch settled into SEVERAL LP positions (a
 * CCA/crowd-launch migration can mint more than one), all three aggregate
 * across every position — claimable is clamped per position before summing.
 *
 * @generated from message data.v2.CreatorFeeTotals
 */
export declare class CreatorFeeTotals extends Message<CreatorFeeTotals> {
    /**
     * The creator's share of all fees collected so far, floored per collect
     * exactly as the FeeSplitter forwards it — equal to the beneficiary
     * vault's cumulative on-chain attribution for the position.
     *
     * @generated from field: data.v2.LaunchCreatorFeeAmounts accumulated = 1;
     */
    accumulated?: LaunchCreatorFeeAmounts;
    /**
     * Paid out by the beneficiary vault to date — across all holders of the
     * transferable vault NFT (past holders' payouts are included).
     *
     * @generated from field: data.v2.LaunchCreatorFeeAmounts claimed = 2;
     */
    claimed?: LaunchCreatorFeeAmounts;
    /**
     * accumulated − claimed, floored at zero per side: what a vault claim
     * would pay right now (donations aside). Settles per-tokenId (the launch
     * LP position), NOT per-beneficiary — whoever holds the vault NFT at
     * claim time receives it.
     *
     * SETTLED-ONLY. Fees reach the beneficiary vault only when somebody calls
     * the permissionless FeeSplitter.collectFees(tokenIds), so this
     * UNDERSTATES the creator's earnings by everything the launch's Uniswap
     * v4 position has accrued since the last collect. Its meaning is
     * unchanged and will not change — see claimable_including_uncollected for
     * the figure to show a creator as "your earnings".
     *
     * @generated from field: data.v2.LaunchCreatorFeeAmounts claimable = 3;
     */
    claimable?: LaunchCreatorFeeAmounts;
    /**
     * `claimable` PLUS the creator's share of the fees still sitting
     * uncollected in the launch's Uniswap v4 position: what a
     * collectFees + claim sent right now would actually pay out.
     *
     * Computed by simulating FeeSplitter.collectFees(tokenIds) against the
     * chain head (eth_simulateV1) and reading the beneficiary vault's
     * amounts(tokenId) inside that same simulated state — no transaction is
     * sent and no state is written. Aggregated across every LP position of
     * the launch, exactly like `claimable`.
     *
     * Always populated: when the simulation cannot run (RPC error, or a
     * collect that reverts) this degrades to the vault's settled on-chain
     * balance, and finally to `claimable` itself, so a creator sees a
     * slightly stale number rather than an error.
     *
     * Read claimable_includes_uncollected before deciding how to treat this.
     *
     * WHEN IT IS TRUE this is the post-collect figure: normally >=
     * `claimable`, but it comes from chain state rather than indexed events,
     * so it can also come in LOWER when the indexer is behind a claim that
     * already landed. It is the authoritative figure in that case — do not
     * max() the two.
     *
     * WHEN IT IS FALSE the collect could not be simulated and this degraded
     * to a settled balance (or to `claimable` itself). It then carries no
     * uncollected remainder and can only UNDERSTATE the creator's earnings,
     * so max() with `claimable` is the right defence and the number must not
     * be labelled "your earnings".
     *
     * @generated from field: data.v2.LaunchCreatorFeeAmounts claimable_including_uncollected = 4;
     */
    claimableIncludingUncollected?: LaunchCreatorFeeAmounts;
    constructor(data?: PartialMessage<CreatorFeeTotals>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.CreatorFeeTotals";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreatorFeeTotals;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreatorFeeTotals;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreatorFeeTotals;
    static equals(a: CreatorFeeTotals | PlainMessage<CreatorFeeTotals> | undefined, b: CreatorFeeTotals | PlainMessage<CreatorFeeTotals> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetLaunchCreatorFeesResponse
 */
export declare class GetLaunchCreatorFeesResponse extends Message<GetLaunchCreatorFeesResponse> {
    /**
     * False for launches created through the fees-off strategy variant: every
     * collected fee auto-compounds, so `creator` is all zeros and
     * fee_beneficiary is never set. Distinguish this from "earned nothing
     * yet" when rendering — they are different states.
     *
     * @generated from field: bool creator_fees_enabled = 1;
     */
    creatorFeesEnabled: boolean;
    /**
     * Everything the creator has earned, been paid, and can still claim.
     *
     * @generated from field: data.v2.CreatorFeeTotals creator = 2;
     */
    creator?: CreatorFeeTotals;
    /**
     * NOT the creator's money, and NEVER additive with `creator`. Released to
     * the CompoundingClaimRecipient, whose claims are enforced on-chain to
     * increase the launch position's own liquidity in the same transaction, so
     * it is protocol-custodied and the creator can never claim it.
     *
     * It is the COMPLEMENTARY leg of the very same collects that produced
     * creator.accumulated — on the chain-4663 fees-on splitter the split is
     * 40% creator / 60% compounded, verified exact against on-chain Claimed
     * payouts. So creator.accumulated + auto_compounded is the position's whole
     * fee revenue, i.e. 2.5x what the creator actually earned. Render it as
     * pool growth if at all, never inside a creator earnings total.
     *
     * @generated from field: data.v2.LaunchCreatorFeeAmounts auto_compounded = 3;
     */
    autoCompounded?: LaunchCreatorFeeAmounts;
    /**
     * The launch's v4 LP position id (uint256 decimal string) — the key the
     * beneficiary vault settles claims on, so a client building a claim
     * transaction needs it (it is not derivable client-side). Unset when the
     * launch has neither a collect nor a vault mint yet, in which case there
     * is nothing to claim. When a CCA/crowd-launch migration minted several
     * positions, this is the EARLIEST-collecting one while the amounts
     * aggregate all of them — a claim on it pays that position's share, not
     * the whole claimable.
     *
     * @generated from field: optional string position_token_id = 4;
     */
    positionTokenId?: string;
    /**
     * Current beneficiary: the CREATOR'S WALLET (EIP-55) — the holder of the
     * beneficiary ERC721 for the position_token_id position, who may claim
     * and re-point the fee stream by transferring the NFT. This is NOT the
     * vault contract; that is beneficiary_vault. Unset when creator fees are
     * off, while vault ingestion lags (for a CCA launch: until the creator's
     * graffiti claim mints the vault NFT), or transiently mid re-registration
     * (NFT burned).
     *
     * @generated from field: optional string fee_beneficiary = 5;
     */
    feeBeneficiary?: string;
    /**
     * Freshness marker: unix seconds of the newest ingested event this
     * response was computed from, across every feed read (fee collections,
     * vault transfers, claims). 0 when no event has been ingested yet. A
     * stalled sink freezes this value while on-chain fees keep accruing, so
     * clients gating actions on creator.claimable (e.g. enabling a Claim
     * button) should treat a stale marker as stale data.
     *
     * @generated from field: int64 as_of_timestamp = 6;
     */
    asOfTimestamp: bigint;
    /**
     * The launch's own FeeSplitter (EIP-55) — the contract to send the
     * permissionless collectFees([position_token_id]) to, which sweeps the v4
     * position's fees into the beneficiary vault and is what makes
     * creator.claimable_including_uncollected actually claimable.
     *
     * PER LAUNCH, NOT A CHAIN CONSTANT: several FeeSplitter generations are
     * deployed and live on the same chain (Robinhood Chain runs two), and a
     * launch's fees only ever flow through the one its strategy was wired to.
     * Clients MUST call the address in this field — a hardcoded per-chain
     * splitter silently targets the wrong generation.
     *
     * Set for every launch this endpoint serves: where the indexed launch row
     * carries no position recipient (a crowd launch, which never gets a row,
     * or a row predating the column) the server falls back to the resolved
     * strategy's own immutable FeeSplitter. Clients no longer need to gate the
     * displayed figure down to the settled balance on an unset splitter.
     *
     * @generated from field: optional string fee_splitter = 7;
     */
    feeSplitter?: string;
    /**
     * The launch's own UERC20BeneficiaryVault (EIP-55) — the contract that
     * custodies the creator's share and that claim(position_token_id, 0, 0)
     * is sent to. Per launch for the same reason fee_splitter is.
     *
     * Read from fee_splitter's OWN on-chain splits, so this vault and that
     * splitter are a matched pair by construction rather than two independent
     * lookups that can name contracts from different generations. Falls back
     * to the indexed beneficiary NFT when that read is unavailable. Unset only
     * when creator fees are off (no vault exists) or neither source has one
     * yet.
     *
     * @generated from field: optional string beneficiary_vault = 8;
     */
    beneficiaryVault?: string;
    /**
     * False when the collect could not be simulated and
     * creator.claimable_including_uncollected is a settled balance (or the
     * event-derived claimable) rather than the post-collect figure. Clients
     * should not present it as "your earnings" when false.
     *
     * as_of_timestamp does NOT cover for this: that marker is computed from
     * indexed events only, so it reads perfectly fresh during an RPC outage
     * while the amount beside it has silently gone stale. This is the only
     * signal that distinguishes the two.
     *
     * `optional` is load-bearing. A bare proto3 bool reads as false when
     * absent, so a client built against <= 0.0.180 would see "degraded" on
     * every response; the presence bit separates "this server does not send
     * it" from "this response is degraded".
     *
     * @generated from field: optional bool claimable_includes_uncollected = 9;
     */
    claimableIncludesUncollected?: boolean;
    constructor(data?: PartialMessage<GetLaunchCreatorFeesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLaunchCreatorFeesResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesResponse;
    static equals(a: GetLaunchCreatorFeesResponse | PlainMessage<GetLaunchCreatorFeesResponse> | undefined, b: GetLaunchCreatorFeesResponse | PlainMessage<GetLaunchCreatorFeesResponse> | undefined): boolean;
}
/**
 * Server-computed Top Traders leaderboard for a launch token: the token's
 * FULL swap history (no page cap) folded into per-wallet cost-basis PnL,
 * with CCA auction claims counted as buy-side acquisitions at what each
 * wallet actually spent (the GetLaunchClaims aggregates). Replaces the
 * client-side capped GetTokenTrades walk, whose 1,500-trade window
 * fabricated zero-basis top rows for pre-window buyers. Non-launch tokens
 * (no CCA auction) are served from their trade history alone — never an
 * error; a token with no swaps and no claims serves an empty list. EVM-only.
 *
 * @generated from message data.v2.GetTokenTopTradersRequest
 */
export declare class GetTokenTopTradersRequest extends Message<GetTokenTopTradersRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    /**
     * Rows to return, best-ranked first. 0/unset defaults to 100; servers cap
     * the limit (currently 1000).
     *
     * @generated from field: optional int32 limit = 3;
     */
    limit?: number;
    /**
     * Per-wallet lookup (LP-1558): serve only this wallet's row, covering ANY
     * wallet in the token's history — the full cached ranking first, and past
     * its cap the row comes from the same uncapped fold the ranking is cut
     * from (server-cached per wallet). Unset/empty serves the ranked
     * leaderboard as before. A wallet with no row (never traded or claimed
     * the token) serves an empty list, never an error.
     *
     * @generated from field: optional string wallet_address = 4;
     */
    walletAddress?: string;
    constructor(data?: PartialMessage<GetTokenTopTradersRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenTopTradersRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTopTradersRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTopTradersRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTopTradersRequest;
    static equals(a: GetTokenTopTradersRequest | PlainMessage<GetTokenTopTradersRequest> | undefined, b: GetTokenTopTradersRequest | PlainMessage<GetTokenTopTradersRequest> | undefined): boolean;
}
/**
 * One wallet's aggregate position on the token, derived from a
 * moving-average cost-basis walk of its chronological trades: buys (and
 * claim seeds) add to the position's basis; each sell realizes
 * proceeds − average cost × amount AND consumes basis at the average cost,
 * so re-entering wallets are accounted correctly. Auction claims are seeded
 * before the trade walk as buys at the wallet's true auction cost, so
 * bidders never show zero buys. Tokens sold beyond tracked inventory
 * (transfers in) entered the wallet outside the swap tape — with the full
 * history and explicit claims in hand, an unexplained inflow is a transfer,
 * not a hidden buy — so the wallet's basis is UNKNOWN (not $0) and the row
 * flags transferred_in.
 *
 * UNKNOWN-BASIS ROWS: when the server cannot compute a wallet's basis — the
 * wallet transferred tokens in (transferred_in), its auction spend was not
 * USD-convertible, or its attributed inventory contradicts its observed
 * balance — basis_unknown is true and the four basis-derived
 * money fields (cost_basis_usd, avg_cost_usd, realized_pnl_usd,
 * unrealized_pnl_usd) are served as 0 and MUST be read as "unknown", never
 * as a real $0.00. Such wallets rank strictly after every computable-PnL
 * row — including loss-makers: an unknown 0 never outranks a real figure —
 * so a transfer-in whale's raw proceeds can never crowd real traders out
 * of the request limit. Observed figures (buys/sells/proceeds/tokens) are
 * always set and always truthful. unrealized_pnl_unknown additionally
 * covers the basis-known wallet whose unrealized leg alone is uncomputable
 * (token has no spot price). (These are flags rather than proto3 `optional`
 * on the money fields because changing an existing field's presence is a
 * breaking gencode change for published clients.)
 *
 * @generated from message data.v2.TokenTopTrader
 */
export declare class TokenTopTrader extends Message<TokenTopTrader> {
    /**
     * EIP-55 checksummed trading wallet (the tx from-address, not the router).
     *
     * @generated from field: string wallet_address = 1;
     */
    walletAddress: string;
    /**
     * Buy-side figures INCLUDE auction acquisitions: claims add one buy per
     * terminal bid, their token amount, and their USD spend.
     *
     * @generated from field: int32 buy_count = 2;
     */
    buyCount: number;
    /**
     * @generated from field: int32 sell_count = 3;
     */
    sellCount: number;
    /**
     * @generated from field: double bought_usd = 4;
     */
    boughtUsd: number;
    /**
     * @generated from field: double sold_usd = 5;
     */
    soldUsd: number;
    /**
     * Token amounts are whole (decimal-adjusted) tokens.
     *
     * @generated from field: double bought_tokens = 6;
     */
    boughtTokens: number;
    /**
     * @generated from field: double sold_tokens = 7;
     */
    soldTokens: number;
    /**
     * Tokens still held. For launch tokens this is the wallet's OBSERVED net
     * balance — the same sum over transfer logs GetLaunchHolders serves, so
     * the two agree and Σ over wallets cannot exceed supply. Tokens outside
     * that feed fall back to the swap walk (acquired minus sold, floored at
     * 0), an attribution that can overstate a wallet signing swaps it does
     * not receive (relayers, bundlers, smart-account signers).
     *
     * @generated from field: double remaining_tokens = 8;
     */
    remainingTokens: number;
    /**
     * USD cost basis of the REMAINING position: grows with buys/claims,
     * shrinks by average cost × amount on every sell. Meaningless (served 0)
     * when basis_unknown — read that as "unknown", not a zero basis.
     *
     * @generated from field: double cost_basis_usd = 9;
     */
    costBasisUsd: number;
    /**
     * cost_basis_usd ÷ the TRACKED quantity the basis was accumulated over
     * (bought + claimed − sold), which is not necessarily remaining_tokens; 0
     * when nothing is tracked. Meaningless (served 0) when basis_unknown.
     *
     * @generated from field: double avg_cost_usd = 10;
     */
    avgCostUsd: number;
    /**
     * Meaningless (served 0) when basis_unknown — proceeds booked against an
     * unknowable basis are not a PnL; such rows rank as realized 0.
     *
     * @generated from field: double realized_pnl_usd = 11;
     */
    realizedPnlUsd: number;
    /**
     * USD the wallet spent in the launch auction (net of exit refunds),
     * converted at the auction currency's USD rate. 0 when the wallet has no
     * claims (always 0 for non-CCA tokens).
     *
     * @generated from field: double auction_spent_usd = 12;
     */
    auctionSpentUsd: number;
    /**
     * True when any of the wallet's auction bids reached a terminal state
     * (claimed, or exited with a nonzero fill).
     *
     * @generated from field: bool has_claims = 13;
     */
    hasClaims: boolean;
    /**
     * Mark-to-market PnL of the remaining position at the token's latest
     * known price: remaining_tokens × spot − cost_basis_usd. The documented
     * ranking tiebreak, served so clients can render it. Meaningless (served
     * 0) when unrealized_pnl_unknown — basis unknown, or no known spot price.
     *
     * @generated from field: double unrealized_pnl_usd = 14;
     */
    unrealizedPnlUsd: number;
    /**
     * True when the wallet sold beyond its tracked inventory at least once —
     * the excess entered the wallet outside the swap tape (a transfer in),
     * so its basis is unknown. Always implies basis_unknown.
     *
     * @generated from field: bool transferred_in = 15;
     */
    transferredIn: boolean;
    /**
     * True when the wallet's basis could not be computed — it transferred
     * tokens in (transferred_in), its auction spend was not USD-convertible,
     * or its attributed inventory contradicts its observed balance (the
     * acquisitions were booked to the wrong address, so the basis they
     * produced is not this wallet's). Clients should render the four
     * basis-derived money
     * fields as unknown ("–"), not $0.00; the row ranks after every
     * computable-PnL row (see message doc). Implies unrealized_pnl_unknown.
     *
     * @generated from field: bool basis_unknown = 16;
     */
    basisUnknown: boolean;
    /**
     * True when unrealized_pnl_usd alone is not computable: basis_unknown, or
     * the token has no known spot price (a missing spot must not read as a
     * total loss). Served 0 then — render unknown ("–"), not $0.00. The other
     * money fields stay real when basis_unknown is false.
     *
     * @generated from field: bool unrealized_pnl_unknown = 17;
     */
    unrealizedPnlUnknown: boolean;
    constructor(data?: PartialMessage<TokenTopTrader>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenTopTrader";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenTopTrader;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenTopTrader;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenTopTrader;
    static equals(a: TokenTopTrader | PlainMessage<TokenTopTrader> | undefined, b: TokenTopTrader | PlainMessage<TokenTopTrader> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenTopTradersResponse
 */
export declare class GetTokenTopTradersResponse extends Message<GetTokenTopTradersResponse> {
    /**
     * Ranked realized PnL desc, unrealized PnL desc as the tiebreak (orders
     * never-sold claimers sensibly — all realized 0), wallet address asc as
     * the final key, capped at the request limit. Unknown-basis rows
     * (transferred_in, or an inconvertible auction spend) partition strictly
     * after every computable-PnL row, including losses — so they cannot
     * consume top slots on raw proceeds or displace losing traders. Only
     * wallets with at least one trade or claim appear.
     *
     * @generated from field: repeated data.v2.TokenTopTrader traders = 1;
     */
    traders: TokenTopTrader[];
    constructor(data?: PartialMessage<GetTokenTopTradersResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenTopTradersResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenTopTradersResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenTopTradersResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenTopTradersResponse;
    static equals(a: GetTokenTopTradersResponse | PlainMessage<GetTokenTopTradersResponse> | undefined, b: GetTokenTopTradersResponse | PlainMessage<GetTokenTopTradersResponse> | undefined): boolean;
}
/**
 * Anti-vamp create-flow check (LP-1311): has a token with this name + ticker
 * combination launched on the chain within the trailing 8 hours? Matching is
 * case-insensitive on both fields and covers every Uniswap token-factory
 * launch (Crowd Launch and Instant Launch, created through our flow or
 * directly against the contracts). The FE renders a soft warning ("this
 * name + ticker launched X hours ago — here's that token") linking the
 * original's token page; nothing is blocked server-side. Backed by the same
 * table and predicate the indexer uses to vamp-flag copycat launches out of
 * ListLaunches, so the warning and the listing filter cannot drift. EVM-only.
 *
 * @generated from message data.v2.CheckLaunchNameTickerRequest
 */
export declare class CheckLaunchNameTickerRequest extends Message<CheckLaunchNameTickerRequest> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * Token name as entered in the create form (compared case-insensitively).
     *
     * @generated from field: string name = 2;
     */
    name: string;
    /**
     * Token ticker/symbol as entered in the create form (compared
     * case-insensitively).
     *
     * @generated from field: string symbol = 3;
     */
    symbol: string;
    constructor(data?: PartialMessage<CheckLaunchNameTickerRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.CheckLaunchNameTickerRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CheckLaunchNameTickerRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerRequest;
    static equals(a: CheckLaunchNameTickerRequest | PlainMessage<CheckLaunchNameTickerRequest> | undefined, b: CheckLaunchNameTickerRequest | PlainMessage<CheckLaunchNameTickerRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.CheckLaunchNameTickerResponse
 */
export declare class CheckLaunchNameTickerResponse extends Message<CheckLaunchNameTickerResponse> {
    /**
     * True when a matching token launched within the trailing 8h window —
     * launching this name + ticker now would be vamp-flagged at ingest.
     *
     * @generated from field: bool recently_launched = 1;
     */
    recentlyLaunched: boolean;
    /**
     * The launch the warning should link to. Set iff recently_launched. When
     * several launches match in the window (chained copycats), this is the
     * earliest match that is not itself vamp-flagged, falling back to the
     * earliest match.
     *
     * @generated from field: data.v2.RecentlyLaunchedToken original_token = 2;
     */
    originalToken?: RecentlyLaunchedToken;
    constructor(data?: PartialMessage<CheckLaunchNameTickerResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.CheckLaunchNameTickerResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CheckLaunchNameTickerResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CheckLaunchNameTickerResponse;
    static equals(a: CheckLaunchNameTickerResponse | PlainMessage<CheckLaunchNameTickerResponse> | undefined, b: CheckLaunchNameTickerResponse | PlainMessage<CheckLaunchNameTickerResponse> | undefined): boolean;
}
/**
 * The already-launched token a CheckLaunchNameTicker warning points at.
 *
 * @generated from message data.v2.RecentlyLaunchedToken
 */
export declare class RecentlyLaunchedToken extends Message<RecentlyLaunchedToken> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * EIP-55 checksummed token address; with chain_id, enough to build the
     * token-page link.
     *
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    /**
     * Stored name/symbol casing (the launched token's on-chain metadata).
     *
     * @generated from field: string name = 3;
     */
    name: string;
    /**
     * @generated from field: string symbol = 4;
     */
    symbol: string;
    /**
     * Unix seconds of the token's launch — the "launched X hours ago" the
     * warning renders.
     *
     * @generated from field: int64 launched_at = 5;
     */
    launchedAt: bigint;
    constructor(data?: PartialMessage<RecentlyLaunchedToken>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.RecentlyLaunchedToken";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RecentlyLaunchedToken;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RecentlyLaunchedToken;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RecentlyLaunchedToken;
    static equals(a: RecentlyLaunchedToken | PlainMessage<RecentlyLaunchedToken> | undefined, b: RecentlyLaunchedToken | PlainMessage<RecentlyLaunchedToken> | undefined): boolean;
}
/**
 * Total USD liquidity per token — the sum of the FULL (two-sided) TVL of every
 * v2/v3/v4 pool the token sits in, which is the figure aggregators publish as a
 * token's "liquidity". Batched on purpose: callers rendering a liquidity column
 * must send the whole visible token set in one request rather than one request
 * per row.
 *
 * @generated from message data.v2.GetLiquidityForTokensRequest
 */
export declare class GetLiquidityForTokensRequest extends Message<GetLiquidityForTokensRequest> {
    /**
     * max 100
     *
     * @generated from field: repeated data.v2.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    constructor(data?: PartialMessage<GetLiquidityForTokensRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLiquidityForTokensRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLiquidityForTokensRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLiquidityForTokensRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLiquidityForTokensRequest;
    static equals(a: GetLiquidityForTokensRequest | PlainMessage<GetLiquidityForTokensRequest> | undefined, b: GetLiquidityForTokensRequest | PlainMessage<GetLiquidityForTokensRequest> | undefined): boolean;
}
/**
 * Best-effort response: one entry per requested token whose liquidity is known.
 * A token with no pools, or whose pools have no computed TVL yet, is OMITTED
 * rather than returned as 0 — so a caller can fall back to its own figure
 * instead of rendering a wrong zero. Match entries back to the request by
 * (chain_id, address).
 *
 * @generated from message data.v2.GetLiquidityForTokensResponse
 */
export declare class GetLiquidityForTokensResponse extends Message<GetLiquidityForTokensResponse> {
    /**
     * @generated from field: repeated data.v2.TokenLiquidity liquidity = 1;
     */
    liquidity: TokenLiquidity[];
    constructor(data?: PartialMessage<GetLiquidityForTokensResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetLiquidityForTokensResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLiquidityForTokensResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLiquidityForTokensResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLiquidityForTokensResponse;
    static equals(a: GetLiquidityForTokensResponse | PlainMessage<GetLiquidityForTokensResponse> | undefined, b: GetLiquidityForTokensResponse | PlainMessage<GetLiquidityForTokensResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.TokenLiquidity
 */
export declare class TokenLiquidity extends Message<TokenLiquidity> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * EIP-55 checksummed token address, echoing the requested token.
     *
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * Summed pool TVL in USD. Always > 0 — see the omission rule above.
     *
     * @generated from field: double liquidity_usd = 3;
     */
    liquidityUsd: number;
    constructor(data?: PartialMessage<TokenLiquidity>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TokenLiquidity";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenLiquidity;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenLiquidity;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenLiquidity;
    static equals(a: TokenLiquidity | PlainMessage<TokenLiquidity> | undefined, b: TokenLiquidity | PlainMessage<TokenLiquidity> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListTokensRequest
 */
export declare class ListTokensRequest extends Message<ListTokensRequest> {
    /**
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * @generated from field: optional data.v2.TokensSort sort = 2;
     */
    sort?: TokensSort;
    /**
     * @generated from field: optional data.v2.TokenListFilter filter = 3;
     */
    filter?: TokenListFilter;
    /**
     * @generated from field: optional data.v2.PageRequest page = 4;
     */
    page?: PageRequest;
    /**
     * Sparkline window. Required — UNSPECIFIED or unknown values are rejected.
     * MAX serves the DAY series.
     *
     * @generated from field: data.v2.HistoryDuration sparkline_duration = 5;
     */
    sparklineDuration: HistoryDuration;
    /**
     * External-consumer request: internally-sourced fields are omitted and
     * the Solana feed is not merged (see GetTokenRequest.external); filtering
     * semantics are unchanged.
     *
     * @generated from field: bool external = 6;
     */
    external: boolean;
    constructor(data?: PartialMessage<ListTokensRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTokensRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTokensRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTokensRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTokensRequest;
    static equals(a: ListTokensRequest | PlainMessage<ListTokensRequest> | undefined, b: ListTokensRequest | PlainMessage<ListTokensRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListTokensResponse
 */
export declare class ListTokensResponse extends Message<ListTokensResponse> {
    /**
     * @generated from field: repeated data.v2.RankedMultichainToken multichain_tokens = 1;
     */
    multichainTokens: RankedMultichainToken[];
    /**
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListTokensResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTokensResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTokensResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTokensResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTokensResponse;
    static equals(a: ListTokensResponse | PlainMessage<ListTokensResponse> | undefined, b: ListTokensResponse | PlainMessage<ListTokensResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListCategoriesRequest
 */
export declare class ListCategoriesRequest extends Message<ListCategoriesRequest> {
    /**
     * Chains to scope the aggregate stats and top_tokens to. Must be non-empty.
     *
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    constructor(data?: PartialMessage<ListCategoriesRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListCategoriesRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCategoriesRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCategoriesRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCategoriesRequest;
    static equals(a: ListCategoriesRequest | PlainMessage<ListCategoriesRequest> | undefined, b: ListCategoriesRequest | PlainMessage<ListCategoriesRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListCategoriesResponse
 */
export declare class ListCategoriesResponse extends Message<ListCategoriesResponse> {
    /**
     * @generated from field: repeated data.v2.RankedCategory categories = 1;
     */
    categories: RankedCategory[];
    constructor(data?: PartialMessage<ListCategoriesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListCategoriesResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCategoriesResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCategoriesResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCategoriesResponse;
    static equals(a: ListCategoriesResponse | PlainMessage<ListCategoriesResponse> | undefined, b: ListCategoriesResponse | PlainMessage<ListCategoriesResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetCategoryRequest
 */
export declare class GetCategoryRequest extends Message<GetCategoryRequest> {
    /**
     * @generated from field: string category_id = 1;
     */
    categoryId: string;
    /**
     * Same semantics as ListCategoriesRequest.chain_ids.
     *
     * @generated from field: repeated uint32 chain_ids = 2;
     */
    chainIds: number[];
    /**
     * When false the response carries metadata/stats only (no series).
     *
     * @generated from field: bool include_charts = 3;
     */
    includeCharts: boolean;
    constructor(data?: PartialMessage<GetCategoryRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetCategoryRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCategoryRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCategoryRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCategoryRequest;
    static equals(a: GetCategoryRequest | PlainMessage<GetCategoryRequest> | undefined, b: GetCategoryRequest | PlainMessage<GetCategoryRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetCategoryResponse
 */
export declare class GetCategoryResponse extends Message<GetCategoryResponse> {
    /**
     * @generated from field: data.v2.RankedCategory category = 1;
     */
    category?: RankedCategory;
    /**
     * Aggregate member swap volume over time. Empty unless include_charts.
     *
     * @generated from field: repeated data.v2.TimeSeriesPoint volume_series = 2;
     */
    volumeSeries: TimeSeriesPoint[];
    /**
     * Aggregate member FDV over time. Empty unless include_charts.
     *
     * @generated from field: repeated data.v2.TimeSeriesPoint fdv_series = 3;
     */
    fdvSeries: TimeSeriesPoint[];
    constructor(data?: PartialMessage<GetCategoryResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetCategoryResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCategoryResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCategoryResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCategoryResponse;
    static equals(a: GetCategoryResponse | PlainMessage<GetCategoryResponse> | undefined, b: GetCategoryResponse | PlainMessage<GetCategoryResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListTokenGroupsRequest
 */
export declare class ListTokenGroupsRequest extends Message<ListTokenGroupsRequest> {
    /**
     * required, non-empty
     *
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * @generated from field: optional data.v2.TokensSort sort = 2;
     */
    sort?: TokensSort;
    /**
     * @generated from field: optional data.v2.TokenGroupListFilter filter = 3;
     */
    filter?: TokenGroupListFilter;
    /**
     * @generated from field: optional data.v2.PageRequest page = 4;
     */
    page?: PageRequest;
    /**
     * Required. UNSPECIFIED or unknown values are rejected.
     *
     * @generated from field: data.v2.HistoryDuration sparkline_duration = 5;
     */
    sparklineDuration: HistoryDuration;
    constructor(data?: PartialMessage<ListTokenGroupsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTokenGroupsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTokenGroupsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTokenGroupsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTokenGroupsRequest;
    static equals(a: ListTokenGroupsRequest | PlainMessage<ListTokenGroupsRequest> | undefined, b: ListTokenGroupsRequest | PlainMessage<ListTokenGroupsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListTokenGroupsResponse
 */
export declare class ListTokenGroupsResponse extends Message<ListTokenGroupsResponse> {
    /**
     * @generated from field: repeated data.v2.RankedTokenGroup token_groups = 1;
     */
    tokenGroups: RankedTokenGroup[];
    /**
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListTokenGroupsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTokenGroupsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTokenGroupsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTokenGroupsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTokenGroupsResponse;
    static equals(a: ListTokenGroupsResponse | PlainMessage<ListTokenGroupsResponse> | undefined, b: ListTokenGroupsResponse | PlainMessage<ListTokenGroupsResponse> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetTokenGroupRequest
 */
export declare class GetTokenGroupRequest extends Message<GetTokenGroupRequest> {
    /**
     * @generated from oneof data.v2.GetTokenGroupRequest.selector
     */
    selector: {
        /**
         * @generated from field: string group_id = 1;
         */
        value: string;
        case: "groupId";
    } | {
        /**
         * @generated from field: data.v2.TokenIdentifier member = 2;
         */
        value: TokenIdentifier;
        case: "member";
    } | {
        case: undefined;
        value?: undefined;
    };
    /**
     * required, non-empty
     *
     * @generated from field: repeated uint32 chain_ids = 3;
     */
    chainIds: number[];
    /**
     * Optional by field presence: absent = no sparklines; present is validated
     * like ListTokens (UNSPECIFIED rejected).
     *
     * @generated from field: optional data.v2.HistoryDuration sparkline_duration = 4;
     */
    sparklineDuration?: HistoryDuration;
    constructor(data?: PartialMessage<GetTokenGroupRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenGroupRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenGroupRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenGroupRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenGroupRequest;
    static equals(a: GetTokenGroupRequest | PlainMessage<GetTokenGroupRequest> | undefined, b: GetTokenGroupRequest | PlainMessage<GetTokenGroupRequest> | undefined): boolean;
}
/**
 * The ranked group flattened; members sorted volume_1d DESC.
 *
 * @generated from message data.v2.GetTokenGroupResponse
 */
export declare class GetTokenGroupResponse extends Message<GetTokenGroupResponse> {
    /**
     * @generated from field: data.v2.TokenGroup group = 1;
     */
    group?: TokenGroup;
    /**
     * @generated from field: data.v2.TokenRankStats stats = 2;
     */
    stats?: TokenRankStats;
    /**
     * @generated from field: repeated data.v2.RankedMultichainToken members = 3;
     */
    members: RankedMultichainToken[];
    /**
     * @generated from field: double price_deviation_pct = 4;
     */
    priceDeviationPct: number;
    constructor(data?: PartialMessage<GetTokenGroupResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetTokenGroupResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetTokenGroupResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetTokenGroupResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetTokenGroupResponse;
    static equals(a: GetTokenGroupResponse | PlainMessage<GetTokenGroupResponse> | undefined, b: GetTokenGroupResponse | PlainMessage<GetTokenGroupResponse> | undefined): boolean;
}
/**
 * Ranked pool discovery: one RankedPool per pool, ordered by the requested
 * stat. Sorted by (sort.order_by, pool_id ASC) — pool_id is the tiebreaker so
 * keyset pagination stays stable when two pools share a sort value.
 *
 * @generated from message data.v2.ListPoolsRequest
 */
export declare class ListPoolsRequest extends Message<ListPoolsRequest> {
    /**
     * required
     *
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * @generated from field: optional data.v2.PoolsSort sort = 2;
     */
    sort?: PoolsSort;
    /**
     * @generated from field: optional data.v2.PoolListFilter filter = 3;
     */
    filter?: PoolListFilter;
    /**
     * page_size (default 100, max 100) + page_token
     *
     * @generated from field: optional data.v2.PageRequest page = 4;
     */
    page?: PageRequest;
    constructor(data?: PartialMessage<ListPoolsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListPoolsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListPoolsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListPoolsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListPoolsRequest;
    static equals(a: ListPoolsRequest | PlainMessage<ListPoolsRequest> | undefined, b: ListPoolsRequest | PlainMessage<ListPoolsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListPoolsResponse
 */
export declare class ListPoolsResponse extends Message<ListPoolsResponse> {
    /**
     * @generated from field: repeated data.v2.RankedPool pools = 1;
     */
    pools: RankedPool[];
    /**
     * next_page_token absent on last page
     *
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListPoolsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListPoolsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListPoolsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListPoolsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListPoolsResponse;
    static equals(a: ListPoolsResponse | PlainMessage<ListPoolsResponse> | undefined, b: ListPoolsResponse | PlainMessage<ListPoolsResponse> | undefined): boolean;
}
/**
 * Wallet NFT balances. EVM-only: a single owner_address covers all supported
 * EVM chains. Spam is returned and flagged by default; malicious is always dropped.
 *
 * @generated from message data.v2.GetWalletNftsRequest
 */
export declare class GetWalletNftsRequest extends Message<GetWalletNftsRequest> {
    /**
     * required, EVM address
     *
     * @generated from field: string owner_address = 1;
     */
    ownerAddress: string;
    /**
     * required; empty/missing returns 400
     *
     * @generated from field: repeated uint32 chain_ids = 2;
     */
    chainIds: number[];
    /**
     * default true (spam returned, flagged); false drops spam
     *
     * @generated from field: optional bool include_spam = 3;
     */
    includeSpam?: boolean;
    /**
     * page_size (default 100) + page_token
     *
     * @generated from field: optional data.v2.PageRequest page = 4;
     */
    page?: PageRequest;
    constructor(data?: PartialMessage<GetWalletNftsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetWalletNftsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetWalletNftsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetWalletNftsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetWalletNftsRequest;
    static equals(a: GetWalletNftsRequest | PlainMessage<GetWalletNftsRequest> | undefined, b: GetWalletNftsRequest | PlainMessage<GetWalletNftsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetWalletNftsResponse
 */
export declare class GetWalletNftsResponse extends Message<GetWalletNftsResponse> {
    /**
     * @generated from field: repeated data.v2.Nft nfts = 1;
     */
    nfts: Nft[];
    /**
     * next_page_token absent on last page
     *
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<GetWalletNftsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetWalletNftsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetWalletNftsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetWalletNftsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetWalletNftsResponse;
    static equals(a: GetWalletNftsResponse | PlainMessage<GetWalletNftsResponse> | undefined, b: GetWalletNftsResponse | PlainMessage<GetWalletNftsResponse> | undefined): boolean;
}
/**
 * Server-side filters applied before pagination.
 * Omitting token_scope returns the global feed (Explore page feed).
 *
 * @generated from message data.v2.TransactionListFilter
 */
export declare class TransactionListFilter extends Message<TransactionListFilter> {
    /**
     * empty = all (V2 + V3 + V4)
     *
     * @generated from field: repeated pools.v1.ProtocolVersion protocol_versions = 1;
     */
    protocolVersions: ProtocolVersion[];
    /**
     * empty = all (swap + add + remove)
     *
     * @generated from field: repeated data.v2.TransactionEventType event_types = 2;
     */
    eventTypes: TransactionEventType[];
    /**
     * default false (spam excluded)
     *
     * @generated from field: optional bool include_spam = 3;
     */
    includeSpam?: boolean;
    /**
     * @generated from oneof data.v2.TransactionListFilter.token_scope
     */
    tokenScope: {
        /**
         * pool address (V2/V3) or poolId bytes32 (V4); absent = global feed
         *
         * @generated from field: string pool_id = 4;
         */
        value: string;
        case: "poolId";
    } | {
        /**
         * @generated from field: string multichain_id = 5;
         */
        value: string;
        case: "multichainId";
    } | {
        /**
         * 1..100 tokens; feed includes txs touching ANY of them
         *
         * @generated from field: data.v2.TokenIdentifierList tokens_on_chain = 6;
         */
        value: TokenIdentifierList;
        case: "tokensOnChain";
    } | {
        case: undefined;
        value?: undefined;
    };
    constructor(data?: PartialMessage<TransactionListFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.TransactionListFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransactionListFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransactionListFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransactionListFilter;
    static equals(a: TransactionListFilter | PlainMessage<TransactionListFilter> | undefined, b: TransactionListFilter | PlainMessage<TransactionListFilter> | undefined): boolean;
}
/**
 * Global protocol transaction feed, newest first. Sorted by
 * (timestamp_ms DESC, chain_id ASC, global_sequence_number DESC); the opaque
 * page_token encodes all three so a next page resumes exactly.
 *
 * @generated from message data.v2.ListTransactionsRequest
 */
export declare class ListTransactionsRequest extends Message<ListTransactionsRequest> {
    /**
     * required
     *
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * @generated from field: optional data.v2.TransactionListFilter filter = 2;
     */
    filter?: TransactionListFilter;
    /**
     * page_size (default 100, max 100) + page_token
     *
     * @generated from field: optional data.v2.PageRequest page = 3;
     */
    page?: PageRequest;
    constructor(data?: PartialMessage<ListTransactionsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTransactionsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTransactionsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTransactionsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTransactionsRequest;
    static equals(a: ListTransactionsRequest | PlainMessage<ListTransactionsRequest> | undefined, b: ListTransactionsRequest | PlainMessage<ListTransactionsRequest> | undefined): boolean;
}
/**
 * @generated from message data.v2.ListTransactionsResponse
 */
export declare class ListTransactionsResponse extends Message<ListTransactionsResponse> {
    /**
     * @generated from field: repeated data.v2.UniswapTransaction transactions = 1;
     */
    transactions: UniswapTransaction[];
    /**
     * next_page_token absent on last page
     *
     * @generated from field: data.v2.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListTransactionsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ListTransactionsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTransactionsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTransactionsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTransactionsResponse;
    static equals(a: ListTransactionsResponse | PlainMessage<ListTransactionsResponse> | undefined, b: ListTransactionsResponse | PlainMessage<ListTransactionsResponse> | undefined): boolean;
}
/**
 * Protocol-level TVL and trailing-1D volume (the Explore page topline),
 * summed over the explore-eligible EVM pool set from the 15-minute
 * protocol-stats snapshots. Both filters are required and explicit: there
 * is no "all chains" default, so a client's idea of the chain set never
 * silently diverges from the server's as chains are added.
 *
 * @generated from message data.v2.GetProtocolStatsRequest
 */
export declare class GetProtocolStatsRequest extends Message<GetProtocolStatsRequest> {
    /**
     * required, non-empty
     *
     * @generated from field: repeated uint32 chain_ids = 1;
     */
    chainIds: number[];
    /**
     * required, non-empty; UNSPECIFIED rejected
     *
     * @generated from field: repeated pools.v1.ProtocolVersion protocol_versions = 2;
     */
    protocolVersions: ProtocolVersion[];
    constructor(data?: PartialMessage<GetProtocolStatsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetProtocolStatsRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetProtocolStatsRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetProtocolStatsRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetProtocolStatsRequest;
    static equals(a: GetProtocolStatsRequest | PlainMessage<GetProtocolStatsRequest> | undefined, b: GetProtocolStatsRequest | PlainMessage<GetProtocolStatsRequest> | undefined): boolean;
}
/**
 * USD-denominated, matching PoolRankStats / TokenRankStats on the same page.
 *
 * @generated from message data.v2.ProtocolStats
 */
export declare class ProtocolStats extends Message<ProtocolStats> {
    /**
     * @generated from field: double tvl = 1;
     */
    tvl: number;
    /**
     * @generated from field: double volume_1d = 2;
     */
    volume1d: number;
    /**
     * @generated from field: optional double tvl_change_1d = 3;
     */
    tvlChange1d?: number;
    /**
     * @generated from field: optional double volume_change_1d = 4;
     */
    volumeChange1d?: number;
    constructor(data?: PartialMessage<ProtocolStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ProtocolStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ProtocolStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ProtocolStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ProtocolStats;
    static equals(a: ProtocolStats | PlainMessage<ProtocolStats> | undefined, b: ProtocolStats | PlainMessage<ProtocolStats> | undefined): boolean;
}
/**
 * @generated from message data.v2.ProtocolVersionStats
 */
export declare class ProtocolVersionStats extends Message<ProtocolVersionStats> {
    /**
     * @generated from field: pools.v1.ProtocolVersion protocol_version = 1;
     */
    protocolVersion: ProtocolVersion;
    /**
     * @generated from field: data.v2.ProtocolStats stats = 2;
     */
    stats?: ProtocolStats;
    constructor(data?: PartialMessage<ProtocolVersionStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.ProtocolVersionStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ProtocolVersionStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ProtocolVersionStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ProtocolVersionStats;
    static equals(a: ProtocolVersionStats | PlainMessage<ProtocolVersionStats> | undefined, b: ProtocolVersionStats | PlainMessage<ProtocolVersionStats> | undefined): boolean;
}
/**
 * @generated from message data.v2.GetProtocolStatsResponse
 */
export declare class GetProtocolStatsResponse extends Message<GetProtocolStatsResponse> {
    /**
     * over the requested chains + versions
     *
     * @generated from field: data.v2.ProtocolStats stats = 1;
     */
    stats?: ProtocolStats;
    /**
     * one entry per requested version, in request order; zero-valued when no data
     *
     * @generated from field: repeated data.v2.ProtocolVersionStats protocol_version_stats = 2;
     */
    protocolVersionStats: ProtocolVersionStats[];
    /**
     * timestamp of the snapshot the numbers come from
     *
     * @generated from field: google.protobuf.Timestamp as_of = 3;
     */
    asOf?: Timestamp;
    constructor(data?: PartialMessage<GetProtocolStatsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "data.v2.GetProtocolStatsResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetProtocolStatsResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetProtocolStatsResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetProtocolStatsResponse;
    static equals(a: GetProtocolStatsResponse | PlainMessage<GetProtocolStatsResponse> | undefined, b: GetProtocolStatsResponse | PlainMessage<GetProtocolStatsResponse> | undefined): boolean;
}