@coinlist-co/react 0.10.1 → 0.11.0

package/dist/config-B5mwS_2l.d.cts

@@ -0,0 +1,1926 @@
+import { Hex } from 'viem';
+
+declare const __brand: unique symbol;
+type Newtype<Base, Branding> = Base & {
+    readonly [__brand]: Branding;
+};
+
+type AuthorizationCode = Newtype<string, 'AuthorizationCode'>;
+declare const AuthorizationCode: (value: string) => AuthorizationCode;
+type CodeVerifier = Newtype<string, 'CodeVerifier'>;
+declare const CodeVerifier: (value: string) => CodeVerifier;
+type CodeChallenge = Newtype<string, 'CodeChallenge'>;
+declare const CodeChallenge: (value: string) => CodeChallenge;
+type PKCEState = Newtype<string, 'PKCEState'>;
+declare const PKCEState: (value: string) => PKCEState;
+type RedirectUri = Newtype<string, 'RedirectUri'>;
+declare const RedirectUri: (value: string) => RedirectUri;
+type ClientId = Newtype<string, 'ClientId'>;
+declare const ClientId: (value: string) => ClientId;
+type ClientSecret = Newtype<string, 'ClientSecret'>;
+declare const ClientSecret: (value: string) => ClientSecret;
+
+/**
+ * The exhaustive chain set: a new {@link EthereumChain} is a compile error
+ * here until it is listed, which is what keeps the constructor total.
+ */
+declare const ETHEREUM_CHAINS: Record<EthereumChain, true>;
+type EthereumChain = 'ethereum_mainnet' | 'ethereum_sepolia';
+/**
+ * Validates that a raw backend string names a chain the SDK supports.
+ *
+ * @throws ValidationError on anything else. Passing an unknown chain through
+ * would let downstream EIP-155 lookups blow up far from the response that
+ * caused it.
+ */
+declare const EthereumChain: (value: string) => EthereumChain;
+/**
+ * The exhaustive chain set: a new {@link SolanaChain} is a compile error
+ * here until it is listed, which is what keeps the constructor total.
+ */
+declare const SOLANA_CHAINS: Record<SolanaChain, true>;
+type SolanaChain = 'solana_mainnet' | 'solana_devnet';
+/**
+ * Validates that a raw backend string names a chain the SDK supports.
+ *
+ * @throws ValidationError on anything else. Passing an unknown chain through
+ * would let downstream EIP-155 lookups blow up far from the response that
+ * caused it.
+ */
+declare const SolanaChain: (value: string) => SolanaChain;
+type Chain = EthereumChain | SolanaChain;
+declare const Chain: (value: string) => Chain;
+/**
+ * Protocol a wallet binding is scoped to. EVM-only for now: an EVM address
+ * binds once per option regardless of which EVM chain proved ownership.
+ * Frontline's enum also has `:solana`, but we don't handle Solana bindings yet,
+ * so this stays `'ethereum'` until Solana support lands.
+ */
+type WalletProtocol = 'ethereum';
+/**
+ * EVM addresses keep a `0x${string}` base so they stay assignable to the
+ * `0x${string}` shapes that on-chain libraries (viem/wagmi) expect. We only
+ * drop the runtime `0x` narrowing: values are trusted at the boundary and
+ * branded via the constructor.
+ */
+type EvmWalletAddress = Newtype<`0x${string}`, 'EvmWalletAddress'>;
+declare const EvmWalletAddress: (value: string) => EvmWalletAddress;
+type EvmContractAddress = Newtype<`0x${string}`, 'EvmContractAddress'>;
+declare const EvmContractAddress: (value: string) => EvmContractAddress;
+/**
+ * What uniquely identifies a token: the chain it is deployed on plus its
+ * contract address. Never a symbol, which can collide across issuers.
+ */
+type TokenIdentifier = {
+    /** The chain the token contract is deployed on. */
+    chain: EthereumChain;
+    /**
+     * The token's contract address, in any casing — consumers that need the
+     * EIP-55 form (e.g. the token registry routes) checksum it themselves.
+     */
+    address: EvmContractAddress;
+};
+type HexEncodedTransactionData = Newtype<`0x${string}`, 'HexEncodedTransactionData'>;
+declare const HexEncodedTransactionData: (value: string) => HexEncodedTransactionData;
+/**
+ * A transaction the backend has already encoded for us — the caller only
+ * broadcasts it. Used by the flows that hand a wallet a ready-made `to`/`data`
+ * pair (allow-listing a wallet, an Ondo swap) rather than encoding a contract
+ * call themselves.
+ */
+type Tx = {
+    to: EvmContractAddress;
+    data: HexEncodedTransactionData;
+};
+/**
+ * The largest exponent whose power of ten still fits a uint256: 10^77 fits,
+ * 10^78 does not.
+ *
+ * The bound is arithmetic rather than a token standard's. ERC-20 reports
+ * `decimals()` as a `uint8`, so 255 is what a contract *can* say, but every
+ * {@link AssetDecimals} in this codebase is paired with a {@link Uint256} raw
+ * by construction, and scaling by anything past this leaves that pairing
+ * unrepresentable. A value between 78 and 255 would therefore pass a
+ * standard-faithful check and then break the first multiplication it reached.
+ */
+declare const MAX_ASSET_DECIMALS = 77;
+/**
+ * How many decimal places one whole token divides into.
+ *
+ * Validated, unlike its neighbours here — {@link Uint256} is a bare `bigint`
+ * with a separate {@link assertUint256} guard, and {@link DecimalString} casts
+ * unchecked. The asymmetry is deliberate and follows the value's provenance:
+ * an `AssetDecimals` used to come only from literals and the token registry,
+ * but backends now publish exponents of their own (`asset_decimals` on an Ondo
+ * quote, both scales on a built swap), and those feed `10n ** BigInt(d)`
+ * during render. Guarding at construction is what keeps a fractional or
+ * unbounded exponent from surfacing as a `RangeError` mid-render — or, at
+ * 10^200, as a hung tab — instead of as the failed state the screen has.
+ *
+ * See docs/ADR-7-VALIDATED-NEWTYPES.md.
+ *
+ * @throws ValidationError on a non-integer, a negative, or anything above
+ * {@link MAX_ASSET_DECIMALS}.
+ */
+type AssetDecimals = Newtype<number, 'AssetDecimals'>;
+declare const AssetDecimals: (value: number) => AssetDecimals;
+declare const STABLE_DECIMALS: AssetDecimals;
+/**
+ * A non-negative decimal number the backend sent as a string, kept unscaled.
+ *
+ * Reach for it when a response gives you a number but not the decimals to
+ * scale it by, or gives you one it has already applied. Inventing an exponent
+ * for either is how a display ends up orders of magnitude out.
+ *
+ * Contrast {@link BlockchainAmount}, which pairs a raw uint256 with the
+ * decimals it is denominated in and so is only constructible when you know
+ * both. Arithmetic on a `DecimalString` needs a decimal library we
+ * deliberately do not ship.
+ */
+type DecimalString = Newtype<string, 'DecimalString'>;
+declare const DecimalString: (value: string) => DecimalString;
+declare const MAX_UINT_256: bigint;
+/**
+ * A non-negative integer within uint256 bounds. Kept unbranded (a plain
+ * `bigint`) so raw on-chain amounts flow in without ceremony; bounds are
+ * enforced where it matters (see {@link combineAmounts}).
+ */
+type Uint256 = bigint;
+/**
+ * Asserts a raw bigint falls within uint256 bounds, throwing otherwise. Use at
+ * on-chain arithmetic boundaries (bps math, price computation) where a computed
+ * value could underflow below zero or overflow above 2^256-1.
+ */
+declare const assertUint256: (value: bigint) => Uint256;
+type BlockchainAmount = Newtype<{
+    raw: Uint256;
+    decimals: AssetDecimals;
+}, 'BlockchainAmount'>;
+/**
+ * Constructs a {@link BlockchainAmount} and exposes arithmetic helpers.
+ * TypeScript has no operator overloading, so use `BlockchainAmount.add(a, b)`
+ * instead of `+`/`-` on the objects directly.
+ */
+declare const BlockchainAmount: ((value: {
+    raw: Uint256;
+    decimals: AssetDecimals;
+}) => BlockchainAmount) & {
+    add: (a: BlockchainAmount, b: BlockchainAmount) => BlockchainAmount;
+    sub: (a: BlockchainAmount, b: BlockchainAmount) => BlockchainAmount;
+};
+type AssetSymbol = Newtype<string, 'AssetSymbol'>;
+declare const AssetSymbol: (value: string) => AssetSymbol;
+/**
+ * A stablecoin symbol is an {@link AssetSymbol} narrowed to the coins we
+ * support. It shares the `AssetSymbol` brand so it stays assignable to it.
+ */
+type StablecoinSymbol = Newtype<'USDC' | 'USDT', 'AssetSymbol'>;
+declare const StablecoinSymbol: (value: "USDC" | "USDT") => StablecoinSymbol;
+type KnownAssetSymbol = StablecoinSymbol;
+declare const KnownAssetSymbol: (value: "USDC" | "USDT") => StablecoinSymbol;
+type Erc20Asset = {
+    name: string;
+    symbol: AssetSymbol;
+    decimals: AssetDecimals;
+};
+type Bps = Newtype<bigint, 'Bps'>;
+declare const Bps: (value: bigint) => Bps;
+
+type GetTokenAllowanceParams = {
+    tokenAddress: EvmContractAddress;
+    owner: EvmWalletAddress;
+    spender: EvmContractAddress;
+    chain: EthereumChain;
+};
+type GetTokenBalanceParams = {
+    tokenAddress: EvmContractAddress;
+    owner: EvmWalletAddress;
+    chain: EthereumChain;
+};
+
+/**
+ * OAuth 2.0 token response (RFC 6749 §5.1).
+ * Maps to OpenAPI schema OauthToken.
+ */
+type OAuthSessionDto = {
+    access_token: string;
+    expires_in: number;
+    refresh_token?: string;
+};
+
+type ClientCredentialsOAuth = Newtype<OAuthAccessToken, 'ClientCredentialsOAuth'>;
+declare const ClientCredentialsOAuth: (value: OAuthAccessToken) => ClientCredentialsOAuth;
+type OAuthAccessToken = {
+    value: string;
+    expiresAt: Date;
+};
+type OAuthRefreshToken = Newtype<string, 'OAuthRefreshToken'>;
+declare const OAuthRefreshToken: (value: string) => OAuthRefreshToken;
+type OAuthSession = {
+    accessToken: OAuthAccessToken;
+    refreshToken?: OAuthRefreshToken;
+};
+declare const OAuthSession: {
+    fromDto: (dto: OAuthSessionDto) => OAuthSession;
+};
+
+type HttpRequestAttributes = {
+    protected?: boolean;
+    userAgent?: boolean;
+    idempotencyKey?: boolean;
+    /** Zero-based attempt index: 0 = first request, 1 = first retry, etc. */
+    retryAttempt?: number;
+    renewAttempted?: boolean;
+    clientCredentials?: ClientCredentialsOAuth;
+};
+
+/**
+ * The value types a query-string parameter may take.
+ *
+ * Declared here rather than beside the HTTP client because domain models build
+ * query parameters too: `ParticipationsPaginationParams.toQueryParams` returns
+ * a `Record<string, QueryParamValue>`, and a domain model must not import
+ * `@/shared/api/**`.
+ */
+type QueryParamValue = string | number | boolean | null | undefined;
+type QueryParamValues = QueryParamValue | QueryParamValue[];
+
+type HttpRequest<TBody = unknown> = {
+    method: 'GET';
+    url: string;
+    queryParams?: Record<string, QueryParamValues>;
+    headers?: Record<string, string>;
+    attributes?: HttpRequestAttributes;
+    redirect?: RequestRedirect;
+} | {
+    method: 'POST';
+    url: string;
+    queryParams?: Record<string, QueryParamValues>;
+    headers?: Record<string, string>;
+    body: TBody;
+    attributes?: HttpRequestAttributes;
+    redirect?: RequestRedirect;
+} | {
+    method: 'DELETE';
+    url: string;
+    queryParams?: Record<string, QueryParamValues>;
+    headers?: Record<string, string>;
+    attributes?: HttpRequestAttributes;
+    redirect?: RequestRedirect;
+};
+type HttpResponse<TBody = unknown> = {
+    status: number;
+    headers?: Record<string, string>;
+    body: TBody | null;
+};
+declare class HttpError<TBody = unknown> extends Error {
+    readonly response: HttpResponse<TBody>;
+    constructor(response: HttpResponse<TBody>);
+}
+/**
+ * The machine-readable `code` frontline attaches to an error, or `null` for
+ * anything else - a non-HTTP failure, or an error body that carries only a
+ * message.
+ *
+ * Frontline answers a failure with `{ type, message, code?, errors?,
+ * event_id? }`, and `code` is the only part of it meant to be branched on:
+ * `message` is prose that may be reworded, and `type` distinguishes
+ * `invalid_request_error` from `api_error` without saying which one.
+ *
+ * Reach for this only where a code has a distinct remedy the user can act on.
+ * Mapping the whole vocabulary would couple the SDK to strings frontline does
+ * not version; falling back to a generic failure is the right default.
+ */
+declare function apiErrorCode(error: unknown): string | null;
+
+/**
+ * Structural interface satisfied by both {@link AuthenticatedApiClient} and
+ * {@link ApiClient}. Used by the shared frontline API functions so they can
+ * be called from either the client or server without any browser dependencies.
+ */
+interface Sender {
+    send<T>(request: HttpRequest): Promise<T>;
+}
+
+interface SharedNamespaceContext {
+    readonly api: Sender;
+    ensureUserAuthenticated(): Promise<void>;
+}
+
+/**
+ * Raw JSON models for the on-chain swap endpoints. uint256 values are encoded
+ * as decimal strings because they can exceed the safe integer range of JSON
+ * consumers.
+ */
+type WalletAuthorizationDto = {
+    object: 'wallet_authorization';
+    authorized: boolean;
+};
+type SwapPreviewDto = {
+    object: 'swap_preview';
+    pay_input_amount: string;
+    fee: string;
+    receive_output_amount: string;
+};
+type SwapStatusDto = {
+    object: 'swap_status';
+    stopped: string;
+    swap_level: string;
+};
+type TokenAllowanceDto = {
+    object: 'token_allowance';
+    allowance: string;
+};
+type TokenBalanceDto = {
+    object: 'token_balance';
+    balance: string;
+};
+type AllowWalletResponseDto = {
+    action: 'broadcast_transaction';
+    to: string;
+    data: string;
+} | {
+    action: 'none';
+    already_allowed: boolean;
+};
+
+/**
+ * Whether a wallet is authorized to interact with a given swap contract.
+ */
+type SwapAuthorization = {
+    authorized: boolean;
+};
+declare const SwapAuthorization: {
+    fromDto: (dto: WalletAuthorizationDto) => SwapAuthorization;
+};
+/**
+ * A read-only quote for a swap: how much goes in, the protocol fee, and how
+ * much would come out. All amounts are raw on-chain integers (uint256).
+ */
+type SwapPreview = {
+    inputAmount: Uint256;
+    fee: Uint256;
+    outputAmount: Uint256;
+};
+declare const SwapPreview: {
+    fromDto: (dto: SwapPreviewDto) => SwapPreview;
+};
+/**
+ * The on-chain state of a swap contract.
+ *
+ * - `stopped`: non-zero when the contract is paused/halted.
+ * - `swapLevel`: the current swap level/tier.
+ */
+type SwapStatus = {
+    stopped: Uint256;
+    swapLevel: Uint256;
+};
+declare const SwapStatus: {
+    fromDto: (dto: SwapStatusDto) => SwapStatus;
+};
+/**
+ * The ERC-20 allowance an owner has granted a spender for a token.
+ */
+type TokenAllowance = {
+    allowance: Uint256;
+};
+declare const TokenAllowance: {
+    fromDto: (dto: TokenAllowanceDto) => TokenAllowance;
+};
+/**
+ * The raw ERC-20 balance an owner holds of a token (uint256).
+ */
+type TokenBalance = {
+    balance: Uint256;
+};
+declare const TokenBalance: {
+    fromDto: (dto: TokenBalanceDto) => TokenBalance;
+};
+/**
+ * The backend's response to an allow-wallet request. Either the caller must
+ * broadcast an on-chain transaction to complete allow-listing, or nothing is
+ * required because the wallet is already allowed.
+ */
+type AllowWalletResponse = {
+    action: 'broadcast_transaction';
+    to: EvmContractAddress;
+    data: HexEncodedTransactionData;
+} | {
+    action: 'none';
+    alreadyAllowed: boolean;
+};
+declare const AllowWalletResponse: {
+    fromDto: (dto: AllowWalletResponseDto) => AllowWalletResponse;
+};
+
+/**
+ * Generic ERC-20 reads shared across on-chain flows (swap, token sale): the
+ * allowance an owner has granted a spender, and the raw token balance an owner
+ * holds. These are plain token reads, not tied to any single product flow.
+ */
+interface Erc20Namespace {
+    /**
+     * Reads the ERC-20 allowance an `owner` has granted a `spender`.
+     */
+    getAllowance(params: GetTokenAllowanceParams): Promise<TokenAllowance>;
+    /**
+     * Reads the raw ERC-20 balance an `owner` holds of a token.
+     */
+    getBalance(params: GetTokenBalanceParams): Promise<TokenBalance>;
+}
+declare class Erc20NamespaceImpl implements Erc20Namespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    getAllowance(params: GetTokenAllowanceParams): Promise<TokenAllowance>;
+    getBalance(params: GetTokenBalanceParams): Promise<TokenBalance>;
+}
+
+/**
+ * The product an offer is checked out through. The backend sends one compound
+ * `{supplier}::{saleType}` string, verbatim as spelled below: a double colon
+ * between the two halves, `snake_case` within each. CoinList's token sale is
+ * `coinlist::token_sale`; there is no `coinlist::sale` and no
+ * `coinlist_token_sale`.
+ *
+ * Kept flat rather than split into a supplier and a sale type, because a flat
+ * union makes a `switch` over it exhaustive: adding a provider without
+ * handling it becomes a compile error.
+ */
+type OfferTypeDto = 'coinlist::token_sale' | 'superstate::swap' | 'ondo::swap';
+type OfferDto = {
+    id: string;
+    slug: string;
+    type: OfferTypeDto;
+    tagline: string;
+    banner_url: string;
+    logo_url: string;
+    starts_at: string;
+    ends_at: string | null;
+};
+
+type OfferId = Newtype<string, 'OfferId'>;
+declare const OfferId: (value: string) => OfferId;
+type OfferSlug = Newtype<string, 'OfferSlug'>;
+declare const OfferSlug: (value: string) => OfferSlug;
+type OfferType = OfferTypeDto;
+type Offer = {
+    id: OfferId;
+    slug: OfferSlug;
+    type: OfferType;
+    tagline: string;
+    bannerUrl: string;
+    logoUrl: string;
+    startsAt: Date;
+    endsAt: Date | null;
+};
+declare const Offer: {
+    fromDto: (dto: OfferDto) => Offer;
+};
+
+/**
+ * The cursor-paginated envelope every list endpoint returns.
+ *
+ * Generic in its item type, so each resource pairs it with its own item DTO
+ * rather than declaring an envelope of its own.
+ */
+interface PaginatedResponseDto<T> {
+    data: T[];
+    starting_after?: string;
+    starting_before?: string;
+}
+
+type Cursor = Newtype<string, 'Cursor'>;
+declare const Cursor: (value: string) => Cursor;
+interface PaginatedResponse<T> {
+    data: T[];
+    startingAfter: Cursor | null;
+    startingBefore: Cursor | null;
+}
+declare const PaginatedResponse: {
+    fromDto: <A, B>(dto: PaginatedResponseDto<A>, itemMapper: (item: A) => B) => PaginatedResponse<B>;
+};
+/**
+ * Cursor-based pagination input used when requesting paginated API resources.
+ * Set `after` or `before` to navigate relative to a known cursor, and `limit`
+ * to control the maximum number of returned items.
+ */
+interface PaginationParams {
+    before?: Cursor;
+    after?: Cursor;
+    limit?: number;
+}
+declare const PaginationParams: {
+    toQueryParams: (params: PaginationParams) => Record<string, QueryParamValue>;
+};
+
+type AssetDto = {
+    code: string;
+    fractional_digits: number;
+    id: string;
+    name: string;
+};
+
+type AssetId = Newtype<string, 'AssetId'>;
+declare const AssetId: (value: string) => AssetId;
+type AssetCode = Newtype<string, 'AssetCode'>;
+declare const AssetCode: (value: string) => AssetCode;
+type Asset = {
+    id: AssetId;
+    code: AssetCode;
+    name: string;
+    fractionalDigits: number;
+};
+declare const Asset: {
+    fromDto: (dto: AssetDto) => Asset;
+};
+
+type ParticipationStatusDto = 'prepared' | 'pending' | 'submitted' | 'completed' | 'failed' | 'remit_submitted' | 'remitted' | 'remit_failed';
+type ParticipationDto = {
+    object: 'participation';
+    id: string;
+    offer_id: string;
+    offer_option_id: string;
+    status: ParticipationStatusDto;
+    amount: string;
+    amount_string: string;
+    asset: AssetDto;
+    chain: string;
+    inserted_at: string | null | undefined;
+    updated_at: string | null | undefined;
+    wallet_address: string | null | undefined;
+};
+type CreateParticipationDto = {
+    offer_id: string;
+    offer_option_id: string;
+    chain: string;
+    wallet_address: string;
+    amount: string;
+    asset_id: string;
+    approval_transaction_hash: string | null | undefined;
+};
+
+type OfferDetailDto = {
+    asset: AssetDto;
+    faqs: OfferDetailFaqDto[];
+    funding_assets: AssetDto[];
+    tokens: OfferDetailTokenDto[];
+    id: string;
+    links: OfferDetailLinkDto[];
+    milestones: OfferDetailMilestoneDto[];
+    name: string;
+    object: 'offer_details';
+    options: OfferDetailOptionDto[];
+    slug: string;
+    type: OfferTypeDto;
+    terms: OfferDetailTermDto[];
+    about: string | null | undefined;
+    banner_url: string;
+    category: string;
+    ends_at: string | null;
+    logo_url: string;
+    starts_at: string;
+    tagline: string;
+};
+type OfferDetailFaqDto = {
+    answer: string | null;
+    question: string | null;
+};
+type OfferDetailLinkDto = {
+    label: string | null;
+    url: string | null;
+};
+type OfferDetailMilestoneDto = {
+    name: string | null;
+    schedule: string | null;
+    status: 'completed' | 'active' | 'upcoming';
+};
+type OfferDetailOptionDto = {
+    bid_increment: number | null;
+    floor_price_usd: number | null;
+    id: string;
+    minimum_purchase_usd: number | null;
+    price_usd: string | null;
+    sale_agreement_url: string | null;
+    slug: string;
+    total_token_supply: number | null;
+};
+type OfferDetailTermDto = {
+    key: string | null;
+    value: string | null;
+};
+type OfferDetailTokenDto = {
+    role: 'funding' | 'distribution' | 'swap';
+    chain: string;
+    address: string;
+};
+
+type OfferOptionId = Newtype<string, 'OfferOptionId'>;
+declare const OfferOptionId: (value: string) => OfferOptionId;
+type OfferOptionSlug = Newtype<string, 'OfferOptionSlug'>;
+declare const OfferOptionSlug: (value: string) => OfferOptionSlug;
+type OfferDetail = {
+    id: OfferId;
+    slug: OfferSlug;
+    type: OfferType;
+    name: string;
+    asset: Asset;
+    fundingAssets: Asset[];
+    tokens: OfferToken[];
+    about: string | null;
+    tagline: string;
+    bannerUrl: string;
+    logoUrl: string;
+    category: string;
+    startsAt: Date;
+    endsAt: Date | null;
+    faqs: FaqItem[];
+    links: Link[];
+    milestones: Milestone[];
+    options: OfferOption[];
+    terms: TermItem[];
+};
+declare const OfferDetail: {
+    fromDto: (dto: OfferDetailDto) => OfferDetail;
+};
+type OfferOption = {
+    id: OfferOptionId;
+    slug: OfferOptionSlug;
+    bidIncrement: number | null;
+    floorPriceUsd: number | null;
+    minimumPurchaseUsd: number | null;
+    priceUsd: string | null;
+    saleAgreementUrl: string | null;
+    totalTokenSupply: number | null;
+};
+declare const OfferOption: {
+    fromDto: (dto: OfferDetailOptionDto) => OfferOption;
+};
+type FaqItem = {
+    question: string | null;
+    answer: string | null;
+};
+declare const FaqItem: {
+    fromDto: (dto: OfferDetailFaqDto) => FaqItem;
+};
+type Link = {
+    label: string | null;
+    url: string | null;
+};
+declare const Link: {
+    fromDto: (dto: OfferDetailLinkDto) => Link;
+};
+type TermItem = {
+    key: string | null;
+    value: string | null;
+};
+declare const TermItem: {
+    fromDto: (dto: OfferDetailTermDto) => TermItem;
+};
+type Milestone = {
+    name: string | null;
+    schedule: string | null;
+    status: 'completed' | 'active' | 'upcoming';
+};
+declare const Milestone: {
+    fromDto: (dto: OfferDetailMilestoneDto) => Milestone;
+};
+type TokenRole = 'funding' | 'distribution' | 'swap';
+type OfferToken = {
+    role: TokenRole;
+    chain: Chain;
+    address: EvmContractAddress;
+};
+declare const OfferToken: {
+    fromDto: (dto: OfferDetailTokenDto) => OfferToken;
+};
+
+/** Unique identifier for a participation. */
+type ParticipationId = Newtype<string, 'ParticipationId'>;
+/** Casts a string into a typed {@link ParticipationId}. */
+declare const ParticipationId: (value: string) => ParticipationId;
+/** Blockchain identifier for where a participation is funded. */
+type Blockchain = Newtype<string, 'Blockchain'>;
+/** Casts a string into a typed {@link Blockchain}. */
+declare const Blockchain: (value: string) => Blockchain;
+/** Wallet address used for a participation. */
+type WalletAddress = Newtype<`0x${string}`, 'WalletAddress'>;
+/** Casts a `0x`-prefixed string into a typed {@link WalletAddress}. */
+declare const WalletAddress: (value: `0x${string}`) => WalletAddress;
+/** Possible participation lifecycle states returned by the API. */
+type ParticipationStatus = ParticipationStatusDto;
+/** Pagination params for listing participations, with an optional offer filter. */
+interface ParticipationsPaginationParams extends PaginationParams {
+    offerId?: OfferId;
+}
+declare const ParticipationsPaginationParams: {
+    toQueryParams: (params: ParticipationsPaginationParams) => Record<string, QueryParamValue>;
+};
+/** Domain model for a participation returned by CoinList APIs. */
+type Participation = {
+    /** Unique participation id. */
+    id: ParticipationId;
+    /** Parent offer id. */
+    offerId: OfferId;
+    /** Selected offer option id. */
+    offerOptionId: OfferOptionId;
+    /** Current processing status. */
+    status: ParticipationStatus;
+    /** Raw participation amount from API. */
+    amount: string;
+    /** Human-readable formatted amount from API. */
+    displayAmount: string;
+    /** Asset metadata for the participation amount. */
+    asset: Asset;
+    /** Funding chain identifier. */
+    chain: Blockchain;
+    /** Creation timestamp, if returned by API. */
+    insertedAt: Date | null;
+    /** Last update timestamp, if returned by API. */
+    updatedAt: Date | null;
+    /** Wallet used for participation, blank values normalized to null. */
+    walletAddress: WalletAddress | null;
+};
+declare const Participation: {
+    /** Maps API DTO shape into the SDK participation domain model. */
+    fromDto: (dto: ParticipationDto) => Participation;
+};
+/** Parameters required to create a new participation. */
+type CreateParticipationParams = {
+    /** Offer to participate in. */
+    offerId: OfferId;
+    /** Offer option selected for participation. */
+    offerOptionId: OfferOptionId;
+    /** Blockchain for funding. */
+    chain: Blockchain;
+    /** Wallet address that funds the participation. */
+    walletAddress: WalletAddress;
+    /**
+     * Decimal token amount to participate with (e.g. `"100"` for 100 USDC), NOT
+     * raw base units. The backend rescales this by the asset's decimals to verify
+     * it against the on-chain approval allowance.
+     */
+    amount: string;
+    /** Funding asset id. */
+    assetId: AssetId;
+    /**
+     * Hash of the ERC-20 `approve()` transaction covering this participation.
+     * Required: the backend verifies it on-chain (sender, token, spender, and
+     * approved amount) before confirming the participation.
+     */
+    approvalTransactionHash: string;
+};
+declare const CreateParticipationParams: {
+    /** Maps participation creation params into API DTO payload. */
+    toDto: (params: CreateParticipationParams) => CreateParticipationDto;
+};
+
+/**
+ * Read/write operations for token sales: listing and reading the current user's
+ * participations, and recording a new one. The on-chain execution flow
+ * (`executeTokenSale`) is layered on top of this in the client-side namespace.
+ */
+interface CoinListTokenSaleNamespace {
+    /**
+     * Fetches all participations by iterating through every paginated response,
+     * optionally filtered by offer.
+     *
+     * Requires an authenticated user; throws {@link NotAuthenticatedError}
+     * otherwise.
+     */
+    list(offerId?: OfferId): Promise<Participation[]>;
+    /**
+     * Fetches a single page of participations, optionally filtered by offer.
+     *
+     * Requires an authenticated user; throws {@link NotAuthenticatedError}
+     * otherwise.
+     */
+    listPage(params: ParticipationsPaginationParams): Promise<PaginatedResponse<Participation>>;
+    /**
+     * Fetches a participation by id.
+     *
+     * Requires an authenticated user; throws {@link NotAuthenticatedError}
+     * otherwise.
+     */
+    get(id: ParticipationId): Promise<Participation>;
+    /**
+     * Records a participation with CoinList.
+     *
+     * Requires an authenticated user; throws {@link NotAuthenticatedError}
+     * otherwise.
+     */
+    createParticipation(params: CreateParticipationParams): Promise<Participation>;
+}
+declare class CoinListTokenSaleNamespaceImpl implements CoinListTokenSaleNamespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    list(offerId?: OfferId): Promise<Participation[]>;
+    listPage(params: ParticipationsPaginationParams): Promise<PaginatedResponse<Participation>>;
+    get(id: ParticipationId): Promise<Participation>;
+    createParticipation(params: CreateParticipationParams): Promise<Participation>;
+}
+
+type Ticker = Newtype<string, 'Ticker'>;
+declare const Ticker: (value: string) => Ticker;
+type OrderBookSide = 'buy' | 'sell';
+
+/**
+ * No `chain` on the read params: Ondo runs no sandbox, so every environment
+ * prices against Ondo production on Ethereum mainnet. Accepting a chain would
+ * let a caller ask for Sepolia and silently receive mainnet pricing.
+ * {@link BuildOndoSwapTransactionParams} is the exception, and says why.
+ */
+type GetOndoTradingStatusParams = {
+    symbol: AssetSymbol;
+    /**
+     * Required, and deliberately not defaulted: `tradable` and both order caps
+     * describe this side only. Guessing `buy` would hand buy caps to someone
+     * sizing a sell. The endpoint answers 422 without it.
+     */
+    side: OrderBookSide;
+};
+/** How long Ondo should hold the price. Omit to take Ondo's own default. */
+type OndoQuoteDuration = 'short' | 'long';
+/**
+ * A quote is sized by the quantity or by the dollar amount. The endpoint takes
+ * exactly one; `getOndoQuote` sends whichever is present.
+ */
+type OndoQuoteSize = {
+    tokenAmount: BlockchainAmount;
+} | {
+    notionalValue: DecimalString;
+};
+type GetOndoQuoteParams = {
+    symbol: AssetSymbol;
+    side: OrderBookSide;
+    duration?: OndoQuoteDuration;
+} & OndoQuoteSize;
+/**
+ * What it takes to turn an indicative price into signed, fillable calldata.
+ *
+ * Sized by `amount` alone - the coin being spent, in its own base units - with
+ * no `notionalValue` alternative: the calldata authorises a specific ERC-20
+ * pull, so the number that ends up on chain has to be the number the caller
+ * meant, not one derived from a dollar figure. It is the **gross**: CoinList's
+ * fee comes off it, and Ondo prices the remainder.
+ *
+ * Buy-only, so there is no `side`. There is no funding token either - frontline
+ * resolves both tokens from the offer, because Ninshubur signs a request bound
+ * to them and a caller that could name them could have CoinList sign for a
+ * contract of its own.
+ *
+ * `chain` is required here although the read params refuse it, because this
+ * one names a real contract on a real chain rather than asking Ondo for a
+ * price. `walletAddress` must be the wallet that will *send* the transaction:
+ * the calldata is signed over it, so a transaction built for one wallet and
+ * broadcast by another reverts.
+ */
+type BuildOndoSwapTransactionParams = {
+    symbol: AssetSymbol;
+    chain: EthereumChain;
+    /** The wallet that will broadcast, and that receives the asset. */
+    walletAddress: EvmWalletAddress;
+    /**
+     * The gross amount to spend, in the funding token's base units.
+     *
+     * Its `decimals` are also what the response's `pay_input_decimals` is
+     * checked against: frontline resolves the funding token from the offer
+     * rather than from this request, so the two are independent answers to the
+     * same question and a disagreement means the wrong token was sized.
+     */
+    amount: BlockchainAmount;
+};
+
+/**
+ * Raw JSON models for the Ondo swap endpoints, mirroring
+ * `OndoSwapTradingStatus`, `OndoSwapQuote` and `OndoSwapTransaction` in
+ * frontline's OpenAPI schema. The two GETs are free to poll: neither spends an
+ * attestation, so a client may call them while the user edits an order. The
+ * POST ({@link OndoSwapTransactionDto}) is not - it spends one and hands back
+ * signed calldata with a deadline.
+ *
+ * Neither GET takes a `chain`. Ondo runs no sandbox, so every environment
+ * prices against Ondo production on Ethereum mainnet. The POST does carry one:
+ * it targets a real contract, which on every environment but production is the
+ * Sepolia one with the mocked attestation.
+ */
+/**
+ * Whether an asset can be traded right now, and the caps if so.
+ *
+ * Every cap is a *human decimal* string and is nullable — Ondo answers a
+ * restricted `/v1/limits/*` with a 403, which frontline turns into
+ * `tradable: false` and three nulls rather than an error. A null cap therefore
+ * means **Ondo restricted the asset, not that the cap is unlimited**. The
+ * response carries no `asset_decimals`, so there is nothing to scale
+ * `gross_max_tokens` by.
+ *
+ * There is no `reason` field. A restriction surfaces only as `tradable: false`
+ * plus the nulls; frontline keeps Ondo's reason codes to its own admin surface
+ * and does not forward them.
+ */
+type OndoTradingStatusDto = {
+    object: 'ondo_swap_trading_status';
+    /** The `side` the request asked for, echoed back. */
+    side: 'buy' | 'sell';
+    /** For `side` only — an asset can be sellable while not buyable. */
+    tradable: boolean;
+    /** Whole tokens, for `side` only. E.g. `"100.000000000000000000"`. */
+    gross_max_tokens: string | null;
+    /** USD, for `side` only. E.g. `"1234.560000000000000000"`. */
+    gross_max_notional_value: string | null;
+    /**
+     * USD cap for the session the market is currently in, e.g. `"200000"`.
+     * Unlike the two above this comes from Ondo's sideless session endpoint, so
+     * it applies across buys and sells together.
+     */
+    gross_max_active_notional_value: string | null;
+};
+/** An indicative, size- and side-aware price for an Ondo asset. */
+type OndoQuoteDto = {
+    object: 'ondo_swap_quote';
+    /** EIP-155 chain id. Always `"1"`, per the no-sandbox note above. */
+    chain_id: string;
+    symbol: string;
+    /** Ticker of the underlying security, e.g. `"AAPL"` for `"AAPLon"`. */
+    ticker: string;
+    asset_address: string;
+    /** Decimals of the `asset_address` contract. Scales `token_base_units`. */
+    asset_decimals: number;
+    side: 'buy' | 'sell';
+    /**
+     * Quantity of the asset in its smallest unit, as a raw uint256 string:
+     * `"5000000000000000000"` is 5 tokens at 18 decimals. Map it with
+     * `blockchainAmountFromRawOrThrow`, not `parseBlockchainAmountOrThrow`.
+     *
+     * Not to be confused with the `token_amount` *request* parameter, which is
+     * the same quantity in whole tokens. Ondo names both `tokenAmount`, 1e18
+     * apart, so echoing one back as the other is a real hazard.
+     */
+    token_base_units: string;
+    /**
+     * USD price of one whole token as a human decimal string, e.g.
+     * `"225.273151158540753535"`. Already scaled, so it needs none of the
+     * handling `token_base_units` does.
+     */
+    price: string;
+};
+/**
+ * Signed, ready-to-broadcast calldata for a buy, and the amounts it commits
+ * to: `POST /v1/ondo/swap/transaction`.
+ *
+ * Unlike {@link OndoQuoteDto} this **spends an attestation**, so it is not
+ * pollable: one call per order, plus one per user-requested refresh. Frontline
+ * also reads the wallet's allowance before asking Ninshubur for anything, so
+ * an unapproved wallet is refused here rather than reverting on chain.
+ *
+ * Buy-only. There is no `side`: the funding token goes in and the asset comes
+ * out, both resolved from the offer, so a caller cannot name either.
+ *
+ * **Carries no identity and no price.** No `chain_id`, `symbol`, `ticker`,
+ * `side` or `price` - the request named the first few and frontline drops
+ * Ninshubur's `price` deliberately, because `GET /v1/ondo/swap/quote` already
+ * publishes one under that name at a different scale. Anything the UI needs
+ * beyond the amounts comes from that GET or from the offer.
+ *
+ * Every amount is a uint256 decimal string in one of two scales, and **both
+ * scales are on the wire**: `receive_output_amount` is in
+ * `receive_output_decimals`, and the other three are in
+ * `pay_input_decimals`. Neither is interchangeable with the quote's
+ * `asset_decimals`, which answers for a different number - see the two fields
+ * below.
+ *
+ * The response has no `object` envelope. `action` says what to do with the
+ * body, matching `AllowWalletResponseDto`.
+ */
+type OndoSwapTransactionDto = {
+    action: 'broadcast_transaction';
+    /** The swap contract the transaction is sent to. */
+    to: string;
+    /** ABI-encoded `swap(...)` calldata. Broadcast verbatim - never re-encode it. */
+    data: string;
+    /**
+     * When the signed calldata stops being accepted - RFC3339, e.g.
+     * `"2026-08-13T23:04:12Z"`. This is Ninshubur's `expiration`, which signs
+     * the same instant as the EIP-712 `deadline` in the calldata, so a
+     * transaction broadcast after it reverts.
+     */
+    expires_at: string;
+    /**
+     * Gross amount the wallet pays, echoing the requested `amount`, in the
+     * funding token's smallest unit. The approval is compared against this.
+     */
+    pay_input_amount: string;
+    /**
+     * Decimals `pay_input_amount`, `fee` and `notional_value` are counted in.
+     *
+     * Frontline reads it on-chain from the funding token, which it resolves from
+     * the offer rather than from anything the caller sent. That makes it the
+     * only published scale for a token the request never names - and an
+     * independent answer to the one the SDK derived when it sized the order,
+     * which is why `buildOndoSwapTransaction` compares the two.
+     */
+    pay_input_decimals: number;
+    /**
+     * CoinList's cut of `pay_input_amount`, in the same units. Taken off the
+     * deposit rather than added on top, so the approval never has to cover more.
+     * `"0"` until ENG-1718 turns a fee on - frontline rejects a non-zero one
+     * today.
+     */
+    fee: string;
+    /**
+     * `pay_input_amount` less `fee`, in the same units. This is the amount Ondo
+     * actually priced, and the numerator of the fill price.
+     */
+    notional_value: string;
+    /**
+     * Quantity of the asset the wallet receives, in the *asset's* smallest unit,
+     * e.g. `"264000000000000000"`. Scale it by `receive_output_decimals`, not by
+     * the funding token's and not by {@link OndoQuoteDto}'s `asset_decimals`.
+     */
+    receive_output_amount: string;
+    /**
+     * Decimals `receive_output_amount` is counted in.
+     *
+     * Reported by whatever priced the quantity, rather than looked up from the
+     * asset. That is not the same number as {@link OndoQuoteDto}'s
+     * `asset_decimals`, which frontline resolves from its own catalogue: the two
+     * are allowed to disagree, and only this one answers for the quantity in
+     * this response.
+     */
+    receive_output_decimals: number;
+};
+
+/**
+ * Whether an Ondo asset can be traded right now.
+ *
+ * The caps only mean anything while trading is open, so they live on the
+ * `tradable` branch. They stay {@link DecimalString} rather than
+ * {@link BlockchainAmount} because the response carries no `asset_decimals`:
+ * there is no honest exponent to attach, and the USD caps arrive with more
+ * fractional digits than a stablecoin has decimals.
+ *
+ * Each cap is independently nullable even when tradable — Ondo may open an
+ * asset for trading without publishing every limit.
+ *
+ * `side` is carried through from the response rather than dropped: the whole
+ * status describes one side, so a buy and a sell status are otherwise
+ * indistinguishable once a caller holds both.
+ */
+type OndoTradingStatus = {
+    type: 'tradable';
+    side: OrderBookSide;
+    /** Largest order in whole tokens. */
+    grossMaxTokens: DecimalString | null;
+    /** Largest order in USD. */
+    grossMaxNotionalValue: DecimalString | null;
+    /** USD cap for the session the market is currently in. */
+    grossMaxActiveNotionalValue: DecimalString | null;
+} | {
+    type: 'not-tradable';
+    side: OrderBookSide;
+};
+declare const OndoTradingStatus: {
+    fromDto: (dto: OndoTradingStatusDto) => OndoTradingStatus;
+};
+/**
+ * An indicative price for an Ondo asset, free to poll while the user edits an
+ * order.
+ *
+ * **No CoinList fee is applied to the quantity or the price.** Ondo prices
+ * exactly the amount asked for. A CoinList approval is fee-inclusive, so
+ * sizing a quote against one without netting the fee first overstates what the
+ * user receives. Showing a gross/net breakdown needs a CoinList swap
+ * contract's `preview`, and no such contract exists for Ondo yet.
+ *
+ * The quote carries no transaction to broadcast and no expiry. Building one is
+ * a separate endpoint that spends an attestation - see
+ * {@link OndoSwapTransaction}.
+ */
+type OndoQuote = {
+    /** Always `ethereum_mainnet`: Ondo runs no sandbox in any environment. */
+    chain: EthereumChain;
+    ticker: Ticker;
+    /** Needed to approve or transfer the asset; the quote is the only source. */
+    assetAddress: EvmContractAddress;
+    /**
+     * The asset as the quote resolves it, from frontline's own catalogue.
+     *
+     * Its `decimals` scale {@link tokenBaseUnits} and nothing else. They are
+     * **not** the scale of an {@link OndoSwapTransaction}'s output: that one is
+     * reported by whatever priced the quantity, the two sources are allowed to
+     * disagree, and only the one that produced a number answers for it.
+     */
+    asset: Erc20Asset;
+    side: OrderBookSide;
+    tokenBaseUnits: BlockchainAmount;
+    /**
+     * USD price of one whole token. Unscaled because Ondo has already scaled it,
+     * and by USDon's 18 decimals rather than the stablecoin's 6 — re-scaling it
+     * by either would be wrong.
+     */
+    price: DecimalString;
+};
+declare const OndoQuote: {
+    fromDto: (dto: OndoQuoteDto) => OndoQuote;
+};
+/**
+ * A signed, expiring buy: the calldata that fills it and the amounts it
+ * commits to, from `buildSwapTransaction`.
+ *
+ * Distinct from {@link OndoQuote} in three ways that matter: it costs an
+ * attestation to obtain, it expires, and it carries a {@link Tx} the wallet
+ * broadcasts verbatim. Treat it as single-use - once broadcast (or once
+ * `expiresAt` passes) it is spent, and a new one must be built.
+ *
+ * **It carries no identity.** No chain, ticker, asset or side: the endpoint
+ * publishes none of them, and inventing them from the request would assert
+ * what the server resolved rather than report it. What it does publish is the
+ * scale of every amount on it, so a caller needs nothing alongside it to read
+ * the numbers - only to name the asset, which the offer already does.
+ *
+ * It carries no price either. Divide {@link notionalValue} by
+ * {@link receiveOutputAmount} - see `computeOndoPrice` - which is the price
+ * this transaction actually fills at rather than an indicative one that has
+ * since moved.
+ */
+type OndoSwapTransaction = {
+    /**
+     * Broadcast as-is. The `to` is the swap contract, which is also the ERC-20
+     * spender the user must have approved.
+     */
+    tx: Tx;
+    /**
+     * When the calldata stops being accepted. A transaction broadcast after this
+     * reverts, so callers must compare against it before signing.
+     */
+    expiresAt: Date;
+    /** Gross amount the wallet pays, in the funding token's decimals. */
+    payInputAmount: BlockchainAmount;
+    /**
+     * CoinList's cut of {@link payInputAmount}, in the same decimals. Taken off
+     * the deposit rather than added on top, so the approval never has to cover
+     * more than `payInputAmount`. Zero until ENG-1718 lands.
+     */
+    fee: BlockchainAmount;
+    /**
+     * `payInputAmount` less `fee`, in the same decimals: what Ondo priced.
+     *
+     * Read from the response rather than subtracted here. Whether the fee comes
+     * off the deposit or goes on top of it is the server's definition to change,
+     * and a client that derives this cannot notice when it does.
+     */
+    notionalValue: BlockchainAmount;
+    /**
+     * What the buyer receives, at the scale whatever priced the quantity
+     * reported - not at the {@link OndoQuote}'s.
+     */
+    receiveOutputAmount: BlockchainAmount;
+};
+declare const OndoSwapTransaction: {
+    fromDto: (dto: OndoSwapTransactionDto) => OndoSwapTransaction;
+};
+
+/**
+ * Ondo swap reads, plus the write that turns one into a fillable transaction.
+ *
+ * The two reads are free to poll - neither spends an attestation, so a client
+ * may call them while the user edits an order. {@link buildSwapTransaction} is
+ * not: budget one call per order placed, plus one per refresh the user asks
+ * for.
+ *
+ * **No CoinList fee is applied to a read quote, and no read discloses one.**
+ * Ondo prices exactly the amount passed. A CoinList approval is fee-inclusive,
+ * so sizing a quote against a user's approval without subtracting the fee
+ * first overstates what they receive. A built transaction carries the fee
+ * explicitly, and it is zero until one lands (ENG-1718).
+ *
+ * Every method requires `AuthState === 'logged-in'` and throws
+ * {@link NotAuthenticatedError} otherwise.
+ */
+interface OndoNamespace {
+    getTradingStatus(params: GetOndoTradingStatusParams): Promise<OndoTradingStatus>;
+    getQuote(params: GetOndoQuoteParams): Promise<OndoQuote>;
+    /**
+     * Builds the buy for a specific wallet and amount: spends an attestation and
+     * returns calldata to broadcast, valid until
+     * {@link OndoSwapTransaction.expiresAt}.
+     *
+     * The wallet must have approved the swap contract to spend `amount` of the
+     * offer's funding token first - frontline reads the allowance before asking
+     * Ninshubur for anything, and rejects a short one with a 422 carrying
+     * `code: "insufficient_allowance"`. See `prepareSwap` on the client
+     * namespace, which approves and then builds, in that order.
+     *
+     * Buy-only, and the tokens are the offer's rather than the caller's to name.
+     */
+    buildSwapTransaction(params: BuildOndoSwapTransactionParams): Promise<OndoSwapTransaction>;
+}
+declare class OndoNamespaceImpl implements OndoNamespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    getTradingStatus(params: GetOndoTradingStatusParams): Promise<OndoTradingStatus>;
+    getQuote(params: GetOndoQuoteParams): Promise<OndoQuote>;
+    buildSwapTransaction(params: BuildOndoSwapTransactionParams): Promise<OndoSwapTransaction>;
+}
+
+/** Parameters shared by contract reads scoped to a chain. */
+type SwapContractRef = {
+    contractAddress: EvmContractAddress;
+    chain: EthereumChain;
+};
+type GetSwapAuthorizationParams = SwapContractRef & {
+    walletAddress: EvmWalletAddress;
+};
+type GetSwapPreviewParams = SwapContractRef & {
+    inputToken: EvmContractAddress;
+    amount: bigint;
+};
+type AllowWalletParams = {
+    offerId: OfferId;
+    walletAddress: EvmWalletAddress;
+    chain: EthereumChain;
+    signature: string;
+};
+
+/**
+ * Read/write operations for the on-chain swap flow: quoting a swap, inspecting
+ * contract state, checking token allowances, and proving/allow-listing wallet
+ * ownership.
+ */
+interface SuperstateSwapNamespace {
+    /**
+     * Checks whether a wallet is authorized to swap against the given contract.
+     */
+    getAuthorization(params: GetSwapAuthorizationParams): Promise<SwapAuthorization>;
+    /**
+     * Fetches a read-only quote for swapping `amount` of `inputToken`.
+     */
+    getPreview(params: GetSwapPreviewParams): Promise<SwapPreview>;
+    /**
+     * Reads the current on-chain state of a swap contract.
+     */
+    getStatus(params: SwapContractRef): Promise<SwapStatus>;
+    /**
+     * Reads the ERC-20 output token a swap contract pays out.
+     */
+    getOutputToken(params: SwapContractRef): Promise<Erc20Asset>;
+    /**
+     * Submits a signed wallet-ownership challenge to allow-list the wallet for
+     * an offer, identified by its offer id. Obtain the challenge from
+     * `WalletsNamespace.createOwnershipChallenge`.
+     */
+    allowWallet(params: AllowWalletParams): Promise<AllowWalletResponse>;
+}
+declare class SuperstateSwapNamespaceImpl implements SuperstateSwapNamespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    getAuthorization(params: GetSwapAuthorizationParams): Promise<SwapAuthorization>;
+    getPreview(params: GetSwapPreviewParams): Promise<SwapPreview>;
+    getStatus(params: SwapContractRef): Promise<SwapStatus>;
+    getOutputToken(params: SwapContractRef): Promise<Erc20Asset>;
+    allowWallet(params: AllowWalletParams): Promise<AllowWalletResponse>;
+}
+
+/** Request body for `POST /v1/offers/:offer_id/addresses`. */
+type CreateOfferOptionAddressDto = {
+    offer_option_id: string;
+    wallet_address: string;
+    chain: string;
+    signature: string;
+};
+/** Binding object returned by the `/v1/offers/:offer_id/addresses` resource. */
+type OfferOptionAddressDto = {
+    id: string;
+    offer_option_id: string;
+    address: string;
+    protocol: WalletProtocol;
+    created_at: string;
+};
+
+/** Unique identifier for a proven wallet binding on an offer option. */
+type OfferOptionAddressId = Newtype<string, 'OfferOptionAddressId'>;
+/** Casts a string into a typed {@link OfferOptionAddressId}. */
+declare const OfferOptionAddressId: (value: string) => OfferOptionAddressId;
+/**
+ * A user's external wallet, proven via a wallet-ownership challenge and bound
+ * to an offer option. Returned by the `/v1/offers/:offer_id/addresses` resource.
+ */
+type OfferOptionAddress = {
+    /** Unique binding id. */
+    id: OfferOptionAddressId;
+    /** Offer option the wallet is bound to. */
+    offerOptionId: OfferOptionId;
+    /** The connected external wallet address. */
+    address: EvmWalletAddress;
+    /**
+     * Protocol the binding is scoped to. An EVM address binds once per option
+     * regardless of which EVM chain proved ownership.
+     */
+    protocol: WalletProtocol;
+    /** When the binding was created. */
+    createdAt: Date;
+};
+declare const OfferOptionAddress: {
+    /** Maps the API DTO into the SDK offer-option-address domain model. */
+    fromDto: (dto: OfferOptionAddressDto) => OfferOptionAddress;
+};
+/** Parameters required to connect a proven external wallet to an offer option. */
+type ConnectExternalWalletParams = {
+    /** Offer the option belongs to. */
+    offerId: OfferId;
+    /** Offer option to bind the wallet to. */
+    offerOptionId: OfferOptionId;
+    /** External wallet address that was proven. */
+    walletAddress: EvmWalletAddress;
+    /** Chain the ownership was proven on. */
+    chain: EthereumChain;
+    /** Signature of the wallet-ownership challenge message. */
+    signature: Hex;
+};
+declare const ConnectExternalWalletParams: {
+    /** Maps connect-wallet params into the API DTO payload. */
+    toDto: (params: ConnectExternalWalletParams) => CreateOfferOptionAddressDto;
+};
+
+/** Challenge kinds accepted by `POST /v1/wallet-ownership`. */
+type WalletOwnershipChallengeTypeDto = 'plain' | 'siwe';
+/**
+ * Request body for `POST /v1/wallet-ownership`. `challenge_type` defaults to
+ * `plain` on the backend; the SIWE fields (`domain`, `uri`, `statement`) are
+ * required only when `challenge_type` is `siwe` and must be absent otherwise.
+ */
+type CreateWalletOwnershipChallengeDto = {
+    wallet_address: string;
+    chain: string;
+    challenge_type?: WalletOwnershipChallengeTypeDto;
+    domain?: string;
+    uri?: string;
+    statement?: string;
+};
+/** Response body for `POST /v1/wallet-ownership`. */
+type WalletOwnershipChallengeDto = {
+    message: string;
+    expires_at: string;
+};
+
+/** Fields common to every wallet-ownership challenge request. */
+type WalletOwnershipChallengeParamsBase = {
+    /** Wallet address to prove ownership of. */
+    walletAddress: EvmWalletAddress;
+    /** Chain the wallet belongs to. */
+    chain: EthereumChain;
+};
+/**
+ * How the ownership challenge is framed: a plain message or a Sign-In With
+ * Ethereum challenge. Extracted as its own type so SDK consumers can pass it as
+ * a standalone param without reaching into the {@link CreateWalletOwnershipChallengeParams}
+ * union.
+ */
+type WalletChallengeType = CreateWalletOwnershipChallengeParams['challengeType'];
+/**
+ * A single-use ownership challenge returned by `POST /v1/wallet-ownership`.
+ * The consumer signs {@link message} with their wallet, then submits the
+ * signature to connect the wallet to an offer option.
+ */
+type WalletOwnershipChallenge = {
+    /** The message the wallet must sign. */
+    message: string;
+    /** When the challenge expires and can no longer be consumed. */
+    expiresAt: Date;
+};
+declare const WalletOwnershipChallenge: {
+    /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
+    fromDto: (dto: WalletOwnershipChallengeDto) => WalletOwnershipChallenge;
+};
+/**
+ * Parameters for requesting a wallet-ownership challenge. Modeled as a
+ * discriminated union on `challengeType` so a `siwe` challenge must carry
+ * `domain`/`uri`/`statement`, matching the backend contract at compile time.
+ */
+type CreateWalletOwnershipChallengeParams = (WalletOwnershipChallengeParamsBase & {
+    /** A bare message the wallet signs. */
+    challengeType: 'plain';
+}) | (WalletOwnershipChallengeParamsBase & {
+    /** Marks this as a Sign-In With Ethereum challenge. */
+    challengeType: 'siwe';
+    /** The requesting site's hostname (e.g. `example.com`). */
+    domain: string;
+    /** The requesting site's URI. */
+    uri: string;
+    /** Human-readable statement shown in the signing prompt. */
+    statement: string;
+});
+declare const CreateWalletOwnershipChallengeParams: {
+    /**
+     * Maps challenge-request params into the API DTO payload. The discriminated
+     * union guarantees SIWE fields are present exactly when `challengeType` is
+     * `siwe`, so the mapping narrows on the discriminant.
+     */
+    toDto: (params: CreateWalletOwnershipChallengeParams) => CreateWalletOwnershipChallengeDto;
+};
+
+type ListOptionAddressesParams = {
+    offerId: OfferId;
+    /** Offer option whose bindings to list. */
+    offerOptionId: OfferOptionId;
+};
+type RemoveOptionAddressParams = {
+    offerId: OfferId;
+    /** Binding to remove, as returned by {@link WalletsNamespace.list}. */
+    addressId: OfferOptionAddressId;
+};
+/**
+ * The user's external wallets: proving ownership of one, binding it to an
+ * offer option, and managing those bindings.
+ *
+ * Ownership proof is a provider-agnostic primitive — the swap flow uses the
+ * same challenge to allow-list a wallet — so it lives here rather than being
+ * duplicated per product namespace.
+ *
+ * Every method requires an authenticated user and throws
+ * {@link NotAuthenticatedError} otherwise.
+ */
+interface WalletsNamespace {
+    /**
+     * Creates a single-use challenge the user signs to prove they control a
+     * wallet. Supports both `plain` and `siwe` challenges. Pass the signature of
+     * the returned {@link WalletOwnershipChallenge.message} to
+     * {@link connectExternal}.
+     */
+    createOwnershipChallenge(params: CreateWalletOwnershipChallengeParams): Promise<WalletOwnershipChallenge>;
+    /**
+     * Binds a proven external wallet to an offer option, using a signature of a
+     * challenge from {@link createOwnershipChallenge}.
+     */
+    connectExternal(params: ConnectExternalWalletParams): Promise<OfferOptionAddress>;
+    /**
+     * Lists the user's proven wallet bindings for one offer option — the single
+     * bound address for an `external_wallet` option, or every allow-listed
+     * wallet for a `whitelisted_wallet` option.
+     */
+    list(params: ListOptionAddressesParams): Promise<OfferOptionAddress[]>;
+    /**
+     * Removes one of the user's wallet bindings and returns the removed binding.
+     */
+    remove(params: RemoveOptionAddressParams): Promise<OfferOptionAddress>;
+}
+declare class WalletsNamespaceImpl implements WalletsNamespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    createOwnershipChallenge(params: CreateWalletOwnershipChallengeParams): Promise<WalletOwnershipChallenge>;
+    connectExternal(params: ConnectExternalWalletParams): Promise<OfferOptionAddress>;
+    list(params: ListOptionAddressesParams): Promise<OfferOptionAddress[]>;
+    remove(params: RemoveOptionAddressParams): Promise<OfferOptionAddress>;
+}
+
+type DocumentSubmissionStatusDto = 'INITIALIZED' | 'SENT' | 'VIEWED' | 'COMPLETED' | 'DECLINED' | 'EXPIRED';
+type DocumentFormTypeDto = 'w8_ben' | 'w8_ben_e';
+type DocumentSubmissionDto = {
+    object: 'document_submission';
+    status: DocumentSubmissionStatusDto;
+    form_type: DocumentFormTypeDto;
+};
+
+/** Document types that can be signed via {@link CoinListClient.submitDocument}. */
+type DocumentType = 'tax_certification';
+/** Signing-state machine status for a document submission. */
+type DocumentSubmissionStatus = DocumentSubmissionStatusDto;
+/** The tax form derived from the entity's kind (individual vs company/trust). */
+type DocumentFormType = DocumentFormTypeDto;
+/** Result of starting (or resuming) a document signing submission. */
+type DocumentSubmission = {
+    status: DocumentSubmissionStatus;
+    formType: DocumentFormType;
+};
+declare const DocumentSubmission: {
+    fromDto: (dto: DocumentSubmissionDto) => DocumentSubmission;
+};
+
+type KycTokenDto = {
+    object: 'kyc_token';
+    token: string;
+};
+
+/**
+ * Sumsub verification level name. Determines which screens the Sumsub WebSDK
+ * shows (levels are configured in the Sumsub dashboard). The backend
+ * prescribes the level (and whether the applicant must be reset first) in the
+ * requirement statuses response — clients never compute levels themselves.
+ */
+type KycLevelName = string;
+/** Short-lived Sumsub WebSDK access token scoped to the current user. */
+type KycToken = {
+    token: string;
+};
+declare const KycToken: {
+    fromDto: (dto: KycTokenDto) => KycToken;
+};
+
+type PiiKindDto = 'person' | 'company';
+type PiiJurisdictionDto = {
+    iso_2: string;
+    name: string | null;
+};
+type PiiAddressDto = {
+    street: string | null;
+    city: string | null;
+    state: string | null;
+    postal_code: string | null;
+    country: string | null;
+};
+type PiiDto = {
+    object: 'user_pii';
+    kind: PiiKindDto;
+    full_legal_name: string | null;
+    date_of_birth: string | null;
+    jurisdiction: PiiJurisdictionDto | null;
+    tax_id: string | null;
+    permanent_address: PiiAddressDto;
+};
+
+/** Whether the PII belongs to an individual or a company/trust entity. */
+type PiiKind = PiiKindDto;
+/** ISO 3166-1 alpha-2 country code (e.g. `'US'`). */
+type Iso2CountryCode = Newtype<string, 'Iso2CountryCode'>;
+declare const Iso2CountryCode: (value: string) => Iso2CountryCode;
+/** Jurisdiction derived from the entity's address country. */
+type PiiJurisdiction = {
+    iso2: Iso2CountryCode;
+    name: string | null;
+};
+declare const PiiJurisdiction: {
+    fromDto: (dto: PiiJurisdictionDto) => PiiJurisdiction;
+};
+/** Permanent address on file for the entity. */
+type PiiAddress = {
+    street: string | null;
+    city: string | null;
+    state: string | null;
+    postalCode: string | null;
+    country: string | null;
+};
+declare const PiiAddress: {
+    fromDto: (dto: PiiAddressDto) => PiiAddress;
+};
+/**
+ * The current user's PII, used to pre-fill tax forms such as the W-8BEN.
+ * Fields the entity hasn't provided are `null`.
+ */
+type Pii = {
+    kind: PiiKind;
+    fullLegalName: string | null;
+    dateOfBirth: string | null;
+    jurisdiction: PiiJurisdiction | null;
+    taxId: string | null;
+    permanentAddress: PiiAddress;
+};
+declare const Pii: {
+    fromDto: (dto: PiiDto) => Pii;
+};
+
+type RequirementTypeDto = 'kyc_approved' | 'identity_verified' | 'proof_of_address' | 'source_of_funds' | 'external_wallet' | 'whitelisted_wallet' | 'jurisdiction' | 'accreditation' | 'document';
+type RequirementDto = {
+    object: 'requirement';
+    id: string;
+    type: RequirementTypeDto;
+    details: Record<string, unknown> | null;
+};
+type RequirementStatusValueDto = 'not_started' | 'in_progress' | 'action_needed' | 'completed' | 'rejected';
+type RequirementActionNeededReasonDto = 'kyc_not_verified' | 'update_pii_data';
+/**
+ * Object form of a requirement status, used when the status carries extra
+ * data: the action-needed reason and/or the Sumsub flow that resolves the
+ * requirement (kyc_level + kyc_reset, forwarded to the kyc-token endpoint).
+ */
+type RequirementStatusObjectDto = {
+    status: RequirementStatusValueDto;
+    action?: RequirementActionNeededReasonDto;
+    kyc_level?: string;
+    kyc_reset?: boolean;
+};
+type RequirementStatusesDto = {
+    object: 'requirement_statuses';
+    offer_id: string;
+    statuses: Record<string, RequirementStatusValueDto | RequirementStatusObjectDto>;
+};
+
+type RequirementId = Newtype<string, 'RequirementId'>;
+declare const RequirementId: (value: string) => RequirementId;
+type RequirementType = RequirementTypeDto;
+type RequirementStatusValue = RequirementStatusValueDto;
+type RequirementActionNeededReason = RequirementActionNeededReasonDto;
+type Requirement = {
+    id: RequirementId;
+    type: RequirementType;
+    details: Record<string, unknown> | null;
+};
+declare const Requirement: {
+    fromDto: (dto: RequirementDto) => Requirement;
+};
+type RequirementStatusInfo = {
+    id: RequirementId;
+    status: RequirementStatusValue;
+    /** Why the requirement needs action (KYC-backed requirements only). */
+    action: RequirementActionNeededReason | null;
+    /**
+     * The Sumsub verification level that resolves this requirement, prescribed
+     * by the backend. Present exactly when an inline Sumsub flow can be started.
+     */
+    kycLevel?: KycLevelName;
+    /**
+     * Whether the Sumsub applicant must be reset before starting the flow
+     * (redoing an already-approved level, e.g. to update stale PII). Forward to
+     * the kyc-token request as-is.
+     */
+    kycReset?: boolean;
+};
+declare const RequirementStatusInfo: {
+    fromStatusesDto: (dto: RequirementStatusesDto) => RequirementStatusInfo[];
+};
+
+type CreateKycTokenParams = {
+    /**
+     * Sumsub verification level to run. Defaults to the backend's standard
+     * level.
+     */
+    levelName?: KycLevelName;
+    /**
+     * Resets the Sumsub applicant first, so an already-approved level can be
+     * executed again (e.g. to update stale PII). Pass the `kycReset` value from
+     * the requirement status, and never on mid-flow token refreshes.
+     */
+    reset?: boolean;
+};
+type SubmitDocumentParams = {
+    /** Currently only `tax_certification` (W-8BEN / W-8BEN-E). */
+    documentType: DocumentType;
+    /**
+     * Signing-form values keyed by the document's DocuSeal field names,
+     * forwarded verbatim to pre-fill the document.
+     */
+    fields: Record<string, string>;
+};
+/**
+ * Everything a user must satisfy before they can participate in an offer:
+ * reading the checklist and its live statuses, and the operations that satisfy
+ * individual requirements — identity verification (KYC) and tax-document
+ * signing.
+ *
+ * Wallet requirements (`external_wallet`, `whitelisted_wallet`) are satisfied
+ * through `WalletsNamespace` instead, since wallet proofs are also used
+ * outside the requirements flow.
+ *
+ * Every method requires an authenticated user and throws
+ * {@link NotAuthenticatedError} otherwise.
+ */
+interface RequirementsNamespace {
+    /**
+     * Fetches the requirements for every option of an offer, grouped by option
+     * id. This is the definition of the checklist; {@link statuses} tells you
+     * where the user stands against it.
+     */
+    forOffer(offerId: OfferId): Promise<Record<OfferOptionId, Requirement[]>>;
+    /**
+     * Fetches the current user's status for each requirement of an offer.
+     */
+    statuses(offerId: OfferId): Promise<RequirementStatusInfo[]>;
+    /**
+     * Creates a short-lived Sumsub WebSDK access token so an identity
+     * verification (KYC) flow can be started, e.g. by the `IdentityVerification`
+     * component.
+     */
+    createKycToken(params?: CreateKycTokenParams): Promise<KycToken>;
+    /**
+     * Fetches the current user's PII, used to pre-fill tax forms such as the
+     * W-8BEN. Fields the entity hasn't provided are `null`.
+     */
+    getPii(): Promise<Pii>;
+    /**
+     * Starts (or resumes) a document signing submission.
+     */
+    submitDocument(params: SubmitDocumentParams): Promise<DocumentSubmission>;
+}
+declare class RequirementsNamespaceImpl implements RequirementsNamespace {
+    protected readonly ctx: SharedNamespaceContext;
+    constructor(ctx: SharedNamespaceContext);
+    forOffer(offerId: OfferId): Promise<Record<OfferOptionId, Requirement[]>>;
+    statuses(offerId: OfferId): Promise<RequirementStatusInfo[]>;
+    createKycToken(params?: CreateKycTokenParams): Promise<KycToken>;
+    getPii(): Promise<Pii>;
+    submitDocument(params: SubmitDocumentParams): Promise<DocumentSubmission>;
+}
+
+/**
+ * Reads over CoinList's offers: the catalogue a user can browse, and the full
+ * detail of a single offer.
+ *
+ * Every method requires an authenticated user and throws
+ * {@link NotAuthenticatedError} otherwise. On the server, the same reads are
+ * additionally available with an app-level token — see
+ * `ServerOffersNamespace`.
+ */
+interface OffersNamespace {
+    /**
+     * Fetches every offer, iterating through all pages. Prefer {@link listPage}
+     * when you render a paginated list yourself.
+     */
+    list(): Promise<Offer[]>;
+    /**
+     * Fetches a single page of offers. Pass the previous response's
+     * `startingAfter` as `after` to advance.
+     */
+    listPage(params: PaginationParams): Promise<PaginatedResponse<Offer>>;
+    /**
+     * Fetches the full detail of one offer, including its options. Note this
+     * returns {@link OfferDetail} — a richer model than the {@link Offer}
+     * summaries {@link list} returns.
+     */
+    get(id: OfferId): Promise<OfferDetail>;
+}
+declare class OffersNamespaceImpl implements OffersNamespace {
+    private readonly ctx;
+    constructor(ctx: SharedNamespaceContext);
+    list(): Promise<Offer[]>;
+    listPage(params: PaginationParams): Promise<PaginatedResponse<Offer>>;
+    get(id: OfferId): Promise<OfferDetail>;
+}
+
+/**
+ * Raw JSON from the token registry (Nabu), a static CDN serving token display
+ * metadata. It is a separate backend from frontline: responses omit optional
+ * fields rather than sending `null`, and may grow unknown fields at any time;
+ * we only read the fields named here.
+ */
+type NabuLogoImageDto = {
+    url: string;
+    width: number;
+    height: number;
+};
+/**
+ * A logo is either a single vector (valid at any size) or a dimensioned
+ * raster original plus pre-scaled variants at ascending widths.
+ */
+type NabuLogoDto = {
+    kind: 'VECTOR';
+    url: string;
+} | {
+    kind: 'RASTER';
+    original: NabuLogoImageDto;
+    variants: NabuLogoImageDto[];
+};
+/** One token from the registry's `/{chain}/token/{address}` route. */
+type NabuTokenDto = {
+    data_version: string;
+    schema_version: number;
+    chain: string;
+    protocol: string;
+    chain_id: number;
+    kind: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logo: NabuLogoDto;
+    logo_dark?: NabuLogoDto;
+    coingecko_id?: string;
+    teller_code?: string;
+    address: string;
+};
+/**
+ * One asset inside a chain snapshot. The snapshot mixes the chain's native
+ * coin (`kind: 'COIN'`, no address) with its tokens (`kind: 'TOKEN'`), so
+ * `address` is optional here where {@link NabuTokenDto} requires it.
+ */
+type NabuChainAssetDto = {
+    kind: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logo: NabuLogoDto;
+    logo_dark?: NabuLogoDto;
+    address?: string;
+};
+/** The registry's `/{chain}/assets.json` route: one chain, all its assets. */
+type NabuChainAssetsDto = {
+    data_version: string;
+    schema_version: number;
+    chain: string;
+    protocol: string;
+    assets: NabuChainAssetDto[];
+};
+
+/**
+ * An absolute URL to a logo image in the token registry. Registry image URLs
+ * are content-fingerprinted and served immutable, so a value is safe to cache
+ * for as long as you hold it.
+ */
+type TokenLogoUrl = Newtype<string, 'TokenLogoUrl'>;
+declare const TokenLogoUrl: (value: string) => TokenLogoUrl;
+type TokenLogoImage = {
+    url: TokenLogoUrl;
+    width: number;
+    height: number;
+};
+/**
+ * `VECTOR` is a single SVG. `RASTER` has webp variants at 32/64/128/256/512px
+ * widths (never wider than the original): use the smallest one that covers
+ * your render size, or `original` if none does.
+ */
+type TokenLogo = {
+    kind: 'VECTOR';
+    url: TokenLogoUrl;
+} | {
+    kind: 'RASTER';
+    original: TokenLogoImage;
+    variants: TokenLogoImage[];
+};
+declare const TokenLogo: {
+    /** `baseUrl` is the registry origin; registry URLs are root-relative. */
+    fromDto: (dto: NabuLogoDto, baseUrl: string) => TokenLogo;
+};
+/**
+ * Display metadata for one token, from CoinList's public token registry.
+ *
+ * Keyed by `(chain, address)` — never by symbol, which can collide. The
+ * registry is curated: a token missing from it is an expected answer, not an
+ * error, so lookups return `null` rather than throwing.
+ */
+type TokenMetadata = {
+    identifier: TokenIdentifier;
+    name: string;
+    symbol: AssetSymbol;
+    decimals: AssetDecimals;
+    logo: TokenLogo;
+    /** Dark-theme logo; `null` when the registry configures none. */
+    logoDark: TokenLogo | null;
+};
+declare const TokenMetadata: {
+    /** `baseUrl` is the registry origin; registry logo URLs are root-relative. */
+    fromDto: (dto: NabuTokenDto, baseUrl: string) => TokenMetadata;
+    /**
+     * Maps a chain snapshot to the tokens it lists, skipping the chain's native
+     * coin (`kind: 'COIN'`, no contract address).
+     */
+    fromChainAssetsDto: (dto: NabuChainAssetsDto, baseUrl: string) => TokenMetadata[];
+};
+
+/**
+ * Token display metadata — name, symbol, decimals, and logos — from
+ * CoinList's public token registry, keyed by {@link TokenIdentifier} (the
+ * same chain + address pairs `OfferDetail.tokens` carries).
+ *
+ * Unlike the other namespaces, this one is public: no method requires an
+ * authenticated user, and nothing here touches the CoinList API — reads go to
+ * the registry's CDN.
+ */
+interface TokensNamespace {
+    /**
+     * Fetches metadata for one token. Returns `null` when the registry does not
+     * list the token — the registry is curated, so callers must fall back to
+     * their own display defaults rather than treat this as an error.
+     */
+    get(token: TokenIdentifier): Promise<TokenMetadata | null>;
+    /**
+     * Fetches all available tokens the registry lists for `chain`, in one
+     * request. Prefer this over calling {@link get} in a loop when displaying a
+     * catalogue: two hundred tokens is still a single snapshot download.
+     *
+     * Unlike {@link get}, a missing chain snapshot throws rather than returning
+     * `[]`: the registry publishes one for every chain it knows, so its absence
+     * is a deployment problem, not an empty catalogue.
+     */
+    list(chain: EthereumChain): Promise<TokenMetadata[]>;
+}
+declare class TokensNamespaceImpl implements TokensNamespace {
+    private readonly api;
+    /**
+     * Takes the registry origin rather than a `SharedNamespaceContext`: the
+     * registry is unauthenticated and on its own host, so the frontline sender
+     * and the auth check would both be dead weight here.
+     */
+    constructor(baseUrl: string);
+    get(token: TokenIdentifier): Promise<TokenMetadata | null>;
+    list(chain: EthereumChain): Promise<TokenMetadata[]>;
+}
+
+interface Config {
+    /** OAuth2 public identifier. */
+    readonly clientId: ClientId;
+    /**
+     * OAuth2 redirect URI. Recommended to point to a frontend page where
+     * {@link CoinListClient#completeOauth} can be called to complete the PKCE
+     * flow on the client side.
+     */
+    readonly redirectUri: RedirectUri;
+    /**
+     * Recommended to leave undefined. Used to change the CoinList environment;
+     * default is production.
+     */
+    readonly baseUrl?: string;
+    /**
+     * Recommended to leave undefined. Overrides the base URL of the public
+     * token registry backing `coinlist.tokens`; default is the production
+     * registry.
+     */
+    readonly tokensBaseUrl?: string;
+}
+
+export { type HttpResponse as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, type RequirementType as D, EvmWalletAddress as E, type RequirementStatusValue as F, OfferOptionAddress as G, RequirementId as H, type WalletChallengeType as I, DocumentSubmission as J, type KycLevelName as K, OndoTradingStatus as L, AssetDecimals as M, OndoQuote as N, OfferId as O, Participation as P, type OrderBookSide as Q, type RequirementsNamespace as R, type SharedNamespaceContext as S, type Tx as T, type OndoQuoteSize as U, type BuildOndoSwapTransactionParams as V, type WalletsNamespace as W, OfferOptionAddressId as X, TokenMetadata as Y, type TokenIdentifier as Z, HttpError as _, EthereumChain as a, type RemoveOptionAddressParams as a$, KycToken as a0, OAuthSession as a1, ClientCredentialsOAuth as a2, ClientSecret as a3, type Sender as a4, PaginationParams as a5, PaginatedResponse as a6, type Uint256 as a7, KnownAssetSymbol as a8, DecimalString as a9, type GetTokenBalanceParams as aA, HexEncodedTransactionData as aB, Iso2CountryCode as aC, Link as aD, type ListOptionAddressesParams as aE, MAX_ASSET_DECIMALS as aF, MAX_UINT_256 as aG, Milestone as aH, OAuthRefreshToken as aI, OfferOption as aJ, OfferOptionSlug as aK, OfferSlug as aL, OfferToken as aM, OffersNamespaceImpl as aN, type OndoQuoteDuration as aO, PKCEState as aP, type PaginatedResponseDto as aQ, ParticipationId as aR, type ParticipationStatus as aS, ParticipationsPaginationParams as aT, Pii as aU, PiiAddress as aV, PiiJurisdiction as aW, type PiiKind as aX, type QueryParamValue as aY, type QueryParamValues as aZ, RedirectUri as a_, SwapStatus as aa, type Newtype as ab, type AllowWalletParams as ac, AllowWalletResponse as ad, Asset as ae, AssetCode as af, Blockchain as ag, Chain as ah, ClientId as ai, CodeChallenge as aj, ConnectExternalWalletParams as ak, type CreateKycTokenParams as al, CreateParticipationParams as am, CreateWalletOwnershipChallengeParams as an, Cursor as ao, type DocumentFormType as ap, type DocumentSubmissionStatus as aq, type DocumentType as ar, ETHEREUM_CHAINS as as, Erc20NamespaceImpl as at, FaqItem as au, type GetOndoQuoteParams as av, type GetOndoTradingStatusParams as aw, type GetSwapAuthorizationParams as ax, type GetSwapPreviewParams as ay, type GetTokenAllowanceParams as az, type Erc20Namespace as b, type RequirementActionNeededReason as b0, SOLANA_CHAINS as b1, STABLE_DECIMALS as b2, SolanaChain as b3, type SubmitDocumentParams as b4, SwapAuthorization as b5, type SwapContractRef as b6, SwapPreview as b7, TermItem as b8, Ticker as b9, TokenAllowance as ba, TokenBalance as bb, TokenLogo as bc, type TokenLogoImage as bd, TokenLogoUrl as be, type TokenRole as bf, TokensNamespaceImpl as bg, WalletAddress as bh, WalletOwnershipChallenge as bi, type WalletProtocol as bj, WalletsNamespaceImpl as bk, apiErrorCode as bl, assertUint256 as bm, EvmContractAddress as c, type CoinListTokenSaleNamespace as d, OfferOptionId as e, AssetId as f, CoinListTokenSaleNamespaceImpl as g, type OndoNamespace as h, AssetSymbol as i, OndoSwapTransaction as j, OndoNamespaceImpl as k, type SuperstateSwapNamespace as l, Bps as m, SuperstateSwapNamespaceImpl as n, Requirement as o, RequirementsNamespaceImpl as p, type Config as q, type OAuthAccessToken as r, type OffersNamespace as s, type TokensNamespace as t, type Erc20Asset as u, OfferDetail as v, StablecoinSymbol as w, type OfferType as x, Offer as y, RequirementStatusInfo as z };