@smartico/public-api 0.0.351 → 0.0.353

package/src/WSAPI/WSAPI.ts

@@ -40,6 +40,15 @@ import {
 	TActivityLog,
 	TRaffleOptinResponse,
 } from './WSAPITypes';
+import {
+	GamesApiResponse,
+	GamePickRound,
+	GamePickRoundBoard,
+	GamePickUserInfo,
+	GamePickGameInfo,
+	GamePickRequestParams,
+	GamePickRoundRequestParams,
+} from '../GamePick';
 import { LeaderBoardPeriodType } from '../Leaderboard';
 import {
 	JackpotDetails,
@@ -102,9 +111,11 @@ enum onUpdateContextKey {
 export class WSAPI {
 	private onUpdateCallback: Map<onUpdateContextKey, (data: any) => void> = new Map();
 	private jackpotGetSignature: string = '';
+	private userExtId: string = null;
 
 	/** @private */
-	constructor(private api: SmarticoAPI) {
+	constructor(private api: SmarticoAPI, userExtId: string = null) {
+		this.userExtId = userExtId;
 		OCache.clearAll();
 		if (this.api.tracker) {
 			const on = this.api.tracker.on;
@@ -193,7 +204,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async checkSegmentMatch(segment_id: number): Promise<boolean> {
-		const r = await this.api.coreCheckSegments(null, [segment_id]);
+		const r = await this.api.coreCheckSegments(this.userExtId, [segment_id]);
 		if (r && r.find((s) => s.segment_id === segment_id && s.is_matching)) {
 			return true;
 		} else {
@@ -211,7 +222,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async checkSegmentListMatch(segment_ids: number[]): Promise<TSegmentCheckResult[]> {
-		return await this.api.coreCheckSegments(null, Array.isArray(segment_ids) ? segment_ids : [segment_ids]);
+		return await this.api.coreCheckSegments(this.userExtId, Array.isArray(segment_ids) ? segment_ids : [segment_ids]);
 	}
 
 	/** Returns all the levels available the current user
@@ -230,7 +241,7 @@ export class WSAPI {
 	 * ```
 	 */
 	public async getLevels(): Promise<TLevel[]> {
-		return OCache.use(onUpdateContextKey.Levels, ECacheContext.WSAPI, () => this.api.levelsGetT(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.Levels, ECacheContext.WSAPI, () => this.api.levelsGetT(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/**
@@ -246,7 +257,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async getCurrentLevel(): Promise<TLevelCurrent> {
-		return OCache.use(onUpdateContextKey.CurrentLevel, ECacheContext.WSAPI, () => this.api.getLevelCurrent(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.CurrentLevel, ECacheContext.WSAPI, () => this.api.getLevelCurrent(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/** Returns all the missions configured for the current user (server-side scoped, not filtered by Widget visibility).
@@ -276,7 +287,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.Missions,
 			ECacheContext.WSAPI,
-			() => this.api.missionsGetItemsT(null),
+			() => this.api.missionsGetItemsT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -287,7 +298,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async getBadges(): Promise<TMissionOrBadge[]> {
-		return OCache.use(onUpdateContextKey.Badges, ECacheContext.WSAPI, () => this.api.badgetsGetItemsT(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.Badges, ECacheContext.WSAPI, () => this.api.badgetsGetItemsT(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/**
@@ -303,7 +314,7 @@ export class WSAPI {
 			this.onUpdateCallback.set(onUpdateContextKey.Bonuses, onUpdate);
 		}
 
-		return OCache.use(onUpdateContextKey.Bonuses, ECacheContext.WSAPI, () => this.api.bonusesGetItemsT(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.Bonuses, ECacheContext.WSAPI, () => this.api.bonusesGetItemsT(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/**
@@ -315,7 +326,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async claimBonus(bonus_id: number): Promise<TClaimBonusResult> {
-		const r = await this.api.bonusClaimItem(null, bonus_id);
+		const r = await this.api.bonusClaimItem(this.userExtId, bonus_id);
 
 		const o: TClaimBonusResult = {
 			err_code: r.errCode,
@@ -344,7 +355,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.LevelExtraCounters,
 			ECacheContext.WSAPI,
-			() => this.api.getUserGamificationInfoT(null),
+			() => this.api.getUserGamificationInfoT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -380,7 +391,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.StoreItems,
 			ECacheContext.WSAPI,
-			() => this.api.storeGetItemsT(null),
+			() => this.api.storeGetItemsT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -396,7 +407,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async buyStoreItem(item_id: number): Promise<TBuyStoreItemResult> {
-		const r = await this.api.buyStoreItem(null, item_id);
+		const r = await this.api.buyStoreItem(this.userExtId, item_id);
 
 		const o: TBuyStoreItemResult = {
 			err_code: r.errCode,
@@ -428,7 +439,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.StoreCategories,
 			ECacheContext.WSAPI,
-			() => this.api.storeGetCategoriesT(null),
+			() => this.api.storeGetCategoriesT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -462,7 +473,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.StoreHistory,
 			ECacheContext.WSAPI,
-			() => this.api.storeGetPurchasedItemsT(null, limit, offset),
+			() => this.api.storeGetPurchasedItemsT(this.userExtId, limit, offset),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -489,7 +500,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.AchCategories,
 			ECacheContext.WSAPI,
-			() => this.api.achGetCategoriesT(null),
+			() => this.api.achGetCategoriesT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -516,7 +527,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.CustomSections,
 			ECacheContext.WSAPI,
-			() => this.api.customSectionsGetT(null),
+			() => this.api.customSectionsGetT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -548,7 +559,7 @@ export class WSAPI {
 			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
 		}
 
-		return OCache.use(onUpdateContextKey.Saw, ECacheContext.WSAPI, () => this.api.sawGetTemplatesT(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.Saw, ECacheContext.WSAPI, () => this.api.sawGetTemplatesT(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/**
@@ -579,7 +590,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.SAWHistory,
 			ECacheContext.WSAPI,
-			() => this.api.getSawWinningHistoryT(null, limit, offset, saw_template_id),
+			() => this.api.getSawWinningHistoryT(this.userExtId, limit, offset, saw_template_id),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -606,8 +617,8 @@ export class WSAPI {
 			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
 		}
 
-		const r = await this.api.sawSpinRequest(null, template_id);
-		this.api.doAcknowledgeRequest(null, r.request_id);
+		const r = await this.api.sawSpinRequest(this.userExtId, template_id);
+		this.api.doAcknowledgeRequest(this.userExtId, r.request_id);
 
 		const o: TMiniGamePlayResult = {
 			err_code: r.errCode,
@@ -628,7 +639,7 @@ export class WSAPI {
 	 * ```
 	 */
 	public async miniGameWinAcknowledgeRequest(request_id: string) {
-		return this.api.doAcknowledgeRequest(null, request_id);
+		return this.api.doAcknowledgeRequest(this.userExtId, request_id);
 	}
 
 	/**
@@ -653,10 +664,10 @@ export class WSAPI {
 			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
 		}
 
-		const response = await this.api.sawSpinBatchRequest(null, template_id, spin_count);
+		const response = await this.api.sawSpinBatchRequest(this.userExtId, template_id, spin_count);
 
 		const request_ids = response.results.map((result) => result.request_id);
-		this.api.doAcknowledgeBatchRequest(null, request_ids);
+		this.api.doAcknowledgeBatchRequest(this.userExtId, request_ids);
 
 		const o: TMiniGamePlayBatchResult[] = response.results.map((result) => ({
 			errCode: result.errCode,
@@ -675,7 +686,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async requestMissionOptIn(mission_id: number): Promise<TMissionOptInResult> {
-		const r = await this.api.missionOptIn(null, mission_id);
+		const r = await this.api.missionOptIn(this.userExtId, mission_id);
 
 		const o: TMissionOptInResult = {
 			err_code: r.errCode,
@@ -691,7 +702,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async requestMissionClaimReward(mission_id: number, ach_completed_id: number): Promise<TMissionClaimRewardResult> {
-		const r = await this.api.missionClaimPrize(null, mission_id, ach_completed_id);
+		const r = await this.api.missionClaimPrize(this.userExtId, mission_id, ach_completed_id);
 
 		const o: TMissionClaimRewardResult = {
 			err_code: r.errCode,
@@ -727,7 +738,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.TournamentList,
 			ECacheContext.WSAPI,
-			() => this.api.tournamentsGetLobbyT(null),
+			() => this.api.tournamentsGetLobbyT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -758,7 +769,7 @@ export class WSAPI {
 	 * ```
 	 */
 	public async getTournamentInstanceInfo(tournamentInstanceId: number): Promise<TTournamentDetailed> {
-		return this.api.tournamentsGetInfoT(null, tournamentInstanceId);
+		return this.api.tournamentsGetInfoT(this.userExtId, tournamentInstanceId);
 	}
 
 	/**
@@ -767,7 +778,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async registerInTournament(tournamentInstanceId: number): Promise<TTournamentRegistrationResult> {
-		const r = await this.api.registerInTournament(null, tournamentInstanceId);
+		const r = await this.api.registerInTournament(this.userExtId, tournamentInstanceId);
 
 		const o: TTournamentRegistrationResult = {
 			err_code: r.errCode,
@@ -799,7 +810,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.LeaderBoards,
 			ECacheContext.WSAPI,
-			() => this.api.leaderboardsGetT(null, periodType, getPreviousPeriod),
+			() => this.api.leaderboardsGetT(this.userExtId, periodType, getPreviousPeriod),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -836,7 +847,7 @@ export class WSAPI {
 		if (onUpdate) {
 			this.onUpdateCallback.set(onUpdateContextKey.InboxMessages, onUpdate);
 		}
-		return await this.api.getInboxMessagesT(null, from, to, onlyFavorite, categoryId, read_status);
+		return await this.api.getInboxMessagesT(this.userExtId, from, to, onlyFavorite, categoryId, read_status);
 	}
 
 	/**
@@ -852,7 +863,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.InboxUnreadCount,
 			ECacheContext.WSAPI,
-			() => this.api.getInboxUnreadCountT(null),
+			() => this.api.getInboxUnreadCountT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 	}
@@ -872,7 +883,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async markInboxMessageAsRead(messageGuid: string): Promise<InboxMarkMessageAction> {
-		const r = await this.api.markInboxMessageRead(null, messageGuid);
+		const r = await this.api.markInboxMessageRead(this.userExtId, messageGuid);
 
 		return {
 			err_code: r.errCode,
@@ -886,7 +897,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async markAllInboxMessagesAsRead(): Promise<InboxMarkMessageAction> {
-		const r = await this.api.markAllInboxMessageRead(null);
+		const r = await this.api.markAllInboxMessageRead(this.userExtId);
 
 		return {
 			err_code: r.errCode,
@@ -900,7 +911,7 @@ export class WSAPI {
 	 * **Visitor mode: not supported**
 	 */
 	public async markUnmarkInboxMessageAsFavorite(messageGuid: string, mark: boolean): Promise<InboxMarkMessageAction> {
-		const r = await this.api.markUnmarkInboxMessageAsFavorite(null, messageGuid, mark);
+		const r = await this.api.markUnmarkInboxMessageAsFavorite(this.userExtId, messageGuid, mark);
 
 		return {
 			err_code: r.errCode,
@@ -915,7 +926,7 @@ export class WSAPI {
 	 */
 
 	public async deleteInboxMessage(messageGuid: string): Promise<InboxMarkMessageAction> {
-		const r = await this.api.deleteInboxMessage(null, messageGuid);
+		const r = await this.api.deleteInboxMessage(this.userExtId, messageGuid);
 
 		return {
 			err_code: r.errCode,
@@ -930,7 +941,7 @@ export class WSAPI {
 	 */
 
 	public async deleteAllInboxMessages(): Promise<InboxMarkMessageAction> {
-		const r = await this.api.deleteAllInboxMessages(null);
+		const r = await this.api.deleteAllInboxMessages(this.userExtId);
 
 		return {
 			err_code: r.errCode,
@@ -942,7 +953,7 @@ export class WSAPI {
 	 * Requests translations for the given language. Returns the object including translation key/translation value pairs. All possible translation keys defined in the back office.
 	 */
 	public async getTranslations(lang_code: string): Promise<TGetTranslations> {
-		const r = await this.api.getTranslationsT(null, lang_code, []);
+		const r = await this.api.getTranslationsT(this.userExtId, lang_code, []);
 
 		return {
 			translations: r.translations,
@@ -974,7 +985,7 @@ export class WSAPI {
 		engagement_uid: string;
 		activityType: ActivityTypeLimited | number;
 	}): void {
-		this.api.reportEngagementImpression(null, engagement_uid, activityType);
+		this.api.reportEngagementImpression(this.userExtId, engagement_uid, activityType);
 	}
 
 	/**
@@ -1007,7 +1018,7 @@ export class WSAPI {
 		activityType: ActivityTypeLimited | number;
 		action?: string;
 	}): void {
-		this.api.reportEngagementAction(null, engagement_uid, activityType, action);
+		this.api.reportEngagementAction(this.userExtId, engagement_uid, activityType, action);
 	}
 
 	/**
@@ -1062,16 +1073,419 @@ export class WSAPI {
 		return await OCache.use(
 			onUpdateContextKey.ActivityLog,
 			ECacheContext.WSAPI,
-			() => this.api.getActivityLogT(null, startTimeSeconds, endTimeSeconds, from, to),
+			() => this.api.getActivityLogT(this.userExtId, startTimeSeconds, endTimeSeconds, from, to),
 			CACHE_DATA_SEC,
 		);
 	}
 
+	/**
+	 * Returns the active rounds for the specified MatchX or Quiz game.
+	 * Each round includes its events (matches/questions) along with the current user's selections and scores.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound[]>`:
+	 * - `errCode` - 0 on success
+	 * - `data` - Array of rounds, each containing:
+	 *   - `round_id`, `round_name` - Round identifier and display name
+	 *   - `open_date`, `last_bet_date` - Timestamps (ms) for round open and betting deadline
+	 *   - `is_active_now`, `is_resolved` - Round state flags
+	 *   - `round_status_id` - Round status: -1 (active), 2 (no more bets), 3 (all events resolved), 4 (round resolved)
+	 *   - `score_full_win`, `score_part_win`, `score_lost` - Scoring rules per prediction outcome
+	 *   - `user_score` - Current user's total score in this round
+	 *   - `user_placed_bet` - Whether the user has submitted predictions
+	 *   - `has_open_for_bet_events` - Whether there are events still open for betting
+	 *   - `events[]` - Array of events with `gp_event_id`, `market_type_id`, `event_meta` (team names, images, sport), `match_date`, `is_open_for_bets`, `odds_details`, and user selection fields
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickActiveRounds({
+	 *      saw_template_id: 1083,
+	 * }).then((result) => {
+	 *      console.log(result.data); // GamePickRound[]
+	 *      result.data.forEach(round => {
+	 *          console.log(round.round_name, round.events.length);
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickActiveRounds(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickRound[]>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		return this.api.gpGetActiveRounds(props.saw_template_id);
+	}
+
+	/**
+	 * Returns a single active round for the specified MatchX or Quiz game.
+	 * The round includes full event details with the current user's selections.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 * @param props.round_id - The specific round to retrieve
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound>`:
+	 * - `errCode` - 0 on success
+	 * - `data` - Single round object with the same structure as in `getGamePickActiveRounds`,
+	 *   including `events[]` with full event details, user selections, and resolution info
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickActiveRound({
+	 *      saw_template_id: 1083,
+	 *      round_id: 31652,
+	 * }).then((result) => {
+	 *      console.log(result.data.round_name, result.data.events.length);
+	 *      console.log(result.data.user_score, result.data.user_placed_bet);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickActiveRound(props: GamePickRoundRequestParams): Promise<GamesApiResponse<GamePickRound>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		if (!props.round_id) {
+			throw new Error('round_id is required');
+		}
+		return this.api.gpGetActiveRound(props.saw_template_id, props.round_id);
+	}
+
+	/**
+	 * Returns the history of all rounds (including resolved ones) for the specified MatchX or Quiz game.
+	 * Each round contains full event details with results and the current user's predictions.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound[]>`:
+	 * - `errCode` - 0 on success
+	 * - `data` - Array of rounds ordered by `round_row_id` descending (newest first).
+	 *   Each round has the same structure as in `getGamePickActiveRounds`, including resolved events
+	 *   with `resolution_type_id` (0=None, 2=Lost, 3=PartialWin, 4=FullWin) and `resolution_score`
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickHistory({
+	 *      saw_template_id: 1083,
+	 * }).then((result) => {
+	 *      result.data.forEach(round => {
+	 *          console.log(round.round_name, 'Score:', round.user_score, 'Resolved:', round.is_resolved);
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickHistory(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickRound[]>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		return this.api.gpGetGamesHistory(props.saw_template_id);
+	}
+
+	/**
+	 * Returns the leaderboard for a specific round within a MatchX or Quiz game.
+	 * Use `round_id = -1` (AllRoundsGameBoardID) to get the season/overall leaderboard across all rounds.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 * @param props.round_id - The round to get the leaderboard for. Use -1 for overall/seasonal leaderboard
+	 *
+	 * **Response** `GamesApiResponse<GamePickRoundBoard>`:
+	 * - `errCode` - 0 on success
+	 * - `data` - Leaderboard object containing:
+	 *   - Round base fields (`round_id`, `round_name`, `open_date`, `last_bet_date`, etc.)
+	 *   - `users[]` - Ranked list of players, each with:
+	 *     - `ext_user_id`, `int_user_id` - User identifiers
+	 *     - `public_username`, `avatar_url` - Display info (usernames may be masked based on label settings)
+	 *     - `gp_position` - Leaderboard rank (null if not yet ranked)
+	 *     - `resolution_score` - Total score in this round
+	 *     - `full_wins_count`, `part_wins_count`, `lost_count` - Prediction outcome counts
+	 *   - `my_user` - Current user's entry (same fields as above), or null if user hasn't participated
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickBoard({
+	 *      saw_template_id: 1083,
+	 *      round_id: 31652,
+	 * }).then((result) => {
+	 *      console.log('Top players:', result.data.users);
+	 *      console.log('My position:', result.data.my_user?.gp_position);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickBoard(props: GamePickRoundRequestParams): Promise<GamesApiResponse<GamePickRoundBoard>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		if (!props.round_id) {
+			throw new Error('round_id is required');
+		}
+		return this.api.gpGetGameBoard(props.saw_template_id, props.round_id);
+	}
+
+	/**
+	 * Submits score predictions for a round in a MatchX game.
+	 * Sends the round object with user selections for all events at once.
+	 * Each event must include `team1_user_selection` and `team2_user_selection` representing predicted scores.
+	 * If the user hasn't placed bets before, one game attempt (spin) will be consumed.
+	 * Predictions can be edited until each match starts (if `allow_edit_answers` is enabled on the round).
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX game template
+	 * @param props.round - Round object containing `round_id` and `events[]`. Typically obtained from `getGamePickActiveRound`
+	 *   and modified with user predictions. Each event needs: `gp_event_id`, `team1_user_selection`, `team2_user_selection`
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound>`:
+	 * - `errCode` - 0 on success. Non-zero codes indicate errors (e.g. not enough points/attempts)
+	 * - `data` - Updated round with all events reflecting the submitted selections.
+	 *   `user_placed_bet` will be `true`, `has_not_submitted_changes` will be `false`
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickActiveRound({
+	 *      saw_template_id: 1190,
+	 *      round_id: 38665,
+	 * }).then((roundData) => {
+	 *      const round = roundData.data;
+	 *      round.events = round.events.map(e => ({
+	 *          gp_event_id: e.gp_event_id,
+	 *          team1_user_selection: 1,
+	 *          team2_user_selection: 0,
+	 *      }));
+	 *      _smartico.api.submitGamePickSelection({
+	 *          saw_template_id: 1190,
+	 *          round: round,
+	 *      }).then((result) => {
+	 *          console.log(result.data.user_placed_bet); // true
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async submitGamePickSelection(props: GamePickRequestParams & { round: Partial<GamePickRound> }): Promise<GamesApiResponse<GamePickRound>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		if (!props.round?.round_id) {
+			throw new Error('round is required');
+		}
+		return this.api.gpSubmitSelection(props.saw_template_id, props.round, false);
+	}
+
+	/**
+	 * Submits answers for a round in a Quiz game.
+	 * Sends the round object with user answers for all events at once.
+	 * Each event must include `user_selection` with the answer value (e.g. '1', '2', 'x', 'yes', 'no' — depending on the market type).
+	 * If the user hasn't placed bets before, one game attempt (spin) will be consumed.
+	 * Answers can be edited until each match starts (if `allow_edit_answers` is enabled on the round).
+	 *
+	 * @param props.saw_template_id - The ID of the Quiz game template
+	 * @param props.round - Round object containing `round_id` and `events[]`. Typically obtained from `getGamePickActiveRound`
+	 *   and modified with user answers. Each event needs: `gp_event_id`, `user_selection`
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound>`:
+	 * - `errCode` - 0 on success. Non-zero codes indicate errors (e.g. not enough points/attempts)
+	 * - `data` - Updated round with all events reflecting the submitted answers.
+	 *   `user_placed_bet` will be `true`, `has_not_submitted_changes` will be `false`
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickActiveRound({
+	 *      saw_template_id: 1183,
+	 *      round_id: 37974,
+	 * }).then((roundData) => {
+	 *      const round = roundData.data;
+	 *      round.events = round.events.map(e => ({
+	 *          gp_event_id: e.gp_event_id,
+	 *          user_selection: 'x',
+	 *      }));
+	 *      _smartico.api.submitGamePickSelectionQuiz({
+	 *          saw_template_id: 1183,
+	 *          round: round,
+	 *      }).then((result) => {
+	 *          console.log(result.data.user_placed_bet); // true
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async submitGamePickSelectionQuiz(props: GamePickRequestParams & { round: Partial<GamePickRound> }): Promise<GamesApiResponse<GamePickRound>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		if (!props.round?.round_id) {
+			throw new Error('round is required');
+		}
+		return this.api.gpSubmitSelection(props.saw_template_id, props.round, true);
+	}
+
+	/**
+	 * Returns the current user's profile information within the specified MatchX or Quiz game.
+	 * The user record is synced from the Smartico platform into the games DB (synced every 1 minute).
+	 * If the user doesn't exist in the games DB yet, it will be created automatically on first call.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 *
+	 * **Response** `GamesApiResponse<GamePickUserInfo>`:
+	 * - `errCode` - 0 on success
+	 * - `data`:
+	 *   - `ext_user_id` - External user ID (Smartico internal numeric ID)
+	 *   - `int_user_id` - Internal user ID within the games system
+	 *   - `public_username` - Display name
+	 *   - `avatar_url` - User's avatar image URL
+	 *   - `last_wallet_sync_time` - Last time the user's balance was synced from Smartico
+	 *   - `ach_points_balance` - User's current points balance
+	 *   - `ach_gems_balance` - User's current gems balance
+	 *   - `ach_diamonds_balance` - User's current diamonds balance
+	 *   - `pubic_username_set` - Whether the user has set a custom username
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickUserInfo({
+	 *      saw_template_id: 1083,
+	 * }).then((result) => {
+	 *      console.log(result.data.public_username, result.data.ach_points_balance);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickUserInfo(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickUserInfo>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		return this.api.gpGetUserInfo(props.saw_template_id);
+	}
+
+	/**
+	 * Returns the game configuration and the list of all rounds for the specified MatchX or Quiz game.
+	 * Includes the SAW template definition, label settings, and round metadata (without events).
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 *
+	 * **Response** `GamesApiResponse<GamePickGameInfo>`:
+	 * - `errCode` - 0 on success
+	 * - `data`:
+	 *   - `sawTemplate` - Game template configuration including:
+	 *     - `saw_template_id`, `saw_game_type_id` (6 = MatchX/Quiz)
+	 *     - `saw_template_ui_definition` - UI settings (name, ranking options, ask_for_username, etc.)
+	 *     - `saw_buyin_type_id` - Cost type (1=Free, 2=Points, 3=Gems, 4=Diamonds, 5=Spins)
+	 *     - `buyin_cost_points` - Cost per attempt
+	 *     - `spin_count` - Available attempts for the current user
+	 *   - `allRounds[]` - List of all rounds (metadata only, no events), each with:
+	 *     - `round_id`, `round_name`, `round_description`
+	 *     - `open_date`, `last_bet_date` - Timestamps (ms)
+	 *     - `is_active_now`, `is_resolved`, `round_status_id`
+	 *   - `labelInfo` - Label/brand configuration and settings
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickGameInfo({
+	 *      saw_template_id: 1189,
+	 * }).then((result) => {
+	 *      console.log(result.data.sawTemplate.saw_template_ui_definition.name);
+	 *      console.log('Rounds:', result.data.allRounds.length);
+	 *      console.log('Buy-in type:', result.data.sawTemplate.saw_buyin_type_id);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickGameInfo(props: GamePickRequestParams): Promise<GamesApiResponse<GamePickGameInfo>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		return this.api.gpGetGameInfo(props.saw_template_id);
+	}
+
+	/**
+	 * Returns translations for the MatchX/Quiz game UI.
+	 * Translations are returned as a key-value map for the Gamification and RetentionGames areas,
+	 * resolved to the current user's language.
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 *
+	 * **Response** `GamesApiResponse<any>`:
+	 * - `errCode` - 0 on success
+	 * - `data`:
+	 *   - `translations` - Key-value map of translation strings (e.g. `rgSubmitSelection`, `rgLeaderboardTitle`, `quizConfirmAnswer`, etc.)
+	 *   - `hash_code` - Hash for cache invalidation
+	 *   - `lang_code` - Resolved language code (e.g. 'EN')
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickTranslations({
+	 *      saw_template_id: 1083,
+	 * }).then((result) => {
+	 *      const tr = result.data.translations;
+	 *      console.log(tr.rgSubmitSelection);   // "Submit selection"
+	 *      console.log(tr.rgLeaderboardTitle);  // "Leaderboard"
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickTranslations(props: GamePickRequestParams): Promise<GamesApiResponse<any>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		return this.api.gpGetTranslations(props.saw_template_id);
+	}
+
+	/**
+	 * Returns round data with events and picks for a specific user (identified by their internal user ID).
+	 * Useful for viewing another user's predictions from the leaderboard.
+	 * The `int_user_id` can be obtained from the `getGamePickBoard` response (`users[].int_user_id`).
+	 *
+	 * @param props.saw_template_id - The ID of the MatchX or Quiz game template
+	 * @param props.round_id - The round to get info for
+	 * @param props.int_user_id - Internal user ID of the player whose predictions to view (from leaderboard data)
+	 *
+	 * **Response** `GamesApiResponse<GamePickRound>`:
+	 * - `errCode` - 0 on success
+	 * - `data` - Round object with the target user's selections.
+	 *   Same structure as `getGamePickActiveRound`, but `user_selection`/`team1_user_selection`/`team2_user_selection`
+	 *   fields on events reflect the specified user's picks instead of the current user's.
+	 *   Events also include `resolution_type_id` (0=None, 2=Lost, 3=PartialWin, 4=FullWin) showing how each prediction was scored
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getGamePickRoundInfoForUser({
+	 *      saw_template_id: 1083,
+	 *      round_id: 31652,
+	 *      int_user_id: 65653810,
+	 * }).then((result) => {
+	 *      result.data.events.forEach(e => {
+	 *          console.log(e.event_meta.team1_name, 'vs', e.event_meta.team2_name, '→', e.user_selection);
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getGamePickRoundInfoForUser(props: GamePickRoundRequestParams & { int_user_id: number }): Promise<GamesApiResponse<GamePickRound>> {
+		if (!props.saw_template_id) {
+			throw new Error('saw_template_id is required');
+		}
+		if (!props.round_id) {
+			throw new Error('round_id is required');
+		}
+		if (!props.int_user_id) {
+			throw new Error('int_user_id is required');
+		}
+		return this.api.gpGetRoundInfoForUser(props.saw_template_id, props.round_id, props.int_user_id);
+	}
+
 	private async updateOnSpin(data: SAWSpinsCountPush) {
 		const templates: TMiniGameTemplate[] = await OCache.use(
 			onUpdateContextKey.Saw,
 			ECacheContext.WSAPI,
-			() => this.api.sawGetTemplatesT(null),
+			() => this.api.sawGetTemplatesT(this.userExtId),
 			CACHE_DATA_SEC,
 		);
 		const index = templates.findIndex((t) => t.id === data.saw_template_id);
@@ -1080,32 +1494,32 @@ export class WSAPI {
 	}
 
 	private async reloadMiniGameTemplate() {
-		const updatedTemplates = await this.api.sawGetTemplatesT(null);
+		const updatedTemplates = await this.api.sawGetTemplatesT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.Saw, updatedTemplates);
 	}
 
 	private async updateMissions() {
-		const payload = await this.api.missionsGetItemsT(null);
+		const payload = await this.api.missionsGetItemsT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.Missions, payload);
 	}
 
 	private async updateBonuses() {
-		const payload = await this.api.bonusesGetItemsT(null);
+		const payload = await this.api.bonusesGetItemsT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.Bonuses, payload);
 	}
 
 	private async updateTournaments() {
-		const payload = await this.api.tournamentsGetLobbyT(null);
+		const payload = await this.api.tournamentsGetLobbyT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.TournamentList, payload);
 	}
 
 	private async updateStorePurchasedItems() {
-		const payload = await this.api.storeGetPurchasedItemsT(null, 20, 0);
+		const payload = await this.api.storeGetPurchasedItemsT(this.userExtId, 20, 0);
 		this.updateEntity(onUpdateContextKey.StoreHistory, payload);
 	}
 
 	private async updateStoreItems() {
-		const payload = await this.api.storeGetItemsT(null);
+		const payload = await this.api.storeGetItemsT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.StoreItems, payload);
 	}
 
@@ -1114,19 +1528,19 @@ export class WSAPI {
 	}
 
 	private async updateInboxMessages() {
-		const payload = await this.api.getInboxMessagesT(null);
+		const payload = await this.api.getInboxMessagesT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.InboxMessages, payload);
 	}
 
 	private async updateRaffles() {
-		const payload = await this.api.getRafflesT(null);
+		const payload = await this.api.getRafflesT(this.userExtId);
 		this.updateEntity(onUpdateContextKey.Raffles, payload);
 	}
 
 	private async notifyActivityLogUpdate() {
 		const startSeconds = Date.now() / 1000 - 600;
 		const endSeconds = Date.now() / 1000;
-		const payload = await this.api.getActivityLogT(null, startSeconds, endSeconds, 0, 50);
+		const payload = await this.api.getActivityLogT(this.userExtId, startSeconds, endSeconds, 0, 50);
 
 		this.updateEntity(onUpdateContextKey.ActivityLog, payload);
 	}
@@ -1180,7 +1594,7 @@ export class WSAPI {
 			onUpdateContextKey.Jackpots,
 			ECacheContext.WSAPI,
 			async () => {
-				const _jackpots = await this.api.jackpotGet(null, filter);
+				const _jackpots = await this.api.jackpotGet(this.userExtId, filter);
 				const _pots = _jackpots.items.map((jp) => jp.pot);
 
 				_jackpots.items.forEach((jp) => {
@@ -1199,7 +1613,7 @@ export class WSAPI {
 				ECacheContext.WSAPI,
 				async () => {
 					const jp_template_ids = jackpots.map((jp) => jp.jp_template_id);
-					return (await this.api.potGet(null, { jp_template_ids })).items;
+					return (await this.api.potGet(this.userExtId, { jp_template_ids })).items;
 				},
 				JACKPOT_POT_CACHE_SEC,
 			);
@@ -1233,7 +1647,7 @@ export class WSAPI {
 			throw new Error('jp_template_id is required in jackpotOptIn');
 		}
 
-		const result = await this.api.jackpotOptIn(null, filter);
+		const result = await this.api.jackpotOptIn(this.userExtId, filter);
 
 		return result;
 	}
@@ -1257,7 +1671,7 @@ export class WSAPI {
 			throw new Error('jp_template_id is required in jackpotOptOut');
 		}
 
-		const result = await this.api.jackpotOptOut(null, filter);
+		const result = await this.api.jackpotOptOut(this.userExtId, filter);
 
 		return result;
 	}
@@ -1290,7 +1704,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.JackpotWinners + jp_template_id,
 			ECacheContext.WSAPI,
-			() => this.api.getJackpotWinnersT(null, limit, offset, jp_template_id),
+			() => this.api.getJackpotWinnersT(this.userExtId, limit, offset, jp_template_id),
 			JACKPOT_WINNERS_CACHE_SEC,
 		);
 	}
@@ -1317,7 +1731,7 @@ export class WSAPI {
 		return OCache.use(
 			onUpdateContextKey.JackpotEligibleGames + jp_template_id,
 			ECacheContext.WSAPI,
-			() => this.api.getJackpotEligibleGamesT(null, { jp_template_id }),
+			() => this.api.getJackpotEligibleGamesT(this.userExtId, { jp_template_id }),
 			JACKPOT_ELIGIBLE_GAMES_CACHE_SEC,
 		);
 	}
@@ -1341,7 +1755,7 @@ export class WSAPI {
 	 * ```
 	 */
 	public async getRelatedItemsForGame(related_game_id: string): Promise<GetRelatedAchTourResponse> {
-		const result = await this.api.getRelatedItemsForGame(null, related_game_id);
+		const result = await this.api.getRelatedItemsForGame(this.userExtId, related_game_id);
 		return result;
 	}
 
@@ -1373,7 +1787,7 @@ export class WSAPI {
 			this.onUpdateCallback.set(onUpdateContextKey.Raffles, onUpdate);
 		}
 
-		return OCache.use(onUpdateContextKey.Raffles, ECacheContext.WSAPI, () => this.api.getRafflesT(null), CACHE_DATA_SEC);
+		return OCache.use(onUpdateContextKey.Raffles, ECacheContext.WSAPI, () => this.api.getRafflesT(this.userExtId), CACHE_DATA_SEC);
 	}
 
 	/**
@@ -1405,7 +1819,7 @@ export class WSAPI {
 			throw new Error('both raffle_id and run_id are required');
 		}
 
-		return await this.api.getRaffleDrawRunT(null, props.raffle_id, props.run_id, props.winners_from, props.winners_to);
+		return await this.api.getRaffleDrawRunT(this.userExtId, props.raffle_id, props.run_id, props.winners_from, props.winners_to);
 	}
 
 	/**
@@ -1431,7 +1845,7 @@ export class WSAPI {
 	 */
 
 	public async getRaffleDrawRunsHistory(props: { raffle_id: number; draw_id?: number }): Promise<TRaffleDrawRun[]> {
-		const res = await this.api.getRaffleDrawRunsHistory(null, props);
+		const res = await this.api.getRaffleDrawRunsHistory(this.userExtId, props);
 
 		if (!props.raffle_id) {
 			throw new Error('raffle_id is required');
@@ -1466,7 +1880,7 @@ export class WSAPI {
 			throw new Error('won_id is required');
 		}
 
-		const res = await this.api.claimRafflePrize(null, { won_id: props.won_id });
+		const res = await this.api.claimRafflePrize(this.userExtId, { won_id: props.won_id });
 		return raffleClaimPrizeResponseTransform(res);
 	}
 
@@ -1486,7 +1900,7 @@ export class WSAPI {
 			throw new Error('raffle_run_id is required');
 		}
 
-		const r = await this.api.raffleOptin(null, props);
+		const r = await this.api.raffleOptin(this.userExtId, props);
 
 		return {
 			err_code: r.errCode,