@coinlist-co/react 0.12.1-rc.c2b6ba5 → 0.12.1-rc.e183ffd

package/dist/{config-DIaFzrMW.d.ts → tokens-namespace-CIWBtgt2.d.ts}

@@ -1,4 +1,4 @@
-import { Hash, Hex } from 'viem';
+import { Hash, Transport, PublicClient, Hex } from 'viem';
 
 declare const __brand: unique symbol;
 type Newtype<Base, Branding> = Base & {
@@ -412,7 +412,7 @@ type PinoLoggerOptions = {
  * - an operation, a flow, a hook - is a {@link LogBinding} and appears as its
  * own field.
  */
-type LogScope = 'HTTP' | 'AUTH' | 'OFFERS' | 'REQUIREMENTS' | 'WALLETS' | 'ERC20' | 'TOKEN_SALE' | 'SUPERSTATE' | 'ONDO' | 'TOKENS' | 'SUPPORT' | 'HOOKS';
+type LogScope = 'HTTP' | 'RPC' | 'AUTH' | 'OFFERS' | 'REQUIREMENTS' | 'WALLETS' | 'ERC20' | 'TOKEN_SALE' | 'SUPERSTATE' | 'ONDO' | 'TOKENS' | 'SUPPORT' | 'HOOKS';
 /**
  * Correlates every line one logical request produces. The first attempt, each
  * retry, and the re-send after a session renewal all carry the same id, so a
@@ -462,6 +462,12 @@ type FrontlineEventId = Newtype<string, 'FrontlineEventId'>;
  * `validation` failure from `OFFERS` surfaced by `useOffers` would have been
  * tagged `HOOKS` on the hook's line. Forward the event, not the cause alone.
  */
+/**
+ * Why an on-chain read failed, named after what a caller would do about it
+ * rather than after the viem error class that reported it. See the `rpc` arm
+ * of {@link LogCause}.
+ */
+type RpcFailureReason = 'reverted' | 'node-rejected' | 'transport' | 'malformed-response' | 'unknown';
 type LogCause = 
 /**
  * A request reached the backend and came back non-2xx.
@@ -538,6 +544,33 @@ type LogCause =
     type: 'wallet';
     error: RedactedWalletError;
 }
+/**
+ * An on-chain read did not answer. `reason` names the remedy, not the viem
+ * class that carried it:
+ *
+ * - `reverted` - the contract refused the call. Check the arguments, or the
+ *   contract's own state (a stopped swap reverts its `preview`).
+ * - `node-rejected` - the node reached the contract and declined. Usually a
+ *   malformed request, a rate limit, or a method the node does not serve.
+ *   Also where a host-supplied `Transport` throwing something viem cannot
+ *   read a code off lands: `buildRequest` wraps it in `UnknownRpcError`.
+ * - `transport` - the node was not reached at all. Retry, or fail over.
+ *   A dropped `webSocket()` socket included.
+ * - `malformed-response` - the call returned something the ABI cannot
+ *   decode, which in practice means the wrong address or a stale ABI.
+ * - `unknown` - anything else. Rare, since viem wraps most of what a read
+ *   can throw into one of the classes the arms above name.
+ *
+ * Decided by `instanceof` alone. Nothing is read off the thrown error - not
+ * its `name`, not its `message`, not a revert reason - because a viem
+ * message embeds the calldata, the contract address and the caller, and
+ * `name` is a writable property a host-supplied transport could set to
+ * anything. All of that is on the paired `'debug'` line.
+ */
+ | {
+    type: 'rpc';
+    reason: RpcFailureReason;
+}
 /**
  * Something the SDK does not recognise - usually a host-supplied lambda
  * (`getAccessToken`, an {@link EvmWallet} method) throwing, or a
@@ -926,8 +959,131 @@ interface Sender {
     send<T>(request: HttpRequest): Promise<T>;
 }
 
+/**
+ * Where the SDK sends its on-chain reads, per chain.
+ *
+ * Leave it undefined and reads go through CoinList's authenticated JSON-RPC
+ * proxy (`POST /v1/chains/{chain}/rpc`), which needs no setup but does need a
+ * logged-in user - the proxy is OAuth-gated, so a read on a chain the SDK is
+ * proxying fails with its `401`, surfaced as the viem error wrapping it. A
+ * chain you name here is read straight from your own node instead, and needs
+ * no CoinList session at all.
+ *
+ * Each entry is either:
+ *
+ * - an RPC URL, which the SDK wraps in viem's `http()` transport, or
+ * - a viem {@link Transport} used as it stands - `fallback([...])`,
+ *   `webSocket()`, or your app's own.
+ *
+ * Chains you leave out fall back to the proxy individually, so overriding
+ * mainnet does not opt Sepolia out. The SDK always constructs the viem
+ * `PublicClient` itself, so the chain definition, batching and retry policy
+ * stay the SDK's regardless of the transport you supply.
+ *
+ * @example
+ * ```ts
+ * createCoinListClient({
+ *   clientId,
+ *   redirectUri,
+ *   rpc: {
+ *     ethereum_mainnet: 'https://eth-mainnet.g.alchemy.com/v2/KEY',
+ *     ethereum_sepolia: fallback([http(primary), http(backup)]),
+ *     // base_* unset -> proxied through CoinList
+ *   },
+ * });
+ * ```
+ */
+type RpcConfig = Partial<Record<EthereumChain, string | Transport>>;
+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;
+    /**
+     * Where the SDK reports what it is doing. **Omit it and the SDK logs nothing
+     * at all** - no `console` fallback, at any level, on any codepath. Supply
+     * one and every request, every classified failure and every hook state
+     * transition is reported at the level your logger asks for.
+     *
+     * Absent, the SDK says nothing at all - there is no fallback to `console`,
+     * at any level, on any codepath.
+     *
+     * **Running the SDK's logging in production is not advised.** The safest
+     * posture is to leave this undefined outside development, staging and
+     * incident reproduction: a seam that emits nothing cannot disclose anything,
+     * and that property does not depend on the SDK continuing to get redaction
+     * right.
+     *
+     * If you do run one there, run it at `'info'` or above and know what that
+     * does and does not buy you. Those levels are **redacted by construction**:
+     * they carry only SDK-authored classification and server-authored
+     * identifiers, and the type system holds that line rather than a convention -
+     * an event at those levels accepts scalar fields only, so a body, a DTO or
+     * an operation's parameters cannot be put on one. What the SDK does **not**
+     * give you is a warranty that the result is safe for your environment. The
+     * mechanism is checkable and stated; the conclusion depends on your sink,
+     * your retention and your threat model, and it is yours to draw.
+     *
+     * **`'debug'` is not.** It reports request and response bodies, full URLs,
+     * headers and operation parameters verbatim - bearer tokens, KYC answers,
+     * tax-document fields, wallet signatures - and **the SDK does not redact**.
+     * Run it on a developer's machine, in tests, and in beta or staging
+     * environments where the data flowing through is not real customer data.
+     * The shipped implementations make that structural: built with
+     * `isDev: false`, `'debug'` does not typecheck. Either way, filtering,
+     * redaction and retention at your sink are yours, not the SDK's.
+     *
+     * Every method you implement here **must be total**: the SDK calls them on
+     * the codepath of the work they report and does not catch them, so a logger
+     * that throws fails the operation it was describing.
+     *
+     * See {@link Logger} for the full contract, and {@link pinoClientLogger} or
+     * {@link pinoServerLogger} for a ready-made implementation over pino.
+     */
+    readonly logger?: Logger;
+    /**
+     * Where on-chain reads go. Omit it and they are proxied through CoinList.
+     * See {@link RpcConfig}.
+     */
+    readonly rpc?: RpcConfig;
+}
+
+/**
+ * Resolves a chain to the viem `PublicClient` the SDK reads it through.
+ *
+ * One function rather than a client per read, because the client is where the
+ * batching lives: viem's multicall scheduler is keyed on the client's `uid`,
+ * so two reads only ever share an `eth_call` if they share a client. Hence the
+ * memoisation - it is correctness for batching, not a performance tweak.
+ */
+type PublicClients = (chain: EthereumChain) => PublicClient;
+
 interface UniversalNamespaceContext {
     readonly api: Sender;
+    /**
+     * The viem `PublicClient` for a chain, over whichever transport that chain
+     * resolved to - the host's own node, or CoinList's proxy.
+     *
+     * A factory rather than a client, because a namespace serves every chain and
+     * only the call knows which. Built once per client instance so that
+     * concurrent reads share a batch; see `publicClients`.
+     */
+    readonly rpc: PublicClients;
     /**
      * The host's logger, or `null` when they supplied none.
      *
@@ -940,133 +1096,35 @@ interface UniversalNamespaceContext {
     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.
+ *
+ * Read from the chain rather than from a CoinList endpoint. By default that
+ * goes through CoinList's authenticated JSON-RPC proxy, so a logged-out caller
+ * gets the proxy's `401` - surfaced as a viem error wrapping the SDK's
+ * `HttpError`, not as `NotAuthenticatedError`, since viem re-wraps whatever a
+ * `Transport` throws. Point `Config.rpc` at your own node for this chain and no
+ * CoinList session is involved at all. See {@link RpcConfig}.
  */
 interface Erc20Namespace {
     /**
-     * Reads the ERC-20 allowance an `owner` has granted a `spender`.
+     * Reads the ERC-20 allowance an `owner` has granted a `spender`, as a raw
+     * on-chain integer.
      */
-    getAllowance(params: GetTokenAllowanceParams): Promise<TokenAllowance>;
+    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
     /**
      * Reads the raw ERC-20 balance an `owner` holds of a token.
      */
-    getBalance(params: GetTokenBalanceParams): Promise<TokenBalance>;
+    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
 }
 declare class Erc20NamespaceImpl implements Erc20Namespace {
     private readonly ctx;
     private readonly log;
     constructor(ctx: UniversalNamespaceContext);
-    getAllowance(params: GetTokenAllowanceParams): Promise<TokenAllowance>;
-    getBalance(params: GetTokenBalanceParams): Promise<TokenBalance>;
+    getAllowance(params: GetTokenAllowanceParams): Promise<Uint256>;
+    getBalance(params: GetTokenBalanceParams): Promise<Uint256>;
 }
 
 /**
@@ -1158,16 +1216,51 @@ type InternalDebugEvent = {
  * handling it becomes a compile error.
  */
 type OfferTypeDto = 'coinlist::token_sale' | 'superstate::swap' | 'ondo::swap';
-type OfferDto = {
+/**
+ * One variant per {@link OfferTypeDto}, mirroring frontline#1365, which keys
+ * `GET /v1/offers` on `type`. Read `type` first: it decides which of the
+ * fields below mean anything.
+ */
+type OfferDto = CoinListTokenSaleOfferDto | SuperstateSwapOfferDto | OndoSwapOfferDto;
+type OfferBaseDto = {
     id: string;
     slug: string;
-    type: OfferTypeDto;
+    ends_at: string | null;
+    tokens: OfferTokenDto[];
+};
+/**
+ * A curated sale window and the hand-authored copy that goes with it. Required
+ * on every variant that runs such a campaign, which is every one but Ondo.
+ */
+type OfferEditorialDto = {
     tagline: string;
     banner_url: string;
-    logo_url: string;
     starts_at: string;
-    ends_at: string | null;
-    tokens: OfferTokenDto[];
+};
+/**
+ * What an Ondo swap sends in place of {@link OfferEditorialDto}. It trades
+ * continuously and runs no campaign, so the keys arrive as `null` and carry
+ * nothing. Declared so a fixture can describe the real payload; no `fromDto`
+ * reads them.
+ */
+type OfferNoEditorialDto = {
+    tagline: null;
+    banner_url: null;
+    starts_at: null;
+};
+type CoinListTokenSaleOfferDto = OfferBaseDto & OfferEditorialDto & {
+    type: 'coinlist::token_sale';
+    logo_url: string;
+};
+type SuperstateSwapOfferDto = OfferBaseDto & OfferEditorialDto & {
+    type: 'superstate::swap';
+    /** Publishing a swap does not require anyone to upload artwork for it. */
+    logo_url: string | null;
+};
+type OndoSwapOfferDto = OfferBaseDto & OfferNoEditorialDto & {
+    type: 'ondo::swap';
+    /** Publishing a swap does not require anyone to upload artwork for it. */
+    logo_url: string | null;
 };
 type OfferTokenDto = {
     role: 'funding' | 'distribution' | 'swap';
@@ -1180,19 +1273,62 @@ declare const OfferId: (value: string) => OfferId;
 type OfferSlug = Newtype<string, 'OfferSlug'>;
 declare const OfferSlug: (value: string) => OfferSlug;
 type OfferType = OfferTypeDto;
-type Offer = {
+declare const isOfferType: (value: string) => value is OfferType;
+type OfferBase = {
     id: OfferId;
     slug: OfferSlug;
-    type: OfferType;
+    endsAt: Date | null;
+    tokens: OfferToken[];
+};
+type CoinListTokenSaleOffer = OfferBase & OfferEditorial & {
+    type: 'coinlist::token_sale';
+    logoUrl: string;
+};
+type SuperstateSwapOffer = OfferBase & OfferEditorial & {
+    type: 'superstate::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
+};
+type OndoSwapOffer = OfferBase & {
+    type: 'ondo::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
+};
+/**
+ * A curated sale window and the hand-authored copy that goes with it. Every
+ * variant that runs such a campaign carries all three, validated; an Ondo swap
+ * trades continuously, runs none, and carries none.
+ */
+type OfferEditorial = {
     tagline: string;
     bannerUrl: string;
-    logoUrl: string;
     startsAt: Date;
-    endsAt: Date | null;
-    tokens: OfferToken[];
 };
+declare const OfferEditorial: {
+    /**
+     * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+     * the same three checks name the payload that failed them.
+     */
+    fromDto: (dto: OfferEditorialDto, model: string) => OfferEditorial;
+};
+/**
+ * An offer as `GET /v1/offers` lists it: a union on {@link OfferType}, each
+ * variant carrying only the fields that mean something for it. Narrow on
+ * `type` before reading anything beyond {@link OfferBase} - an Ondo swap has
+ * no `startsAt` to read, and the compiler says so.
+ */
+type Offer = CoinListTokenSaleOffer | SuperstateSwapOffer | OndoSwapOffer;
 declare const Offer: {
     fromDto: (dto: OfferDto) => Offer;
+    /**
+     * Maps a page of offers, dropping every offer whose `type` this SDK does not
+     * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+     * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+     * reject the whole page, so one offer of an unknown type would blank the
+     * grid for every offer beside it. A single offer fetched by id still
+     * throws, because there is nothing beside it to keep.
+     */
+    listFromDto: (dtos: OfferDto[]) => Offer[];
 };
 type TokenRole = 'funding' | 'distribution' | 'swap';
 type OfferToken = {
@@ -1237,6 +1373,13 @@ interface PaginatedResponse<T> {
 }
 declare const PaginatedResponse: {
     fromDto: <A, B>(dto: PaginatedResponseDto<A>, itemMapper: (item: A) => B) => PaginatedResponse<B>;
+    /**
+     * For a mapper that decides the page as a whole - one that drops items it
+     * cannot map, such as `Offer.listFromDto` - rather than item by item. The
+     * cursors are the wire's either way: dropping an item changes what the
+     * page holds, not where the next page starts.
+     */
+    fromDtoPage: <A, B>(dto: PaginatedResponseDto<A>, pageMapper: (items: A[]) => B[]) => PaginatedResponse<B>;
 };
 /**
  * Cursor-based pagination input used when requesting paginated API resources.
@@ -1298,12 +1441,41 @@ type CreateParticipationDto = {
     approval_transaction_hash: string | null | undefined;
 };
 
-type OfferDetailDto = {
+/**
+ * One variant per `OfferTypeDto`, the same split as `OfferDto` with what
+ * `GET /v1/offers/:id` adds on top. Read `type` first.
+ */
+type OfferDetailDto = CoinListTokenSaleOfferDetailDto | SuperstateSwapOfferDetailDto | OndoSwapOfferDetailDto;
+type CoinListTokenSaleOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & {
+    type: 'coinlist::token_sale';
+    logo_url: string;
+};
+type SuperstateSwapOfferDetailDto = OfferDetailBaseDto & OfferEditorialDto & OfferDetailNoSwapContractsDto & {
+    type: 'superstate::swap';
+    logo_url: string | null;
+};
+type OndoSwapOfferDetailDto = OfferDetailBaseDto & OfferNoEditorialDto & {
+    type: 'ondo::swap';
+    logo_url: string | null;
+    /**
+     * Every chain this offer swaps on, with the contract each settles
+     * through. `[]` is an answer - "swaps nowhere" - and a missing key is not.
+     */
+    swap_contracts: OfferDetailSwapContractDto[];
+};
+/**
+ * An offer that does not settle through a CoinList swap contract sends `[]`
+ * or no key at all, and either way there is nothing to read. Declared so a
+ * fixture can describe the real payload.
+ */
+type OfferDetailNoSwapContractsDto = {
+    swap_contracts?: OfferDetailSwapContractDto[];
+};
+type OfferDetailBaseDto = {
     asset: AssetDto;
     faqs: OfferDetailFaqDto[];
     funding_assets: AssetDto[];
     tokens: OfferTokenDto[];
-    swap_contracts?: OfferDetailSwapContractDto[];
     id: string;
     links: OfferDetailLinkDto[];
     milestones: OfferDetailMilestoneDto[];
@@ -1311,15 +1483,20 @@ type OfferDetailDto = {
     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;
+    /** Issuer of the *token*, not of the security it tracks. Ondo offers only. */
+    issuer: string | null;
+    /** ISO 6166 id of the underlying security. Null when the supplier has none. */
+    isin: string | null;
+    /** The underlying's symbol on its venue (`QQQ`), never the token's (`QQQon`). */
+    ticker: string | null;
+    /** Supplier vocabulary (`Stock`, `ETF`). Open set — display, do not branch. */
+    instrument_type: string | null;
+    /** Venue the underlying lists on. Not served by the supplier; entered by hand. */
+    listing_venue: string | null;
 };
 type OfferDetailFaqDto = {
     answer: string | null;
@@ -1353,44 +1530,93 @@ type OfferDetailSwapContractDto = {
     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 Ticker = Newtype<string, 'Ticker'>;
+declare const Ticker: (value: string) => Ticker;
 /**
- * A chain an offer can be swapped on, with the CoinList contract the swap
- * settles through - the spender to approve before any quote exists.
+ * An ISO 6166 International Securities Identification Number, e.g.
+ * `US0378331005`. Identifies the security itself, which is what makes it the
+ * stable key across venues where a {@link Ticker} is not: the same security
+ * trades under different tickers in different places, and the same ticker
+ * means different securities in different places.
  *
- * Carries no role, unlike {@link OfferToken}: there is one swap contract per
- * chain and it serves every Ondo asset on it, so which token is being traded
- * does not change the answer.
+ * Not validated on construction — the value comes from a supplier that has
+ * already checked it, and a client-side check-digit test could only reject
+ * data the SDK still has to display.
  */
-type OfferSwapContract = {
-    chain: Chain;
-    address: EvmContractAddress;
+type Isin = Newtype<string, 'Isin'>;
+declare const Isin: (value: string) => Isin;
+type OrderBookSide = 'buy' | 'sell';
+
+type CoinListTokenSaleOfferDetail = OfferDetailBase & OfferEditorial & {
+    type: 'coinlist::token_sale';
+    logoUrl: string;
 };
-declare const OfferSwapContract: {
-    fromDto: (dto: OfferDetailSwapContractDto) => OfferSwapContract;
+type SuperstateSwapOfferDetail = OfferDetailBase & OfferEditorial & {
+    type: 'superstate::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
 };
-type OfferDetail = {
+type OndoSwapOfferDetail = OfferDetailBase & {
+    type: 'ondo::swap';
+    /** Null when nobody has uploaded artwork: a swap publishes without it. */
+    logoUrl: string | null;
+    /**
+     * Every chain this offer can be swapped on, with the CoinList contract each
+     * settles through. Empty means it cannot be swapped anywhere.
+     */
+    swapContracts: OfferSwapContract[];
+};
+type OfferDetailBase = {
     id: OfferId;
     slug: OfferSlug;
-    type: OfferType;
     name: string;
     asset: Asset;
     fundingAssets: Asset[];
     tokens: OfferToken[];
-    /**
-     * Every chain this offer can be swapped on, with the CoinList contract each
-     * settles through. Empty means it cannot be swapped anywhere.
-     */
-    swapContracts: OfferSwapContract[];
     about: string | null;
-    tagline: string;
-    bannerUrl: string;
-    logoUrl: string;
     category: string;
-    startsAt: Date;
+    /**
+     * The legal issuer of the *token*, e.g. `'Ondo Global Markets'`. The issuer
+     * of the security it tracks is {@link OfferDetail.name} (`'Apple Inc.'`).
+     * Null on offers with no single named issuer.
+     */
+    issuer: string | null;
+    /**
+     * ISO 6166 identifier of the underlying security, e.g. `'US0378331005'`.
+     * Null both on offers that tokenize no security and on the few that do but
+     * whose supplier publishes no ISIN, so absence does not imply "not a
+     * security".
+     */
+    isin: Isin | null;
+    /**
+     * The underlying security's symbol on its listing venue, e.g. `'QQQ'`. This
+     * is *not* the token's symbol — that is `asset.code` (`'QQQon'`). Null on
+     * offers that tokenize no listed security.
+     */
+    ticker: Ticker | null;
+    /**
+     * What kind of instrument the underlying is, as the supplier classifies it:
+     * `'Stock'`, `'ETF'`. Distinct from {@link OfferDetail.category}, which is
+     * the broader class the offer is grouped under (`'Equities'`) — this field
+     * describes the single instrument, `category` describes the shelf it sits
+     * on.
+     *
+     * An open set: the vocabulary belongs to the supplier and may grow without
+     * notice, so render an unrecognized value rather than branching on it. Note
+     * the supplier's spelling is its own — a common stock arrives as `'Stock'`.
+     */
+    instrumentType: string | null;
+    /**
+     * The exchange the underlying security lists on, e.g. `'NASDAQ'`. Not
+     * derivable from {@link OfferDetail.isin}, whose country prefix is the
+     * country of issuance rather than the venue.
+     *
+     * Unlike the fields above, this one is recorded by hand rather than served
+     * by the supplier, so it is null until someone records it — on a newly
+     * listed offer that is the normal state, and it says nothing about whether
+     * the offer tokenizes a security.
+     */
+    listingVenue: string | null;
     endsAt: Date | null;
     faqs: FaqItem[];
     links: Link[];
@@ -1398,6 +1624,32 @@ type OfferDetail = {
     options: OfferOption[];
     terms: TermItem[];
 };
+type OfferOptionId = Newtype<string, 'OfferOptionId'>;
+declare const OfferOptionId: (value: string) => OfferOptionId;
+type OfferOptionSlug = Newtype<string, 'OfferOptionSlug'>;
+declare const OfferOptionSlug: (value: string) => OfferOptionSlug;
+/**
+ * A chain an offer can be swapped on, with the CoinList contract the swap
+ * settles through - the spender to approve before any quote exists.
+ *
+ * Carries no role, unlike {@link OfferToken}: there is one swap contract per
+ * chain and it serves every Ondo asset on it, so which token is being traded
+ * does not change the answer.
+ */
+type OfferSwapContract = {
+    chain: Chain;
+    address: EvmContractAddress;
+};
+declare const OfferSwapContract: {
+    fromDto: (dto: OfferDetailSwapContractDto) => OfferSwapContract;
+};
+/**
+ * An offer as `GET /v1/offers/:id` serves it: the same union on `type` as
+ * {@link Offer}, each variant carrying only the fields that mean something
+ * for it. Narrow on `type` before reading anything beyond
+ * {@link OfferDetailBase}.
+ */
+type OfferDetail = CoinListTokenSaleOfferDetail | SuperstateSwapOfferDetail | OndoSwapOfferDetail;
 declare const OfferDetail: {
     fromDto: (dto: OfferDetailDto) => OfferDetail;
 };
@@ -1570,10 +1822,6 @@ declare class CoinListTokenSaleNamespaceImpl implements CoinListTokenSaleNamespa
     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
@@ -2230,6 +2478,105 @@ declare class OndoNamespaceImpl implements OndoNamespace {
     buildSellTransaction(params: BuildOndoSellParams): Promise<OndoSellTransaction>;
 }
 
+/**
+ * Raw JSON models for the Superstate swap endpoints that are still backend
+ * calls.
+ *
+ * The contract *reads* no longer have DTOs: the SDK calls `status()`,
+ * `preview()`, `authorized()` and `outputToken()` on-chain through
+ * `@/universal/api/rpc`, so their wire shape is the ABI rather than JSON.
+ * Allow-listing a wallet stays here because it is a backend write, not a read.
+ */
+type AllowWalletResponseDto = {
+    action: 'broadcast_transaction';
+    to: string;
+    data: string;
+} | {
+    action: 'none';
+    already_allowed: boolean;
+};
+
+/**
+ * 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: {
+    /** Maps the contract's `Preview { input, fee, output }` struct. */
+    fromContract: (preview: {
+        input: bigint;
+        fee: bigint;
+        output: bigint;
+    }) => SwapPreview;
+};
+/**
+ * The bitmask of operations a swap contract has paused, as `Operable.paused`
+ * reports it. Each bit is one operation level; swapping is
+ * {@link SWAP_LEVEL}.
+ *
+ * Meaningful only while the contract is paused, which is why it lives on that
+ * arm of {@link SwapStatus} alone: an active contract has nothing paused, and
+ * a stopped one is past caring which level was.
+ */
+type PauseFlags = Newtype<number, 'PauseFlags'>;
+declare const PauseFlags: (value: number) => PauseFlags;
+/**
+ * The on-chain state of a swap contract, as `status()` reports it.
+ *
+ * - `active` - operating normally.
+ * - `paused` - one or more operations are suspended, and may be resumed.
+ *   `pausedLevels` says which. **This does not by itself mean swapping is
+ *   down**: a contract can pause an unrelated operation and keep swapping.
+ *   Ask `isSwapAvailable` rather than reading the state.
+ * - `stopped` - permanently halted, and cannot be reactivated.
+ */
+type SwapStatus = {
+    state: 'active';
+} | {
+    state: 'paused';
+    pausedLevels: PauseFlags;
+} | {
+    state: 'stopped';
+};
+declare const SwapStatus: {
+    /**
+     * Maps the contract's `Status { uint32 flags; State state }` struct, where
+     * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
+     *
+     * `flags` is carried onto the `paused` arm only. On the other two the
+     * contract sets it to a self-identifying marker rather than to information -
+     * so repeating it would invite a caller to read meaning into a constant.
+     *
+     * @throws ValidationError on a `state` outside the enum. A contract that has
+     * grown a fourth state is one the SDK does not model, and guessing `active`
+     * would let a halted swap read as a live one.
+     */
+    fromContract: (status: {
+        flags: number;
+        state: number;
+    }) => SwapStatus;
+};
+/**
+ * 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;
+};
+
 /** Parameters shared by contract reads scoped to a chain. */
 type SwapContractRef = {
     contractAddress: EvmContractAddress;
@@ -2251,30 +2598,46 @@ type AllowWalletParams = {
 
 /**
  * Read/write operations for the on-chain swap flow: quoting a swap, inspecting
- * contract state, checking token allowances, and proving/allow-listing wallet
- * ownership.
+ * contract state, and proving/allow-listing wallet ownership.
+ *
+ * Every read here is a contract call the SDK makes itself. By default those go
+ * through CoinList's authenticated JSON-RPC proxy, so a logged-out caller gets
+ * the proxy's `401` - surfaced as a viem error wrapping the SDK's `HttpError`,
+ * not as `NotAuthenticatedError`, since viem re-wraps whatever a `Transport`
+ * throws. Point `Config.rpc` at your own node for this chain and no CoinList
+ * session is involved at all. `allowWallet` is the exception: it is a backend
+ * write and always needs one, and throws `NotAuthenticatedError` without.
  */
 interface SuperstateSwapNamespace {
     /**
      * Checks whether a wallet is authorized to swap against the given contract.
      */
-    getAuthorization(params: GetSwapAuthorizationParams): Promise<SwapAuthorization>;
+    getAuthorization(params: GetSwapAuthorizationParams): Promise<boolean>;
     /**
      * Fetches a read-only quote for swapping `amount` of `inputToken`.
+     *
+     * The contract reverts rather than quoting when it is stopped, or when
+     * `inputToken` is not one it accepts, so this surfaces a viem
+     * `ContractFunctionRevertedError` naming the contract's own error. Check
+     * {@link getStatus} first if you would rather not provoke one.
      */
     getPreview(params: GetSwapPreviewParams): Promise<SwapPreview>;
     /**
-     * Reads the current on-chain state of a swap contract.
+     * Reads the current on-chain state of a swap contract. See
+     * {@link isSwapAvailable} before concluding that a `paused` contract cannot
+     * swap - the two are not the same question.
      */
     getStatus(params: SwapContractRef): Promise<SwapStatus>;
     /**
-     * Reads the ERC-20 output token a swap contract pays out.
+     * Reads the ERC-20 output token a swap contract pays out, with its metadata.
      */
     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`.
+     *
+     * @throws NotAuthenticatedError without a logged-in user.
      */
     allowWallet(params: AllowWalletParams): Promise<AllowWalletResponse>;
 }
@@ -2282,7 +2645,7 @@ declare class SuperstateSwapNamespaceImpl implements SuperstateSwapNamespace {
     private readonly ctx;
     protected readonly log: InternalLogger;
     constructor(ctx: UniversalNamespaceContext);
-    getAuthorization(params: GetSwapAuthorizationParams): Promise<SwapAuthorization>;
+    getAuthorization(params: GetSwapAuthorizationParams): Promise<boolean>;
     getPreview(params: GetSwapPreviewParams): Promise<SwapPreview>;
     getStatus(params: SwapContractRef): Promise<SwapStatus>;
     getOutputToken(params: SwapContractRef): Promise<Erc20Asset>;
@@ -2935,68 +3298,4 @@ declare class TokensNamespaceImpl implements TokensNamespace {
     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;
-    /**
-     * Where the SDK reports what it is doing. **Omit it and the SDK logs nothing
-     * at all** - no `console` fallback, at any level, on any codepath. Supply
-     * one and every request, every classified failure and every hook state
-     * transition is reported at the level your logger asks for.
-     *
-     * Absent, the SDK says nothing at all - there is no fallback to `console`,
-     * at any level, on any codepath.
-     *
-     * **Running the SDK's logging in production is not advised.** The safest
-     * posture is to leave this undefined outside development, staging and
-     * incident reproduction: a seam that emits nothing cannot disclose anything,
-     * and that property does not depend on the SDK continuing to get redaction
-     * right.
-     *
-     * If you do run one there, run it at `'info'` or above and know what that
-     * does and does not buy you. Those levels are **redacted by construction**:
-     * they carry only SDK-authored classification and server-authored
-     * identifiers, and the type system holds that line rather than a convention -
-     * an event at those levels accepts scalar fields only, so a body, a DTO or
-     * an operation's parameters cannot be put on one. What the SDK does **not**
-     * give you is a warranty that the result is safe for your environment. The
-     * mechanism is checkable and stated; the conclusion depends on your sink,
-     * your retention and your threat model, and it is yours to draw.
-     *
-     * **`'debug'` is not.** It reports request and response bodies, full URLs,
-     * headers and operation parameters verbatim - bearer tokens, KYC answers,
-     * tax-document fields, wallet signatures - and **the SDK does not redact**.
-     * Run it on a developer's machine, in tests, and in beta or staging
-     * environments where the data flowing through is not real customer data.
-     * The shipped implementations make that structural: built with
-     * `isDev: false`, `'debug'` does not typecheck. Either way, filtering,
-     * redaction and retention at your sink are yours, not the SDK's.
-     *
-     * Every method you implement here **must be total**: the SDK calls them on
-     * the codepath of the work they report and does not catch them, so a logger
-     * that throws fails the operation it was describing.
-     *
-     * See {@link Logger} for the full contract, and {@link pinoClientLogger} or
-     * {@link pinoServerLogger} for a ready-made implementation over pino.
-     */
-    readonly logger?: Logger;
-}
-
-export { type BuildOndoSellParams as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, TokenMetadata as D, type Erc20Namespace as E, type OfferType as F, Offer as G, RequirementStatusInfo as H, type RequirementType as I, type RequirementStatusValue as J, OfferOptionAddress as K, type Logger as L, RequirementId as M, type KycLevelName as N, OfferId as O, Participation as P, DocumentSubmission as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, type WalletChallengeType as V, type WalletError as W, type PinoLoggerOptions as X, OndoTradingStatus as Y, AssetDecimals as Z, type BuildOndoBuyParams as _, EthereumChain as a, MAX_ASSET_DECIMALS as a$, OndoQuote as a0, type OndoQuoteSize as a1, type TokenIdentifier as a2, OfferOptionAddressId as a3, TokenLogo as a4, type DebugEvent as a5, type FrontlineEventId as a6, HttpError as a7, type HttpResponse as a8, KycToken as a9, AssetCode as aA, Blockchain as aB, type BuildOndoSwapParamsCore as aC, Chain as aD, ClientId as aE, CodeChallenge as aF, ConnectExternalWalletParams as aG, type CreateKycTokenParams as aH, CreateParticipationParams as aI, CreateWalletOwnershipChallengeParams as aJ, Cursor as aK, type DocumentFormType as aL, type DocumentSubmissionStatus as aM, type DocumentType as aN, ETHEREUM_CHAINS as aO, Erc20NamespaceImpl as aP, FaqItem as aQ, type GetOndoQuoteParams as aR, type GetOndoTradingStatusParams as aS, type GetSwapAuthorizationParams as aT, type GetSwapPreviewParams as aU, type GetTokenAllowanceParams as aV, type GetTokenBalanceParams as aW, HexEncodedTransactionData as aX, Iso2CountryCode as aY, Link as aZ, type ListOptionAddressesParams as a_, type LogBinding as aa, type LogBindings as ab, type LogCause as ac, type LogLevel as ad, type LogScope as ae, type LogValue as af, type ProductionLogLevel as ag, RedactedWalletError as ah, type RequestId as ai, type SafeEvent as aj, type SafeFields as ak, type UnredactedFields as al, OAuthSession as am, ClientCredentialsOAuth as an, ClientSecret as ao, type Sender as ap, PaginationParams as aq, PaginatedResponse as ar, DecimalString as as, SwapStatus as at, type Uint256 as au, KnownAssetSymbol as av, type Newtype as aw, type AllowWalletParams as ax, AllowWalletResponse as ay, Asset as az, EvmContractAddress as b, MAX_UINT_256 as b0, Milestone as b1, OAuthRefreshToken as b2, OfferOption as b3, OfferOptionSlug as b4, OfferSlug as b5, OfferToken as b6, OffersNamespaceImpl as b7, type OndoQuoteDuration as b8, type OndoSellOutcome as b9, TokenLogoUrl as bA, type TokenRole as bB, TokensNamespaceImpl as bC, type Tx as bD, WalletAddress as bE, WalletOwnershipChallenge as bF, type WalletProtocol as bG, WalletsNamespaceImpl as bH, apiErrorCode as bI, assertUint256 as bJ, isChain as bK, parseUint256 as bL, PKCEState as ba, type PaginatedResponseDto as bb, ParticipationId as bc, type ParticipationStatus as bd, ParticipationsPaginationParams as be, Pii as bf, PiiAddress as bg, PiiJurisdiction as bh, type PiiKind as bi, type QueryParamValue as bj, type QueryParamValues as bk, RedirectUri as bl, type RemoveOptionAddressParams as bm, type RequirementActionNeededReason as bn, SOLANA_CHAINS as bo, STABLE_DECIMALS as bp, SolanaChain as bq, type SubmitDocumentParams as br, SwapAuthorization as bs, type SwapContractRef as bt, SwapPreview as bu, TermItem as bv, Ticker as bw, TokenAllowance as bx, TokenBalance as by, type TokenLogoImage as bz, type CoinListTokenSaleNamespace as c, OfferOptionId as d, AssetId as e, CoinListTokenSaleNamespaceImpl as f, type OndoNamespace as g, AssetSymbol as h, OfferSwapContract as i, OndoBuyTransaction as j, OndoSellTransaction as k, type OndoSwapTransactionCore as l, type OrderBookSide as m, OndoNamespaceImpl as n, type WalletsNamespace as o, Bps as p, EvmWalletAddress as q, SuperstateSwapNamespaceImpl as r, Requirement as s, RequirementsNamespaceImpl as t, type Config as u, type OAuthAccessToken as v, type OffersNamespace as w, StablecoinSymbol as x, type Erc20Asset as y, OfferDetail as z };
+export { OndoTradingStatus as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, TokenMetadata as D, type Erc20Namespace as E, type OfferType as F, type OndoSwapOfferDetail as G, type CoinListTokenSaleOfferDetail as H, type SuperstateSwapOfferDetail as I, Offer as J, RequirementStatusInfo as K, type Logger as L, type RequirementType as M, type RequirementStatusValue as N, OfferId as O, Participation as P, OfferOptionAddress as Q, type RequirementsNamespace as R, type SuperstateSwapNamespace as S, type TokensNamespace as T, type UniversalNamespaceContext as U, RequirementId as V, type WalletError as W, type KycLevelName as X, DocumentSubmission as Y, type WalletChallengeType as Z, type PinoLoggerOptions as _, EthereumChain as a, type GetTokenBalanceParams as a$, AssetDecimals as a0, type BuildOndoBuyParams as a1, type BuildOndoSellParams as a2, OndoQuote as a3, type OndoQuoteSize as a4, type TokenIdentifier as a5, OfferOptionAddressId as a6, TokenLogo as a7, type DebugEvent as a8, type FrontlineEventId as a9, type Newtype as aA, type AllowWalletParams as aB, AllowWalletResponse as aC, Asset as aD, AssetCode as aE, Blockchain as aF, type BuildOndoSwapParamsCore as aG, Chain as aH, ClientId as aI, CodeChallenge as aJ, type CoinListTokenSaleOffer as aK, ConnectExternalWalletParams as aL, type CreateKycTokenParams as aM, CreateParticipationParams as aN, CreateWalletOwnershipChallengeParams as aO, Cursor as aP, type DocumentFormType as aQ, type DocumentSubmissionStatus as aR, type DocumentType as aS, ETHEREUM_CHAINS as aT, Erc20NamespaceImpl as aU, FaqItem as aV, type GetOndoQuoteParams as aW, type GetOndoTradingStatusParams as aX, type GetSwapAuthorizationParams as aY, type GetSwapPreviewParams as aZ, type GetTokenAllowanceParams as a_, HttpError as aa, type HttpResponse as ab, KycToken as ac, type LogBinding as ad, type LogBindings as ae, type LogCause as af, type LogLevel as ag, type LogScope as ah, type LogValue as ai, type ProductionLogLevel as aj, RedactedWalletError as ak, type RequestId as al, type RpcFailureReason as am, type SafeEvent as an, type SafeFields as ao, type UnredactedFields as ap, OAuthSession as aq, ClientCredentialsOAuth as ar, ClientSecret as as, type Sender as at, PaginationParams as au, PaginatedResponse as av, DecimalString as aw, SwapStatus as ax, type Uint256 as ay, KnownAssetSymbol as az, EvmContractAddress as b, HexEncodedTransactionData as b0, Isin as b1, Iso2CountryCode as b2, Link as b3, type ListOptionAddressesParams as b4, MAX_ASSET_DECIMALS as b5, MAX_UINT_256 as b6, Milestone as b7, OAuthRefreshToken as b8, type OfferBase as b9, SOLANA_CHAINS as bA, STABLE_DECIMALS as bB, SolanaChain as bC, type SubmitDocumentParams as bD, type SuperstateSwapOffer as bE, type SwapContractRef as bF, SwapPreview as bG, TermItem as bH, Ticker as bI, type TokenLogoImage as bJ, TokenLogoUrl as bK, type TokenRole as bL, TokensNamespaceImpl as bM, type Tx as bN, WalletAddress as bO, WalletOwnershipChallenge as bP, type WalletProtocol as bQ, WalletsNamespaceImpl as bR, apiErrorCode as bS, assertUint256 as bT, isChain as bU, isOfferType as bV, parseUint256 as bW, type OfferDetailBase as ba, OfferEditorial as bb, OfferOption as bc, OfferOptionSlug as bd, OfferSlug as be, OfferToken as bf, OffersNamespaceImpl as bg, type OndoQuoteDuration as bh, type OndoSellOutcome as bi, type OndoSwapOffer as bj, PKCEState as bk, type PaginatedResponseDto as bl, ParticipationId as bm, type ParticipationStatus as bn, ParticipationsPaginationParams as bo, PauseFlags as bp, Pii as bq, PiiAddress as br, PiiJurisdiction as bs, type PiiKind as bt, type QueryParamValue as bu, type QueryParamValues as bv, RedirectUri as bw, type RemoveOptionAddressParams as bx, type RequirementActionNeededReason as by, type RpcConfig as bz, type CoinListTokenSaleNamespace as c, OfferOptionId as d, AssetId as e, CoinListTokenSaleNamespaceImpl as f, type OndoNamespace as g, AssetSymbol as h, OfferSwapContract as i, OndoBuyTransaction as j, OndoSellTransaction as k, type OndoSwapTransactionCore as l, type OrderBookSide as m, OndoNamespaceImpl as n, type WalletsNamespace as o, Bps as p, EvmWalletAddress as q, SuperstateSwapNamespaceImpl as r, Requirement as s, RequirementsNamespaceImpl as t, type Config as u, type OAuthAccessToken as v, type OffersNamespace as w, StablecoinSymbol as x, type Erc20Asset as y, OfferDetail as z };