@smartico/public-api 0.0.426 → 0.0.428

package/docs/SmarticoObject.md

@@ -286,12 +286,12 @@ to have run.
 Renders an operator-configured banner into a host element, and pushes runtime
 data into a rendered banner placement.
 
-### `suspendPopups(flag)` · `suspendInbox(flag)` · `suspendMiniGames(flag)`
+### `suspendPopups(flag)` · `suspendInbox(flag)` · `suspendMiniGames(flag)` · `suspendForms(flag)`
 
 Temporarily suppress (or re-enable) automatically-triggered surfaces — popups,
-inbox prompts, and server-triggered mini-game pop-ups respectively. Pass `true`
-to suspend, `false` to resume. Useful while the user is mid-flow (e.g. on a
-deposit page or completing a KYC form) and you don't want Smartico surfaces
+inbox prompts, server-triggered mini-game pop-ups, and forms respectively. Pass
+`true` to suspend, `false` to resume. Useful while the user is mid-flow (e.g. on
+a deposit page or completing a KYC step) and you don't want Smartico surfaces
 interrupting. Require an identified user.
 
 ```js
@@ -304,6 +304,11 @@ When suspension is turned off, the first surface that was missed while
 suspended is shown — provided the session is still active (the user hasn't
 refreshed or navigated away).
 
+`suspendForms` is the exception: a form requested while forms are suspended is
+dropped, not queued, so nothing replays when you resume. A campaign-triggered
+form that is dropped this way is reported as failed to deliver, which fires the
+journey's failure branch.
+
 ---
 
 ## Events & analytics

package/docs/ui/leaderboard/UIGuide_getLeaderBoard.md

@@ -45,10 +45,25 @@ Columns per row (in the Leaders tab):
 | Column | Source | Notes |
 |---|---|---|
 | Position | `user.position` | Server-computed DENSE_RANK. Show as `01`, `02`, … `20`. |
-| Avatar | `user.avatar_url` | Hide via operator config `hide_avatars_leaderboards` if applicable. |
+| Avatar | `user.avatar_url` | Hidden when `getLeaderBoardSettings().hide_avatars`. |
 | Username | `user.public_username` | |
-| Points | `user.points` | Operator config `leaderboard_hide_other_points` may suppress points for everyone except the current user. |
-| Level badge | (Drives from separate `getCurrentLevel` lookup, not on this type) | Operator config `leaderboard_hide_levels` may suppress. |
+| Points | `user.points` | Hidden for every row except the current user's when `getLeaderBoardSettings().hide_other_points`. |
+| Level badge | (Drives from separate `getCurrentLevel` lookup, not on this type) | Hidden when `getLeaderBoardSettings().hide_levels`. |
+
+**Privacy flags are the consumer's job.** `getLeaderBoard` always returns
+`avatar_url`, `level_id` and `points` on every row — the server does not
+strip them. Read the operator's configuration with the synchronous
+`getLeaderBoardSettings()` and apply it while rendering:
+
+```ts
+const settings = window._smartico.api.getLeaderBoardSettings();
+const showPoints = (row: LeaderBoardUserT) => row.is_me || !settings.hide_other_points;
+```
+
+Note the default on an unconfigured label: `hide_avatars` and
+`hide_levels` are `false` (show), but `hide_other_points` is `true`
+(hide). Rendering points unconditionally is therefore a divergence from
+the default Smartico UI, not just a missed setting.
 
 **Top-3 podium styling**: apply distinct CSS classes (`place-1`,
 `place-2`, `place-3`) to rows with `position <= 3` (and

package/docs/ui/missions/UIGuide_getBadges.md

@@ -137,6 +137,12 @@ top.
 | `AfterStartDateWithProgressAndEndDate` (3) — active with progress, has end date | Full-color | `"<countdown>"` to `active_till_ts` (see "Countdown / timing format") |
 | `AfterEndDateNotStarted` (4) — expired, never started | Grayscale + dim overlay + slash/X overlay | `"Expired"` |
 | `AfterEndDateWithProgress` (5) — expired with some progress | Grayscale + dim overlay | `"Ended"` (or `"Expired"`) |
+| `AfterStartDateWithProgress` (6) — active with progress, no end date | Full-color, no overlay | No chip |
+
+States 1 and 6 are the open-ended pair: a badge with no `active_till_ts`
+can only ever report one of them, never states 4 or 5. Never render an
+open-ended badge as expired, and never key an "expired" treatment off
+the absence of a countdown.
 
 On top of the time-window treatment, layer the completion state:
 

package/docs/ui/raffles/UIGuide_getRaffles.md

@@ -20,11 +20,16 @@ raffle expanding to show its draws. There are no top-level tabs.
 
 Per-raffle, draws are bucketed within the detail panel:
 
-  1. **Active / Upcoming** — `draws.filter(d => d.current_state !== 3)`
+  1. **Active / Upcoming** — `draws.filter(d => d.current_state === 1 || d.current_state === 2)`
      (1 = Open, 2 = WinnerSelection); sort by `execution_ts` ASC.
   2. **Executed** — `draws.filter(d => d.current_state === 3)`;
      rendered after the active draws.
 
+Bucket on the active states explicitly rather than on
+`current_state !== 3`: Cancelled (4) is also terminal, and a
+`!== 3` test files it under Active, where it renders as a live draw
+that never resolves.
+
 ## Ticket-cap banner
 
 Drive from `TRaffle.ticket_cap_visualization` (enum):
@@ -49,6 +54,18 @@ Fields rendered on each raffle row:
 operator-defined custom section. `custom_data` is operator-defined
 JSON / string for custom UI extensions.
 
+**Rules / Terms & Conditions**: `hint_text` is the operator-authored
+rules text for the raffle. The default Smartico UI surfaces it behind a
+"Rules" button next to the draw-history entry point. It may be empty —
+in that case hide the button entirely. Never substitute generic
+boilerplate for it: the text is a legal artefact the operator is
+responsible for, and inventing your own makes the widget state terms
+the operator never agreed to.
+
+**Per-prize privacy**: `hide_chance_to_win` is set per prize. When it
+is `true`, do not render that prize's `chances_to_win_perc` anywhere —
+neither on the card nor in the expanded draw.
+
 ## Draw card (per-raffle children)
 
 Fields rendered on each `draws[i]`:

package/docs/ui/tournaments/UIGuide_getTournamentsList.md

@@ -34,10 +34,15 @@ tabs only. No visual difference on the card itself — just position.
 - Desktop: Overview · MyTournaments · InProgress · Finished
 - Mobile: Overview · MyTournaments · InProgress
 
-**Custom section filtering**: if your UI scopes the lobby to a
-specific custom section (e.g. a deep-link `?custom_section_id=42`),
-filter to tournaments whose `custom_section_id` matches; the SDK does
-not filter for you.
+**Custom section filtering**: the SDK does not filter by placement —
+do it yourself, and apply the same filter to the tab counters, not just
+to the rendered cards:
+
+- Main lobby: drop custom-section-only entries —
+  `tournaments.filter(t => !t.only_in_custom_section)`.
+- A lobby scoped to one custom section (e.g. a deep-link
+  `?custom_section_id=42`): keep the entries whose `custom_section_id`
+  matches that section instead.
 
 **Bucketing helper** (raw-state to bucket — for reference):
 
@@ -81,8 +86,9 @@ Fields rendered on the card (top-to-bottom):
     `registration_cost_gems` / `registration_cost_diamonds` (only
     one is set per tournament) — show "Free" if all are falsy.
     `custom_price_text` (operator-supplied string) overrides if set.
-  - Prize pool: `prize_pool_short` if set, else a derived label
-    from `prizes[]` (or "Mixed" / "—" as fallback).
+  - Prize pool: `prize_pool_short` if set, else "Mixed". The default
+    Smartico UI does not derive a card label from `prizes[]` and never
+    renders a bare dash — keep the fallback a single stable string.
 - **CTA button** — see "Action button decision matrix".
 
 **Mobile card variant**: ribbon renders ABOVE the image (not as an

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smartico/public-api",
-	"version": "0.0.426",
+	"version": "0.0.428",
 	"description": "Smartico public API",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/Core/PublicLabelSettings.ts

@@ -6,6 +6,8 @@ export enum PublicLabelSettings {
 	GAMIFICATION_UI_WIDGET = 'GAMIFICATION_UI_WIDGET',
 	GAMIFICATION_UI_MINI_GAME = 'GAMIFICATION_UI_MINI_GAME',
 	GAMIFICATION_UI_SETTINGS = 'GAMIFICATION_UI_SETTINGS',
+	GAMIFICATION_UI_SETTINGS_V2 = 'GAMIFICATION_UI_SETTINGS_V2',
+	GAMIFICATION_UI_SETTINGS_TEST_V2 = 'GAMIFICATION_UI_SETTINGS_TEST_V2',
 	GAMIFICATION_UI_MAIN_TEST = 'GAMIFICATION_UI_MAIN_TEST',
 	GAMIFICATION_UI_WIDGET_TEST = 'GAMIFICATION_UI_WIDGET_TEST',
 	GAMIFICATION_UI_SETTINGS_TEST = 'GAMIFICATION_UI_SETTINGS_TEST',

package/src/Missions/BadgesTimeLimitStates.ts

@@ -11,5 +11,10 @@ export enum BadgesTimeLimitStates {
 	AfterEndDateNotStarted = 4,
 	/** After End Date (player has some progress, but not completed) */
 	AfterEndDateWithProgress = 5,
+	/**
+	 * After Start Date, player has some progress, and the badge has no End Date.
+	 * The badge is still earnable — do not render it as expired.
+	 */
+	AfterStartDateWithProgress = 6,
 }
 

package/src/Missions/MissionsUtils.ts

@@ -302,8 +302,8 @@ export class MissionUtils {
             if (progress === 0) {
                 return BadgesTimeLimitStates.AfterStartDateNoProgress;
             }
-            // If infinite and with progress → this state does not exist in enum
-            // (but if needed we can add one)
+
+            return BadgesTimeLimitStates.AfterStartDateWithProgress;
         }
       
         // 3. AFTER START, BEFORE END DATE

package/src/Raffle/GetRafflesResponse.ts

@@ -43,6 +43,7 @@ export const prizeTransform = (items: RafflePrize[]): TRafflePrize[] => {
 			description: item.public_meta.description,
 			image_url: item.public_meta.image_url,
 			custom_data: item.public_meta.custom_data,
+			hide_chance_to_win: item.public_meta.hide_chance_to_win,
 			prizes_per_run: item.prizes_per_run,
 			prizes_per_run_actual: item.prizes_per_run_actual,
 			chances_to_win_perc: item.chances_to_win_perc,
@@ -103,6 +104,7 @@ export const raffleTransform = (items: Raffle[]): TRaffle[] => {
 			custom_section_id: item.public_meta.custom_section_id,
 			image_url: item.public_meta.image_url,
 			image_url_mobile: item.public_meta.image_url_mobile,
+			hint_text: item.public_meta.hint_text,
 			custom_data: item.public_meta.custom_data,
 			start_date: item.start_date_ts,
 			end_date: item.end_date_ts,

package/src/Raffle/RaffleDraw.ts

@@ -9,19 +9,25 @@ export enum RaffleDrawInstanceState {
     WinnerSelection = 2,
     /** Draw is executed and the winners are selected */
     Executed = 3,
+    /**
+     * Draw was cancelled and will never be executed.
+     * Treat it as a terminal state: stop any polling of the draw run
+     * and do not show the winner-selection progress UI.
+     */
+    Cancelled = 4,
 }
 
 export enum RaffleDrawTypeExecution {
     /** Draw is executed only once */
-    ExecDate = 0,
+    ExecDate = 1,
     /** Draw is executed on a recurring basis */
-    Recurring = 1,
-    /** 
+    Recurring = 2,
+    /**
      * Draw is executed once and is marked as grand.
      * This means it is a special or significant draw,
      * often with larger prizes or more importance.
      */
-    Grand = 2,
+    Grand = 3,
 }
 
 

package/src/SmarticoAPI.ts

@@ -95,6 +95,7 @@ import {
 	TTournament,
 	TTournamentDetailed,
 	LeaderBoardDetailsT,
+	LeaderBoardSettingsT,
 	UserLevelExtraCountersT,
 	TSegmentCheckResult,
 	TUICustomSection,
@@ -191,6 +192,7 @@ interface Tracker {
 	getLabelSetting: (key: PublicLabelSettings) => any;
 	triggerExternalCallBack: (callBackKey: string, payload: any) => void;
 	getExtUserId: () => string;
+	getHash?: () => string;
 }
 interface IOptions {
 	logger?: ILogger;
@@ -1244,6 +1246,49 @@ class SmarticoAPI {
 		return (await this.leaderboardsGetList(user_ext_id)).map(getLeaderBoardTransform);
 	}
 
+	public leaderboardsGetSettings(): LeaderBoardSettingsT {
+		// Defaults match the default Smartico UI when the operator has not
+		// configured the gamification UI settings: avatars and levels are
+		// shown, other players' points are not.
+		const settings = this.getGamificationUISettings();
+
+		return {
+			hide_avatars: settings?.hide_avatars_leaderboards === true,
+			hide_levels: settings?.leaderboard_hide_levels === true,
+			// Deliberately asymmetric: points stay hidden unless the operator
+			// explicitly opted in by setting the flag to false. This mirrors the
+			// default Smartico UI, so a consumer rendering both surfaces agrees
+			// with it on an unconfigured label.
+			hide_other_points: settings?.leaderboard_hide_other_points !== false,
+		};
+	}
+
+	private getGamificationUISettings(): Record<string, any> {
+		if (!this.tracker) {
+			return null;
+		}
+
+		const parse = (raw: any): Record<string, any> => {
+			if (typeof raw !== 'string' || raw.length === 0) {
+				return null;
+			}
+
+			try {
+				const parsed = JSON.parse(raw);
+				return parsed && Object.keys(parsed).length ? parsed : null;
+			} catch (e) {
+				return null;
+			}
+		};
+
+		// Test accounts read the operator's test variant when one is configured;
+		// everyone else reads the live settings.
+		const isTestAccount = this.tracker.userPublicProps?.core_is_test_account === true;
+		const testSettings = isTestAccount ? parse(this.tracker.getLabelSetting(PublicLabelSettings.GAMIFICATION_UI_SETTINGS_TEST_V2)) : null;
+
+		return testSettings || parse(this.tracker.getLabelSetting(PublicLabelSettings.GAMIFICATION_UI_SETTINGS_V2));
+	}
+
 	public async levelsGet(user_ext_id: string, force_language?: string): Promise<GetLevelMapResponse> {
 		const message = this.buildMessage<any, GetLevelMapResponse>(user_ext_id, ClassId.GET_LEVEL_MAP_REQUEST);
 		return await this.send<GetLevelMapResponse>(message, ClassId.GET_LEVEL_MAP_RESPONSE, force_language);
@@ -1455,6 +1500,11 @@ class SmarticoAPI {
 			lang: this.tracker.userPublicProps?.core_user_language,
 		});
 
+		const user_hash = this.tracker.getHash?.();
+		if (user_hash) {
+			params.user_hash = user_hash;
+		}
+
 		return params;
 	}
 

package/src/SmarticoGlobal.ts

@@ -171,6 +171,8 @@ export interface SmarticoGlobal {
 	suspendInbox(flag: boolean): void;
 	/** Temporarily suspend/resume mini-games. */
 	suspendMiniGames(flag: boolean): void;
+	/** Temporarily suspend/resume forms. */
+	suspendForms(flag: boolean): void;
 
 	/** Show a visitor-mode game. */
 	showVisitorGame(params: Record<string, unknown>): void;

package/src/Tournaments/Tournament.ts

@@ -90,6 +90,7 @@ export const TournamentItemsTransform = (items: Tournament[]): TTournament[] =>
 				prize_pool_short: r.publicMeta.prize_pool_short,
 				custom_price_text: r.publicMeta.custom_price_text,
 				custom_section_id: r.publicMeta.custom_section_id,
+				only_in_custom_section: r.publicMeta.only_in_custom_section,
 				custom_data: IntUtils.JsonOrText(r.publicMeta.custom_data),
 				is_featured: r.publicMeta.featured,
 				ribbon: r.publicMeta.label_tag === 'custom' ? r.publicMeta.custom_label_tag : r.publicMeta.label_tag,

package/src/WSAPI/WSAPILeaderBoard.ts

@@ -1,6 +1,7 @@
 import { ECacheContext, OCache } from '../OCache';
 import {
 	LeaderBoardDetailsT,
+	LeaderBoardSettingsT,
 } from './WSAPITypes';
 import { LeaderBoardPeriodType } from '../Leaderboard';
 import {
@@ -223,4 +224,55 @@ export class WSAPILeaderBoard extends WSAPIGamePick {
 			CACHE_DATA_SEC,
 		);
 	}
+
+	/**
+	 * Returns the operator's privacy configuration for leaderboard rendering.
+	 * Apply it to every leaderboard row you draw — the standings returned by
+	 * {@link getLeaderBoard} always carry `avatar_url`, `level_id` and
+	 * `points`, so honouring these flags is the consumer's responsibility.
+	 * Ignoring them surfaces data the operator asked to keep private.
+	 *
+	 * @remarks
+	 * **Flags** — each is `true` when the corresponding data must be hidden:
+	 * - `hide_avatars` — draw rows without the player avatar.
+	 * - `hide_levels` — draw rows without the player's level name.
+	 * - `hide_other_points` — hide `points` for every row except the current
+	 *   user's. The current user always sees their own points.
+	 *
+	 * **Defaults on an unconfigured label** — `hide_avatars` and
+	 * `hide_levels` default to `false` (show), while `hide_other_points`
+	 * defaults to `true` (hide) unless the operator explicitly turned it off.
+	 * The asymmetry is intentional: it matches the default Smartico UI, so a
+	 * consumer rendering its own leaderboard next to the built-in one agrees
+	 * with it rather than exposing points the built-in surface hides.
+	 *
+	 * **Synchronous** — the settings arrive with the session handshake, so
+	 * this returns immediately and never issues a round-trip. Call it on
+	 * every render rather than caching the result yourself.
+	 *
+	 * **Idempotency / Side effects**: safe. Read-only.
+	 *
+	 * **Visitor mode**: supported. Returns the same label-level configuration.
+	 *
+	 * @returns The resolved leaderboard privacy flags. Never `null`.
+	 *
+	 * @example
+	 * ```ts
+	 * import { LeaderBoardPeriodType } from '@smartico/public-api';
+	 *
+	 * const settings = window._smartico.api.getLeaderBoardSettings();
+	 * const board = await window._smartico.api.getLeaderBoard(LeaderBoardPeriodType.WEEKLY);
+	 *
+	 * for (const row of board?.users ?? []) {
+	 *   const showPoints = row.is_me || !settings.hide_other_points;
+	 *
+	 *   console.log('[smartico] render row', row.position, row.public_username,
+	 *     settings.hide_avatars ? '(no avatar)' : row.avatar_url,
+	 *     showPoints ? row.points : '(points hidden)');
+	 * }
+	 * ```
+	 */
+	public getLeaderBoardSettings(): LeaderBoardSettingsT {
+		return this.api.leaderboardsGetSettings();
+	}
 }

package/src/WSAPI/WSAPIMissions.ts

@@ -216,7 +216,11 @@ export class WSAPIMissions extends WSAPIGeneral {
 	 * as undefined / default. Time windows are absolute calendar timestamps
 	 * (`active_from_ts` / `active_till_ts`), not opt-in-relative durations —
 	 * drive availability chips from the SDK-computed `badgeTimeLimitState`
-	 * (enum {@link BadgesTimeLimitStates}), not `time_limit_ms`. Locking for
+	 * (enum {@link BadgesTimeLimitStates}), not `time_limit_ms`. A badge
+	 * with no `active_till_ts` is open-ended and never reaches the
+	 * "after end date" states — it reports `AfterStartDateNoProgress`
+	 * or `AfterStartDateWithProgress` — so it must never be rendered as
+	 * expired. Locking for
 	 * badges is purely time-based: `is_locked` is `true` only when
 	 * `badgeTimeLimitState === BadgesTimeLimitStates.BeforeStartDate` (the
 	 * time window hasn't started yet). The primary navigation field is

package/src/WSAPI/WSAPIRaffles.ts

@@ -68,8 +68,12 @@ export class WSAPIRaffles extends WSAPIJackpots {
 	 *   sold-out message).
 	 * - Within each draw, `current_state`
 	 *   ({@link RaffleDrawInstanceState}) buckets the draw into Open
-	 *   (accepting tickets), WinnerSelection (currently drawing), or
-	 *   Executed (winners selected).
+	 *   (accepting tickets), WinnerSelection (currently drawing),
+	 *   Executed (winners selected), or Cancelled (will never run).
+	 *   Treat every state other than Open and WinnerSelection as
+	 *   terminal — stop polling the draw run and clear any
+	 *   "drawing in progress" indicator, otherwise a cancelled draw
+	 *   leaves the UI spinning forever.
 	 * - `execution_type` ({@link RaffleDrawTypeExecution}) distinguishes
 	 *   one-shot (`ExecDate`), repeating (`Recurring`), or special
 	 *   one-shot (`Grand`) draws. Recurring draws share a stable

package/src/WSAPI/WSAPITournaments.ts

@@ -52,6 +52,12 @@ export class WSAPITournaments extends WSAPIStore {
 	 * tournaments not yet published. SDK consumers receive only items
 	 * the user is eligible to see; no client-side gating is required.
 	 *
+	 * Client-side filtering you may still want: tournaments with
+	 * `only_in_custom_section: true` are intended for their custom-section
+	 * view only and should be hidden from the main lobby list — including
+	 * from any per-tab counters rendered next to the tab labels, otherwise
+	 * the counts disagree with the number of cards the user can see.
+	 *
 	 * **Reading state from the returned item**
 	 * Drive list bucketing and CTA labels from the SDK-computed booleans
 	 * (`is_active`, `is_can_register`, `is_cancelled`, `is_finished`,
@@ -116,19 +122,22 @@ export class WSAPITournaments extends WSAPIStore {
 	 *   },
 	 * });
 	 *
+	 * // Main lobby list — custom-section-only tournaments belong to that section's own view.
+	 * const lobby = tournaments.filter(t => !t.only_in_custom_section);
+	 *
 	 * // Bucket items by lifecycle state for a tabbed UI.
-	 * const live = tournaments.filter(t => t.is_in_progress);
-	 * const upcoming = tournaments
+	 * const live = lobby.filter(t => t.is_in_progress);
+	 * const upcoming = lobby
 	 *   .filter(t => t.is_upcoming && !t.is_user_registered)
 	 *   .sort((a, b) => a.start_time - b.start_time);
-	 * const mine = tournaments.filter(t => t.is_user_registered);
-	 * const finished = tournaments.filter(t => t.is_finished);
+	 * const mine = lobby.filter(t => t.is_user_registered);
+	 * const finished = lobby.filter(t => t.is_finished);
 	 *
 	 * console.log('[smartico] render lobby tabs with these counts: live=', live.length,
 	 *   'upcoming=', upcoming.length, 'mine=', mine.length, 'finished=', finished.length);
 	 *
 	 * // Featured tournament: pin to position 0 of the Overview/Top tabs.
-	 * const featured = tournaments.find(t => t.is_featured && !t.is_cancelled);
+	 * const featured = lobby.find(t => t.is_featured && !t.is_cancelled);
 	 * if (featured) {
 	 *   console.log('[smartico] featured tournament — pin to position 0 of the Overview tab:', featured.name);
 	 * }

package/src/WSAPI/WSAPITypes.ts

@@ -389,6 +389,8 @@ export interface TTournament {
 	 * The list of custom sections can be retrieved using _smartico.api.getCustomSections() method
 	 */
 	custom_section_id: number;
+	/** The indicator if the tournament is visible only in the custom section and should be hidden from the main overview of tournaments */
+	only_in_custom_section?: boolean;
 	/** The custom data of the tournament defined by operator. Can be a JSON object, string or number */
 	custom_data: any;
 
@@ -1192,6 +1194,22 @@ export interface LeaderBoardDetailsT {
 	me?: LeaderBoardUserT;
 }
 
+/**
+ * LeaderBoardSettingsT carries the operator's privacy configuration for
+ * leaderboard rendering. Every flag means "hide" when `true`.
+ */
+export interface LeaderBoardSettingsT {
+	/** When `true`, render leaderboard rows without player avatars. */
+	hide_avatars: boolean;
+	/** When `true`, render leaderboard rows without player level names. */
+	hide_levels: boolean;
+	/**
+	 * When `true`, hide the points of every player except the current user.
+	 * The current user's own points are always shown, regardless of this flag.
+	 */
+	hide_other_points: boolean;
+}
+
 /**
  * LeaderBoardsRewardsT describes one place's prize on a leaderboard.
  * Leaderboard prizes are always gamification points (never gems / diamonds / items).
@@ -1421,6 +1439,13 @@ export interface TRaffle {
 	image_url: string;
 	/** URL of the mobile image that represents the raffle, 300x142px */
 	image_url_mobile: string;
+	/**
+	 * Terms and Conditions text configured by the operator for this raffle.
+	 * Render it as the raffle rules. It is absent or empty when the operator
+	 * configured none — hide the rules section in that case rather than
+	 * substituting your own copy.
+	 */
+	hint_text?: string;
 	/**
 	 * Custom data as string or JSON string that can be used in API to build custom UI
 	 * You can request from Smartico to define fields for your specific case that will be managed from Smartico BackOffice
@@ -1477,6 +1502,12 @@ export interface TRafflePrize {
 	 * Can be used to build custom UI for gamification.
 	 */
 	custom_data?: string;
+	/**
+	 * Indicates whether the chance to win should be hidden in the UI.
+	 * When `true`, do not render `chances_to_win_perc` for this prize.
+	 * Absent means "not hidden".
+	 */
+	hide_chance_to_win?: boolean;
 	/**
 	 * The number of prizes available per run of the draw.
 	 * E.g. if the draw is run daily, this is the number of prizes available each day, for example 3 iPhones.

package/src/index.ts

@@ -22,7 +22,7 @@ export type {
 	TSetAvatarResult, TStoreCategory, TStoreItem, TTournament, TTournamentDetailed,
 	TTournamentRegistrationResult, TUICustomSection, TUserProfile,
 	TransformedRaffleClaimPrizeResponse, InboxMarkMessageAction, LeaderBoardDetailsT,
-	LeaderBoardUserT, LeaderBoardsRewardsT, UserLevelExtraCountersT,
+	LeaderBoardUserT, LeaderBoardsRewardsT, LeaderBoardSettingsT, UserLevelExtraCountersT,
 } from './WSAPI/WSAPITypes';
 
 export * from './Analytics';

package/dist/ActivityLog/ActivityLogMapper.d.ts

@@ -1,4 +0,0 @@
-import { UserBalanceType } from './UserBalanceType';
-import { TActivityLogEntry } from '../WSAPI/WSAPITypes';
-export declare const mapActivityLogHistory: (logHistory: unknown[]) => TActivityLogEntry[];
-export declare const resolveWalletDisplayType: (entry: TActivityLogEntry) => UserBalanceType;

package/dist/Quiz/MarketsAnswers.d.ts

@@ -1,40 +0,0 @@
-export declare enum QuizAnswersValueType {
-    HomeTeam = "1",
-    AwayTeam = "2",
-    Draw = "x",
-    HomeTeamHomeTeam = "1/1",
-    HomeTeamDraw = "1/x",
-    HomeTeamAwayTeam = "1/2",
-    DrawHomeTeam = "x/1",
-    DrawDraw = "x/x",
-    DrawAwayTeam = "x/2",
-    AwayTeamHomeTeam = "2/1",
-    AwayTeamDraw = "2/x",
-    AwayTeamAwayTeam = "2/2",
-    Yes = "yes",
-    No = "no",
-    Odd = "odd",
-    Even = "even",
-    HomeOdd = "1/odd",
-    HomeEven = "1/even",
-    AwayOdd = "2/odd",
-    AwayEven = "2/even"
-}
-export declare const quizAnswerHomeTeamReplacementText = "{quiz_home_team}";
-export declare const quizAnswerAwayTeamReplacementText = "{quiz_away_team}";
-export declare const quizDrawReplacementText = "{quiz_draw}";
-export declare const quizYesReplacementText = "{yes}";
-export declare const quizNoReplacementText = "{no}";
-export declare const quizOddReplacementText = "{odd}";
-export declare const quizEvenReplacementText = "{even}";
-export declare const quizOrReplacementText = "{or}";
-export declare const quizNoGoalsReplacementText = "{quiz_no_goals}";
-export declare const quizAnswersTrKeys: {
-    "{quiz_draw}": string;
-    "{yes}": string;
-    "{no}": string;
-    "{odd}": string;
-    "{even}": string;
-    "{or}": string;
-    "{quiz_no_goals}": string;
-};

package/dist/Quiz/MarketsInfo.d.ts

@@ -1,14 +0,0 @@
-import { QuizAnswersValueType } from './MarketsAnswers';
-import { SAWGPMarketType } from './MarketsType';
-export declare const marketsInfo: {
-    type: SAWGPMarketType;
-    name: string;
-    question: {
-        text: string;
-        trKey: string;
-    };
-    answers: {
-        text: string;
-        value: QuizAnswersValueType;
-    }[];
-}[];

package/dist/Quiz/MarketsPerSport.d.ts

@@ -1,6 +0,0 @@
-import { SAWGPMarketType } from './MarketsType';
-export declare const QuizMarketPerSport: {
-    2: SAWGPMarketType[];
-    1: SAWGPMarketType[];
-    5: SAWGPMarketType[];
-};

package/dist/Quiz/MarketsType.d.ts

@@ -1,28 +0,0 @@
-export declare enum SAWGPMarketType {
-    TwoTeamsWithScore = 1,
-    RedCard = 2,
-    OneXTwo = 3,
-    OneXTwoHalftime = 4,
-    FirstGoal = 6,
-    DoubleChance = 7,
-    OverUnder2_5 = 8,
-    OverUnder1_5Halftime = 9,
-    OverUnder1_5__2ndHalf = 10,
-    TotalCorners8_5 = 11,
-    TotalCorners9_5 = 12,
-    Corners1x2 = 13,
-    One_Two = 14,
-    Overtime = 15,
-    OddEven = 16,
-    OddEvenHomeAway = 17,
-    FirstSet = 18,
-    SecondSet = 19,
-    ThirdSet = 20,
-    FourthSet = 21,
-    FifthSet = 22,
-    PlayerOneWinsOneSet = 23,
-    PlayerTwoWinsOneSet = 24,
-    LastGoal = 25,
-    CustomSport = 26,
-    CustomNonSport = 27
-}