@smartico/public-api 0.0.402 → 0.0.404

package/docs/capabilities/claimBonus.md

@@ -0,0 +1,125 @@
+# claimBonus — API (TClaimBonusResult)
+
+> Triggers manual redemption of a coupon-model bonus the user has been awarded.
+> Import: `import { TClaimBonusResult } from '@smartico/public-api'`
+> Search terms: claimBonus, bonuses, TClaimBonusResult, err_code, err_message
+
+## Signature
+```ts
+_smartico.api.claimBonus(bonus_id: number): Promise<TClaimBonusResult>
+```
+
+## Parameters
+- `bonus_id` — The `bonus_id` from a `TBonus` returned by `getBonuses`.
+
+## Returns — `Promise<TClaimBonusResult>`
+`TClaimBonusResult`:
+- `err_code` (number) — Error code. `0` = success. See `claimBonus` TSDoc for the full table.
+- `err_message` (string) — Optional error message; populated on non-zero `err_code`.
+- `success` (boolean) — Unreliable on the wire — prefer `err_code === 0` as the success check.
+
+## Behavioral contract
+**Preconditions**
+Read the candidate bonus from `getBonuses` and gate the
+call on `is_redeemable === true`. The SDK forwards the request
+unconditionally — calling on a non-claimable bonus returns
+`err_code = -1`.
+
+
+
+**Refresh after success (and after failure)**
+The SDK automatically refreshes the bonuses cache on every
+response (success OR failure) and fires any `onUpdate` callback
+registered via `getBonuses`'s `onUpdate`. After
+`err_code === 0`, the redeemed bonus shifts from
+`COUPON_ISSUED` / `REDEEM_FAILED` to `REDEEMED` on the refreshed
+array, with `redeem_date` populated. After a failure, the bonus
+typically lands in `REDEEM_FAILED` and remains claimable for a
+retry.
+
+**Idempotency**: NOT idempotent at the SDK level. A second call
+returns `err_code = -1` once the first has succeeded — treat that
+as success in the UI rather than as a real error. Guard the call
+site against double-clicks (set a local "claiming" flag on click,
+clear it on response).
+
+**Side effects** (on `err_code === 0`)
+- Bonus status transitions to `REDEEMED`; `redeem_date` is set.
+- The operator's integration credits the player's account
+ externally. The SDK does not observe that credit directly —
+ balance updates flow over the user-properties channel from the
+ operator's side, not from this response.
+- Server-side analytics events fire downstream (not directly
+ observable from the SDK).
+
+**UI guidance**: see [UI Guide — `claimBonus`](../../docs/ui/bonuses/UIGuide_claimBonus.md).
+
+**Visitor mode**: not supported.
+
+## Example
+```ts
+const bonuses = await window._smartico.api.getBonuses({
+  onUpdate: (refreshed) => console.log('[smartico] bonuses refreshed — re-render from this array', refreshed),
+});
+const bonus = bonuses.find(b => b.bonus_id === bonusId);
+
+if (!bonus) {
+  console.log('[smartico] bonus no longer visible — refresh list and hide CTA');
+  return;
+}
+if (!bonus.is_redeemable) {
+  console.log('[smartico] bonus is not claimable (auto-redeemed or already finalised) — keep CTA hidden');
+  return;
+}
+
+console.log('[smartico] claim starting — set in-flight flag, show loading dots on the Claim button, keep the modal open');
+const r = await window._smartico.api.claimBonus(bonus.bonus_id);
+console.log('[smartico] claim response received — clear in-flight flag');
+
+if (r.err_code === 0 || r.err_code === -1) {
+  console.log('[smartico] claim succeeded (or was already done) — show a success toast; the getBonuses onUpdate above will fire with the refreshed list');
+} else if (r.err_code === 9999) {
+  console.error('[smartico] uncaught server exception — show a generic error toast and allow retry');
+} else {
+  console.error('[smartico] claim failed — surface this error message to the user; the bonus will move to REDEEM_FAILED state and remain claimable for a retry:', r.err_message);
+}
+```
+
+### Example response (REAL shape)
+> Where this real payload differs from the typed Returns above (TS interface vs raw wire), the REAL shape is the runtime truth.
+```json
+{
+  "err_code": -1,
+  "err_message": "System Error, Bonus not found or already claimed"
+}
+```
+
+## Errors
+**Error codes** (in `err_code`)
+
+The SDK currently types `err_code` as `SAWSpinErrorCode` for
+historical reasons, but the values returned by this method come
+from the server's general error space and are NOT mini-game codes.
+Branch on the numeric values:
+
+- `0` — success; the bonus has been redeemed and the operator's
+ integration has credited the player's account.
+- `-1` — bonus not claimable: not found, already claimed by
+ another session, or its status is no longer `COUPON_ISSUED` /
+ `REDEEM_FAILED`. Treat as idempotent — refresh
+ `getBonuses` and reconcile.
+- `1` — generic server error. Transient; allow retry after a brief
+ delay.
+- `9999` — uncaught server exception. Treat as a transient failure;
+ surface a generic error and allow retry.
+- other non-zero — generic server error. Surface `err_message` if
+ any.
+
+**`success` field is unreliable**: the wire response does not
+carry a `success` boolean — the field on `TClaimBonusResult` will
+be `undefined` in practice. Always branch on `err_code === 0`
+for the success check.
+
+## Related
+- `getBonuses`
+- `SAWSpinErrorCode`

package/docs/capabilities/claimRafflePrize.md

@@ -0,0 +1,116 @@
+# claimRafflePrize — API (TransformedRaffleClaimPrizeResponse)
+
+> Claims a raffle prize the user has won.
+> Import: `import { TransformedRaffleClaimPrizeResponse } from '@smartico/public-api'`
+> Search terms: claimRafflePrize, raffles, TransformedRaffleClaimPrizeResponse
+
+## Signature
+```ts
+_smartico.api.claimRafflePrize(props: { won_id: number }): Promise<TransformedRaffleClaimPrizeResponse>
+```
+
+## Parameters
+- `props.won_id` — The winning row's `raf_won_id` (from `TRafflePrizeWinner` returned by `getRaffleDrawRun`).
+
+## Returns — `Promise<TransformedRaffleClaimPrizeResponse>`
+`TransformedRaffleClaimPrizeResponse`:
+- `errorCode` (number) — Error code. `0` = success. See `claimRafflePrize` TSDoc for the full table.
+- `errorMessage` (string) — Optional error message; populated on non-zero `errorCode`.
+
+## Behavioral contract
+**Result shape note**: this method returns
+`TransformedRaffleClaimPrizeResponse` with `errorCode` /
+`errorMessage` (camelCase full-word) — different from most other
+SDK result types which use `err_code` / `err_message` (snake_case
+short-word). Branch on the camelCase keys when reading this
+method's result.
+
+**Preconditions**
+Pass a `won_id` that identifies an unclaimed winning row for the
+current user. The `won_id` comes from
+`TRafflePrizeWinner.raf_won_id` returned by
+`getRaffleDrawRun`.
+
+
+
+**Claim window**
+There is no server-enforced claim deadline. Won prizes remain
+claimable indefinitely until the operator archives them.
+
+**Idempotency**: NOT idempotent. A second call on the same
+`won_id` returns `errorCode === 1` with `errorMessage` indicating
+the prize has already been claimed. The SDK does NOT enforce an
+in-flight lock. Guard the call site against double-clicks (set
+a local "claiming" flag on click, clear it on response).
+
+**Refresh after success (and after failure)**
+The SDK automatically refreshes the raffles cache on every
+response — both success and failure paths fire the `onUpdate`
+callback registered via `getRaffles`. After `errorCode === 0`,
+the affected `TRaffleDrawRun.has_unclaimed_prize` (in history)
+and the winner row's `claimed_date` reflect the claim on the next
+refresh.
+
+**Side effects** (on `errorCode === 0`)
+- The winner row's `claimed_date` is set server-side.
+- Prize delivery is queued for the operator's integration to
+ process. Balance / bonus / inbox updates that result from the
+ delivery arrive through their own channels — not in this
+ response.
+
+**Throws**
+`won_id` is required — the SDK throws synchronously when missing
+or falsy.
+
+**UI guidance**: see [UI Guide — `claimRafflePrize`](../../docs/ui/raffles/UIGuide_claimRafflePrize.md).
+
+**Visitor mode**: not meaningfully supported. The SDK does not
+block the call, but visitor sessions have no win history and the
+server will reject it.
+
+## Example
+```ts
+const detail = await window._smartico.api.getRaffleDrawRun({
+  raffle_id: raffleId,
+  run_id: runId,
+});
+const myWin = detail.prizes.flatMap(p => p.winners).find(w => /* user match here *\/ true);
+
+if (!myWin || !myWin.raf_won_id || myWin.claimed_date) {
+  console.log('[smartico] nothing to claim — keep CTA hidden');
+  return;
+}
+
+console.log('[smartico] claim starting — set in-flight flag, show loading dots on the Claim button, keep the modal open');
+const r = await window._smartico.api.claimRafflePrize({ won_id: myWin.raf_won_id });
+console.log('[smartico] claim response received — clear in-flight flag');
+
+if (r.errorCode === 0) {
+  console.log('[smartico] claim succeeded — show a success toast; getRaffles onUpdate above will fire with refreshed state; prize delivery happens server-side');
+} else if (r.errorCode === 1 && r.errorMessage?.toLowerCase().includes('already claimed')) {
+  console.log('[smartico] prize was already claimed (perhaps from another tab) — treat as success, hide the Claim CTA');
+} else {
+  console.error('[smartico] claim failed — surface this error message to the user and allow retry:', r.errorMessage);
+}
+```
+
+## Errors
+**Error codes** (in `errorCode`)
+- `0` — success; the claim is recorded and prize delivery is
+ queued server-side.
+- `1` — generic claim failure. The `errorMessage` distinguishes
+ the specific cause (the server uses one error code for several
+ distinct conditions): the prize has already been claimed, the
+ `won_id` doesn't match a winning row for this user, or the user
+ is in a control group for this raffle. Treat `1` as a retryable
+ error if the message suggests a transient condition; treat as
+ idempotent success if the message indicates already-claimed
+ (the underlying state is what the consumer wants either way —
+ the prize is claimed).
+- other non-zero — generic server error. Surface `errorMessage`
+ if any.
+
+## Related
+- `getRaffleDrawRun`
+- `getRaffleDrawRunsHistory`
+- `getRaffles`

package/docs/capabilities/deleteAllInboxMessages.md

@@ -0,0 +1,66 @@
+# deleteAllInboxMessages — API (InboxMarkMessageAction)
+
+> Soft-deletes ALL of the user's inbox messages in one server round-trip — typically wired to a "Delete all" CTA in the inbox header (usually behind a confirm dialog given the destructive nature).
+> Import: `import { InboxMarkMessageAction } from '@smartico/public-api'`
+> Search terms: deleteAllInboxMessages, inbox, InboxMarkMessageAction
+
+## Signature
+```ts
+_smartico.api.deleteAllInboxMessages(): Promise<InboxMarkMessageAction>
+```
+
+## Parameters
+_None._
+
+## Returns — `Promise<InboxMarkMessageAction>`
+`InboxMarkMessageAction`:
+- `err_code` (number) — Error code. `0` = success. See the calling method's TSDoc for the full error semantics (server returns generic codes; the five inbox mutations share the same shape).
+- `err_message` (string) — Optional server-side error message. Present only on non-zero `err_code`; may be empty even then.
+
+## Behavioral contract
+**Race condition note**: a new message arriving server-side
+between the call and its processing is NOT deleted (the
+server's delete-all operation is a snapshot in time). Subsequent
+`getInboxMessages` calls show the new message.
+
+**Refresh after success**
+Same as `deleteInboxMessage` — `getInboxMessages` `onUpdate`
+does not fire automatically. Replace the local list with `[]`
+(or re-call `getInboxMessages`). The unread count drops to 0
+(or near-0 if races) via the user-properties channel.
+
+**Idempotency**: safe. A second call on an already-empty inbox
+returns `err_code === 0` with no-op effect.
+
+**Side effects** (on success)
+- Every message flipped to deleted server-side.
+- `core_inbox_unread_count` drops to 0.
+- There is no SDK undelete path — recovery requires operator
+ intervention.
+
+**UI guidance**: included in the
+[UI Guide — `deleteInboxMessage`](../../docs/ui/inbox/UIGuide_deleteInboxMessage.md)
+(Bulk variant section).
+
+**Visitor mode**: not supported.
+
+## Example
+```ts
+// After a confirm dialog "Are you sure you want to delete all messages?"
+console.log('[smartico] delete-all confirmed — show loading state on the "Delete all" button');
+const r = await window._smartico.api.deleteAllInboxMessages();
+if (r.err_code === 0) {
+  console.log('[smartico] inbox cleared — replace the local list with [], fire a "All messages deleted" toast, badge auto-drops to 0');
+} else {
+  console.error('[smartico] delete-all failed — show a non-blocking error toast:', r.err_message);
+}
+```
+
+## Errors
+**Error codes** (in `err_code`)
+- `0` — success; the entire inbox is now empty from the user's
+ view.
+- other non-zero — server error. Surface `err_message` if any.
+
+## Related
+- `deleteInboxMessage`

package/docs/capabilities/deleteInboxMessage.md

@@ -0,0 +1,60 @@
+# deleteInboxMessage — API (InboxMarkMessageAction)
+
+> Soft-deletes a single inbox message.
+> Import: `import { InboxMarkMessageAction } from '@smartico/public-api'`
+> Search terms: deleteInboxMessage, inbox, InboxMarkMessageAction
+
+## Signature
+```ts
+_smartico.api.deleteInboxMessage(messageGuid: string): Promise<InboxMarkMessageAction>
+```
+
+## Parameters
+- `messageGuid` — The `message_guid` from a `TInboxMessage`.
+
+## Returns — `Promise<InboxMarkMessageAction>`
+`InboxMarkMessageAction`:
+- `err_code` (number) — Error code. `0` = success. See the calling method's TSDoc for the full error semantics (server returns generic codes; the five inbox mutations share the same shape).
+- `err_message` (string) — Optional server-side error message. Present only on non-zero `err_code`; may be empty even then.
+
+## Behavioral contract
+**Refresh after success**
+The SDK does NOT auto-refresh `getInboxMessages`. Drop the
+deleted message from your local list, or re-call
+`getInboxMessages` to reload. If the deleted message was unread,
+the unread count drops automatically via the user-properties
+channel.
+
+**Idempotency**: safe. A second call on an already-deleted
+`messageGuid` returns `err_code === 0` (server treats it as a
+no-op — already-deleted messages are filtered out).
+
+**Side effects** (on success)
+- Server-side `is_deleted` flag set to true.
+- If the message was unread, `core_inbox_unread_count`
+ decrements via the user-properties channel.
+
+**UI guidance**: see [UI Guide — `deleteInboxMessage`](../../docs/ui/inbox/UIGuide_deleteInboxMessage.md).
+
+**Visitor mode**: not supported.
+
+## Example
+```ts
+// Swipe-to-delete on mobile; trash-icon click on desktop.
+console.log('[smartico] delete starting — animate the row out of the list (slide left/right by 100%)');
+const r = await window._smartico.api.deleteInboxMessage(message.message_guid);
+if (r.err_code === 0) {
+  console.log('[smartico] deleted — drop the message from the local list, fire a brief "Message deleted" toast (no undo affordance — there is no undelete via the SDK)');
+} else {
+  console.error('[smartico] delete failed — animate the row back into place and show a non-blocking error:', r.err_message);
+}
+```
+
+## Errors
+**Error codes** (in `err_code`)
+- `0` — success; the message is now deleted from the user's
+ view.
+- other non-zero — server error. Surface `err_message` if any.
+
+## Related
+- `getInboxMessages`

package/docs/capabilities/gamePickGetActiveRound.md

@@ -0,0 +1,248 @@
+# gamePickGetActiveRound — API (GamePickRound)
+
+> Returns a single round (events, user selections, scoring rules) for a MatchX or Quiz game.
+> Import: `import { GamePickRound } from '@smartico/public-api'`
+> Search terms: gamePickGetActiveRound, gamepick, GamePickRound, GPRoundStatus, GamePickScoreType, GameRoundOrderType, GamePickRoundPublicMeta, GamePickEvent, SAWGPMarketType, GamePickEventMeta, QuizAnswersValueType, GamePickResolutionType, errCode, data
+
+## Signature
+```ts
+_smartico.api.gamePickGetActiveRound(props: GamePickRoundRequestParams): Promise<GamesApiResponse<GamePickRound>>
+```
+
+## Parameters
+- `props.saw_template_id` — ID of the MatchX or Quiz game template.
+- `props.round_id` — ID of the round to fetch.
+
+## Returns — `Promise<GamesApiResponse<GamePickRound>>`
+Wrapped in `GamesApiResponse`: `errCode` (number — `0` = success), `errMessage?` (string), `data?` — the payload:
+
+`GamePickRound`:
+- `round_id` (number) — Unique round identifier
+- `round_row_id` (number) — Sequential row ID used for ordering rounds
+- `round_name` (string) — Localized display name of the round
+- `round_description` (string) — Localized description of the round
+- `final_screen_cta_button_title` (string) — Label for the CTA button on the final/results screen
+- `final_screen_message` (string) — Message displayed on the final/results screen
+- `final_screen_image_desktop` (string) — URL of the final screen image (desktop)
+- `final_screen_image_mobile` (string) — URL of the final screen image (mobile)
+- `promo_image` (string) — URL of the promotional image for the round
+- `promo_text` (string) — Promotional text displayed with the round
+- `open_date` (number) — Timestamp (ms) when the round opens for participation
+- `last_bet_date` (number) — Timestamp (ms) of the last moment bets are accepted
+- `resolution_date` (number) — Timestamp (ms) when the round is expected to be resolved
+- `score_full_win` (number) — Points awarded for a fully correct prediction
+- `score_part_win` (number) — Points awarded for a partially correct prediction
+- `score_lost` (number) — Points awarded (or deducted) for an incorrect prediction
+- `is_active_now` (boolean) — Whether the round is currently active for participation
+- `is_resolved` (boolean) — Whether the round has been fully resolved and scored
+- `round_status_id` (GPRoundStatus) — Current lifecycle status of the round
+- `events_total` (number) — Total number of events in the round
+- `events_resolved` (number) — Number of events that have been resolved
+- `score_type_id` (GamePickScoreType) — Scoring method used for this round
+- `order_events` (GameRoundOrderType) — How events are ordered for display
+- `board_users_count` (number) — Maximum number of users shown on the leaderboard
+- `hide_users_predictions` (boolean) — Whether other users' predictions are hidden until resolution
+- `public_meta` (GamePickRoundPublicMeta) — Public metadata including translations and display settings from the BackOffice
+  - `round_name` (string) — Localized round name
+  - `round_description` (string) — Localized round description
+  - `promo_image` (string) — URL of the promotional image for the round
+  - `promo_text` (string) — Promotional text displayed with the round
+  - `hide_resolved_round` (boolean) — Whether to hide the round from the UI after it has been resolved
+  - `final_screen_image_desktop` (string) — URL of the final screen image for desktop
+  - `final_screen_image_mobile` (string) — URL of the final screen image for mobile
+  - `final_screen_message` (string) — Message displayed on the final/results screen
+  - `final_screen_cta_button_title` (string) — Label for the CTA button on the final screen
+  - `final_screen_cta_dp` (string) — Deep link triggered by the CTA button on the final screen
+  - `allow_edit_answers` (boolean) — Whether users can edit their answers after initial submission (within betting window)
+  - `_translations` ({
+		[key: string]: {
+			round_name: string;
+			round_description: string;
+			promo_image: string;
+			promo_text: string;
+			final_screen_image_desktop: string;
+			final_screen_image_mobile: string;
+			final_screen_message: string;
+			final_screen_cta_button_title: string;
+		};
+	}) — Per-language overrides for round display content
+- `next_round_open_date` (number) — Timestamp (ms) when the next round opens, if available
+- `show_users_preference` (boolean) — Whether to show aggregated user preference percentages for each outcome
+- `events` (GamePickEvent[]) — List of events (matches/questions) in this round
+  - `gp_event_id` (number) — Unique identifier of the event
+  - `event_resolution_date` (string) — ISO 8601 date-time string when the event was resolved; null until resolved.
+  - `match_date` (string) — ISO 8601 date-time string of the match/event start time.
+  - `market_type_id` (SAWGPMarketType) — Market type defining the prediction format (e.g. two-team score, quiz question, custom)
+  - `event_meta` (GamePickEventMeta) — Event metadata containing team names, images, sport type, and question details
+    - `answers` ({
+		/** Answer identifier value sent on submission */
+		value: string;
+		/** Localized display text of the answer */
+		text: string;
+		/** Per-language overrides for the answer text */
+		_translations: {
+			[key: string]: {
+				text: string;
+			};
+		};
+	}[]) — List of possible answer options for the quiz question
+    - `question_image` (string) — URL of an image associated with the question
+    - `result` (QuizAnswersValueType) — Correct answer value after resolution
+    - `custom_question` (string) — Custom question text displayed to the user
+    - `event_name` (string) — Display name of the event/match
+    - `team1_name` (string) — Name of the first team (home)
+    - `team1_image` (string) — URL of the first team's logo image
+    - `team2_name` (string) — Name of the second team (away)
+    - `team2_image` (string) — URL of the second team's logo image
+    - `team1_result` (number) — Actual result score for team 1 after resolution
+    - `team2_result` (number) — Actual result score for team 2 after resolution
+    - `sport_type_id` (number) — Betradar sport type ID for the event
+    - `is_canceled` (boolean) — Whether the event has been canceled
+    - `auto_resolve_enabled` (boolean) — Whether auto-resolution from live data feed is enabled
+    - `auto_resolve_date` (string) — ISO date string for when auto-resolution is expected
+    - `team1_auto_result` (number) — Auto-resolved score for team 1 from live data feed
+    - `team2_auto_result` (number) — Auto-resolved score for team 2 from live data feed
+    - `auto_result` (string) — Auto-resolved answer value from live data feed (for quiz events)
+    - `_translations` ({
+		[key: string]: {
+			team1_name: string;
+			team2_name: string;
+			event_name: string;
+			custom_question: string;
+		};
+	}) — Per-language overrides for team names, event name, and custom question
+  - `user_placed_bet` (boolean) — Whether the current user has submitted a prediction for this event
+  - `team1_user_selection` (number | { from: number; to: number }) — User's predicted score for team 1 (MatchX only). Can be a number or a range object
+  - `team2_user_selection` (number | { from: number; to: number }) — User's predicted score for team 2 (MatchX only). Can be a number or a range object
+  - `user_selection` (QuizAnswersValueType) — User's selected answer (Quiz only). Value depends on market type (e.g. '1', '2', 'x', 'yes', 'no')
+  - `resolution_type_id` (GamePickResolutionType) — How the user's prediction was scored after resolution
+  - `resolution_score` (number) — Points awarded for this event based on prediction accuracy
+  - `is_open_for_bets` (boolean) — Whether this event is still accepting predictions
+  - `odds_details` ({ odd_value: { [key: string]: number } }) — Betting odds details for the event outcomes
+  - `question_image` (string) — URL of a question-specific image (quiz events)
+- `user_score` (number) — Current user's total score in this round
+- `user_placed_bet` (boolean) — Whether the current user has submitted any predictions in this round
+- `has_open_for_bet_events` (boolean) — Whether there are events still open for betting
+- `has_not_submitted_changes` (boolean) — Whether the user has unsaved changes to their predictions
+
+## Behavioral contract
+**Preconditions**
+- User must be authenticated. Visitor mode not supported.
+- `saw_template_id` and `round_id` are mandatory — the SDK throws if either
+ is missing.
+
+
+
+**Refresh**
+- No cache; every call is live.
+- Re-call after `gamePickSubmitSelection` or
+ `gamePickSubmitSelectionQuiz` to surface the persisted predictions.
+- Poll while the user is on the prediction screen if event resolution
+ updates are needed (typically every 30–60 s).
+
+**Visitor mode**: not supported.
+
+**UI guidance**: see [UI Guide — `gamePickGetActiveRound`](../../docs/ui/gamepick/UIGuide_gamePickGetActiveRound.md).
+
+## Example
+```ts
+const r = await window._smartico.api.gamePickGetActiveRound({
+    saw_template_id: 1083,
+    round_id:        31652,
+});
+
+if (r.errCode === 0 && r.data) {
+    console.log('[smartico] render round detail page —', r.data.round_name, '— user has placed bet:', r.data.user_placed_bet, 'score so far:', r.data.user_score);
+} else {
+    console.error('[smartico] round fetch failed — bounce back to the lobby and refresh:', r.errMessage);
+}
+```
+
+### Example response (REAL shape)
+> Where this real payload differs from the typed Returns above (TS interface vs raw wire), the REAL shape is the runtime truth.
+```json
+{
+  "errCode": 0,
+  "data": {
+    "round_id": 42115,
+    "round_row_id": 2,
+    "public_meta": {
+      "round_name": "Group stage 15-28 June",
+      "_translations": {
+        "BR": {},
+        "TH": {}
+      },
+      "allow_edit_answers": true,
+      "final_screen_cta_dp": "dp:ok",
+      "hide_resolved_round": false
+    },
+    "score_type_id": 1,
+    "open_date": 1782200297406,
+    "last_bet_date": 1782691140000,
+    "is_active_now": true,
+    "is_resolved": false,
+    "round_status_id": -1,
+    "score_full_win": 0,
+    "score_part_win": 0,
+    "score_lost": 0,
+    "events_total": "28",
+    "events_resolved": "1",
+    "show_users_preference": true,
+    "order_events": 1,
+    "board_users_count": 20,
+    "hide_users_predictions": false,
+    "round_name": "Group stage 15-28 June",
+    "user_score": 0,
+    "user_placed_bet": false,
+    "events": [
+      {
+        "gp_event_id": 147400,
+        "market_type_id": 4,
+        "event_meta": {
+          "event_name": "World Cup",
+          "team1_name": "Czech Republic",
+          "team2_name": "Mexico",
+          "is_canceled": false,
+          "team1_image": "https://cdn.example/games/teams-images/1299262.png",
+          "team2_image": "https://cdn.example/games/teams-images/4781.png",
+          "sport_type_id": 1,
+          "question_image": "https://cdn.example/5ff1fc35b419e43886d227-Artboard3.png",
+          "scores_manually_adjusted": false
+        },
+        "event_resolution_date": null,
+        "match_date": "2026-06-25T01:00:00.000Z",
+        "odds_details": {
+          "odd_value": {
+            "1": 22,
+            "2": 35,
+            "x": 43
+          }
+        },
+        "user_placed_bet": false,
+        "resolution_score": 0,
+        "is_open_for_bets": true,
+        "resolution_type_id": 0
+      }
+    ],
+    "has_open_for_bet_events": true,
+    "has_not_submitted_changes": false
+  }
+}
+```
+
+## Errors
+**Error codes** (in `errCode`)
+- `0` — success.
+- `4` — round / event not found (e.g. round resolved after the last
+ `gamePickGetActiveRounds` poll); non-fatal — retry after a fresh active-
+ rounds fetch.
+- `100002` — template not found.
+- `100000` — auth hash invalid.
+- `100004` — generic server error.
+
+## Related
+- `gamePickGetActiveRounds`
+- `gamePickSubmitSelection`
+- `gamePickSubmitSelectionQuiz`
+- `GamesApiResponse`
+- `GamePickRound`