import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
/**
 * Sort field for ListLaunches; UNSPECIFIED defaults to LAUNCHED_AT (newest first).
 *
 * @generated from enum launches.v1.LaunchesOrderBy
 */
export declare enum LaunchesOrderBy {
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_LAUNCHED_AT = 1;
     */
    LAUNCHED_AT = 1,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_VOLUME_1D = 2;
     */
    VOLUME_1D = 2,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_TVL = 3;
     */
    TVL = 3,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1H = 4;
     */
    PRICE_CHANGE_1H = 4,
    /**
     * @generated from enum value: LAUNCHES_ORDER_BY_PRICE_CHANGE_1D = 5;
     */
    PRICE_CHANGE_1D = 5,
    /**
     * Trending: launches with recent buy-side momentum. Candidates are tokens
     * with buy activity in the trailing hour REGARDLESS of launch age; gated
     * (non-negative 1h price change, minimum FDV, minimum distinct 1h buyers)
     * and scored by volume/buyer acceleration vs the preceding hours, with the
     * remainder of the page backfilled by 24h volume so the module never
     * renders empty. Needs no LaunchListFilter.window — any window filter is
     * ignored under this sort.
     *
     * @generated from enum value: LAUNCHES_ORDER_BY_TRENDING = 6;
     */
    TRENDING = 6,
    /**
     * Fully-diluted valuation, descending by default. Served from the RANKED
     * launch_tokens read (the live attribution scan has no FDV engine), which
     * every non-LAUNCHED_AT sort already routes to. Unlike TRENDING, a
     * LaunchListFilter.window IS applied under this sort: the launch-age floor
     * reaches both arms, so FDV + LAST_24H ranks by FDV among launches inside
     * that window rather than across all launches.
     *
     * @generated from enum value: LAUNCHES_ORDER_BY_FDV = 7;
     */
    FDV = 7
}
/**
 * Launch-recency window for ListLaunches. UNSPECIFIED applies no window (all
 * launches); LAST_24H / LAST_1H keep only launches whose launched_at is within
 * the trailing 24 hours / 1 hour respectively.
 *
 * @generated from enum launches.v1.LaunchWindow
 */
export declare enum LaunchWindow {
    /**
     * @generated from enum value: LAUNCH_WINDOW_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: LAUNCH_WINDOW_LAST_24H = 1;
     */
    LAST_24H = 1,
    /**
     * @generated from enum value: LAUNCH_WINDOW_LAST_1H = 2;
     */
    LAST_1H = 2
}
/**
 * The trade's direction from the trader's perspective: BUY = the trader
 * received the requested token, SELL = the trader gave it up. UNSPECIFIED
 * when the direction can't be derived (zero/unknown amount).
 *
 * @generated from enum launches.v1.TradeSide
 */
export declare enum TradeSide {
    /**
     * @generated from enum value: TRADE_SIDE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from enum value: TRADE_SIDE_BUY = 1;
     */
    BUY = 1,
    /**
     * @generated from enum value: TRADE_SIDE_SELL = 2;
     */
    SELL = 2
}
/**
 * @generated from message launches.v1.TimestampedValue
 */
export declare class TimestampedValue extends Message<TimestampedValue> {
    /**
     * @generated from field: uint64 timestamp = 1;
     */
    timestamp: bigint;
    /**
     * @generated from field: double value = 2;
     */
    value: number;
    constructor(data?: PartialMessage<TimestampedValue>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.TimestampedValue";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampedValue;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampedValue;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampedValue;
    static equals(a: TimestampedValue | PlainMessage<TimestampedValue> | undefined, b: TimestampedValue | PlainMessage<TimestampedValue> | undefined): boolean;
}
/**
 * @generated from message launches.v1.TokenSafety
 */
export declare class TokenSafety extends Message<TokenSafety> {
    /**
     * @generated from field: bool is_spam = 1;
     */
    isSpam: boolean;
    /**
     * @generated from field: bool is_verified = 2;
     */
    isVerified: boolean;
    /**
     * @generated from field: bool is_blocked = 3;
     */
    isBlocked: boolean;
    /**
     * @generated from field: optional string verdict = 4;
     */
    verdict?: string;
    /**
     * @generated from field: repeated string features = 5;
     */
    features: string[];
    constructor(data?: PartialMessage<TokenSafety>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.TokenSafety";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenSafety;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenSafety;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenSafety;
    static equals(a: TokenSafety | PlainMessage<TokenSafety> | undefined, b: TokenSafety | PlainMessage<TokenSafety> | undefined): boolean;
}
/**
 * A token launchpad known to the Launches surface (see the data-api
 * launchpad registry). A launchpad is the launching FRONTEND users see; id is
 * the stable slug used in launchpad_id filters.
 *
 * @generated from message launches.v1.Launchpad
 */
export declare class Launchpad extends Message<Launchpad> {
    /**
     * @generated from field: string id = 1;
     */
    id: string;
    /**
     * @generated from field: string name = 2;
     */
    name: string;
    /**
     * @generated from field: optional string logo_url = 3;
     */
    logoUrl?: string;
    /**
     * Underlying shared launch protocol (e.g. "doppler") when the frontend
     * launches through contracts it doesn't own. Unset for self-contained
     * launchpads; several frontends can share one protocol value.
     *
     * @generated from field: optional string protocol = 4;
     */
    protocol?: string;
    constructor(data?: PartialMessage<Launchpad>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.Launchpad";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launchpad;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launchpad;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launchpad;
    static equals(a: Launchpad | PlainMessage<Launchpad> | undefined, b: Launchpad | PlainMessage<Launchpad> | undefined): boolean;
}
/**
 * Optional filters for ListLaunches. When a window is set and sort_by is
 * UNSPECIFIED the server sorts by 24h volume (VOLUME_1D).
 *
 * @generated from message launches.v1.LaunchListFilter
 */
export declare class LaunchListFilter extends Message<LaunchListFilter> {
    /**
     * @generated from field: launches.v1.LaunchWindow window = 1;
     */
    window: LaunchWindow;
    constructor(data?: PartialMessage<LaunchListFilter>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchListFilter";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchListFilter;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchListFilter;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchListFilter;
    static equals(a: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined, b: LaunchListFilter | PlainMessage<LaunchListFilter> | undefined): boolean;
}
/**
 * The launched token's identity and display metadata.
 *
 * @generated from message launches.v1.LaunchToken
 */
export declare class LaunchToken extends Message<LaunchToken> {
    /**
     * @generated from field: uint32 chain_id = 1;
     */
    chainId: number;
    /**
     * @generated from field: string address = 2;
     */
    address: string;
    /**
     * @generated from field: string symbol = 3;
     */
    symbol: string;
    /**
     * @generated from field: string name = 4;
     */
    name: string;
    /**
     * @generated from field: optional string logo_url = 5;
     */
    logoUrl?: string;
    /**
     * Safety classification from Aurora canonical_tokens — the same source and
     * shape GetToken serves (safety.is_blocked carries the compliance
     * blocklist). Unset when the token has no canonical row yet (fresh
     * launches lag ingestion) or the read failed: treat as not blocked.
     *
     * @generated from field: launches.v1.TokenSafety safety = 6;
     */
    safety?: TokenSafety;
    constructor(data?: PartialMessage<LaunchToken>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchToken";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchToken;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchToken;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchToken;
    static equals(a: LaunchToken | PlainMessage<LaunchToken> | undefined, b: LaunchToken | PlainMessage<LaunchToken> | undefined): boolean;
}
/**
 * Live USD stats for a launch's pool/token. Each field is unset when its
 * source has no data yet (fresh launches lag the stats pipelines).
 *
 * @generated from message launches.v1.LaunchStats
 */
export declare class LaunchStats extends Message<LaunchStats> {
    /**
     * @generated from field: optional double volume_24h_usd = 1;
     */
    volume24hUsd?: number;
    /**
     * @generated from field: optional double tvl_usd = 2;
     */
    tvlUsd?: number;
    /**
     * @generated from field: optional double price_usd = 3;
     */
    priceUsd?: number;
    /**
     * price x total supply; unset where no supply source
     *
     * @generated from field: optional double fdv_usd = 4;
     */
    fdvUsd?: number;
    /**
     * @generated from field: optional double price_change_percent_1h = 5;
     */
    priceChangePercent1h?: number;
    /**
     * @generated from field: optional double price_change_percent_24h = 6;
     */
    priceChangePercent24h?: number;
    /**
     * USD price sparkline over the trailing 24h, oldest first. Same shape as
     * RankedMultichainToken.sparkline (Aurora-side timestamps are synthesized;
     * CCA points are observed). Empty when no series is available.
     *
     * @generated from field: repeated launches.v1.TimestampedValue sparkline = 7;
     */
    sparkline: TimestampedValue[];
    /**
     * price_usd in ETH terms, derived at serve time as price_usd divided by
     * the chain's native-ETH USD rate. Only set on chains whose native
     * currency is ETH; unset when either price is unavailable.
     *
     * @generated from field: optional double price_eth = 8;
     */
    priceEth?: number;
    /**
     * USD price ~24h ago — the anchor price_change_percent_24h is measured
     * against. When set, price_change_percent_24h is computed at serve time
     * from the live current price against this anchor; unset when the stats
     * pipeline has not resolved an anchor yet.
     *
     * @generated from field: optional double price_24h_ago_usd = 9;
     */
    price24hAgoUsd?: number;
    constructor(data?: PartialMessage<LaunchStats>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchStats";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchStats;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchStats;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchStats;
    static equals(a: LaunchStats | PlainMessage<LaunchStats> | undefined, b: LaunchStats | PlainMessage<LaunchStats> | undefined): boolean;
}
/**
 * One token launch: the earliest pool a (token, launchpad) pair created.
 *
 * @generated from message launches.v1.Launch
 */
export declare class Launch extends Message<Launch> {
    /**
     * @generated from field: string launchpad_id = 1;
     */
    launchpadId: string;
    /**
     * @generated from field: launches.v1.LaunchToken token = 2;
     */
    token?: LaunchToken;
    /**
     * v4 pool id for hook-attributed and direct launches; CCA pool key hash
     * once the auction has migrated to a pool, empty before then.
     *
     * @generated from field: string pool_id = 3;
     */
    poolId: string;
    /**
     * @generated from field: optional string hooks_address = 4;
     */
    hooksAddress?: string;
    /**
     * unix seconds
     *
     * @generated from field: int64 launched_at = 5;
     */
    launchedAt: bigint;
    /**
     * @generated from field: launches.v1.LaunchStats stats = 6;
     */
    stats?: LaunchStats;
    /**
     * CCA + direct-launch launches: true once the launch graduated. CCA:
     * auction migrated into its pool (on-chain fact). Direct launches
     * (launchpad "uniswap-bonding-curve") have NO on-chain graduation — the
     * pool is a vanilla v4 pool from block one — so this is currently always
     * false for them; a serving-side FDV-threshold graduation rule may set it
     * later. Unset for other hook-attributed launches, which are pools
     * already.
     *
     * @generated from field: optional bool graduated = 7;
     */
    graduated?: boolean;
    /**
     * CCA launches only, pre-graduation: bid volume as a percent of the
     * required raise, clamped to [0, 100]. Unset once graduated, when the
     * auction has no required raise, and for hook-attributed launches.
     *
     * @generated from field: optional double auction_fill_pct = 8;
     */
    auctionFillPct?: number;
    /**
     * CCA launches only, pre-graduation: the auction's end block number
     * (bigint as string). Clients estimate calendar time from blocks, like the
     * v1 auction start_block/end_block. Unset once graduated.
     *
     * @generated from field: optional string auction_end_block = 9;
     */
    auctionEndBlock?: string;
    /**
     * CCA launches only: distinct wallets that have placed bids in the auction
     * (all bids, including withdrawn/exited — historical participation, so it
     * stays set after graduation). Unset for hook-attributed launches, which
     * have no auction. int32 matches the v1 auction total_bid_count.
     *
     * @generated from field: optional int32 bidder_count = 10;
     */
    bidderCount?: number;
    /**
     * Direct-launch overlay (see BondingCurveInfo), set only for launches of
     * the Uniswap direct-launch launchpad ("uniswap-bonding-curve").
     *
     * @generated from field: optional launches.v1.BondingCurveInfo bonding_curve = 11;
     */
    bondingCurve?: BondingCurveInfo;
    /**
     * Launchpad token metadata (12-15), joined from launched_tokens — present
     * only for launches whose token was created via the Uniswap token factory
     * (CCA and bonding-curve launches); other launchpads' tokens have no row
     * and serve unset. Verification gating mirrors v1 GetAuction
     * (AuctionsBL.enrichWithLaunchpadMetadata): the description is on-chain
     * creator text at the same trust level as name/symbol, served ungated.
     *
     * @generated from field: optional string token_description = 12;
     */
    tokenDescription?: string;
    /**
     * The launch tx's from address (launched_tokens.creator_wallet),
     * EIP-55 checksummed. Public on-chain data, served ungated.
     *
     * @generated from field: optional string creator_address = 13;
     */
    creatorAddress?: string;
    /**
     * Creator-declared project website. Served only once website verification
     * passes; verification is deferred today (status stays 'pending', same
     * rule that keeps the token mirror's homepageUrl null), so this stays
     * unset until that ships.
     *
     * @generated from field: optional string website_url = 14;
     */
    websiteUrl?: string;
    /**
     * X handle, only when its inline-at-ingest Ed25519 verification passed.
     *
     * @generated from field: optional string x_handle = 15;
     */
    xHandle?: string;
    /**
     * Bonding-curve launches only (16-17): distinct wallets (swap tx senders)
     * that bought the launch token on its curve pool — all-time and trailing
     * hour. Served from ClickHouse v4 swaps; absent (never 0) when the stats
     * source fails or for non-curve launches, so clients can tell degraded
     * from a real zero.
     *
     * @generated from field: optional int32 unique_buyer_count = 16;
     */
    uniqueBuyerCount?: number;
    /**
     * @generated from field: optional int32 buyers_last_1h = 17;
     */
    buyersLast1h?: number;
    /**
     * Exact on-chain holder count of the launch token, computed at query time
     * over the raw launch-transfers feed (ClickHouse, reorg-excluded):
     * addresses with a positive net balance, contracts included, burn sinks
     * like 0x…dEaD included while they hold a balance — raw Etherscan-style
     * semantics. Present only for tokens created via the Uniswap token
     * factory (CCA + bonding-curve launches, whose transfers the feed
     * whitelists); absent — never 0 — while the token has no ingested
     * transfers or when the enrichment fails.
     *
     * @generated from field: optional int32 holder_count = 18;
     */
    holderCount?: number;
    /**
     * Cumulative burned amount of the launch token, split by burn sink and
     * computed from the same transfer feed. Raw uint256 base units as decimal
     * strings; total burned = burned_to_zero + burned_to_dead. Because burn
     * addresses never spend, a holders-excluding-burn count is
     * client-derivable as holder_count - (burned_to_dead > 0 ? 1 : 0). Same
     * presence rule as holder_count (absent without ingested transfers), but
     * once the token has transfers a genuine "0" is served.
     *
     * @generated from field: optional string burned_to_zero = 19;
     */
    burnedToZero?: string;
    /**
     * @generated from field: optional string burned_to_dead = 20;
     */
    burnedToDead?: string;
    /**
     * CCA launches only, pre-graduation (same lifecycle as auction_end_block):
     * wall-clock time of the auction's end block in unix seconds, computed
     * server-side (LP-1300) — the exact block timestamp once the end block is
     * mined, otherwise an estimate from a per-chain block-time model. Unset
     * once graduated, when the source data is unavailable, and for
     * hook-attributed launches.
     *
     * @generated from field: optional int64 auction_end_time = 21;
     */
    auctionEndTime?: bigint;
    /**
     * X profile image URL of the verified launcher account, captured from the
     * launch's signed x-verification claims. Same gate as x_handle: served only
     * when the inline-at-ingest Ed25519 verification passed. Unset for launches
     * that predate claim capture (backfill pending) or carry no avatar.
     *
     * @generated from field: optional string x_profile_image_url = 22;
     */
    xProfileImageUrl?: string;
    /**
     * Whether the launcher's X account was verified (blue check) when captured.
     * Tri-state via presence: unset = unknown (pre-feature launch, not yet
     * backfilled), false = X reported not verified, true = verified. Same
     * x_handle_status gate as x_handle / x_profile_image_url.
     *
     * @generated from field: optional bool x_verified = 23;
     */
    xVerified?: boolean;
    /**
     * Home-card trade tape: the launch token's most recent swaps, newest
     * first, capped at the last 5 within the trailing 24h — same rows (and
     * message) GetTokenTrades serves, aggregated across all the token's pools
     * on its chain. Served from a short-TTL cache refreshed off the request
     * path, so entries can lag live trades by the cache TTL (~30s) and a
     * cold cache serves an empty list — clients treat empty as "no recent
     * activity known", not an error. Pre-graduation CCA launches have no
     * swaps by construction (bids are not trades) — the auction tape is
     * AuctionWithStats.recent_bids on ListTopAuctions.
     *
     * @generated from field: repeated launches.v1.TokenTrade recent_trades = 24;
     */
    recentTrades: TokenTrade[];
    /**
     * Badges earned by the launch's token (LP badges), one per badge type,
     * highest tier only, canonical order. Empty until the token has earned
     * any (badges are awarded at ingest and by a slow tier cron, so the
     * common row serves an empty list).
     *
     * @generated from field: repeated launches.v1.LaunchBadge badges = 25;
     */
    badges: LaunchBadge[];
    constructor(data?: PartialMessage<Launch>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.Launch";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Launch;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Launch;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Launch;
    static equals(a: Launch | PlainMessage<Launch> | undefined, b: Launch | PlainMessage<Launch> | undefined): boolean;
}
/**
 * One badge earned by a launch's token. type/tier are deliberately plain
 * strings, NOT enums: the client contract pins the lowercase ids on the
 * wire, and proto-JSON would serialize an enum's VALUE NAMES instead.
 *
 * @generated from message launches.v1.LaunchBadge
 */
export declare class LaunchBadge extends Message<LaunchBadge> {
    /**
     * "original" | "frontrunner" | "volume" | "holders" | "badger".
     *
     * @generated from field: string type = 1;
     */
    type: string;
    /**
     * Tier id, present only for the tiered types — volume: "5m" | "10m" |
     * "50m"; holders: "100" | "1k" | "10k". Unset for untiered types.
     *
     * @generated from field: optional string tier = 2;
     */
    tier?: string;
    /**
     * When the badge was earned (proto-JSON serializes this as an ISO-8601
     * string, which is the client contract). Exact on-chain launch time for
     * frontrunner; observation time for original and for tier crossings,
     * which are only known to have happened by the pass that spots them.
     *
     * @generated from field: google.protobuf.Timestamp earned_at = 3;
     */
    earnedAt?: Timestamp;
    /**
     * Rarity: percentage (0-100) of eligible tokens that hold this badge
     * TYPE (any tier), for the client's rarity-tag hover. The denominator is
     * every factory-launched token (the launched_tokens registry). Served
     * from a short-TTL cached aggregate; unset when the aggregate is
     * unavailable — clients hide the rarity detail rather than showing 0.
     *
     * @generated from field: optional double holder_percentage = 4;
     */
    holderPercentage?: number;
    constructor(data?: PartialMessage<LaunchBadge>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchBadge";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchBadge;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchBadge;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchBadge;
    static equals(a: LaunchBadge | PlainMessage<LaunchBadge> | undefined, b: LaunchBadge | PlainMessage<LaunchBadge> | undefined): boolean;
}
/**
 * One row of a launch token's holder list (GetLaunchHolders).
 *
 * @generated from message launches.v1.LaunchHolder
 */
export declare class LaunchHolder extends Message<LaunchHolder> {
    /**
     * EIP-55 checksummed, so clients can equality-match against
     * Launch.creator_address and well-known addresses (LP, burn sinks).
     *
     * @generated from field: string address = 1;
     */
    address: string;
    /**
     * Net balance, raw base units as a decimal string. For the synthetic
     * zero-address burn row this is the cumulative amount burned to 0x0.
     *
     * @generated from field: string balance = 2;
     */
    balance: string;
    /**
     * balance as a percent of minted_supply, in [0, 100].
     *
     * @generated from field: double supply_pct = 3;
     */
    supplyPct: number;
    /**
     * True for burn-sink rows (the zero address and 0x…dEaD). Burn rows are
     * served in the list (burned tokens stay visible) but excluded from
     * top10_supply_pct; the synthetic zero-address row is also excluded from
     * holder_count (0x…dEaD counts, matching Launch.holder_count).
     *
     * @generated from field: bool is_burn_address = 4;
     */
    isBurnAddress: boolean;
    /**
     * True for the launch pool's custody row — the chain's v4 PoolManager
     * singleton, which holds the pool's token-side balance (the LP NFT sits
     * in the FeeSplitter, the ERC-20 supply does not). Served in the list so
     * clients can label it, but excluded from top10_supply_pct like burn rows
     * (the pool is the market, not a dumpable holder); it stays inside
     * holder_count.
     *
     * @generated from field: bool is_pool_address = 5;
     */
    isPoolAddress: boolean;
    constructor(data?: PartialMessage<LaunchHolder>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.LaunchHolder";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LaunchHolder;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LaunchHolder;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LaunchHolder;
    static equals(a: LaunchHolder | PlainMessage<LaunchHolder> | undefined, b: LaunchHolder | PlainMessage<LaunchHolder> | undefined): boolean;
}
/**
 * Overlay for launches of the Uniswap direct-launch launchpad (launchpad_id
 * "uniswap-bonding-curve", kept for client compatibility). The current
 * launcher generation (DirectLaunchStrategy, LP-1289) is hookless with NO
 * on-chain graduation lifecycle: launch pools are vanilla v4 pools from
 * block one, and "graduation" is a serving/frontend concept (an FDV
 * threshold), not a contract event. Fields 1-5 and 7-9 belong to the
 * never-launched bonding-curve hook generation and are no longer set for
 * new launches; they are kept so the message shape stays wire-compatible.
 *
 * @generated from message launches.v1.BondingCurveInfo
 */
export declare class BondingCurveInfo extends Message<BondingCurveInfo> {
    /**
     * Legacy bonding-curve-hook fields (1-5, 7-9): never set for direct-launch
     * (hookless) launches — there is no curve and no on-chain graduation.
     *
     * @generated from field: optional string graduation_sqrt_price_x96 = 1;
     */
    graduationSqrtPriceX96?: string;
    /**
     * @generated from field: optional int32 curve_tick_lower = 2;
     */
    curveTickLower?: number;
    /**
     * @generated from field: optional int32 curve_tick_upper = 3;
     */
    curveTickUpper?: number;
    /**
     * @generated from field: optional string curve_supply = 4;
     */
    curveSupply?: string;
    /**
     * @generated from field: optional string reserve_supply = 5;
     */
    reserveSupply?: string;
    /**
     * @generated from field: optional string graduated_tx_hash = 7;
     */
    graduatedTxHash?: string;
    /**
     * @generated from field: optional double curve_progress_pct = 8;
     */
    curveProgressPct?: number;
    /**
     * @generated from field: optional int64 graduated_at = 9;
     */
    graduatedAt?: bigint;
    /**
     * The launch's fee beneficiary, EIP-55 checksummed: the CURRENT holder of
     * the launch's BeneficiaryVault NFT, i.e. the address receiving the
     * creator share of the launch pool's trading fees. Freely chosen at
     * launch time by whoever built the launch transaction — a payee, NOT
     * proven authorship (see Launch.creator_address for the launch tx
     * sender) — and it MOVES with later NFT transfers. Unset while ingestion
     * of the vault events lags the launch, or when the position is
     * unregistered.
     *
     * @generated from field: optional string fee_beneficiary = 10;
     */
    feeBeneficiary?: string;
    constructor(data?: PartialMessage<BondingCurveInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.BondingCurveInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BondingCurveInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BondingCurveInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BondingCurveInfo;
    static equals(a: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined, b: BondingCurveInfo | PlainMessage<BondingCurveInfo> | undefined): boolean;
}
/**
 * One swap involving the requested token, returned by GetTokenTrades.
 *
 * @generated from message launches.v1.TokenTrade
 */
export declare class TokenTrade extends Message<TokenTrade> {
    /**
     * @generated from field: string tx_hash = 1;
     */
    txHash: string;
    /**
     * @generated from field: launches.v1.TradeSide side = 2;
     */
    side: TradeSide;
    /**
     * The transaction's from-address (the EOA that signed it), not the router
     * contract that forwarded the swap to the pool.
     *
     * @generated from field: string wallet = 3;
     */
    wallet: string;
    /**
     * Whole-swap USD value at trade time; unset when no USD price is known.
     *
     * @generated from field: optional double amount_usd = 4;
     */
    amountUsd?: number;
    /**
     * Absolute amount of the requested token traded, decimal string in token
     * units (decimals applied). Empty when the token's decimals are unknown.
     *
     * @generated from field: string token_amount = 5;
     */
    tokenAmount: string;
    /**
     * USD price of the requested token at trade time; unset when unknown.
     *
     * @generated from field: optional double price_usd = 6;
     */
    priceUsd?: number;
    /**
     * @generated from field: google.protobuf.Timestamp timestamp = 7;
     */
    timestamp?: Timestamp;
    constructor(data?: PartialMessage<TokenTrade>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "launches.v1.TokenTrade";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TokenTrade;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TokenTrade;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TokenTrade;
    static equals(a: TokenTrade | PlainMessage<TokenTrade> | undefined, b: TokenTrade | PlainMessage<TokenTrade> | undefined): boolean;
}