@smartico/public-api 0.0.379 → 0.0.380

package/src/WSAPI/WSAPIGamePick.ts

@@ -0,0 +1,382 @@
+import {
+	GamesApiResponse,
+	GamePickRound,
+	GamePickRoundBoard,
+	GamePickUserInfo,
+	GamePickGameInfo,
+	GamePickRequestParams,
+	GamePickRoundRequestParams,
+} from './WSAPITypes';
+import { WSAPIAvatars } from './WSAPIAvatars';
+
+/** @group GamePick */
+export class WSAPIGamePick extends WSAPIAvatars {
+	/**
+	 * 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.gamePickGetActiveRounds({
+	 *      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 gamePickGetActiveRounds(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 `gamePickGetActiveRounds`,
+	 *   including `events[]` with full event details, user selections, and resolution info
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.gamePickGetActiveRound({
+	 *      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 gamePickGetActiveRound(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 `gamePickGetActiveRounds`, including resolved events
+	 *   with `resolution_type_id` (0=None, 2=Lost, 3=PartialWin, 4=FullWin) and `resolution_score`
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.gamePickGetHistory({
+	 *      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 gamePickGetHistory(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.gamePickGetBoard({
+	 *      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 gamePickGetBoard(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 `gamePickGetActiveRound`
+	 *   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.gamePickGetActiveRound({
+	 *      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.gamePickSubmitSelection({
+	 *          saw_template_id: 1190,
+	 *          round: round,
+	 *      }).then((result) => {
+	 *          console.log(result.data.user_placed_bet); // true
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async gamePickSubmitSelection(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 `gamePickGetActiveRound`
+	 *   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.gamePickGetActiveRound({
+	 *      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.gamePickSubmitSelectionQuiz({
+	 *          saw_template_id: 1183,
+	 *          round: round,
+	 *      }).then((result) => {
+	 *          console.log(result.data.user_placed_bet); // true
+	 *      });
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async gamePickSubmitSelectionQuiz(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.gamePickGetUserInfo({
+	 *      saw_template_id: 1083,
+	 * }).then((result) => {
+	 *      console.log(result.data.public_username, result.data.ach_points_balance);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async gamePickGetUserInfo(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.gamePickGetGameInfo({
+	 *      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 gamePickGetGameInfo(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 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 `gamePickGetBoard` 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 `gamePickGetActiveRound`, 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.gamePickGetRoundInfoForUser({
+	 *      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 gamePickGetRoundInfoForUser(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);
+	}
+}

package/src/WSAPI/WSAPIGeneral.ts

@@ -0,0 +1,57 @@
+import { ECacheContext, OCache } from '../OCache';
+import {
+	TGetTranslations,
+	TUICustomSection,
+} from './WSAPITypes';
+import { GetRelatedAchTourResponse } from '../Missions/GetRelatedAchTourResponse';
+import {
+	CACHE_DATA_SEC,
+	onUpdateContextKey,
+} from './WSAPIBase';
+import { WSAPIUser } from './WSAPIUser';
+
+/** @group General */
+export class WSAPIGeneral extends WSAPIUser {
+	public async getCustomSections(): Promise<TUICustomSection[]> {
+		return OCache.use(
+			onUpdateContextKey.CustomSections,
+			ECacheContext.WSAPI,
+			() => this.api.customSectionsGetT(this.userExtId),
+			CACHE_DATA_SEC,
+		);
+	}
+
+	/**
+	 * 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(this.userExtId, lang_code, []);
+
+		return {
+			translations: r.translations,
+		};
+	}
+
+	/**
+	 * Returns all the related tournaments and missions for the provided game id for the current user
+	 * The provided Game ID should correspond to the ID from the Games Catalog - https://help.smartico.ai/welcome/technical-guides/games-catalog-api
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getRelatedItemsForGame('gold-slot2').then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Example in the Visitor mode**:
+	 * ```
+	 * _smartico.vapi('EN').getRelatedItemsForGame('gold-slot2').then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 */
+	public async getRelatedItemsForGame(related_game_id: string): Promise<GetRelatedAchTourResponse> {
+		const result = await this.api.getRelatedItemsForGame(this.userExtId, related_game_id);
+		return result;
+	}
+}

package/src/WSAPI/WSAPIInbox.ts

@@ -0,0 +1,222 @@
+import { ActivityTypeLimited } from '../Core';
+import { ECacheContext, OCache } from '../OCache';
+import {
+	InboxMarkMessageAction,
+	TInboxMessage,
+	TInboxMessageBody,
+} from './WSAPITypes';
+import { InboxCategories } from '../Inbox/InboxCategories';
+import { InboxReadStatus } from '../Inbox/InboxReadStatus';
+import {
+	CACHE_DATA_SEC,
+	onUpdateContextKey,
+} from './WSAPIBase';
+import { WSAPILeaderBoard } from './WSAPILeaderBoard';
+
+/** @group Inbox */
+export class WSAPIInbox extends WSAPILeaderBoard {
+	/**
+	 * Reports an impression event for an engagement (when engagement content is displayed to the user).
+	 * Use this method to track when users view engagement content such as inbox messages, popups.
+	 * When using for Inbox cases, you need to use message guid as engagement_uid, and pass 31 as activityType.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.reportImpressionEvent({
+	 *      engagement_uid: 'abc123-def456',
+	 *      activityType: 31 // Inbox
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 * @param params - Event parameters
+	 * @param params.engagement_uid - Unique identifier for the engagement
+	 * @param params.activityType - Type of engagement activity (Popup=30, Inbox=31)
+	 */
+	public reportImpressionEvent({
+		engagement_uid,
+		activityType,
+	}: {
+		engagement_uid: string;
+		activityType: ActivityTypeLimited | number;
+	}): void {
+		this.api.reportEngagementImpression(this.userExtId, engagement_uid, activityType);
+	}
+
+	/**
+	 * Reports a click/action event for an engagement (when user interacts with engagement content).
+	 * Use this method to track when users click on or interact with engagement content such as inbox messages, popups.
+	 * When using for Inbox cases, you need to use message guid as engagement_uid, and pass 31 as activityType, and pass the action/deeplink that was triggered by the user interaction as action.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.reportClickEvent({
+	 *      engagement_uid: 'abc123-def456',
+	 *      activityType: 31 // Inbox
+	 *      action: 'dp:gf_missions'
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 * @param params - Event parameters
+	 * @param params.engagement_uid - Unique identifier for the engagement
+	 * @param params.activityType - Type of engagement activity (Popup=30, Inbox=31)
+	 * @param params.action - Optional action/deeplink that was triggered by the user interaction
+	 */
+	public reportClickEvent({
+		engagement_uid,
+		activityType,
+		action,
+	}: {
+		engagement_uid: string;
+		activityType: ActivityTypeLimited | number;
+		action?: string;
+	}): void {
+		this.api.reportEngagementAction(this.userExtId, engagement_uid, activityType, action);
+	}
+
+	/** Returns inbox messages based on the provided parameters. "From" and "to" indicate the range of messages to be fetched.
+	 * The maximum number of messages per request is limited to 20. 
+	 * An indicator "onlyFavorite" can be passed to get only messages marked as favorites.
+	 * An indicator "read_status" can be passed to get only messages marked as read or unread.
+	 * You can leave this params empty and by default it will return list of messages ranging from 0 to 20.
+	 * This function returns a list of messages without the body of each message.
+	 * To get the body of the message you need to call getInboxMessageBody function and pass the message guid contained in each message of this request.
+	 * All other action like mark as read, favorite, delete, etc. can be done using this message GUID.
+	 * The "onUpdate" callback will be triggered when the user receives a new message. It will provide an updated list of messages, ranging from 0 to 20, to the onUpdate callback function.
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 * @param params
+	 */
+	public async getInboxMessages({
+		from,
+		to,
+		onlyFavorite,
+		categoryId,
+		read_status,
+		onUpdate,
+	}: {
+		from?: number;
+		to?: number;
+		onlyFavorite?: boolean;
+		categoryId?: InboxCategories;
+		read_status?: InboxReadStatus;
+		onUpdate?: (data: TInboxMessage[]) => void;
+	} = {}): Promise<TInboxMessage[]> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.InboxMessages, onUpdate);
+		}
+		return await this.api.getInboxMessagesT(this.userExtId, from, to, onlyFavorite, categoryId, read_status);
+	}
+
+	/**
+	 * Returns inbox unread count.
+	 *
+	 * **Visitor mode: not supported**
+	 * @param params
+	 */
+	public async getInboxUnreadCount({ onUpdate }: { onUpdate?: (unread_count: number) => void } = {}): Promise<number> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.InboxUnreadCount, onUpdate);
+		}
+		return OCache.use(
+			onUpdateContextKey.InboxUnreadCount,
+			ECacheContext.WSAPI,
+			() => this.api.getInboxUnreadCountT(this.userExtId),
+			CACHE_DATA_SEC,
+		);
+	}
+
+	/**
+	 * Returns the message body of the specified message guid.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getInboxMessageBody(messageGuid: string): Promise<TInboxMessageBody> {
+		return await this.api.getInboxMessageBodyT(messageGuid);
+	}
+
+	/**
+	 * Requests to mark inbox message with specified guid as read
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async markInboxMessageAsRead(messageGuid: string): Promise<InboxMarkMessageAction> {
+		const r = await this.api.markInboxMessageRead(this.userExtId, messageGuid);
+
+		return {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+		};
+	}
+
+	/**
+	 * Requests to mark all inbox messages as read
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async markAllInboxMessagesAsRead(): Promise<InboxMarkMessageAction> {
+		const r = await this.api.markAllInboxMessageRead(this.userExtId);
+
+		return {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+		};
+	}
+
+	/**
+	 * Requests to mark inbox message with specified guid as favorite. Pass mark true to add message to favorite and false to remove.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async markUnmarkInboxMessageAsFavorite(messageGuid: string, mark: boolean): Promise<InboxMarkMessageAction> {
+		const r = await this.api.markUnmarkInboxMessageAsFavorite(this.userExtId, messageGuid, mark);
+
+		return {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+		};
+	}
+
+	/**
+	 * Requests to delete inbox message
+	 *
+	 * **Visitor mode: not supported**
+	 */
+
+	public async deleteInboxMessage(messageGuid: string): Promise<InboxMarkMessageAction> {
+		const r = await this.api.deleteInboxMessage(this.userExtId, messageGuid);
+
+		return {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+		};
+	}
+
+	/**
+	 * Requests to delete all inbox messages
+	 *
+	 * **Visitor mode: not supported**
+	 */
+
+	public async deleteAllInboxMessages(): Promise<InboxMarkMessageAction> {
+		const r = await this.api.deleteAllInboxMessages(this.userExtId);
+
+		return {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+		};
+	}
+
+	protected async updateInboxUnreadCount(count: number) {
+		this.updateEntity(onUpdateContextKey.InboxUnreadCount, count);
+	}
+
+	protected async updateInboxMessages() {
+		const payload = await this.api.getInboxMessagesT(this.userExtId);
+		this.updateEntity(onUpdateContextKey.InboxMessages, payload);
+	}
+}