@nadohq/mobile-client 0.65.0 → 0.67.0

package/dist/types-CByl_NyJ.d.ts

@@ -0,0 +1,825 @@
+import { $t as MobileSocialFeedUnavailableTarget, A as MobileServerNotificationPreferences, B as MobileServerSocialFeedChartRange, Bt as MobileSocialFeedPositionResolution, D as MobileServerNotificationInboxItem, E as MobileServerNotificationDeviceMetadata, F as MobileServerSocialFeedActionCandidate, Ft as MobileSocialFeedMention, I as MobileServerSocialFeedActionMarker, J as MobileServerSocialFeedEstimatedLiquidationLine, L as MobileServerSocialFeedAuthor, M as MobileServerNotificationSettings, N as MobileServerProductEvent, Ot as MobileSocialFeedChartDataQuality, P as MobileServerProfile, Pt as MobileSocialFeedMarketCategory, Q as MobileServerSocialFeedHistoryTake, Qt as MobileSocialFeedType, R as MobileServerSocialFeedCandle, Tt as MobileSocialFeedActionResolution, U as MobileServerSocialFeedCommentGroup, Ut as MobileSocialFeedPresenceState, V as MobileServerSocialFeedCohort, Vt as MobileSocialFeedPositionResolutionReason, Z as MobileServerSocialFeedHistorySummary, _ as MobileServerAvatarPreset, at as MobileServerSocialFeedMarket, b as MobileServerFeedTrade, bt as MobileServerSocialFeedTradingContext, ft as MobileServerSocialFeedPublishablePosition, h as MobileNotificationTypeId, ht as MobileServerSocialFeedTimelineEntry, it as MobileServerSocialFeedItemPatch, jt as MobileSocialFeedHistoryQuality, kt as MobileSocialFeedChartInterval, lt as MobileServerSocialFeedPositionHistoryCard, m as MobileNotificationRouteName, nt as MobileServerSocialFeedItem, pt as MobileServerSocialFeedReadSession, q as MobileServerSocialFeedDrawing, ut as MobileServerSocialFeedPositionPatch, v as MobileServerAvatarSelection, w as MobileServerNotificationCapabilities, x as MobileServerFollowListAccount } from "./serverModelTypes-CTHMNIQS.js";
+import { Tt as MobileSignedRequestParams } from "./clientTypes-XRI41VdC.js";
+import { WalletClientWithAccount } from "@nadohq/shared";
+import { Hex } from "viem";
+
+//#region src/types/serverBaseTypes.d.ts
+/**
+ * Base success envelope shared by every mobile service API route: just the `status` discriminant. Query
+ * routes intersect this with their payload (see {@link MobileServerPublicQuerySuccessResponse}), inlining the
+ * payload fields alongside `status` rather than nesting them under a `data` key like the engine does; execute
+ * routes return it as-is because they carry no payload.
+ */
+interface MobileServerSuccessResponse {
+  status: 'success';
+}
+/**
+ * Failure envelope returned by any mobile service API route. A response missing this envelope shape
+ * (e.g. a malformed body, or a non-JSON response) is a transport-level error, not a domain error.
+ */
+interface MobileServerFailureResponse {
+  status: 'failure';
+  error: string;
+  error_code: number;
+  request_type: MobileServerRequestType;
+}
+//#endregion
+//#region src/types/serverQueryTypes.d.ts
+/**
+ * Success payloads for each signed `query`, keyed by request `type`.
+ */
+interface MobileServerSignedQueryResponseByType {
+  /** Wallet subscriptions and the signing Identity's bells. */
+  notification_subscriptions: MobileServerNotificationSubscriptionsResponse;
+  /** Private notification page. */
+  notification_inbox_v2: MobileServerNotificationInboxV2Response;
+}
+/**
+ * Full success response for a signed `query`, with its payload inlined alongside `status`.
+ */
+type MobileServerSignedQuerySuccessResponse<T extends MobileServerSignedQueryRequestType = MobileServerSignedQueryRequestType> = MobileServerSuccessResponse & MobileServerSignedQueryResponseByType[T];
+/**
+ * Unsigned `public_query` request body: a `type` discriminant flattened with its params.
+ */
+type MobileServerPublicQueryRequest<T extends MobileServerPublicQueryRequestType = MobileServerPublicQueryRequestType> = { [K in MobileServerPublicQueryRequestType]: {
+  type: K;
+} & MobileServerPublicQueryRequestByType[K] }[T];
+/**
+ * Payload of the `username_availability` public query success response.
+ */
+interface MobileServerUsernameAvailabilityResponse {
+  username: string;
+  available: boolean;
+}
+/**
+ * Payload of the `avatar_presets` public query success response.
+ */
+interface MobileServerAvatarPresetsResponse {
+  /** Available presets in display order. */
+  presets: MobileServerAvatarPreset[];
+}
+/**
+ * Payload of the `profiles` public query success response. One entry per requested subaccount, in the exact
+ * order they were requested, so callers can correlate positionally as well as by `subaccount`.
+ */
+interface MobileServerProfilesResponse {
+  profiles: MobileServerProfile[];
+}
+/**
+ * Payload of the `search_profiles` public query success response. Matches come in ascending bytewise
+ * username order, an exact match first, and carry the same include-gated fields as a `profiles` entry.
+ */
+interface MobileServerSearchProfilesResponse {
+  profiles: MobileServerProfile[];
+  /** `null` means there are no further matches. */
+  next_cursor: string | null;
+}
+/**
+ * Payload of the `followers` and `following` public query success responses. Both list directions share one
+ * shape; only the relationship that selected the rows differs.
+ */
+interface MobileServerFollowListResponse {
+  accounts: MobileServerFollowListAccount[];
+  /** `null` means the list is complete. */
+  next_cursor: string | null;
+}
+/**
+ * Payload of the `feed` public query success response.
+ */
+interface MobileServerFeedResponse {
+  trades: MobileServerFeedTrade[];
+  /**
+   * `null` when there was no additional candidate at query time; a page may contain fewer than `limit` trades
+   * (or none) with a non-null cursor because invalid enrichment rows are omitted and pagination is live
+   * rather than snapshot.
+   */
+  next_cursor: string | null;
+}
+/** Fixed-window list response; an empty page can still have a next cursor. */
+interface MobileServerSocialFeedResponse {
+  /** Reading session and its browser credential. */
+  read_session: MobileServerSocialFeedReadSession;
+  /** Visible items in server order; deduplicate by ID without local reordering. */
+  items: MobileServerSocialFeedItem[];
+  /** Opaque cursor; null only when pagination is complete. */
+  next_cursor: string | null;
+  /** New-content baseline, not a pagination or update cursor. */
+  watermark: string;
+}
+/** Main-feed page with its ordering version. */
+interface MobileServerSocialFeedRankedResponse extends MobileServerSocialFeedResponse {
+  /** Current ordering contract: chronological-v1. */
+  ranking_version: string;
+}
+/** Top Traders page, with one shared qualification snapshot for eligibility and badges. */
+interface MobileServerSocialFeedTopTradersResponse extends MobileServerSocialFeedRankedResponse {
+  /** Author eligibility snapshot. */
+  cohort: MobileServerSocialFeedCohort;
+}
+/** Item details with either a new item session or the reused authorized session. */
+interface MobileServerSocialFeedItemResponse {
+  /** Full visible item. */
+  item: MobileServerSocialFeedItem;
+  /** Session authorized for subsequent updates. */
+  read_session: MobileServerSocialFeedReadSession;
+}
+/** Batched viewport updates; apply only the current viewport's latest request sequence. */
+interface MobileServerSocialFeedUpdatesResponse {
+  /** Item deltas, independent of current-position patches. */
+  item_patches: MobileServerSocialFeedItemPatch[];
+  /** Complete mutable position facts at one version. */
+  position_patches: MobileServerSocialFeedPositionPatch[];
+  /** Previously authorized targets that can no longer be read. */
+  unavailable_targets: MobileSocialFeedUnavailableTarget[];
+  /** New-content hint; always zero for directly created item sessions. */
+  new_items_count: number;
+  /** Baseline to use for the next update call with the same viewport. */
+  update_cursor: string;
+  /** Full snapshot of applicable mutable fields; currently always true. Apply author updates even when the item version is unchanged. */
+  reset: boolean;
+  /** Echoed viewport revision. */
+  viewport_revision: number;
+  /** Echoed request sequence. */
+  request_seq: number;
+}
+/**
+ * Payload of the `notification_preferences` public query success response.
+ */
+interface MobileServerNotificationPreferencesResponse {
+  preferences: MobileServerNotificationPreferences;
+}
+/**
+ * Payload of the `notification_registration_v2` public query, including legacy registrations.
+ */
+interface MobileServerNotificationRegistrationV2Response {
+  /** Opaque decimal string; do not convert to a JavaScript number. */
+  registration_generation: string;
+  /** Persisted capabilities of the most recent registration; legacy type/route arrays are empty. */
+  capabilities: MobileServerNotificationCapabilities;
+}
+/**
+ * Full settings document returned by both `notification_settings_v2` and `update_notification_settings_v2`.
+ */
+interface MobileServerNotificationSettingsV2Response {
+  /** Settings schema version. */
+  schema_version: 2;
+  /** Settings revision, independent of the subscription revision. */
+  revision: number;
+  /** Full saved settings. */
+  settings: MobileServerNotificationSettings;
+}
+/**
+ * Payload of the `notification_subscriptions` signed query.
+ */
+interface MobileServerNotificationSubscriptionsResponse {
+  /** Wallet-level subscription revision; read again after every mutation. */
+  revision: number;
+  /** Whether the one-time local favorites import has completed. */
+  favorites_imported: boolean;
+  /** Subscribed market IDs in ascending order. */
+  market_ids: number[];
+  /** Followed subaccounts with bells enabled for the signing Identity. */
+  trader_bells: Hex[];
+}
+/**
+ * Payload of the `notification_inbox_v2` signed query, ordered newest first.
+ */
+interface MobileServerNotificationInboxV2Response {
+  /** Accepted intents owned by the signing wallet. */
+  notifications: MobileServerNotificationInboxItem[];
+  /** Pass unchanged to the next request, or null when pagination is complete. */
+  next_cursor: string | null;
+}
+/**
+ * Payload of the `registered_wallet` public query success response. Inlined into the envelope rather than
+ * nested under a key, matching the backend's `RegisteredWalletResponse`.
+ */
+interface MobileServerRegisteredWalletResponse extends MobileServerNotificationDeviceMetadata {
+  wallet: Hex;
+  token_fingerprint_prefix: string;
+  last_seen_at: number;
+}
+/**
+ * Success payloads for each unsigned `public_query`, keyed by request `type`. Counterpart to
+ * {@link MobileServerPublicQueryRequestByType} so a query's request params and response share one lookup,
+ * matching engine's `EngineServerQueryResponseByType`. Holds the unwrapped payload; the envelope is applied
+ * by {@link MobileServerPublicQuerySuccessResponse}.
+ */
+interface MobileServerPublicQueryResponseByType {
+  /** Latest saved device generation and v1/v2 capabilities. */
+  notification_registration_v2: MobileServerNotificationRegistrationV2Response;
+  /** Full settings document with its revision. */
+  notification_settings_v2: MobileServerNotificationSettingsV2Response;
+  /** Open position candidates. */
+  self_feed_positions: MobileServerSocialFeedPositionsResponse;
+  /** Position command resolution. */
+  resolve_feed_position: MobileServerSocialFeedPositionResolutionResponse;
+  /** Trusted order action resolution. */
+  resolve_feed_action: MobileServerSocialFeedActionResolutionResponse;
+  /** Parent drawing and version. */
+  feed_chart_drawing: MobileServerSocialFeedDrawingResponse;
+  /** Comment thread page. */
+  feed_comments: MobileServerSocialFeedCommentsResponse;
+  /** Full lifecycle history. */
+  position_history: MobileServerSocialFeedPositionHistoryResponse;
+  /** Most recent 500 actions, without pagination or authored content. */
+  position_history_all: MobileServerSocialFeedPositionHistoryResponse;
+  /** Published nonblank text with complete drawings. */
+  position_thoughts: MobileServerSocialFeedPositionThoughtsResponse;
+  /** Candle page and markers. */
+  position_chart: MobileServerSocialFeedPositionChartResponse;
+  /** Read-only watcher observation. */
+  position_watchers: MobileServerSocialFeedWatchersResponse;
+  /** Preset IDs and public image URLs in display order. */
+  avatar_presets: MobileServerAvatarPresetsResponse;
+  /** For You recommendations. */
+  for_you_feed: MobileServerSocialFeedRankedResponse;
+  /** Qualified authors and cohort metadata. */
+  top_traders_feed: MobileServerSocialFeedTopTradersResponse;
+  /** Public content from followed authors. */
+  friends_feed: MobileServerSocialFeedRankedResponse;
+  /** Published author content. */
+  profile_feed: MobileServerSocialFeedResponse;
+  /** Published market content. */
+  market_feed: MobileServerSocialFeedResponse;
+  /** Published position activity. */
+  position_feed: MobileServerSocialFeedResponse;
+  /** Item details and reading session. */
+  feed_item: MobileServerSocialFeedItemResponse;
+  /** Authorized viewport changes. */
+  feed_updates: MobileServerSocialFeedUpdatesResponse;
+  username_availability: MobileServerUsernameAvailabilityResponse;
+  profiles: MobileServerProfilesResponse;
+  search_profiles: MobileServerSearchProfilesResponse;
+  followers: MobileServerFollowListResponse;
+  following: MobileServerFollowListResponse;
+  feed: MobileServerFeedResponse;
+  notification_preferences: MobileServerNotificationPreferencesResponse;
+  registered_wallet: MobileServerRegisteredWalletResponse;
+}
+/**
+ * Full success response for an unsigned `public_query`: the {@link MobileServerSuccessResponse} envelope with
+ * the query's payload inlined alongside `status`. Derived from {@link MobileServerPublicQueryResponseByType},
+ * mirroring engine's `EngineServerQuerySuccessResponse` (inlined here instead of nested under `data`).
+ */
+type MobileServerPublicQuerySuccessResponse<T extends MobileServerPublicQueryRequestType = MobileServerPublicQueryRequestType> = MobileServerSuccessResponse & MobileServerPublicQueryResponseByType[T];
+/** Selected account's current candidates. */
+interface MobileServerSocialFeedPositionsResponse {
+  /** Position eligibility hints. */
+  positions: MobileServerSocialFeedPublishablePosition[];
+  /** Next bound cursor, or null. */
+  next_cursor: string | null;
+  /** Observation time. */
+  as_of_ms: number;
+}
+/** Slash-command resolution, including normal empty outcomes. */
+interface MobileServerSocialFeedPositionResolutionResponse {
+  /** Resolution status. */
+  resolution: MobileSocialFeedPositionResolution;
+  /** Resolved market, or null. */
+  product: MobileServerSocialFeedMarket | null;
+  /** Current candidates. */
+  candidates: MobileServerSocialFeedPublishablePosition[];
+  /** Explanation for empty candidates. */
+  reason: MobileSocialFeedPositionResolutionReason | null;
+}
+/** Authoritative order segments, not an inferred latest trade. */
+interface MobileServerSocialFeedActionResolutionResponse {
+  /** Requested order. */
+  order_digest: Hex;
+  /** Pending until all confirmed segments are projected. */
+  resolution: MobileSocialFeedActionResolution;
+  /** Trusted actions, empty when pending. */
+  actions: MobileServerSocialFeedActionCandidate[];
+  /** Observation time. */
+  as_of_ms: number;
+}
+/** Drawing read result; a readable parent without a drawing succeeds with null. */
+interface MobileServerSocialFeedDrawingResponse {
+  /** Parent UUID. */
+  item_id: string;
+  /** Display version. */
+  item_version: string;
+  /** Parsed drawing, or null. */
+  drawing: MobileServerSocialFeedDrawing | null;
+}
+/** Comment thread, including bidirectional pagination around an optional anchor. */
+interface MobileServerSocialFeedCommentsResponse {
+  /** Top-level comments, newest first, each with all readable descendants in the snapshot. */
+  comments: MobileServerSocialFeedCommentGroup[];
+  /** All readable replies across the thread snapshot, including descendants. */
+  total_count: number;
+  /** All readable top-level comments across the thread snapshot. */
+  top_level_count: number;
+  /** Forward cursor. */
+  next_cursor: string | null;
+  /** Backward cursor. */
+  previous_cursor: string | null;
+  /** Requested anchor, or null. */
+  anchor_reply_id: string | null;
+  /** Original or new session. */
+  read_session: MobileServerSocialFeedReadSession;
+}
+/** Full position history with additional metrics and trusted trading hints. */
+interface MobileServerSocialFeedPositionHistoryResponse {
+  /** Current position owner. */
+  owner: MobileServerSocialFeedAuthor;
+  /** Current or frozen position and history metrics. */
+  position: MobileServerSocialFeedPositionHistoryCard;
+  /** Counts across the authorized history. */
+  summary: MobileServerSocialFeedHistorySummary;
+  /** Ordered action and take entries. */
+  timeline: MobileServerSocialFeedTimelineEntry[];
+  /** Next history cursor. */
+  next_cursor: string | null;
+  /** History completeness. */
+  history_quality: MobileSocialFeedHistoryQuality;
+  /** Position-mode session. */
+  read_session: MobileServerSocialFeedReadSession;
+  /** Viewing-account state, not authentication. */
+  trading_context: MobileServerSocialFeedTradingContext;
+}
+/** Candles and actions, with separate estimated risk-price line. */
+interface MobileServerSocialFeedPositionChartResponse {
+  /** Descending candle page. */
+  candles: MobileServerSocialFeedCandle[];
+  /** Action markers with explicit price bases. */
+  action_markers: MobileServerSocialFeedActionMarker[];
+  /** Estimated line, if applicable and available. */
+  estimated_liquidation_line: MobileServerSocialFeedEstimatedLiquidationLine | null;
+  /** Exclusive next-page bound. */
+  next_before_ms: number | null;
+  /** Observation time. */
+  as_of_ms: number;
+  /** Overall source quality. */
+  data_quality: MobileSocialFeedChartDataQuality;
+}
+/** Read-only watcher observation; account previews are self-reported. */
+interface MobileServerSocialFeedWatchersResponse {
+  /** Distinct active browsing credentials. */
+  watcher_count: number;
+  /** Deduplicated public account previews. */
+  watcher_preview: MobileServerSocialFeedAuthor[];
+  /** Observation time. */
+  as_of_ms: number;
+}
+/** Published position thought with nonblank text and a complete saved drawing. */
+type MobileServerSocialFeedPositionThought = MobileServerSocialFeedHistoryTake & {
+  /** Always true for this endpoint; uploaded or external images alone do not qualify. */has_analysis: true; /** Parsed current drawing; saved data does not necessarily contain visible strokes. */
+  drawing: MobileServerSocialFeedDrawing;
+};
+/** Thoughts in descending drawing creation time and item UUID order; no 500-item total cap. */
+interface MobileServerSocialFeedPositionThoughtsResponse {
+  /** Complete content in server order; never reorder by display time. */
+  items: MobileServerSocialFeedPositionThought[];
+  /** Null only at the directory end; an empty page can still have a cursor. */
+  next_cursor: string | null;
+  /** Independent position session; newly published content requires a refresh. */
+  read_session: MobileServerSocialFeedReadSession;
+}
+//#endregion
+//#region src/types/serverRequestTypes.d.ts
+/**
+ * Common wire-format credential for token-authenticated notification requests.
+ * Unregistration also accepts an inactive or unknown well-formed token.
+ */
+interface MobileServerWithExpoTokenParams {
+  /** Expo push token; never expose it to another user. */
+  expo_token: string;
+}
+/**
+ * Registration fields shared by v1 and v2 signed inner payloads.
+ * Nullable metadata keys remain present when signing so the MessagePack hash matches the backend.
+ */
+interface MobileServerRegisterExpoTokenParams extends MobileServerWithExpoTokenParams, MobileServerNotificationDeviceMetadata {}
+/** Registration request with a v2-only capability declaration. */
+interface MobileServerRegisterExpoTokenV2Params extends MobileServerRegisterExpoTokenParams {
+  /** Actual notification features supported by the device. */
+  capabilities: {
+    /** Registration accepts only the v2 protocol. */payload_versions: [2]; /** Supported notification types. */
+    type_ids: MobileNotificationTypeId[]; /** Supported navigation destinations. */
+    routes: MobileNotificationRouteName[];
+  };
+}
+/**
+ * One subscription operation; exactly one operation is non-null and unused operations must be null.
+ */
+interface MobileServerNotificationSubscriptionsUpdate {
+  /** Latest subscription revision, not the settings revision. */
+  expected_revision: number;
+  /** Set one bell; enabling requires an existing follow relationship. */
+  trader_bell: {
+    /** Target non-isolated subaccount belonging to another wallet. */subaccount: Hex; /** Desired bell state. */
+    enabled: boolean;
+  } | null;
+  /** Subscribe or unsubscribe one known market. */
+  market: {
+    /** Positive market product ID. */product_id: number; /** Desired subscription state. */
+    subscribed: boolean;
+  } | null;
+  /** One-time merge of up to 500 local market IDs; mutually exclusive with the other operations. */
+  import_markets: number[] | null;
+}
+/**
+ * Opt-in extras for a `profiles` query. Each one costs extra rate-limit weight per profile and adds fields
+ * that are otherwise absent from the response, so the backend gates them behind an explicit request rather
+ * than always resolving the follow graph on a public route.
+ */
+interface MobileServerProfilesInclude {
+  /** Adds `follower_count` and `following_count` to every entry. Omitted or `false` leaves both absent. */
+  follow_counts?: boolean;
+  /**
+   * Adds `follow_summary` to every entry, relative to the `view_as` subaccount. As on every public route,
+   * `view_as` is an unauthenticated claim.
+   */
+  follow_summary?: {
+    view_as: Hex;
+  };
+}
+/**
+ * Params shared by the `followers` and `following` public queries: only the relationship that selects the
+ * rows differs between the two.
+ */
+interface MobileServerFollowListRequest {
+  /** The viewed Profile, i.e. the account whose Followers or Following are being listed. */
+  subaccount: Hex;
+  /**
+   * Viewer perspective the rows are resolved against. Omitted asks for no perspective, which drops
+   * `is_following` from every row and falls back to plain recency order. Like the `profiles` query's
+   * `view_as`, this is an unauthenticated claim on an unsigned route.
+   */
+  view_as?: Hex;
+  /** Opaque keyset cursor from a prior page's `next_cursor`. Omitted requests the first page. */
+  cursor?: string;
+  /** Page size, 1–50; the backend defaults to 25 when omitted. */
+  limit?: number;
+}
+/**
+ * Params of the `search_profiles` public query.
+ */
+interface MobileServerSearchProfilesRequest {
+  /**
+   * Username prefix, 1-20 ASCII bytes: a letter or digit first, then letters, digits, `_` or `.`. The
+   * backend lowercases letters and trims nothing.
+   */
+  query: string;
+  /** Same opt-in extras as the `profiles` query, applied to every match on the page. */
+  include?: MobileServerProfilesInclude;
+  /** Opaque keyset cursor from a prior page's `next_cursor`. Omitted requests the first page. */
+  cursor?: string;
+  /** Page size, 1-50, or 1-25 when `include` asks for follow data; the backend defaults to 25 when omitted. */
+  limit?: number;
+}
+/** Common filters and pagination for social feed lists. */
+interface MobileServerSocialFeedListParams {
+  /** OR-ed content filters; combined with other filters using AND. */
+  feed_types?: MobileSocialFeedType[];
+  /** Strict lower bound in whole dollars, 1 through Number.MAX_SAFE_INTEGER. */
+  minimum_notional?: number;
+  /** Page size, 1–50; defaults to 20. */
+  limit?: number;
+  /** Original reading session; required with cursor. Legitimate requests renew its idle expiration. */
+  session_id?: string;
+  /** Opaque pagination cursor, distinct from update_cursor and watermark. */
+  cursor?: string;
+}
+/** List fields for main feeds and author feeds. */
+interface MobileServerSocialFeedCategorizedParams extends MobileServerSocialFeedListParams {
+  /** Omit to read all market categories. */
+  market_category?: MobileSocialFeedMarketCategory;
+}
+/** Unsigned browsing context; the viewing account is not proof of wallet ownership. */
+interface MobileServerSocialFeedReadParams {
+  /**
+   * Complete non-isolated viewing account. Profile, position, and item reads include this account's
+   * own hidden content under account_view, in addition to resolving relationship state.
+   */
+  view_as?: Hex;
+  /** Original browsing credential when reusing a session. */
+  viewer_token?: string;
+}
+/**
+ * Params for each unsigned `public_query`, keyed by request `type`.
+ */
+interface MobileServerPublicQueryRequestByType {
+  /** Selected account's open position candidates. */
+  self_feed_positions: {
+    /** Full identity. */view_as: Hex; /** Market filter. */
+    product_id?: number; /** Bound pagination cursor. */
+    cursor?: string; /** Page size, 1-50. */
+    limit?: number;
+  };
+  /** Resolve a position command without signing. */
+  resolve_feed_position: {
+    /** Full identity. */view_as: Hex; /** Unmodified command text. */
+    input: string; /** Optional market disambiguation. */
+    product_id?: number;
+  };
+  /** Resolve an order's complete trusted lifecycle segments. */
+  resolve_feed_action: {
+    /** Order-owning identity. */view_as: Hex; /** Trading order digest. */
+    order_digest: Hex;
+  };
+  /** Read a drawing within the parent item's visibility. */
+  feed_chart_drawing: MobileServerSocialFeedReadParams & {
+    /** Parent UUID. */item_id: string; /** Original session, paired with viewer_token. */
+    session_id?: string;
+  };
+  /** Read or navigate a comment thread. */
+  feed_comments: MobileServerSocialFeedReadParams & {
+    /** Root UUID. */root_item_id: string; /** Thread cursor. */
+    cursor?: string; /** Top-level group count, 1-50; descendants do not consume the limit. */
+    limit?: number; /** Anchor at any depth selecting its top-level group; mutually exclusive with cursor. */
+    anchor_reply_id?: string; /** Original reading session. */
+    session_id?: string;
+  };
+  /** Full lifecycle history rather than published feed items alone. */
+  position_history: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */position_id: string; /** Filter to published takes. */
+    takes_only?: boolean; /** History cursor. */
+    cursor?: string; /** Page size, 1-50. */
+    limit?: number; /** Original position-mode session. */
+    session_id?: string;
+  };
+  /** Recent actions only, capped at 500; creates a new session and does not paginate. */
+  position_history_all: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */position_id: string;
+  };
+  /** Published nonblank text with a saved drawing, newest first by drawing creation time. */
+  position_thoughts: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */position_id: string; /** Page size, 1-50; defaults to 20 and must remain unchanged across pages. */
+    limit?: number; /** Original thoughts session; cannot be reused from history or feed queries. */
+    session_id?: string; /** Previous next_cursor; requires the original session and viewer_token. */
+    cursor?: string;
+  };
+  /** Market candles and independently priced action markers. */
+  position_chart: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */position_id: string; /** Original session, paired with viewer_token. */
+    session_id?: string; /** Candle interval. */
+    interval: MobileSocialFeedChartInterval; /** Half-open time interval. */
+    range: MobileServerSocialFeedChartRange; /** Exclusive next-page bound. */
+    before_ms?: number; /** Page size, 1-500. */
+    limit?: number;
+  };
+  /** Watcher query; does not register presence. */
+  position_watchers: {
+    /** Lifecycle UUID. */position_id: string; /** Relationship perspective only. */
+    view_as?: Hex;
+  };
+  /** Ordered server-owned avatar catalogue. */
+  avatar_presets: Record<never, never>;
+  /** Public recommendations with optional relationship perspective. */
+  for_you_feed: MobileServerSocialFeedCategorizedParams & MobileServerSocialFeedReadParams;
+  /** Public content from qualified authors. */
+  top_traders_feed: MobileServerSocialFeedCategorizedParams & MobileServerSocialFeedReadParams;
+  /** Public content from authors followed by view_as. */
+  friends_feed: MobileServerSocialFeedCategorizedParams & MobileServerSocialFeedReadParams & {
+    /** Complete non-isolated identity subaccount; required on every request. */view_as: Hex;
+  };
+  /** Author content visible to view_as; the target is separate from the viewing account. */
+  profile_feed: MobileServerSocialFeedCategorizedParams & MobileServerSocialFeedReadParams & {
+    /** Target author identity, independent of view_as. */subaccount: Hex;
+  };
+  /** Public market content. */
+  market_feed: MobileServerSocialFeedListParams & MobileServerSocialFeedReadParams & {
+    /** Target product. */product_id: number;
+  };
+  /** Published activity in one lifecycle, including hidden content owned by view_as. */
+  position_feed: MobileServerSocialFeedListParams & MobileServerSocialFeedReadParams & {
+    /** Target position UUID. */position_id: string;
+  };
+  /** Item details visible to view_as, optionally reusing a reading session. */
+  feed_item: MobileServerSocialFeedReadParams & {
+    /** Target item UUID. */item_id: string; /** Preview size, 0-3. */
+    comment_preview_limit?: number; /** Omit to create a new reading session. */
+    session_id?: string;
+  };
+  /** Updates inherit the original public session's viewing account. */
+  feed_updates: {
+    /** Original reading session. */session_id: string; /** Previously delivered item UUIDs. */
+    visible_item_ids: string[]; /** Authorized position UUIDs. */
+    visible_position_ids: string[]; /** Baseline from the last accepted update. */
+    update_cursor?: string | null; /** Current viewport version. */
+    viewport_revision: number; /** Request sequence increasing across the entire session, including viewport changes. */
+    request_seq: number; /** Original public browsing credential. */
+    viewer_token: string; /** The viewing account cannot be changed by an update. */
+    view_as?: never;
+  };
+  username_availability: {
+    display_name: string;
+  };
+  profiles: {
+    /**
+     * 1–`MOBILE_PROFILES_MAX_BATCH_SIZE` (25) distinct subaccounts. Results come back in this exact order,
+     * one entry per request slot.
+     */
+    subaccounts: Hex[];
+    include?: MobileServerProfilesInclude;
+  };
+  search_profiles: MobileServerSearchProfilesRequest;
+  followers: MobileServerFollowListRequest;
+  following: MobileServerFollowListRequest;
+  feed: {
+    /**
+     * Minimum notional as a whole-dollar JSON integer (NOT an x18 string), at least $1,000. Omitted or
+     * `null` means unfiltered.
+     */
+    minimum_notional?: number; /** Page size, 1–50; the backend defaults to `MOBILE_FEED_MAX_PAGE_SIZE` (50) when omitted. */
+    limit?: number;
+    /**
+     * Opaque keyset cursor from a prior page's `next_cursor`. Bound to the exact `minimum_notional` it was
+     * issued for (including the unfiltered state) — reusing it with a different filter fails.
+     */
+    cursor?: string;
+  };
+  notification_preferences: MobileServerWithExpoTokenParams;
+  /** Persisted device generation and capabilities. */
+  notification_registration_v2: MobileServerWithExpoTokenParams;
+  /** Versioned notification settings. */
+  notification_settings_v2: MobileServerWithExpoTokenParams;
+  registered_wallet: MobileServerWithExpoTokenParams;
+}
+/**
+ * Discriminant `type` values for unsigned `public_query` requests.
+ */
+type MobileServerPublicQueryRequestType = keyof MobileServerPublicQueryRequestByType;
+/**
+ * Params for each unsigned `public_execute`, keyed by request `type`. No signature, sender, or nonce is sent.
+ * `record_feed_views` and `position_presence` are authorized by the original reading session (`session_id`)
+ * and browser credential (`viewer_token`), not an Expo push token.
+ * For `unregister_expo_token` and `update_preferences`, possession of an active Expo push token authorizes
+ * the notification mutation: the backend resolves the token's owning wallet and mutates its state. These
+ * notification writes use the backend's last-write-wins commit order, so callers must serialize them.
+ */
+interface MobileServerPublicExecuteRequestByType {
+  /** Full settings replacement with optimistic concurrency control. */
+  update_notification_settings_v2: MobileServerWithExpoTokenParams & {
+    /** Latest settings revision. */expected_revision: number; /** Complete settings document. */
+    settings: MobileServerNotificationSettings;
+  };
+  /** Independent unsigned batch view report; repeat requests increment again. */
+  record_feed_views: {
+    /** 1–50 canonical lowercase item UUIDs before deduplication; duplicates count once in this request. */item_ids: string[];
+  };
+  /** Per-page visitor lease; no wallet signature. */
+  position_presence: {
+    /** Lifecycle UUID. */position_id: string; /** Original reading session. */
+    session_id: string; /** Page-scoped UUID. */
+    view_session_id: string; /** Lease lifecycle state. */
+    state: MobileSocialFeedPresenceState; /** Original browsing credential. */
+    viewer_token: string; /** Omission preserves the display account; null clears it. */
+    watcher_subaccount?: Hex | null;
+  };
+  unregister_expo_token: {
+    expo_token: string;
+  };
+  update_preferences: {
+    expo_token: string;
+    preferences: MobileServerNotificationPreferences;
+  };
+}
+/**
+ * Discriminant `type` values for unsigned `public_execute` requests.
+ */
+type MobileServerPublicExecuteRequestType = keyof MobileServerPublicExecuteRequestByType;
+/**
+ * Discriminant `type` values for signed `execute` requests, excluding signed queries. Unlike the public
+ * queries these carry no separate params map — a signed request body is its inner payload flattened with the envelope, so
+ * {@link MobileSignedInner} is the single source of truth for both the fields and their significant order.
+ */
+type MobileServerExecuteRequestType = Exclude<MobileSignedInner['type'], MobileServerSignedQueryRequestType>;
+/**
+ * Discriminant `type` values for signed `query` requests, distinct from unsigned `public_query` requests.
+ */
+type MobileServerSignedQueryRequestType = keyof MobileServerSignedQueryResponseByType;
+/**
+ * Wire `request_type` the backend echoes on failure envelopes, prefixed by the route that produced it:
+ * `public_query_*` for unsigned queries, `public_execute_*` for unsigned writes, and `execute_*` for signed
+ * writes (e.g. `execute_set_username`), or `query_*` for signed reads. Unlike the EIP-712 method,
+ * these values never carry the `mobile:` prefix. Protected image reads use `feed_image` or
+ * `feed_comment_image` without a route prefix; malformed multipart uploads use `execute_image_upload`.
+ */
+type MobileServerRequestType = 'feed_image' | 'feed_comment_image' | 'execute_image_upload' | `query_${MobileServerSignedQueryRequestType}` | `public_query_${MobileServerPublicQueryRequestType}` | `public_execute_${MobileServerPublicExecuteRequestType}` | `execute_${MobileServerExecuteRequestType}`;
+//#endregion
+//#region src/signing/types.d.ts
+/**
+ * Unsigned inner payloads that can be authenticated against the mobile service API.
+ *
+ * Key order is significant: the payload hash is `keccak256(msgpack(inner))`, and msgpack encodes object keys
+ * in insertion order, so every field of every sub-type must be serialized in the exact order the backend
+ * declares its structs — `type` first, then the remaining fields — or the hash won't match and signature
+ * verification fails. This type only describes the shape; the authoritative runtime key order is enforced by
+ * {@link canonicalizeMobileInner}, which is the source of truth. Keep the field order here in sync with it.
+ *
+ * Every bytes32 field must be lowercase hex. The backend decodes them case-insensitively but hashes its own
+ * re-serialization, which is always lowercase, so a mixed-case value is accepted on the wire and then fails
+ * authentication against a hash the client never reproduced. Build them with `subaccountToHex`, which
+ * lowercases; unlike bytes32, string fields such as `display_name` are hashed as-is and keep their casing.
+ */
+type MobileSignedInner = ({
+  /** Capability-aware device registration. */type: 'register_expo_token_v2';
+} & MobileServerRegisterExpoTokenV2Params) | {
+  /** Signed query for wallet markets and Identity bells. */type: 'notification_subscriptions';
+} | ({
+  /** One revision-guarded subscription operation. */type: 'update_notification_subscriptions';
+} & MobileServerNotificationSubscriptionsUpdate) | {
+  /** Signed query for the wallet's private notification page. */type: 'notification_inbox_v2'; /** Previous page cursor, or nil for the first page. */
+  cursor: string | null; /** Page size, or nil for the server default. */
+  limit: number | null;
+} | {
+  /** Atomic product analytics batch. */type: 'record_product_events'; /** Events in caller order. */
+  events: MobileServerProductEvent[];
+} | {
+  /** Atomic post publication. */type: 'create_feed_post'; /** Author-scoped idempotency UUID. */
+  client_request_id: string; /** Owned position UUID. */
+  position_id: string; /** Optional trusted action UUID, omitted rather than encoded as nil. */
+  action_id?: string; /** Unmodified original text. */
+  text: string; /** Ordered mentions into the original text. */
+  mentions: MobileSocialFeedMention[]; /** Original JSON text; omitted when absent. */
+  drawing_data_json?: string; /** Ordered ready image UUIDs; omitted when absent. */
+  image_ids?: string[]; /** Up to ten original HTTP/HTTPS URLs in order; omission differs from an empty array. */
+  image_urls?: string[];
+} | {
+  /** Atomic comment publication. */type: 'create_feed_comment'; /** Author-scoped idempotency UUID. */
+  client_request_id: string; /** Root UUID. */
+  root_item_id: string; /** Optional same-thread reply UUID. */
+  reply_to_item_id?: string; /** Unmodified original text. */
+  text: string; /** Ordered mentions. */
+  mentions: MobileSocialFeedMention[]; /** Optional owned position UUID. */
+  attached_position_id?: string; /** Ordered ready image UUIDs; omitted when absent. */
+  image_ids?: string[]; /** Up to ten original HTTP/HTTPS URLs in order; omission differs from an empty array. */
+  image_urls?: string[];
+} | {
+  /** Direct multipart post-image upload; content_hash is Keccak256 of the raw file bytes. */type: 'create_feed_post_image_uploads'; /** `0x`-prefixed lowercase Keccak256 of the original file bytes. */
+  content_hash: Hex;
+} | {
+  /** Direct multipart comment-image upload; content_hash is Keccak256 of the raw file bytes. */type: 'create_feed_comment_image_uploads'; /** `0x`-prefixed lowercase Keccak256 of the original file bytes. */
+  content_hash: Hex;
+} | {
+  /** First attachment. */type: 'create_feed_chart_drawing'; /** Parent UUID. */
+  item_id: string; /** Original JSON text, not parsed or reformatted before hashing. */
+  data_json: string;
+} | {
+  /** Full replacement of an existing drawing. */type: 'update_feed_chart_drawing'; /** Parent UUID. */
+  item_id: string; /** Original JSON text. */
+  data_json: string;
+} | {
+  /** Idempotent relationship mutation. */type: 'set_feed_like'; /** Item UUID. */
+  item_id: string; /** Desired relationship state. */
+  is_liked: boolean;
+} | {
+  type: 'set_bio';
+  bio: string;
+} | {
+  type: 'create_avatar_upload';
+  content_length: number;
+} | {
+  type: 'set_avatar';
+  avatar: MobileServerAvatarSelection | null;
+} | {
+  type: 'set_username';
+  display_name: string;
+} | {
+  type: 'set_private_mode';
+  private_mode: boolean;
+} | ({
+  /** Legacy device registration without a capability declaration. */type: 'register_expo_token';
+} & MobileServerRegisterExpoTokenParams) | {
+  type: 'set_follow';
+  subaccount: Hex; /** `true` follows the target, `false` unfollows it. Both directions are idempotent. */
+  is_following: boolean;
+} | {
+  type: 'set_follow_batch'; /** Distinct targets in request order; the response keeps this order. */
+  subaccounts: Hex[]; /** `true` follows every target, `false` unfollows every target. Both directions are idempotent. */
+  is_following: boolean;
+};
+/**
+ * The single {@link MobileSignedInner} member carrying the given `type` tag.
+ */
+type MobileSignedInnerByType<T extends MobileSignedInner['type']> = Extract<MobileSignedInner, {
+  type: T;
+}>;
+/**
+ * Type-specific payload fields for a signed inner request of a given `type` (the inner payload without its
+ * `type` tag). Derived from {@link MobileSignedInner} so the two never drift apart.
+ */
+type MobileSignedInnerParams<T extends MobileSignedInner['type']> = Omit<MobileSignedInnerByType<T>, 'type'>;
+/**
+ * A signed mobile service API request body: the inner payload flattened with its signature, sender, and
+ * nonce (unlike the engine client, which wraps params under a `{ [type]: params }` key).
+ */
+type MobileSignedRequest<T extends MobileSignedInner = MobileSignedInner> = T & {
+  signature: Hex;
+  sender: Hex;
+  nonce: string;
+};
+/**
+ * Params for {@link buildSignedMobileRequest}.
+ */
+interface BuildSignedMobileRequestParams extends MobileSignedRequestParams {
+  walletClient: WalletClientWithAccount;
+  inner: MobileSignedInner;
+}
+//#endregion
+export { MobileServerSocialFeedWatchersResponse as $, MobileServerNotificationSubscriptionsResponse as A, MobileServerSocialFeedCommentsResponse as B, MobileServerAvatarPresetsResponse as C, MobileServerNotificationPreferencesResponse as D, MobileServerNotificationInboxV2Response as E, MobileServerRegisteredWalletResponse as F, MobileServerSocialFeedPositionResolutionResponse as G, MobileServerSocialFeedItemResponse as H, MobileServerSearchProfilesResponse as I, MobileServerSocialFeedPositionsResponse as J, MobileServerSocialFeedPositionThought as K, MobileServerSignedQueryResponseByType as L, MobileServerPublicQueryRequest as M, MobileServerPublicQueryResponseByType as N, MobileServerNotificationRegistrationV2Response as O, MobileServerPublicQuerySuccessResponse as P, MobileServerSocialFeedUpdatesResponse as Q, MobileServerSignedQuerySuccessResponse as R, MobileServerWithExpoTokenParams as S, MobileServerFollowListResponse as T, MobileServerSocialFeedPositionChartResponse as U, MobileServerSocialFeedDrawingResponse as V, MobileServerSocialFeedPositionHistoryResponse as W, MobileServerSocialFeedResponse as X, MobileServerSocialFeedRankedResponse as Y, MobileServerSocialFeedTopTradersResponse as Z, MobileServerSearchProfilesRequest as _, MobileSignedRequest as a, MobileServerSocialFeedListParams as b, MobileServerNotificationSubscriptionsUpdate as c, MobileServerPublicExecuteRequestType as d, MobileServerUsernameAvailabilityResponse as et, MobileServerPublicQueryRequestByType as f, MobileServerRequestType as g, MobileServerRegisterExpoTokenV2Params as h, MobileSignedInnerParams as i, MobileServerProfilesResponse as j, MobileServerNotificationSettingsV2Response as k, MobileServerProfilesInclude as l, MobileServerRegisterExpoTokenParams as m, MobileSignedInner as n, MobileServerSuccessResponse as nt, MobileServerExecuteRequestType as o, MobileServerPublicQueryRequestType as p, MobileServerSocialFeedPositionThoughtsResponse as q, MobileSignedInnerByType as r, MobileServerFollowListRequest as s, BuildSignedMobileRequestParams as t, MobileServerFailureResponse as tt, MobileServerPublicExecuteRequestByType as u, MobileServerSignedQueryRequestType as v, MobileServerFeedResponse as w, MobileServerSocialFeedReadParams as x, MobileServerSocialFeedCategorizedParams as y, MobileServerSocialFeedActionResolutionResponse as z };
+//# sourceMappingURL=types-CByl_NyJ.d.ts.map