import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Launch, LaunchesOrderBy, LaunchHolder, LaunchListFilter, Launchpad, TimestampedValue, TokenTrade } from "./types_pb.js";
import { PageRequest, PageResponse } from "./common_pb.js";
/**
 * @generated from enum launches.v1.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 launches.v1.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 = "launches.v1.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;
}
/**
 * The launchpad registry, for building launchpad filters/labels client-side.
 *
 * @generated from message launches.v1.ListLaunchpadsRequest
 */
export declare class ListLaunchpadsRequest extends Message<ListLaunchpadsRequest> {
    constructor(data?: PartialMessage<ListLaunchpadsRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.ListLaunchpadsResponse
 */
export declare class ListLaunchpadsResponse extends Message<ListLaunchpadsResponse> {
    /**
     * @generated from field: repeated launches.v1.Launchpad launchpads = 1;
     */
    launchpads: Launchpad[];
    constructor(data?: PartialMessage<ListLaunchpadsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.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: launches.v1.LaunchesOrderBy sort_by = 3;
     */
    sortBy: LaunchesOrderBy;
    /**
     * @generated from field: optional launches.v1.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 launches.v1.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 unless include_all_launches is set.
     *
     * @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;
    /**
     * Also return institutional and unclassified CCA launches. Only applies
     * with token_addresses; ignored otherwise.
     *
     * @generated from field: optional bool include_all_launches = 13;
     */
    includeAllLaunches?: boolean;
    constructor(data?: PartialMessage<ListLaunchesRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.ListLaunchesResponse
 */
export declare class ListLaunchesResponse extends Message<ListLaunchesResponse> {
    /**
     * @generated from field: repeated launches.v1.Launch launches = 1;
     */
    launches: Launch[];
    /**
     * @generated from field: launches.v1.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<ListLaunchesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.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 = "launches.v1.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;
}
/**
 * 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 launches.v1.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 launches.v1.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 launches.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 = "launches.v1.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;
}
/**
 * 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 launches.v1.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 = "launches.v1.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;
}
/**
 * @generated from message launches.v1.GetLaunchActivityStatsResponse
 */
export declare class GetLaunchActivityStatsResponse extends Message<GetLaunchActivityStatsResponse> {
    /**
     * One entry per window, always all five, in enum order.
     *
     * @generated from field: repeated launches.v1.LaunchActivityStatsWindow windows = 1;
     */
    windows: LaunchActivityStatsWindow[];
    constructor(data?: PartialMessage<GetLaunchActivityStatsResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.LaunchActivityStatsWindow
 */
export declare class LaunchActivityStatsWindow extends Message<LaunchActivityStatsWindow> {
    /**
     * @generated from field: launches.v1.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 = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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: launches.v1.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: launches.v1.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: launches.v1.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: launches.v1.LaunchCreatorFeeAmounts claimable_including_uncollected = 4;
     */
    claimableIncludingUncollected?: LaunchCreatorFeeAmounts;
    constructor(data?: PartialMessage<CreatorFeeTotals>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.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: launches.v1.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: launches.v1.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 = "launches.v1.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;
}
/**
 * Batched GetLaunchCreatorFees: the SAME per-token metrics for a whole set of
 * tokens in one request. A creator portfolio polling 30 launches otherwise
 * makes 30 requests every tick; this is the batched replacement, modelled on
 * GetLiquidityForTokens below.
 *
 * Not a widening of GetLaunchCreatorFees: that response is a SINGLETON message
 * with no repeated field and no (chain_id, token_address) identity on it, so a
 * batch cannot be expressed in it without making every existing field
 * mode-dependent. The single-token RPC keeps working unchanged and stays the
 * right call for one token.
 *
 * @generated from message launches.v1.GetLaunchCreatorFeesForTokensRequest
 */
export declare class GetLaunchCreatorFeesForTokensRequest extends Message<GetLaunchCreatorFeesForTokensRequest> {
    /**
     * max 100
     *
     * @generated from field: repeated launches.v1.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    constructor(data?: PartialMessage<GetLaunchCreatorFeesForTokensRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.GetLaunchCreatorFeesForTokensRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesForTokensRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesForTokensRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesForTokensRequest;
    static equals(a: GetLaunchCreatorFeesForTokensRequest | PlainMessage<GetLaunchCreatorFeesForTokensRequest> | undefined, b: GetLaunchCreatorFeesForTokensRequest | PlainMessage<GetLaunchCreatorFeesForTokensRequest> | undefined): boolean;
}
/**
 * One entry per requested token, in request order. Read the THREE-WAY
 * distinction below before rendering anything — it is the whole point of the
 * batch form, and collapsing two of the cases produces a wrong zero:
 *
 *   * entry present, `fees` SET     -> the token's fee position (identical to
 *     what the single-token GetLaunchCreatorFees returns for it).
 *   * entry present, `fees` UNSET   -> NO POSITION. Exactly the case the
 *     single-token RPC answers with not_found: the token has neither indexed
 *     Instant Launch fee events nor a resolvable launch. A durable, cacheable
 *     answer — render "no fees", do not retry.
 *   * entry ABSENT from `entries`   -> NOT EVALUATED. The server could not
 *     determine this token's fees (a transient upstream failure on that token
 *     alone). NOT a statement that there is no position: keep the previous
 *     value or retry, never render zero.
 *
 * A single failing or position-less token therefore never fails the batch —
 * the other tokens are still served.
 *
 * @generated from message launches.v1.GetLaunchCreatorFeesForTokensResponse
 */
export declare class GetLaunchCreatorFeesForTokensResponse extends Message<GetLaunchCreatorFeesForTokensResponse> {
    /**
     * @generated from field: repeated launches.v1.LaunchCreatorFeesEntry entries = 1;
     */
    entries: LaunchCreatorFeesEntry[];
    constructor(data?: PartialMessage<GetLaunchCreatorFeesForTokensResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.GetLaunchCreatorFeesForTokensResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetLaunchCreatorFeesForTokensResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesForTokensResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetLaunchCreatorFeesForTokensResponse;
    static equals(a: GetLaunchCreatorFeesForTokensResponse | PlainMessage<GetLaunchCreatorFeesForTokensResponse> | undefined, b: GetLaunchCreatorFeesForTokensResponse | PlainMessage<GetLaunchCreatorFeesForTokensResponse> | undefined): boolean;
}
/**
 * A requested token paired with its fees. chain_id AND token_address are both
 * always set so a caller matches rows back by identity rather than by index —
 * order is request order today, but absent entries make positional matching
 * wrong, so do not rely on it.
 *
 * @generated from message launches.v1.LaunchCreatorFeesEntry
 */
export declare class LaunchCreatorFeesEntry extends Message<LaunchCreatorFeesEntry> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * EIP-55 checksummed token address, echoing the requested token.
     *
     * @generated from field: string token_address = 2;
     */
    tokenAddress: string;
    /**
     * The single-token response embedded verbatim, so the batch and single-token
     * forms can never drift in meaning. UNSET = no position (see above).
     *
     * @generated from field: optional launches.v1.GetLaunchCreatorFeesResponse fees = 3;
     */
    fees?: GetLaunchCreatorFeesResponse;
    constructor(data?: PartialMessage<LaunchCreatorFeesEntry>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchCreatorFeesEntry";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchCreatorFeesEntry;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchCreatorFeesEntry;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchCreatorFeesEntry;
    static equals(a: LaunchCreatorFeesEntry | PlainMessage<LaunchCreatorFeesEntry> | undefined, b: LaunchCreatorFeesEntry | PlainMessage<LaunchCreatorFeesEntry> | 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 launches.v1.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 = "launches.v1.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 launches.v1.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: launches.v1.RecentlyLaunchedToken original_token = 2;
     */
    originalToken?: RecentlyLaunchedToken;
    constructor(data?: PartialMessage<CheckLaunchNameTickerResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.GetLiquidityForTokensRequest
 */
export declare class GetLiquidityForTokensRequest extends Message<GetLiquidityForTokensRequest> {
    /**
     * max 100
     *
     * @generated from field: repeated launches.v1.TokenIdentifier tokens = 1;
     */
    tokens: TokenIdentifier[];
    constructor(data?: PartialMessage<GetLiquidityForTokensRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.GetLiquidityForTokensResponse
 */
export declare class GetLiquidityForTokensResponse extends Message<GetLiquidityForTokensResponse> {
    /**
     * @generated from field: repeated launches.v1.TokenLiquidity liquidity = 1;
     */
    liquidity: TokenLiquidity[];
    constructor(data?: PartialMessage<GetLiquidityForTokensResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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 launches.v1.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 = "launches.v1.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;
}
/**
 * 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 launches.v1.GetTokenTradesRequest
 */
export declare class GetTokenTradesRequest extends Message<GetTokenTradesRequest> {
    /**
     * @generated from field: launches.v1.TokenIdentifier token = 1;
     */
    token?: TokenIdentifier;
    /**
     * page_size (default 25, max 100) + page_token
     *
     * @generated from field: optional launches.v1.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 = "launches.v1.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 launches.v1.GetTokenTradesResponse
 */
export declare class GetTokenTradesResponse extends Message<GetTokenTradesResponse> {
    /**
     * @generated from field: repeated launches.v1.TokenTrade trades = 1;
     */
    trades: TokenTrade[];
    /**
     * next_page_token absent on last page
     *
     * @generated from field: launches.v1.PageResponse page = 2;
     */
    page?: PageResponse;
    constructor(data?: PartialMessage<GetTokenTradesResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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;
}
/**
 * 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 launches.v1.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 = "launches.v1.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 launches.v1.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 = "launches.v1.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 launches.v1.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 launches.v1.TokenTopTrader traders = 1;
     */
    traders: TokenTopTrader[];
    constructor(data?: PartialMessage<GetTokenTopTradersResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.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;
}