@smartico/public-api 0.0.364 → 0.0.365

package/src/SmarticoAPI.ts

@@ -68,6 +68,8 @@ import {
 	enrichUserAchievementsWithBadgeState,
 } from './Missions';
 import {
+	GetClanTournamentPlayersRequest,
+	GetClanTournamentPlayersResponse,
 	GetTournamentInfoRequest,
 	GetTournamentInfoResponse,
 	GetTournamentsRequest,
@@ -75,6 +77,7 @@ import {
 	TournamentItemsTransform,
 	TournamentRegisterRequest,
 	TournamentRegisterResponse,
+	clanTournamentPlayersTransform,
 	tournamentInfoItemTransform,
 } from './Tournaments';
 import { GetLeaderBoardsRequest, GetLeaderBoardsResponse, LeaderBoardDetails, LeaderBoardPeriodType } from './Leaderboard';
@@ -103,6 +106,10 @@ import {
 	TAvatarDefinition,
 	TAvatarCustomized,
 	TAvatarPrompt,
+	TClans,
+	TClanInfo,
+	TClanJoinResult,
+	TClanTournamentPlayers,
 } from './WSAPI/WSAPITypes';
 import { getLeaderBoardTransform } from './Leaderboard/LeaderBoards';
 import { GetAchievementsUserInfoResponse } from './Core/GetAchievementsUserInfoResponse';
@@ -130,6 +137,7 @@ import { GetRelatedAchTourResponse } from './Missions/GetRelatedAchTourResponse'
 import { GetRafflesResponse, raffleTransform } from './Raffle/GetRafflesResponse';
 import { GetRafflesRequest } from './Raffle/GetRafflesRequest';
 import { GetActivityLogRequest, GetActivityLogResponse, ActivityLogTransform } from './ActivityLog';
+import { GetClanListRequest, GetClanListResponse, GetClanInfoRequest, GetClanInfoResponse, JoinClanRequest, JoinClanResponse } from './Clans';
 import { InboxCategories } from './Inbox/InboxCategories';
 import { GetDrawRunRequest, GetDrawRunResponse, GetRaffleDrawRunsHistoryRequest, GetRaffleDrawRunsHistoryResponse, RaffleClaimPrizeRequest, RaffleClaimPrizeResponse, RaffleOptinRequest, RaffleOptinResponse, drawRunTransform } from './Raffle';
 import { GetAvatarsListResponse, avatarDefinitionTransform } from './Avatars/GetAvatarsListResponse';
@@ -1005,6 +1013,69 @@ class SmarticoAPI {
 		return TournamentItemsTransform((await this.tournamentsGetLobby(user_ext_id)).tournaments);
 	}
 
+	public async clansGetList(user_ext_id: string, force_language?: string): Promise<GetClanListResponse> {
+		const message = this.buildMessage<GetClanListRequest, GetClanListResponse>(
+			user_ext_id,
+			ClassId.GET_CLAN_LIST_REQUEST,
+		);
+		return await this.send<GetClanListResponse>(message, ClassId.GET_CLAN_LIST_RESPONSE, force_language);
+	}
+
+	public async clansGetListT(user_ext_id: string): Promise<TClans> {
+		const response = await this.clansGetList(user_ext_id);
+		return {
+			clans: response.clans,
+			user_clan_id: response.user_clan_id,
+			cooldown_until: response.cooldown_until,
+		};
+	}
+
+	public async clansGetInfo(user_ext_id: string, clanId: number, force_language?: string): Promise<GetClanInfoResponse> {
+		const message = this.buildMessage<GetClanInfoRequest, GetClanInfoResponse>(
+			user_ext_id,
+			ClassId.GET_CLAN_INFO_REQUEST,
+			{ clan_id: clanId },
+		);
+		return await this.send<GetClanInfoResponse>(message, ClassId.GET_CLAN_INFO_RESPONSE, force_language);
+	}
+
+	public async clansGetInfoT(user_ext_id: string, clanId: number, force_language?: string): Promise<TClanInfo> {
+		const response = await this.clansGetInfo(user_ext_id, clanId, force_language);
+		const c = response.clan_info;
+		return {
+			clan_id: c.clan_id,
+			public_meta: c.public_meta,
+			member_count: c.member_count,
+			capacity_limit: c.capacity_limit,
+			entry_fee_currency_type_id: response.entry_fee_currency_type_id ?? c.entry_fee_currency_type_id,
+			entry_fee_amount: response.entry_fee_amount ?? c.entry_fee_amount,
+			rating_position: c.rating_position,
+			rating_score: c.rating_score,
+			cooldown_until: response.cooldown_until ?? null,
+			members: (response.members || []).map((m) => ({
+				user_id: m.user_id,
+				public_username: m.public_username,
+				avatar_id: m.avatar_id,
+				avatar_real_id: m.avatar_real_id,
+				avatar_url: CoreUtils.avatarUrl(m.avatar_id, this.avatarDomain),
+				position: m.position,
+				contribution_score: m.contribution_score,
+				is_me: m.is_me,
+				clean_ext_user_id: m.clean_ext_user_id,
+			})),
+		};
+	}
+
+	public async clanJoin(user_ext_id: string, clanId: number, joinSourceId: number = 0): Promise<TClanJoinResult> {
+		const message = this.buildMessage<JoinClanRequest, JoinClanResponse>(
+			user_ext_id,
+			ClassId.JOIN_CLAN_REQUEST,
+			{ clan_id: clanId, join_source_id: joinSourceId },
+		);
+		const response = await this.send<JoinClanResponse>(message, ClassId.JOIN_CLAN_RESPONSE);
+		return { errCode: response.errCode ?? 0, errMsg: response.errMsg ?? '' };
+	}
+
 	public async tournamentsGetInfo(
 		user_ext_id: string,
 		tournamentInstanceId: number,
@@ -1044,6 +1115,30 @@ class SmarticoAPI {
 		return tournamentInfoItemTransform(response);
 	}
 
+	public async clanTournamentGetPlayers(
+		user_ext_id: string,
+		tournamentInstanceId: number,
+		clanId: number,
+		force_language?: string,
+	): Promise<TClanTournamentPlayers> {
+		const message = this.buildMessage<GetClanTournamentPlayersRequest, GetClanTournamentPlayersResponse>(
+			user_ext_id,
+			ClassId.GET_CLAN_TOURNAMENT_PLAYERS_REQUEST,
+			{ tournamentInstanceId, clanId, forceLanguage: force_language },
+		);
+		const response = await this.send<GetClanTournamentPlayersResponse>(
+			message,
+			ClassId.GET_CLAN_TOURNAMENT_PLAYERS_RESPONSE,
+			force_language,
+		);
+		if (response.players?.length) {
+			response.players.forEach((p) => {
+				p.avatar_url = CoreUtils.avatarUrl(p.avatar_id, this.avatarDomain);
+			});
+		}
+		return clanTournamentPlayersTransform(response);
+	}
+
 	public async leaderboardGet(
 		user_ext_id: string,
 		period_type_id?: LeaderBoardPeriodType,

package/src/SmarticoLib/index.ts

@@ -1030,6 +1030,155 @@ export interface TTournamentDetailed extends TTournament {
 		/** if the prize is points related, indicates amount of points */
 		points?: number;
 	}[];
+	/** True when this tournament groups participants by clan */
+	is_clan_based?: boolean;
+	/** Ranked list of clans in this tournament; null for non-clan tournaments */
+	clan_leaderboard?: {
+		clan_id: number;
+		public_meta: { name: string; description: string; image_url: string };
+		position: number;
+		total_score: number;
+		contributing_members: number;
+	}[] | null;
+	/** The clan ID the current user belongs to; null when clanless or non-clan tournament */
+	user_clan_id?: number | null;
+	/** The user's rank within their own clan; null when clanless or not registered */
+	user_position_in_clan?: number | null;
+	/** The user's score contribution to their clan; null when clanless or not registered */
+	user_score_in_clan?: number | null;
+	/** Per-clan prize structure; null for non-clan tournaments */
+	clan_prize_structure?: {
+			clan_place: number;
+		/** 1 = Fixed, 2 = Dynamic */
+		prize_type_id: number;
+		prize_pool_amount: number | null;
+		activity_type_id: number | null;
+		details_json: Record<string, any>;
+		public_meta: { name: string; description: string; image_url: string } | null;
+		tiers: {
+			player_place_from: number;
+			player_place_to: number;
+			pool_amount: number | null;
+			/** 1 = ScoreWeighted, 2 = EqualSplit; null for Fixed */
+			distribution_type: number | null;
+			activity_type_id: number;
+			details_json: Record<string, any>;
+			public_meta: { name: string; description: string; image_url: string } | null;
+		}[];
+	}[] | null;
+}
+/**
+ * TClanTournamentPlayers describes the players of a specific clan in a clan-based tournament.
+ */
+export interface TClanTournamentPlayers {
+	/** Clan ID */
+	clan_id: number;
+	/** Clan display metadata */
+	public_meta: { name: string; image_url: string };
+	/** Top players of this clan ranked by score DESC */
+	players: {
+		user_id: number;
+		public_username: string;
+		avatar_id: string;
+		avatar_real_id: number;
+		avatar_url?: string;
+		position: number;
+		scores: number;
+		is_me: boolean;
+		clean_ext_user_id: string;
+	}[];
+}
+export interface GetClanListResponse extends ProtocolResponse {
+	clans: {
+		clan_id: number;
+		public_meta: { name: string; description: string; image_url: string };
+		member_count: number;
+		capacity_limit: number;
+		entry_fee_currency_type_id: number;
+		entry_fee_amount: number;
+		rating_position: number;
+		rating_score: number;
+	}[];
+	user_clan_id?: number | null;
+	cooldown_until?: string | null;
+}
+export interface GetClanInfoResponse extends ProtocolResponse {
+	clan_info: {
+		clan_id: number;
+		public_meta: { name: string; description: string; image_url: string };
+		member_count: number;
+		capacity_limit: number;
+		entry_fee_currency_type_id: number;
+		entry_fee_amount: number;
+		rating_position: number;
+		rating_score: number;
+	};
+	members: {
+		user_id: number;
+		public_username: string;
+		avatar_id: string;
+		avatar_real_id: number;
+		position: number;
+		contribution_score: number;
+		is_me?: boolean;
+		clean_ext_user_id?: string;
+	}[];
+	entry_fee_currency_type_id: number;
+	entry_fee_amount: number;
+	cooldown_until: string | null;
+}
+/**
+ * TClan describes one clan item from the clans list.
+ */
+export interface TClan {
+	clan_id: number;
+	public_meta: { name: string; description: string; image_url: string };
+	member_count: number;
+	capacity_limit: number;
+	entry_fee_currency_type_id: number;
+	entry_fee_amount: number;
+	rating_position: number;
+	rating_score: number;
+}
+/**
+ * TClans describes the clans payload returned by the API.
+ */
+export interface TClans {
+	clans: TClan[];
+	user_clan_id: number | null;
+	cooldown_until: string | null;
+}
+/**
+ * TClanInfo describes the detailed info of a single clan including its members.
+ */
+export interface TClanInfo {
+	clan_id: number;
+	public_meta: { name: string; description: string; image_url: string };
+	member_count: number;
+	capacity_limit: number;
+	entry_fee_currency_type_id: number;
+	entry_fee_amount: number;
+	rating_position: number;
+	rating_score: number;
+	cooldown_until: string | null;
+	members: {
+		user_id: number;
+		public_username: string;
+		avatar_id: string;
+		avatar_real_id: number;
+		avatar_url?: string;
+		position: number;
+		contribution_score: number;
+		is_me?: boolean;
+		clean_ext_user_id?: string;
+	}[];
+}
+/**
+ * TClanJoinResult describes the result of a join clan request.
+ */
+export interface TClanJoinResult {
+	errCode: number;
+	errMsg: string;
 }
 /**
  * TStoreCategory describes the store category item. Each store item can be assigned to 1 or more categories
@@ -1756,8 +1905,16 @@ declare class WSAPI {
 	getTournamentsList({ onUpdate }?: { onUpdate?: (data: TTournament[]) => void }): Promise<TTournament[]>;
 	/** Returns details information of specific tournament instance, the response will include tournament info and the leaderboard of players */
 	getTournamentInstanceInfo(tournamentInstanceId: number): Promise<TTournamentDetailed>;
+	/** Returns the players of a specific clan in a clan-based tournament */
+	getClanTournamentPlayers(tournamentInstanceId: number, clanId: number): Promise<TClanTournamentPlayers>;
 	/** Requests registration for the specified tournament instance. Returns the err_code. */
 	registerInTournament(tournamentInstanceId: number): Promise<TTournamentRegistrationResult>;
+	/** Returns clans list */
+	getClans({ onUpdate }?: { onUpdate?: (data: TClans) => void }): Promise<TClans>;
+	/** Returns detailed info for a specific clan including its members */
+	getClanInfo(clanId: number): Promise<TClanInfo>;
+	/** Joins a clan on behalf of the current user */
+	joinClan(clanId: number): Promise<TClanJoinResult>;
 	/** Returns the leaderboard for the current type (default is Daily). If getPreviousPeriod is passed as true, a leaderboard for the previous period for the current type will be returned.
 		For example, if the type is Weekly and getPreviousPeriod is true, a leaderboard for the previous week will be returned.
 	 */
@@ -1887,6 +2044,12 @@ declare class SmarticoAPI {
 	tournamentsGetLobbyT(user_ext_id: string): Promise<TTournament[]>;
 	tournamentsGetInfo(user_ext_id: string, tournamentInstanceId: number): Promise<GetTournamentInfoResponse>;
 	tournamentsGetInfoT(user_ext_id: string, tournamentInstanceId: number): Promise<TTournamentDetailed>;
+	clanTournamentGetPlayers(user_ext_id: string, tournamentInstanceId: number, clanId: number, force_language?: string): Promise<TClanTournamentPlayers>;
+	clansGetList(user_ext_id: string, force_language?: string): Promise<GetClanListResponse>;
+	clansGetListT(user_ext_id: string): Promise<TClans>;
+	clansGetInfo(user_ext_id: string, clanId: number, force_language?: string): Promise<GetClanInfoResponse>;
+	clansGetInfoT(user_ext_id: string, clanId: number, force_language?: string): Promise<TClanInfo>;
+	clanJoin(user_ext_id: string, clanId: number, joinSourceId?: number): Promise<TClanJoinResult>;
 	leaderboardGet(
 		user_ext_id: string,
 		period_type_id?: LeaderBoardPeriodType,

package/src/Tournaments/GetClanTournamentPlayersRequest.ts

@@ -0,0 +1,7 @@
+import { ProtocolMessage } from '../Base/ProtocolMessage';
+
+export interface GetClanTournamentPlayersRequest extends ProtocolMessage {
+	tournamentInstanceId: number;
+	clanId: number;
+	forceLanguage?: string;
+}

package/src/Tournaments/GetClanTournamentPlayersResponse.ts

@@ -0,0 +1,58 @@
+import { ProtocolResponse } from '../Base/ProtocolResponse';
+
+export interface ClanTournamentPlayerRaw {
+	user_id: number;
+	public_username: string;
+	avatar_id: string;
+	avatar_real_id: number;
+	position: number;
+	scores: number;
+	is_me: boolean;
+	clean_ext_user_id: string;
+	avatar_url?: string;
+}
+
+export interface GetClanTournamentPlayersResponse extends ProtocolResponse {
+	clan_id: number;
+	clan_public_meta: { name: string; image_url: string };
+	players: ClanTournamentPlayerRaw[];
+}
+
+export interface TClanTournamentPlayer {
+	user_id: number;
+	public_username: string;
+	avatar_id: string;
+	avatar_real_id: number;
+	avatar_url?: string;
+	position: number;
+	scores: number;
+	is_me: boolean;
+	clean_ext_user_id: string;
+}
+
+export interface TClanTournamentPlayersResult {
+	clan_id: number;
+	clan_public_meta: { name: string; image_url: string };
+	players: TClanTournamentPlayer[];
+}
+
+export const clanTournamentPlayersTransform = (response: GetClanTournamentPlayersResponse): TClanTournamentPlayersResult => {
+	return {
+		clan_id: response.clan_id,
+		clan_public_meta: {
+			name: response.clan_public_meta.name,
+			image_url: response.clan_public_meta.image_url,
+		},
+		players: (response.players || []).map((p) => ({
+			user_id: p.user_id,
+			public_username: p.public_username,
+			avatar_id: p.avatar_id,
+			avatar_real_id: p.avatar_real_id,
+			avatar_url: p.avatar_url,
+			position: p.position,
+			scores: p.scores,
+			is_me: p.is_me,
+			clean_ext_user_id: p.clean_ext_user_id,
+		})),
+	};
+};

package/src/Tournaments/GetTournamentInfoResponse.ts

@@ -4,6 +4,7 @@ import { ProtocolResponse } from '../Base/ProtocolResponse';
 import { TournamentPrize } from './TournamentPrize';
 import { TTournamentDetailed } from '../WSAPI/WSAPITypes';
 import { TournamentUtils } from './TournamentUtils';
+import { ClanLeaderboardEntry, ClanPrizeStructureEntry } from './TournamentClan';
 
 export interface GetTournamentInfoResponse extends ProtocolResponse {
 	/** tournament info */
@@ -20,6 +21,16 @@ export interface GetTournamentInfoResponse extends ProtocolResponse {
 	prizeStructure?: {
 		prizes: TournamentPrize[];
 	};
+	/** Ranked list of clans in this tournament. Empty/null for non-clan tournaments. */
+	clanLeaderboard?: ClanLeaderboardEntry[] | null;
+	/**
+	 * The clan ID the current user belongs to.
+	 * null when the user has no clan or the tournament is not clan-based.
+	 * Match against clanLeaderboard[i].clan_id to highlight the user's clan row.
+	 */
+	userClanId?: number | null;
+	/** Per-clan prize structure. Empty/null for non-clan tournaments. */
+	clanPrizes?: ClanPrizeStructureEntry[] | null;
 }
 
 export const tournamentInfoItemTransform = (t: GetTournamentInfoResponse): TTournamentDetailed => {
@@ -49,5 +60,46 @@ export const tournamentInfoItemTransform = (t: GetTournamentInfoResponse): TTour
 		response.me = TournamentUtils.getPlayerTransformed(t.userPosition, true);
 	}
 
+	if (t.tournamentInfo?.tournamentLobbyInfo?.isClanBased) {
+		response.is_clan_based = true;
+		response.user_clan_id = t.userClanId ?? null;
+		response.clan_leaderboard = t.clanLeaderboard
+			? t.clanLeaderboard.map((entry) => ({
+					clan_id: entry.clan_id,
+					public_meta: {
+						name: entry.public_meta.name,
+						description: entry.public_meta.description,
+						image_url: entry.public_meta.image_url,
+					},
+					position: entry.position,
+					total_score: entry.total_score,
+					contributing_members: entry.contributing_members,
+			  }))
+			: null;
+		response.clan_prize_structure = t.clanPrizes
+			? t.clanPrizes.map((entry) => ({
+					clan_place: entry.clan_place,
+					prize_type_id: entry.prize_type_id,
+					prize_pool_amount: entry.prize_pool_amount,
+					activity_type_id: entry.activity_type_id,
+					details_json: entry.details_json,
+					public_meta: entry.public_meta
+						? { name: entry.public_meta.name, description: entry.public_meta.description, image_url: entry.public_meta.image_url }
+						: null,
+					tiers: (entry.tiers || []).map((tier) => ({
+						player_place_from: tier.player_place_from,
+						player_place_to: tier.player_place_to,
+						pool_amount: tier.pool_amount,
+						distribution_type: tier.distribution_type,
+						activity_type_id: tier.activity_type_id,
+						details_json: tier.details_json,
+						public_meta: tier.public_meta
+							? { name: tier.public_meta.name, description: tier.public_meta.description, image_url: tier.public_meta.image_url }
+							: null,
+					})),
+			  }))
+			: null;
+	}
+
 	return response;
 };

package/src/Tournaments/Tournament.ts

@@ -70,6 +70,8 @@ export interface Tournament {
 	hideLeaderboardsMinScores?: boolean;
 	/** Total scores across all participants in the tournament */
 	totalScores?: number;
+	/** Indicates if the tournament is clan-based */
+	isClanBased?: boolean;
 }
 
 export const TournamentItemsTransform = (items: Tournament[]): TTournament[] => {

package/src/Tournaments/TournamentClan.ts

@@ -0,0 +1,30 @@
+import { ClanPublicMeta } from '../Clans/Clan';
+
+export interface ClanLeaderboardEntry {
+	clan_id: number;
+	public_meta: ClanPublicMeta;
+	position: number;
+	total_score: number;
+	contributing_members: number;
+}
+
+export interface ClanPrizeTier {
+	player_place_from: number;
+	player_place_to: number;
+	pool_amount: number | null;
+	distribution_type: number | null;
+	activity_type_id: number;
+	details_json: Record<string, any>;
+	public_meta: ClanPublicMeta | null;
+}
+
+export interface ClanPrizeStructureEntry {
+	clan_place: number;
+	/** 1 = Fixed, 2 = Dynamic */
+	prize_type_id: number;
+	prize_pool_amount: number | null;
+	activity_type_id: number | null;
+	details_json: Record<string, any>;
+	public_meta: ClanPublicMeta;
+	tiers: ClanPrizeTier[];
+}

package/src/Tournaments/index.ts

@@ -1,8 +1,11 @@
+export * from './GetClanTournamentPlayersRequest';
+export * from './GetClanTournamentPlayersResponse';
 export * from './GetTournamentInfoRequest';
 export * from './GetTournamentInfoResponse';
 export * from './GetTournamentsRequest';
 export * from './GetTournamentsResponse';
 export * from './Tournament';
+export * from './TournamentClan';
 export * from './TournamentInstanceStatus';
 export * from './TournamentPlayer';
 export * from './TournamentPrize';

package/src/WSAPI/WSAPI.ts

@@ -39,6 +39,10 @@ import {
 	TLevelCurrent,
 	TActivityLog,
 	TRaffleOptinResponse,
+	TClans,
+	TClanInfo,
+	TClanJoinResult,
+	TClanTournamentPlayers,
 	GamesApiResponse,
 	GamePickRound,
 	GamePickRoundBoard,
@@ -66,8 +70,6 @@ import { InboxCategories } from '../Inbox/InboxCategories';
 import {
 	drawRunHistoryTransform,
 	raffleClaimPrizeResponseTransform,
-	RaffleOptinRequest,
-	RaffleOptinResponse,
 } from '../Raffle';
 import { IntUtils } from '../IntUtils';
 import { TGetJackpotEligibleGamesResponse } from '../Jackpots/GetJackpotEligibleGamesResponse';
@@ -100,6 +102,7 @@ enum onUpdateContextKey {
 	Pots = 'Pots',
 	CustomSections = 'customSections',
 	Bonuses = 'bonuses',
+	Clans = 'clans',
 	SAWHistory = 'sawHistory',
 	JackpotWinners = 'jackpotWinners',
 	Raffles = 'raffles',
@@ -748,6 +751,44 @@ export class WSAPI {
 		);
 	}
 
+	/**
+	 * Returns clans list payload for the current user.
+	 * The returned payload is cached for 30 seconds.
+	 * If onUpdate is passed, it will be called when clans response is received.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getClans({ onUpdate }: { onUpdate?: (data: TClans) => void } = {}): Promise<TClans> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.Clans, onUpdate);
+		}
+
+		return OCache.use(
+			onUpdateContextKey.Clans,
+			ECacheContext.WSAPI,
+			() => this.api.clansGetListT(this.userExtId),
+			CACHE_DATA_SEC,
+		);
+	}
+
+	/**
+	 * Returns detailed information for a specific clan including its members.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getClanInfo(clanId: number): Promise<TClanInfo> {
+		return this.api.clansGetInfoT(this.userExtId, clanId);
+	}
+
+	/**
+	 * Joins a clan on behalf of the current user.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async joinClan(clanId: number): Promise<TClanJoinResult> {
+		return this.api.clanJoin(this.userExtId, clanId);
+	}
+
 	/**
 	 * Returns detailed information for a specific tournament instance; the response includes tournament info and the leaderboard of players
 	 *
@@ -777,6 +818,15 @@ export class WSAPI {
 		return this.api.tournamentsGetInfoT(this.userExtId, tournamentInstanceId);
 	}
 
+	/**
+	 * Returns the players of a specific clan in a clan-based tournament.
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async getClanTournamentPlayers(tournamentInstanceId: number, clanId: number): Promise<TClanTournamentPlayers> {
+		return this.api.clanTournamentGetPlayers(this.userExtId, tournamentInstanceId, clanId);
+	}
+
 	/**
 	 * Requests registration for the specified tournament instance. Returns the err_code.
 	 *
@@ -980,6 +1030,7 @@ export class WSAPI {
 	 *
 	 * **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)
 	 */
@@ -1010,6 +1061,7 @@ export class WSAPI {
 	 *
 	 * **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
@@ -1051,6 +1103,7 @@ export class WSAPI {
 	 *
 	 * **Visitor mode: not supported**
 	 *
+	 * @param params - Activity log parameters
 	 * @param params.startTimeSeconds - Start time in seconds (epoch timestamp)
 	 * @param params.endTimeSeconds - End time in seconds (epoch timestamp)
 	 * @param params.from - Start index of records to return
@@ -1596,6 +1649,11 @@ export class WSAPI {
 		this.updateEntity(onUpdateContextKey.TournamentList, payload);
 	}
 
+	private async updateClans() {
+		const payload = await this.api.clansGetListT(this.userExtId);
+		this.updateEntity(onUpdateContextKey.Clans, payload);
+	}
+
 	private async updateStorePurchasedItems() {
 		const payload = await this.api.storeGetPurchasedItemsT(this.userExtId, 20, 0);
 		this.updateEntity(onUpdateContextKey.StoreHistory, payload);
@@ -1775,6 +1833,7 @@ export class WSAPI {
 	 *
 	 * **Visitor mode: not supported**
 	 *
+	 * @param params - Jackpot winners parameters
 	 * @param params.jp_template_id - Jackpot template id (required; throws if missing)
 	 * @param params.limit - Page size (server default 20 when omitted)
 	 * @param params.offset - Offset into the winner list