@gamelobby/common 1.0.372 → 1.0.374

package/build/interfaces/bracketBackend.interface.d.ts

@@ -1,11 +1,62 @@
+export declare type BracketMatchType = 'winner' | 'loser' | 'grandFinal' | 'grandFinalReset' | 'consolation';
 export interface BracketBackEnd {
-    round: Number;
-    match: Number;
-    player1: Number | null;
-    player2?: Number | null;
+    round: number;
+    match: number;
+    player1: number | null;
+    player2?: number | null;
     win: {
         round: number;
         match: number;
+        bracketType?: BracketMatchType;
     };
-    lose?: string;
+    loss?: {
+        round: number;
+        match: number;
+        bracketType?: BracketMatchType;
+    } | string;
+    bracketType?: BracketMatchType;
+    isBye?: boolean;
+    byeAdvancesTo?: {
+        round: number;
+        match: number;
+    };
+    player1Score?: number;
+    player2Score?: number;
+    winnerId?: number;
+    loserId?: number;
+    status?: 'pending' | 'in_progress' | 'completed' | 'forfeited' | 'bye';
+    isForfeited?: boolean;
+    forfeitedBy?: number;
+    forfeitReason?: string;
+    player1Raw?: {
+        teamId: number;
+        teamName: string;
+        logo?: string;
+        seed?: number;
+    };
+    player2Raw?: {
+        teamId: number;
+        teamName: string;
+        logo?: string;
+        seed?: number;
+    };
+    scheduledTime?: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+export interface BracketStructure {
+    roomId: number;
+    bracketType: 'single' | 'double' | 'swiss' | 'roundRobin';
+    totalParticipants: number;
+    totalRounds: number;
+    winnerBracket: BracketBackEnd[];
+    loserBracket?: BracketBackEnd[];
+    grandFinal?: BracketBackEnd;
+    grandFinalReset?: BracketBackEnd;
+    consolation?: BracketBackEnd;
+    currentRound: number;
+    isComplete: boolean;
+    championTeamId?: number;
+    runnerUpTeamId?: number;
+    thirdPlaceTeamId?: number;
 }

package/build/interfaces/bracketConfig.interface.d.ts

@@ -1,7 +1,21 @@
+export declare type TournamentType = 'single' | 'double' | 'swiss' | 'roundRobin';
 export interface BracketConfig {
     _id?: string;
     name?: string;
     total?: number;
     ordered?: boolean;
     generated?: boolean;
+    bracketType?: TournamentType;
+    enableGrandFinalReset?: boolean;
+    enableConsolationBracket?: boolean;
+    consolationPlaces?: number;
+    swissRounds?: number;
+    roundRobinGroups?: number;
+    teamsAdvancingPerGroup?: number;
+    seedByRanking?: boolean;
+    randomSeed?: boolean;
+    byeHandling?: 'top_seed' | 'bottom_seed' | 'random';
+    bestOf?: number;
+    matchDurationMinutes?: number;
+    breakBetweenMatchesMinutes?: number;
 }

package/build/interfaces/creator.interface.d.ts

@@ -1,6 +1,15 @@
 import { ColorsUserInfo } from './colorsUserInfo.interface';
 import { Question } from './question.interface';
 import { UserBanners } from './userBanners.interface';
+export interface CreatorSocialNetwork {
+    id: number;
+    socialId: number;
+    usuario: string;
+    url?: string;
+    nombre?: string;
+    icono?: string;
+    baseUrl?: string;
+}
 export interface Creator {
     userInfoId: string;
     apellido: string;
@@ -17,4 +26,5 @@ export interface Creator {
     hasCode: boolean;
     codeAnswered: boolean;
     contact: string;
+    socialNetworks?: CreatorSocialNetwork[];
 }

package/build/interfaces/gameDay.interface.d.ts

@@ -1,3 +1,4 @@
+import { GameDayStatus, QualificationRules } from './gameDayStatus.interface';
 export interface GameDay {
     _id?: string;
     id?: number;
@@ -11,4 +12,16 @@ export interface GameDay {
     ranked?: number;
     generated?: boolean;
     createdAt?: string;
+    status?: GameDayStatus;
+    closedAt?: string;
+    closedBy?: string;
+    finalizedAt?: string;
+    finalizedBy?: string;
+    reopenedAt?: string;
+    reopenedBy?: string;
+    qualificationRules?: QualificationRules;
+    totalParticipants?: number;
+    qualifiedCount?: number;
+    eliminatedCount?: number;
+    actionsExecuted?: boolean;
 }

package/build/interfaces/gameDayStatus.interface.d.ts

@@ -0,0 +1,111 @@
+/**
+ * GameDay Status - States for tournament game days
+ */
+export declare enum GameDayStatus {
+    DRAFT = "draft",
+    OPEN = "open",
+    IN_PROGRESS = "in_progress",
+    PENDING_CLOSE = "pending_close",
+    CLOSED = "closed",
+    FINALIZED = "finalized",
+    REOPENED = "reopened"
+}
+/**
+ * Qualification Action Types
+ */
+export declare enum QualifiedActionType {
+    STAY = "stay",
+    MOVE_TO_ROOM = "move_to_room",
+    EXCLUDE_NEXT = "exclude_next",
+    EXCLUDE_BRACKET = "exclude_bracket"
+}
+export declare enum EliminatedActionType {
+    ALLOW_REENTRY = "allow_reentry",
+    EXCLUDE = "exclude",
+    MOVE_TO_ROOM = "move_to_room"
+}
+/**
+ * Qualification Rules Configuration
+ */
+export interface QualificationRules {
+    enabled: boolean;
+    qualifyTop: number;
+    qualifyByPoints?: number;
+    qualifiedAction: QualifiedActionType;
+    qualifiedTargetRoomId?: string;
+    qualifiedTargetRoomName?: string;
+    eliminatedAction: EliminatedActionType;
+    eliminatedTargetRoomId?: string;
+    allowReentry: boolean;
+    autoExecute: boolean;
+    gracePeriodMinutes: number;
+}
+/**
+ * Participant Status per GameDay
+ */
+export declare enum ParticipantGameDayStatus {
+    ACTIVE = "active",
+    QUALIFIED = "qualified",
+    ELIMINATED = "eliminated",
+    PROMOTED = "promoted",
+    RELEGATED = "relegated",
+    PENDING = "pending"
+}
+export interface ParticipantGameDayState {
+    participantId: number;
+    teamId: number;
+    teamName: string;
+    roomId: number;
+    gameDayId: string;
+    status: ParticipantGameDayStatus;
+    qualifiedPosition?: number;
+    points?: number;
+    nextAction?: QualifiedActionType | EliminatedActionType;
+    targetRoomId?: string;
+    actionExecuted: boolean;
+    actionExecutedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Pending Qualification Action
+ */
+export interface QualificationAction {
+    id: number;
+    roomId: number;
+    gameDayId: string;
+    participantId: number;
+    teamId: number;
+    teamName: string;
+    actionType: QualifiedActionType | EliminatedActionType;
+    targetRoomId?: string;
+    status: 'pending' | 'executed' | 'cancelled' | 'failed';
+    position?: number;
+    points?: number;
+    executedAt?: Date;
+    executedBy?: string;
+    failureReason?: string;
+    createdAt: Date;
+}
+/**
+ * GameDay State Transition Result
+ */
+export interface GameDayTransitionResult {
+    success: boolean;
+    previousStatus: GameDayStatus;
+    newStatus: GameDayStatus;
+    message: string;
+    requiresConfirmation?: boolean;
+    dependencies?: {
+        hasPromotedPlayers: boolean;
+        promotedPlayersCount: number;
+        hasNextBracketGenerated: boolean;
+        hasPrizesDistributed: boolean;
+    };
+    affectedParticipants?: ParticipantGameDayState[];
+    pendingActions?: QualificationAction[];
+}
+/**
+ * Default Qualification Rules
+ */
+export declare const DEFAULT_QUALIFICATION_RULES: QualificationRules;

package/build/interfaces/gameDayStatus.interface.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUALIFICATION_RULES = exports.ParticipantGameDayStatus = exports.EliminatedActionType = exports.QualifiedActionType = exports.GameDayStatus = void 0;
+/**
+ * GameDay Status - States for tournament game days
+ */
+var GameDayStatus;
+(function (GameDayStatus) {
+    GameDayStatus["DRAFT"] = "draft";
+    GameDayStatus["OPEN"] = "open";
+    GameDayStatus["IN_PROGRESS"] = "in_progress";
+    GameDayStatus["PENDING_CLOSE"] = "pending_close";
+    GameDayStatus["CLOSED"] = "closed";
+    GameDayStatus["FINALIZED"] = "finalized";
+    GameDayStatus["REOPENED"] = "reopened"; // Reopened (special case)
+})(GameDayStatus = exports.GameDayStatus || (exports.GameDayStatus = {}));
+/**
+ * Qualification Action Types
+ */
+var QualifiedActionType;
+(function (QualifiedActionType) {
+    QualifiedActionType["STAY"] = "stay";
+    QualifiedActionType["MOVE_TO_ROOM"] = "move_to_room";
+    QualifiedActionType["EXCLUDE_NEXT"] = "exclude_next";
+    QualifiedActionType["EXCLUDE_BRACKET"] = "exclude_bracket"; // Exclude from next bracket generation
+})(QualifiedActionType = exports.QualifiedActionType || (exports.QualifiedActionType = {}));
+var EliminatedActionType;
+(function (EliminatedActionType) {
+    EliminatedActionType["ALLOW_REENTRY"] = "allow_reentry";
+    EliminatedActionType["EXCLUDE"] = "exclude";
+    EliminatedActionType["MOVE_TO_ROOM"] = "move_to_room"; // Move to consolation room
+})(EliminatedActionType = exports.EliminatedActionType || (exports.EliminatedActionType = {}));
+/**
+ * Participant Status per GameDay
+ */
+var ParticipantGameDayStatus;
+(function (ParticipantGameDayStatus) {
+    ParticipantGameDayStatus["ACTIVE"] = "active";
+    ParticipantGameDayStatus["QUALIFIED"] = "qualified";
+    ParticipantGameDayStatus["ELIMINATED"] = "eliminated";
+    ParticipantGameDayStatus["PROMOTED"] = "promoted";
+    ParticipantGameDayStatus["RELEGATED"] = "relegated";
+    ParticipantGameDayStatus["PENDING"] = "pending";
+})(ParticipantGameDayStatus = exports.ParticipantGameDayStatus || (exports.ParticipantGameDayStatus = {}));
+/**
+ * Default Qualification Rules
+ */
+exports.DEFAULT_QUALIFICATION_RULES = {
+    enabled: false,
+    qualifyTop: 0,
+    qualifiedAction: QualifiedActionType.STAY,
+    eliminatedAction: EliminatedActionType.ALLOW_REENTRY,
+    allowReentry: true,
+    autoExecute: false,
+    gracePeriodMinutes: 60
+};

package/build/interfaces/index.d.ts

@@ -71,6 +71,9 @@ export * from './requestStates.enum';
 export * from './awardNew.interface';
 export * from './awardType.enum';
 export * from './bracketBackend.interface';
+export * from './bracketConfig.interface';
 export * from './wallet.interface';
 export * from './imageGallery.interface';
+export * from './gameDayStatus.interface';
 export * from './gameDay.interface';
+export * from './prizePool.interface';

package/build/interfaces/index.js

@@ -83,6 +83,9 @@ __exportStar(require("./requestStates.enum"), exports);
 __exportStar(require("./awardNew.interface"), exports);
 __exportStar(require("./awardType.enum"), exports);
 __exportStar(require("./bracketBackend.interface"), exports);
+__exportStar(require("./bracketConfig.interface"), exports);
 __exportStar(require("./wallet.interface"), exports);
 __exportStar(require("./imageGallery.interface"), exports);
+__exportStar(require("./gameDayStatus.interface"), exports);
 __exportStar(require("./gameDay.interface"), exports);
+__exportStar(require("./prizePool.interface"), exports);

package/build/interfaces/prizePool.interface.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Prize Pool Configuration
+ * Defines how coins are collected and distributed in tournaments
+ */
+/**
+ * Prize distribution per position
+ */
+export interface PrizePosition {
+    position: number;
+    percentage: number;
+    minAmount?: number;
+    label?: string;
+}
+/**
+ * Platform fee configuration
+ */
+export interface PlatformFeeConfig {
+    enabled: boolean;
+    percentage: number;
+    minFee?: number;
+    maxFee?: number;
+}
+/**
+ * Prize pool source configuration
+ */
+export declare enum PrizePoolSource {
+    ENTRY_FEES = "entry_fees",
+    GUARANTEED = "guaranteed",
+    MIXED = "mixed"
+}
+/**
+ * Prize pool status
+ */
+export declare enum PrizePoolStatus {
+    COLLECTING = "collecting",
+    LOCKED = "locked",
+    DISTRIBUTING = "distributing",
+    DISTRIBUTED = "distributed",
+    REFUNDED = "refunded"
+}
+/**
+ * Individual escrow hold for a participant
+ */
+export interface ParticipantEscrow {
+    participantId: number;
+    participantType: 'team' | 'player';
+    amount: number;
+    currency: string;
+    holdId?: string;
+    status: 'held' | 'released' | 'refunded';
+    heldAt: Date;
+    releasedAt?: Date;
+    refundedAt?: Date;
+}
+/**
+ * Prize distribution record
+ */
+export interface PrizeDistributionRecord {
+    participantId: number;
+    participantType: 'team' | 'player';
+    participantName: string;
+    position: number;
+    percentage: number;
+    amount: number;
+    currency: string;
+    transactionId?: string;
+    distributedAt?: Date;
+    status: 'pending' | 'distributed' | 'failed';
+    errorMessage?: string;
+}
+/**
+ * Complete Prize Pool Configuration for a Room
+ */
+export interface PrizePoolConfig {
+    enabled: boolean;
+    source: PrizePoolSource;
+    currency: string;
+    entryFee: number;
+    entryFeePerPlayer?: boolean;
+    guaranteedAmount?: number;
+    distribution: PrizePosition[];
+    platformFee: PlatformFeeConfig;
+    minParticipantsForPrizes: number;
+    insufficientParticipantsAction: 'refund_all' | 'distribute_anyway' | 'cancel';
+}
+/**
+ * Live Prize Pool State (runtime state)
+ */
+export interface PrizePoolState {
+    roomId: number;
+    gameDayId?: string;
+    totalCollected: number;
+    guaranteedAmount: number;
+    platformFeeAmount: number;
+    distributedAmount: number;
+    totalPoolAmount: number;
+    availableForDistribution: number;
+    status: PrizePoolStatus;
+    participantCount: number;
+    escrows: ParticipantEscrow[];
+    distributions: PrizeDistributionRecord[];
+    createdAt: Date;
+    updatedAt: Date;
+    lockedAt?: Date;
+    distributedAt?: Date;
+    refundedAt?: Date;
+}
+/**
+ * Default prize distributions for common tournament sizes
+ */
+export declare const DEFAULT_PRIZE_DISTRIBUTIONS: Record<string, PrizePosition[]>;
+/**
+ * Helper to calculate prize amount for a position
+ */
+export declare function calculatePrizeAmount(position: number, totalPool: number, distribution: PrizePosition[]): number;
+/**
+ * Validate that distribution percentages sum to 100 (or less)
+ */
+export declare function validateDistribution(distribution: PrizePosition[]): {
+    valid: boolean;
+    totalPercentage: number;
+    message?: string;
+};

package/build/interfaces/prizePool.interface.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Prize Pool Configuration
+ * Defines how coins are collected and distributed in tournaments
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDistribution = exports.calculatePrizeAmount = exports.DEFAULT_PRIZE_DISTRIBUTIONS = exports.PrizePoolStatus = exports.PrizePoolSource = void 0;
+/**
+ * Prize pool source configuration
+ */
+var PrizePoolSource;
+(function (PrizePoolSource) {
+    PrizePoolSource["ENTRY_FEES"] = "entry_fees";
+    PrizePoolSource["GUARANTEED"] = "guaranteed";
+    PrizePoolSource["MIXED"] = "mixed"; // Entry fees + guaranteed minimum
+})(PrizePoolSource = exports.PrizePoolSource || (exports.PrizePoolSource = {}));
+/**
+ * Prize pool status
+ */
+var PrizePoolStatus;
+(function (PrizePoolStatus) {
+    PrizePoolStatus["COLLECTING"] = "collecting";
+    PrizePoolStatus["LOCKED"] = "locked";
+    PrizePoolStatus["DISTRIBUTING"] = "distributing";
+    PrizePoolStatus["DISTRIBUTED"] = "distributed";
+    PrizePoolStatus["REFUNDED"] = "refunded"; // Tournament cancelled, all refunded
+})(PrizePoolStatus = exports.PrizePoolStatus || (exports.PrizePoolStatus = {}));
+/**
+ * Default prize distributions for common tournament sizes
+ */
+exports.DEFAULT_PRIZE_DISTRIBUTIONS = {
+    // Winner takes all
+    'winner_takes_all': [
+        { position: 1, percentage: 100, label: 'Champion' }
+    ],
+    // Top 2
+    'top_2': [
+        { position: 1, percentage: 70, label: 'Champion' },
+        { position: 2, percentage: 30, label: 'Runner-up' }
+    ],
+    // Top 3
+    'top_3': [
+        { position: 1, percentage: 50, label: 'Champion' },
+        { position: 2, percentage: 30, label: 'Runner-up' },
+        { position: 3, percentage: 20, label: '3rd Place' }
+    ],
+    // Top 4
+    'top_4': [
+        { position: 1, percentage: 40, label: 'Champion' },
+        { position: 2, percentage: 25, label: 'Runner-up' },
+        { position: 3, percentage: 20, label: '3rd Place' },
+        { position: 4, percentage: 15, label: '4th Place' }
+    ],
+    // Top 8
+    'top_8': [
+        { position: 1, percentage: 30, label: 'Champion' },
+        { position: 2, percentage: 20, label: 'Runner-up' },
+        { position: 3, percentage: 15, label: '3rd Place' },
+        { position: 4, percentage: 10, label: '4th Place' },
+        { position: 5, percentage: 7, label: '5th-8th' },
+        { position: 6, percentage: 7, label: '5th-8th' },
+        { position: 7, percentage: 6, label: '5th-8th' },
+        { position: 8, percentage: 5, label: '5th-8th' }
+    ]
+};
+/**
+ * Helper to calculate prize amount for a position
+ */
+function calculatePrizeAmount(position, totalPool, distribution) {
+    var positionConfig = distribution.find(function (d) { return d.position === position; });
+    if (!positionConfig)
+        return 0;
+    var calculatedAmount = Math.floor((totalPool * positionConfig.percentage) / 100);
+    // Apply minimum if configured
+    if (positionConfig.minAmount && calculatedAmount < positionConfig.minAmount) {
+        return positionConfig.minAmount;
+    }
+    return calculatedAmount;
+}
+exports.calculatePrizeAmount = calculatePrizeAmount;
+/**
+ * Validate that distribution percentages sum to 100 (or less)
+ */
+function validateDistribution(distribution) {
+    var totalPercentage = distribution.reduce(function (sum, pos) { return sum + pos.percentage; }, 0);
+    if (totalPercentage > 100) {
+        return {
+            valid: false,
+            totalPercentage: totalPercentage,
+            message: "Distribution percentages sum to " + totalPercentage + "%, which exceeds 100%"
+        };
+    }
+    if (totalPercentage < 100) {
+        return {
+            valid: true,
+            totalPercentage: totalPercentage,
+            message: "Distribution uses " + totalPercentage + "%, remaining " + (100 - totalPercentage) + "% goes to platform"
+        };
+    }
+    return {
+        valid: true,
+        totalPercentage: totalPercentage
+    };
+}
+exports.validateDistribution = validateDistribution;

package/build/interfaces/room.interface.d.ts

@@ -4,7 +4,9 @@ import { BracketConfig } from "./bracketConfig.interface";
 import { ConfigRoom } from "./config.interface";
 import { Game } from "./game.interface";
 import { GameDay } from "./gameDay.interface";
+import { QualificationRules } from "./gameDayStatus.interface";
 import { GameMode } from "./gamemode.interface";
+import { PrizePoolConfig } from "./prizePool.interface";
 import { Platform } from "./platform.interface";
 import { Points } from "./points.interface";
 import { RegistrationType } from "./registrationType";
@@ -81,6 +83,7 @@ export interface Room {
     welcomeMsgMatch: string;
     welcomeMsgRoom: string;
     price: number;
+    priceCurrency?: string;
     online: boolean;
     userInfo?: UserInfo;
     streaming: Streaming;
@@ -104,4 +107,6 @@ export interface Room {
     gameDay?: GameDay;
     bannerImageUrl?: string;
     showOpponentInInvitation?: boolean;
+    qualificationRules?: QualificationRules;
+    prizePoolConfig?: PrizePoolConfig;
 }

package/build/interfaces/tournamentRound.interface.d.ts

@@ -1,18 +1,59 @@
 import { GameDay } from "./gameDay.interface";
+import { BracketMatchType } from "./bracketBackend.interface";
 export interface TournamentRound {
-    roomId: string;
-    round: string;
-    match: string;
-    player1: string;
-    player2: string;
+    id?: number;
+    roomId: string | number;
+    round: string | number;
+    match: string | number;
+    player1: string | number | null;
+    player2: string | number | null;
+    player1Raw?: {
+        teamId: number;
+        teamName: string;
+        logo?: string;
+        seed?: number;
+    };
+    player2Raw?: {
+        teamId: number;
+        teamName: string;
+        logo?: string;
+        seed?: number;
+    };
     win: {
-        round: string;
-        match: string;
+        round: string | number;
+        match: string | number;
+        bracketType?: BracketMatchType;
     };
     loss: {
-        round: string;
-        match: string;
+        round: string | number;
+        match: string | number;
+        bracketType?: BracketMatchType;
     };
     created: boolean;
     gameDay: GameDay;
+    bracketType?: BracketMatchType;
+    status?: 'pending' | 'in_progress' | 'completed' | 'forfeited' | 'bye';
+    isBye?: boolean;
+    isForfeited?: boolean;
+    forfeitedBy?: number;
+    forfeitReason?: string;
+    player1Score?: number;
+    player2Score?: number;
+    winnerId?: number;
+    loserId?: number;
+    manualScore1?: number;
+    manualScore2?: number;
+    isManuallyEdited?: boolean;
+    editedBy?: string;
+    editedAt?: Date;
+    previousResult?: {
+        player1Score?: number;
+        player2Score?: number;
+        winnerId?: number;
+        loserId?: number;
+        status?: string;
+    };
+    matchId?: number;
+    createdAt?: Date;
+    updatedAt?: Date;
 }

package/build/topics/matchestopics.d.ts

@@ -11,5 +11,13 @@ export declare enum Matchestopics {
     matchTournamentDelete = "match.tournament.delete",
     matchTournamentDeleted = "match.tournament.deleted",
     matchTournamentUpdate = "match.tournament.update",
-    matchTournamentUpdated = "match.tournament.updated"
+    matchTournamentUpdated = "match.tournament.updated",
+    bracketGenerated = "bracket.generated",
+    bracketUpdated = "bracket.updated",
+    bracketMatchCompleted = "bracket.match.completed",
+    bracketForfeit = "bracket.forfeit",
+    bracketRollback = "bracket.rollback",
+    bracketByeAdvanced = "bracket.bye.advanced",
+    bracketGrandFinalReset = "bracket.grandfinal.reset",
+    bracketCompleted = "bracket.completed"
 }

package/build/topics/matchestopics.js

@@ -16,4 +16,13 @@ var Matchestopics;
     Matchestopics["matchTournamentDeleted"] = "match.tournament.deleted";
     Matchestopics["matchTournamentUpdate"] = "match.tournament.update";
     Matchestopics["matchTournamentUpdated"] = "match.tournament.updated";
+    // Bracket events
+    Matchestopics["bracketGenerated"] = "bracket.generated";
+    Matchestopics["bracketUpdated"] = "bracket.updated";
+    Matchestopics["bracketMatchCompleted"] = "bracket.match.completed";
+    Matchestopics["bracketForfeit"] = "bracket.forfeit";
+    Matchestopics["bracketRollback"] = "bracket.rollback";
+    Matchestopics["bracketByeAdvanced"] = "bracket.bye.advanced";
+    Matchestopics["bracketGrandFinalReset"] = "bracket.grandfinal.reset";
+    Matchestopics["bracketCompleted"] = "bracket.completed";
 })(Matchestopics = exports.Matchestopics || (exports.Matchestopics = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamelobby/common",
-  "version": "1.0.372",
+  "version": "1.0.374",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",