tods-competition-factory 2.0.60 → 2.1.0

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.60';
+    return '2.1.0';
 }
 
 function isFunction(obj) {
@@ -446,6 +446,10 @@ const MISSING_VALUE = {
     message: 'Missing value',
     code: 'ERR_MISSING_VALUE',
 };
+const MISSING_BIRTH_DATE = {
+    message: 'Missing birthdate',
+    code: 'ERR_MISSING_BIRTH_DATE',
+};
 const MISSING_DATE = {
     message: 'Missing date',
     code: 'ERR_MISSING_DATE',
@@ -506,6 +510,10 @@ const CANNOT_REMOVE_PARTICIPANTS = {
     message: 'Cannot remove participants',
     code: 'ERR_UNCHANGED_CANNOT_REMOVE_PARTICIPANTS',
 };
+const CATEGORY_MISMATCH = {
+    message: 'Participant category mismatch',
+    code: 'ERR_CATEGORY_MISMATCH',
+};
 const CANNOT_CHANGE_WINNING_SIDE = {
     message: 'Cannot change winningSide',
     code: 'ERR_UNCHANGED_CANNOT_CHANGE_WINNING_SIDE',
@@ -818,6 +826,7 @@ const errorConditionConstants = {
     CANNOT_MODIFY_PARTICIPANT_TYPE,
     CANNOT_REMOVE_MAIN_STRUCTURE,
     CANNOT_REMOVE_PARTICIPANTS,
+    CATEGORY_MISMATCH,
     COURT_EXISTS,
     COURT_NOT_FOUND,
     DRAW_DEFINITION_NOT_FOUND,
@@ -900,6 +909,7 @@ const errorConditionConstants = {
     MISSING_ASSIGNMENTS,
     MISSING_ASYNC_STATE_PROVIDER,
     MISSING_AVOIDANCE_POLICY,
+    MISSING_BIRTH_DATE,
     MISSING_COLLECTION_DEFINITION,
     MISSING_COURT_ID,
     MISSING_COURTS_INFO,
@@ -3414,9 +3424,11 @@ const MUTATIONS = 'mutations';
 const PUBLISH_EVENT = 'publishEvent';
 const PUBLISH_EVENT_SEEDING = 'publishEventSeeding';
 const PUBLISH_ORDER_OF_PLAY = 'publishOrderOfPlay';
+const PUBLISH_PARTICIPANTS = 'publishParticipants';
 const UNPUBLISH_EVENT = 'unPublishEvent';
 const UNPUBLISH_EVENT_SEEDING = 'unPublishEventSeeding';
 const UNPUBLISH_ORDER_OF_PLAY = 'unPublishOrderOfPlay';
+const UNPUBLISH_PARTICIPANTS = 'unPublishParticipants';
 const UPDATE_INCONTEXT_MATCHUP = 'updateInContextMatchUp';
 const topicConstants = {
     ADD_DRAW_DEFINITION,
@@ -3443,6 +3455,7 @@ const topicConstants = {
     PUBLISH_EVENT_SEEDING,
     PUBLISH_EVENT,
     PUBLISH_ORDER_OF_PLAY,
+    PUBLISH_PARTICIPANTS,
     UNPUBLISH_EVENT_SEEDING,
     UNPUBLISH_EVENT,
     UNPUBLISH_ORDER_OF_PLAY,
@@ -11537,12 +11550,16 @@ function addScheduleItem(params) {
     }
 }
 
-function getTournamentPublishStatus({ tournamentRecord, status = PUBLIC }) {
+function getTournamentPublishStatus(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, status = PUBLIC } = params;
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    return getTournamentTimeItem({
+    return makeDeepCopy(getTournamentTimeItem({
         tournamentRecord,
         itemType,
-    })?.timeItem?.itemValue?.[status];
+    })?.timeItem?.itemValue?.[status], false, true);
 }
 
 function isValidTournamentRecord(tournamentRecord) {
@@ -11637,6 +11654,8 @@ function getPublishState(params) {
     if (tournamentRecord) {
         const pubStatus = getTournamentPublishStatus({ tournamentRecord });
         publishState.tournament = pubStatus ?? {};
+        if (pubStatus?.orderOfPlay?.published || pubStatus?.participants?.published)
+            tournamentPublished = true;
         publishState.tournament.status = { published: tournamentPublished, publishedEventIds };
     }
     return { ...SUCCESS, publishState };
@@ -21875,30 +21894,9 @@ function validateTieFormat(params) {
     const event = params?.event;
     const stack = 'validateTieFormat';
     const errors = [];
-    if (!params || !tieFormat || typeof tieFormat !== 'object') {
-        errors.push('tieFormat must be an object');
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
-    if (typeof tieFormat.winCriteria !== 'object') {
-        errors.push('tieFormat.winCriteria must be an object');
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
-    if (!Array.isArray(tieFormat.collectionDefinitions)) {
-        errors.push(mustBeAnArray('tieFormat.collectionDefinitions'));
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
+    const paramsCheck = checkParams$1({ ...params, stack });
+    if (paramsCheck?.error)
+        return paramsCheck;
     let aggregateValueImperative;
     const validCollections = tieFormat.collectionDefinitions.every((collectionDefinition) => {
         const { setValue, scoreValue, collectionValue } = collectionDefinition;
@@ -21951,6 +21949,31 @@ function validateTieFormat(params) {
     }
     return result;
 }
+function checkParams$1(params) {
+    const { tieFormat, stack } = params;
+    if (!params || !tieFormat || !isObject(tieFormat)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'tieformat must be an object' },
+            stack,
+        });
+    }
+    if (!isObject(tieFormat.winCriteria)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'tieformat.winCritiera must be an object' },
+            stack,
+        });
+    }
+    if (!Array.isArray(tieFormat.collectionDefinitions)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'collectionDefinitions must be an array' },
+            stack,
+        });
+    }
+    return { ...SUCCESS };
+}
 
 function generateTieMatchUpScore(params) {
     const { sideAdjustments = [0, 0], separator = '-', drawDefinition, matchUpsMap, structure, matchUp, event, } = params;
@@ -33654,6 +33677,7 @@ function getTournamentInfo(params) {
                 eventInfo.push(info);
         }
     }
+    tournamentInfo.publishState = publishState?.tournament;
     tournamentInfo.eventInfo = eventInfo;
     return {
         tournamentInfo: makeDeepCopy(tournamentInfo, false, true),
@@ -34608,6 +34632,7 @@ var query$5 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData
 };
 
@@ -35991,11 +36016,9 @@ function competitionScheduleMatchUps(params) {
     const getResult = getSchedulingProfile(params);
     const schedulingProfile = getResult.schedulingProfile;
     const { sortDateMatchUps = true, courtCompletedMatchUps, alwaysReturnCompleted, activeTournamentId, tournamentRecords, withCourtGridRows, minCourtGridRows, usePublishState, status = PUBLIC, sortCourtsData, } = params;
+    const tournamentId = activeTournamentId ?? getTournamentId() ?? Object.keys(tournamentRecords)[0];
     const tournamentPublishStatus = usePublishState
-        ? getTournamentTimeItem({
-            tournamentRecord: tournamentRecords[activeTournamentId ?? getTournamentId() ?? Object.keys(tournamentRecords)[0]],
-            itemType: `${PUBLISH}.${STATUS$1}`,
-        }).timeItem?.itemValue?.[status]
+        ? getTournamentPublishStatus({ tournamentRecord: tournamentRecords[tournamentId], status })
         : undefined;
     const allCompletedMatchUps = alwaysReturnCompleted
         ? getCompetitionMatchUps({
@@ -36007,7 +36030,7 @@ function competitionScheduleMatchUps(params) {
             contextFilters: params.contextFilters,
         }).completedMatchUps
         : [];
-    if (usePublishState && (!tournamentPublishStatus || !Object.keys(tournamentPublishStatus).length)) {
+    if (usePublishState && !tournamentPublishStatus?.orderOfPlay?.published) {
         return {
             completedMatchUps: allCompletedMatchUps,
             dateMatchUps: [],
@@ -37345,6 +37368,7 @@ var index$f = {
     getTournamentInfo: getTournamentInfo,
     getTournamentPenalties: getTournamentPenalties,
     getTournamentPersons: getTournamentPersons,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
     getValidGroupSizes: getValidGroupSizes,
@@ -39542,8 +39566,86 @@ function modifyEvent(params) {
     ]);
     if (paramsCheck.error)
         return paramsCheck;
-    const { tournamentRecord, eventUpdates, event } = params;
+    const { eventUpdates, event } = params;
     const stack = 'modifyEvent';
+    const enteredParticipants = getEnteredParticipants(params);
+    const participantsProfile = getParticipantsProfile({ enteredParticipants });
+    const { enteredParticipantGenders, enteredParticipantTypes } = participantsProfile;
+    const genderResult = checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack });
+    if (genderResult.error)
+        return genderResult;
+    const eventTypeResult = checkEventType({ enteredParticipantTypes, eventUpdates, stack });
+    if (eventTypeResult.error)
+        return eventTypeResult;
+    const categoryResult = checkCategoryUpdates({ ...params, ...participantsProfile, enteredParticipants, stack });
+    if (categoryResult.error)
+        return categoryResult;
+    const dateResult = dateUpdates({ ...params, stack });
+    if (dateResult.error)
+        return dateResult;
+    if (eventUpdates.eventType)
+        event.eventType = eventUpdates.eventType;
+    if (eventUpdates.eventName)
+        event.eventName = eventUpdates.eventName;
+    if (eventUpdates.gender)
+        event.gender = eventUpdates.gender;
+    return { ...SUCCESS };
+}
+function checkCategoryUpdates(params) {
+    const category = params.eventUpdates?.category;
+    if (!category)
+        return { ...SUCCESS };
+    const categoryCheck = validateCategory({ category });
+    if (categoryCheck.error)
+        return categoryCheck;
+    if (params.event.eventType === TEAM$2) {
+        const drawTieFormats = params.event?.drawDefinitions?.map((draw) => getObjectTieFormat(draw)) ?? [];
+        const eventTieFormat = getObjectTieFormat(params.event);
+        const eventMatchUps = allEventMatchUps(params)?.matchUps ?? [];
+        const matchUpTieFormats = eventMatchUps.map((matchUp) => getObjectTieFormat(matchUp)) ?? [];
+        const tieFormats = [eventTieFormat, ...drawTieFormats, ...matchUpTieFormats].filter(Boolean);
+        const validCategory = tieFormats.every((tieFormat) => tieFormat.collectionDefinitions.every((cd) => !cd.category || categoryCanContain({ category: params.eventUpdates.category, childCategory: cd.category })));
+        if (!validCategory)
+            return decorateResult({ result: { error: INVALID_CATEGORY }, stack: params.stack });
+    }
+    if (params.enteredParticipants?.length) {
+        const startDate = params.eventUpdates.startDate || params.event.startDate || params.tournamentRecord.startDate;
+        const endDate = params.eventUpdates.endDate || params.event.endDate || params.tournamentRecord.endDate;
+        const individualParticpants = params.enteredParticipants
+            .map((p) => (p.participantType === INDIVIDUAL ? p : p.individualParticpants ?? []))
+            .flat();
+        const startAgeDetails = getCategoryAgeDetails({ category, consideredDate: startDate });
+        const endAgeDetails = getCategoryAgeDetails({ category, consideredDate: endDate });
+        if (startAgeDetails?.ageMinDate ||
+            startAgeDetails?.ageMaxDate ||
+            endAgeDetails?.ageMinDate ||
+            endAgeDetails?.ageMaxDate) {
+            for (const individualParticipant of individualParticpants) {
+                const birthDate = individualParticipant.person?.birthDate;
+                if (!birthDate)
+                    return decorateResult({ result: { error: MISSING_BIRTH_DATE }, stack: params.stack });
+                const birthTime = new Date(birthDate).getTime();
+                if (startAgeDetails.ageMinDate || startAgeDetails.ageMaxDate) {
+                    const minTime = new Date(startAgeDetails.ageMinDate).getTime();
+                    const maxTime = new Date(startAgeDetails.ageMaxDate).getTime();
+                    if (birthTime < minTime || birthTime > maxTime) {
+                        return decorateResult({ result: { error: CATEGORY_MISMATCH }, stack: params.stack });
+                    }
+                }
+                if (endAgeDetails.ageMin || endAgeDetails.ageMax) {
+                    const minTime = new Date(endAgeDetails.ageMinDate).getTime();
+                    const maxTime = new Date(endAgeDetails.ageMaxDate).getTime();
+                    if (birthTime < minTime || birthTime > maxTime) {
+                        return decorateResult({ result: { error: CATEGORY_MISMATCH }, stack: params.stack });
+                    }
+                }
+            }
+        }
+    }
+    return { ...SUCCESS };
+}
+function dateUpdates(params) {
+    const { tournamentRecord, eventUpdates, event, stack } = params;
     if (eventUpdates.startDate || eventUpdates.endDate) {
         const result = setEventDates({
             startDate: eventUpdates.startDate,
@@ -39554,19 +39656,25 @@ function modifyEvent(params) {
         if (result.error)
             return decorateResult({ result, stack });
     }
+    return { ...SUCCESS };
+}
+function getEnteredParticipants(params) {
+    const { tournamentRecord, event } = params;
     const enteredParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => {
         const status = entryStatus;
         return [...STRUCTURE_SELECTED_STATUSES, ALTERNATE].includes(status);
     })
         .map(({ participantId }) => participantId) ?? [];
-    const enteredParticipants = enteredParticipantIds
+    return enteredParticipantIds
         ? getParticipants({
             participantFilters: { participantIds: enteredParticipantIds },
             withIndividualParticipants: true,
             tournamentRecord,
         }).participants ?? []
         : [];
+}
+function getParticipantsProfile({ enteredParticipants }) {
     const genderAccumulator = [];
     const enteredParticipantTypes = enteredParticipants.reduce((types, participant) => {
         const genders = participant.person?.sex
@@ -39576,32 +39684,32 @@ function modifyEvent(params) {
         return !types.includes(participant.participantType) ? types.concat(participant.participantType) : types;
     }, []);
     const enteredParticipantGenders = unique(genderAccumulator);
+    return { enteredParticipantTypes, enteredParticipantGenders };
+}
+function checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack }) {
     const validGender = !enteredParticipantGenders.length ||
         [MIXED, ANY].includes(eventUpdates.gender ?? '') ||
         (enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender);
-    if (eventUpdates.gender && !validGender)
-        return decorateResult({
+    return eventUpdates.gender && !validGender
+        ? decorateResult({
             context: { gender: eventUpdates.gender, validGender },
-            result: { error: INVALID_VALUES },
+            result: { error: INVALID_GENDER },
             stack,
-        });
+        })
+        : { ...SUCCESS };
+}
+function checkEventType({ enteredParticipantTypes, eventUpdates, stack }) {
     const validEventTypes = (enteredParticipantTypes.includes(TEAM$2) && [TEAM$2]) ||
         (enteredParticipantTypes.includes(INDIVIDUAL) && [SINGLES$1]) ||
         (enteredParticipantTypes.includes(PAIR) && [DOUBLES$1]) || [DOUBLES$1, SINGLES$1, TEAM$2];
     const validEventType = validEventTypes.includes(eventUpdates.eventType ?? '');
-    if (eventUpdates.eventType && !validEventType)
-        return decorateResult({
+    return eventUpdates.eventType && !validEventType
+        ? decorateResult({
             context: { participantType: eventUpdates.eventType, validEventType },
-            result: { error: INVALID_VALUES },
+            result: { error: INVALID_EVENT_TYPE },
             stack,
-        });
-    if (eventUpdates.eventType)
-        event.eventType = eventUpdates.eventType;
-    if (eventUpdates.eventName)
-        event.eventName = eventUpdates.eventName;
-    if (eventUpdates.gender)
-        event.gender = eventUpdates.gender;
-    return { ...SUCCESS };
+        })
+        : { ...SUCCESS };
 }
 
 function addFlight({ qualifyingPositions, drawEntries = [], drawName, drawId, event, stage, }) {
@@ -51796,39 +51904,58 @@ function unPublishEventSeeding({ removePriorValues = true, seedingScaleNames, to
     return { ...SUCCESS };
 }
 
-function unPublishOrderOfPlay(params) {
-    const tournamentRecords = params?.tournamentRecords ??
-        (params?.tournamentRecord && {
-            [params.tournamentRecord.tournamentId]: params.tournamentRecord,
-        }) ??
-        {};
+function unPublishParticipants(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
     if (!Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
     for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const result = unPublishOOP({
-            tournamentRecord,
-            ...params,
-        });
+        const result = unpublish({ tournamentRecord, ...params });
         if (result.error)
             return result;
     }
     return { ...SUCCESS };
 }
-function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
+function unpublish({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    const { timeItem } = getTimeItem({
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
+    const itemValue = timeItem?.itemValue || { [status]: {} };
+    if (itemValue[status])
+        delete itemValue[status].participants;
+    const updatedTimeItem = { itemValue, itemType };
+    addTimeItem({
+        timeItem: updatedTimeItem,
         element: tournamentRecord,
-        itemType,
+        removePriorValues,
     });
+    addNotice({
+        payload: { tournamentId: tournamentRecord.tournamentId },
+        topic: UNPUBLISH_PARTICIPANTS,
+    });
+    return { ...SUCCESS };
+}
+
+function unPublishOrderOfPlay(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
+    if (!Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const result = unPublishOOP({ tournamentRecord, ...params });
+        if (result.error)
+            return result;
+    }
+    return { ...SUCCESS };
+}
+function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const itemType = `${PUBLISH}.${STATUS$1}`;
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
     const itemValue = timeItem?.itemValue || { [status]: {} };
     if (itemValue[status])
         delete itemValue[status].orderOfPlay;
-    const updatedTimeItem = {
-        itemValue,
-        itemType,
-    };
+    const updatedTimeItem = { itemValue, itemType };
     addTimeItem({
         timeItem: updatedTimeItem,
         element: tournamentRecord,
@@ -51843,34 +51970,56 @@ function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUB
     return { ...SUCCESS };
 }
 
-function publishOrderOfPlay(params) {
+function publishParticipants(params) {
     const tournamentRecords = resolveTournamentRecords(params);
     if (!Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
     for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const result = publishOOP({
-            tournamentRecord,
-            ...params,
-        });
+        const result = publish({ tournamentRecord, ...params });
         if (result.error)
             return result;
     }
     return { ...SUCCESS };
 }
-function publishOOP({ scheduledDates = [], removePriorValues, tournamentRecord, status = PUBLIC, eventIds = [] }) {
+function publish({ removePriorValues, tournamentRecord, status = PUBLIC }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    const { timeItem } = getTimeItem({
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
+    const itemValue = timeItem?.itemValue || { [status]: {} };
+    itemValue[status].participants = { published: true };
+    const updatedTimeItem = { itemValue, itemType };
+    addTimeItem({
+        timeItem: updatedTimeItem,
         element: tournamentRecord,
-        itemType,
+        removePriorValues,
     });
+    addNotice({
+        payload: { tournamentId: tournamentRecord.tournamentId },
+        topic: PUBLISH_PARTICIPANTS,
+    });
+    return { ...SUCCESS };
+}
+
+function publishOrderOfPlay(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
+    if (!Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const result = publishOOP({ tournamentRecord, ...params });
+        if (result.error)
+            return result;
+    }
+    return { ...SUCCESS };
+}
+function publishOOP({ scheduledDates = [], removePriorValues, tournamentRecord, status = PUBLIC, eventIds = [] }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const itemType = `${PUBLISH}.${STATUS$1}`;
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
     const itemValue = timeItem?.itemValue || { [status]: {} };
     itemValue[status].orderOfPlay = { published: true, scheduledDates, eventIds };
-    const updatedTimeItem = {
-        itemValue,
-        itemType,
-    };
+    const updatedTimeItem = { itemValue, itemType };
     addTimeItem({
         timeItem: updatedTimeItem,
         element: tournamentRecord,
@@ -51928,10 +52077,12 @@ var mutate$4 = {
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
+    publishParticipants: publishParticipants,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
-    unPublishOrderOfPlay: unPublishOrderOfPlay
+    unPublishOrderOfPlay: unPublishOrderOfPlay,
+    unPublishParticipants: unPublishParticipants
 };
 
 var index$7 = {
@@ -51943,16 +52094,19 @@ var index$7 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData,
     mutate: mutate$4,
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
+    publishParticipants: publishParticipants,
     query: query$5,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
-    unPublishOrderOfPlay: unPublishOrderOfPlay
+    unPublishOrderOfPlay: unPublishOrderOfPlay,
+    unPublishParticipants: unPublishParticipants
 };
 
 function getParticipantStats({ withCompetitiveProfiles, opponentParticipantId, withIndividualStats, teamParticipantId, tournamentRecord, withScaleValues, tallyPolicy, matchUps, }) {