@smartico/public-api 0.0.363 → 0.0.365

package/src/Missions/MissionsUtils.ts

@@ -8,6 +8,35 @@ import { BadgesTimeLimitStates } from "./BadgesTimeLimitStates";
 type UserStateParamsKeys = 'core_fav_game_top3' | 'core_fav_game_type_top3' | 'core_fav_game_provider_top3' | 'core_recommended_deposit_amount' | 'core_recommended_casino_bet_amount' | 'casino_last_bet_amount' | 'casino_last_bet_amount_real' | 'casino_last_bet_amount_bonus' | 'acc_last_deposit_amount';
 const USER_STATE_PARAMS_KEYS_GAMES: UserStateParamsKeys[] = ['core_fav_game_top3', 'core_fav_game_type_top3', 'core_fav_game_provider_top3'];
 const USER_STATE_PARAMS_KEYS_BET_AMOUNT: UserStateParamsKeys[] = ['core_recommended_deposit_amount', 'core_recommended_casino_bet_amount', 'casino_last_bet_amount', 'casino_last_bet_amount_real', 'casino_last_bet_amount_bonus', 'acc_last_deposit_amount'];
+
+const MINOR_WORDS = new Set([
+    'of', 'at', 'in', 'on', 'to', 'up', 'as', 'by', 'for',
+    'from', 'into', 'onto', 'with', 'upon', 'via',
+    'and', 'but', 'or', 'nor', 'so', 'yet',
+    'vs', 'v',
+    'a', 'an', 'the',
+]);
+
+function toGameTitleCase(raw: string): string {
+    if (!raw) return raw;
+    const tokens = raw.toLowerCase().split(/(\b\w+\b)/);
+    const wordTokens = tokens.filter((t) => /^\w+$/.test(t));
+    const lastWordIdx = wordTokens.length - 1;
+    let wordIndex = 0;
+    return tokens
+        .map((token) => {
+            if (!/^\w+$/.test(token)) return token;
+            const isFirst = wordIndex === 0;
+            const isLast  = wordIndex === lastWordIdx;
+            wordIndex++;
+            if (isFirst || isLast || !MINOR_WORDS.has(token)) {
+                return token.charAt(0).toUpperCase() + token.slice(1);
+            }
+            return token;
+        })
+        .join('');
+}
+
 export class MissionUtils {
 
     public static getAvailabilityStatus = (mission: UserAchievement) => {
@@ -199,8 +228,8 @@ export class MissionUtils {
                     const value = userStateParams[k]?.filter(v => Boolean(v));
                     if (value && value.length > 0) {
                         suggestedGames = value.map((v: string) => {
-                            const cleaned = v.replace(/_/g, ' ').toLowerCase();
-                            return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+                            const cleaned = v.replace(/_/g, ' ');
+                            return toGameTitleCase(cleaned);
                         }).join(', ');
                     }
                 }
@@ -213,8 +242,7 @@ export class MissionUtils {
                         suggestedGames = value[pos];
 
                         if (suggestedGames) {
-                            suggestedGames = suggestedGames.replace('_', ' ').toLowerCase();
-                            suggestedGames = suggestedGames.charAt(0).toUpperCase() + suggestedGames.slice(1);
+                            suggestedGames = toGameTitleCase(suggestedGames.replace(/_/g, ' '));
                         }
 
                     }

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';