tods-competition-factory 2.0.60 → 2.1.1

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.1';
 }
 
 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,
@@ -1085,7 +1095,12 @@ function setSubscriptions$1(params) {
     if (typeof params.subscriptions !== 'object')
         return { error: INVALID_VALUES };
     Object.keys(params.subscriptions).forEach((subscription) => {
-        syncGlobalState.subscriptions[subscription] = params.subscriptions[subscription];
+        if (typeof params.subscriptions[subscription] === 'function') {
+            syncGlobalState.subscriptions[subscription] = params.subscriptions[subscription];
+        }
+        else {
+            delete syncGlobalState.subscriptions[subscription];
+        }
     });
     return { ...SUCCESS };
 }
@@ -1630,6 +1645,9 @@ function deleteNotices() {
 function getTopics() {
     return _globalStateProvider.getTopics();
 }
+function hasTopic(topic) {
+    return getTopics()?.topics?.includes(topic);
+}
 async function callListener(payload) {
     return _globalStateProvider.callListener(payload, globalState.globalSubscriptions);
 }
@@ -1727,6 +1745,7 @@ var globalState$1 = {
     getTournamentRecords: getTournamentRecords,
     globalLog: globalLog$1,
     handleCaughtError: handleCaughtError,
+    hasTopic: hasTopic,
     removeTournamentRecord: removeTournamentRecord,
     setDeepCopy: setDeepCopy,
     setDevContext: setDevContext,
@@ -1813,6 +1832,184 @@ const eventConstants = {
     TEAM: TEAM$2,
 };
 
+const MAIN = 'MAIN';
+const QUALIFYING = 'QUALIFYING';
+const CONSOLATION = 'CONSOLATION';
+const VOLUNTARY_CONSOLATION = 'VOLUNTARY_CONSOLATION';
+const PLAY_OFF = 'PLAY_OFF';
+const validStages = [MAIN, QUALIFYING, CONSOLATION, PLAY_OFF, VOLUNTARY_CONSOLATION];
+const stageOrder$1 = {
+    [QUALIFYING]: 1,
+    [MAIN]: 2,
+    [PLAY_OFF]: 3,
+    [CONSOLATION]: 3,
+    [VOLUNTARY_CONSOLATION]: 4,
+};
+const FINISHING_POSITIONS = 'finishingPositions';
+const AGGREGATE_EVENT_STRUCTURES = 'aggregateEventStructures';
+const finishOrder = {
+    [MAIN]: 1,
+    [PLAY_OFF]: 2,
+    [CONSOLATION]: 3,
+    [QUALIFYING]: 4,
+    [VOLUNTARY_CONSOLATION]: 5,
+};
+const aggregateOrder = {
+    [PLAY_OFF]: 1,
+    [MAIN]: 2,
+    [CONSOLATION]: 3,
+    [QUALIFYING]: 4,
+    [VOLUNTARY_CONSOLATION]: 5,
+};
+const CLUSTER = 'CLUSTER';
+const SEPARATE = 'SEPARATE';
+const WATERFALL = 'WATERFALL';
+const ITEM = 'ITEM';
+const CONTAINER = 'CONTAINER';
+const DRAW = 'DRAW';
+const RANDOM = 'RANDOM';
+const TOP_DOWN = 'TOP_DOWN';
+const BOTTOM_UP = 'BOTTOM_UP';
+const POSITION = 'POSITION';
+const WINNER = 'WINNER';
+const LOSER = 'LOSER';
+const FIRST_MATCHUP = 'FIRST_MATCHUP';
+const AD_HOC = 'AD_HOC';
+const FLEX_ROUNDS = 'AD_HOC';
+const FEED_IN$1 = 'FEED_IN';
+const COMPASS = 'COMPASS';
+const OLYMPIC = 'OLYMPIC';
+const KNOCKOUT = 'SINGLE_ELIMINATION';
+const SINGLE_ELIMINATION = 'SINGLE_ELIMINATION';
+const DOUBLE_ELIMINATION = 'DOUBLE_ELIMINATION';
+const FIRST_MATCH_LOSER_CONSOLATION = 'FIRST_MATCH_LOSER_CONSOLATION';
+const FIRST_ROUND_LOSER_CONSOLATION = 'FIRST_ROUND_LOSER_CONSOLATION';
+const LUCKY_DRAW = 'LUCKY_DRAW';
+const CURTIS = 'CURTIS_CONSOLATION';
+const CURTIS_CONSOLATION = 'CURTIS_CONSOLATION';
+const FICSF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
+const FEED_IN_CHAMPIONSHIP_TO_SF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
+const FICQF = 'FEED_IN_CHAMPIONSHIP_TO_QF';
+const FEED_IN_CHAMPIONSHIP_TO_QF = 'FEED_IN_CHAMPIONSHIP_TO_QF';
+const FICR16 = 'FEED_IN_CHAMPIONSHIP_TO_R16';
+const FEED_IN_CHAMPIONSHIP_TO_R16 = 'FEED_IN_CHAMPIONSHIP_TO_R16';
+const MFIC = 'MODIFIED_FEED_IN_CHAMPIONSHIP';
+const MODIFIED_FEED_IN_CHAMPIONSHIP = 'MODIFIED_FEED_IN_CHAMPIONSHIP';
+const FEED_IN_CHAMPIONSHIP = 'FEED_IN_CHAMPIONSHIP';
+const DOUBLE_ROUND_ROBIN = 'DOUBLE_ROUND_ROBIN';
+const ROUND_ROBIN = 'ROUND_ROBIN';
+const ROUND_ROBIN_WITH_PLAYOFF = 'ROUND_ROBIN_WITH_PLAYOFF';
+const DECIDER = 'DECIDER';
+const BACKDRAW = 'BACKDRAW';
+const COMPASS_ATTRIBUTES = {
+    0: { name: 'East', abbreviation: 'E' },
+    '0-1': { name: 'West', abbreviation: 'W' },
+    '0-2': { name: 'North', abbreviation: 'N' },
+    '0-3': { name: 'Northeast', abbreviation: 'NE' },
+    '0-1-1': { name: 'South', abbreviation: 'S' },
+    '0-1-2': { name: 'Southwest', abbreviation: 'SW' },
+    '0-2-1': { name: 'Northwest', abbreviation: 'NW' },
+    '0-1-1-1': { name: 'Southeast', abbreviation: 'SE' },
+};
+const OLYMPIC_ATTRIBUTES = {
+    0: { name: 'East', abbreviation: 'E' },
+    '0-1': { name: 'West', abbreviation: 'W' },
+    '0-2': { name: 'North', abbreviation: 'N' },
+    '0-1-1': { name: 'South', abbreviation: 'S' },
+};
+const WIN_RATIO$1 = 'WIN_RATIO';
+const ROUND_OUTCOME = 'ROUND_OUTCOME';
+const MULTI_STRUCTURE_DRAWS = [
+    COMPASS,
+    CURTIS,
+    FEED_IN_CHAMPIONSHIP_TO_QF,
+    FEED_IN_CHAMPIONSHIP_TO_R16,
+    FEED_IN_CHAMPIONSHIP_TO_SF,
+    FEED_IN_CHAMPIONSHIP,
+    FICQF,
+    FICR16,
+    FICSF,
+    FIRST_MATCH_LOSER_CONSOLATION,
+    FIRST_ROUND_LOSER_CONSOLATION,
+    LUCKY_DRAW,
+    MODIFIED_FEED_IN_CHAMPIONSHIP,
+    OLYMPIC,
+    PLAY_OFF,
+    ROUND_ROBIN_WITH_PLAYOFF,
+];
+const generatedDrawTypes = [
+    AD_HOC,
+    COMPASS,
+    CURTIS,
+    DOUBLE_ELIMINATION,
+    FEED_IN_CHAMPIONSHIP_TO_QF,
+    FEED_IN_CHAMPIONSHIP_TO_R16,
+    FEED_IN_CHAMPIONSHIP_TO_SF,
+    FEED_IN_CHAMPIONSHIP,
+    FEED_IN$1,
+    FIRST_MATCH_LOSER_CONSOLATION,
+    FIRST_ROUND_LOSER_CONSOLATION,
+    LUCKY_DRAW,
+    MODIFIED_FEED_IN_CHAMPIONSHIP,
+    OLYMPIC,
+    PLAY_OFF,
+    ROUND_ROBIN,
+    ROUND_ROBIN_WITH_PLAYOFF,
+    SINGLE_ELIMINATION,
+];
+const drawDefinitionConstants = {
+    MAIN,
+    QUALIFYING,
+    CONSOLATION,
+    ITEM,
+    CONTAINER,
+    FIRST_MATCHUP,
+    WINNER,
+    LOSER,
+    AD_HOC,
+    FEED_IN: FEED_IN$1,
+    FLEX_ROUNDS,
+    COMPASS,
+    PLAY_OFF,
+    OLYMPIC,
+    KNOCKOUT,
+    SINGLE_ELIMINATION,
+    DOUBLE_ELIMINATION,
+    CURTIS,
+    FICSF,
+    FICQF,
+    FICR16,
+    MFIC,
+    VOLUNTARY_CONSOLATION,
+    FIRST_MATCH_LOSER_CONSOLATION,
+    FIRST_ROUND_LOSER_CONSOLATION,
+    MODIFIED_FEED_IN_CHAMPIONSHIP,
+    FEED_IN_CHAMPIONSHIP_TO_R16,
+    FEED_IN_CHAMPIONSHIP_TO_QF,
+    FEED_IN_CHAMPIONSHIP_TO_SF,
+    FEED_IN_CHAMPIONSHIP,
+    LUCKY_DRAW,
+    ROUND_ROBIN_WITH_PLAYOFF,
+    ROUND_ROBIN,
+    DECIDER,
+    BACKDRAW,
+    COMPASS_ATTRIBUTES,
+    OLYMPIC_ATTRIBUTES,
+    DRAW,
+    RANDOM,
+    TOP_DOWN,
+    BOTTOM_UP,
+    WATERFALL,
+    WIN_RATIO: WIN_RATIO$1,
+    ROUND_OUTCOME,
+    MULTI_STRUCTURE_DRAWS,
+    generatedDrawTypes,
+    stageOrder: stageOrder$1,
+    finishOrder,
+    AGGREGATE_EVENT_STRUCTURES,
+    FINISHING_POSITIONS,
+};
+
 const TOURNAMENT_RECORDS = 'tournamentRecords';
 const POLICY_DEFINITIONS = 'policyDefinitions';
 const TOURNAMENT_RECORD = 'tournamentRecord';
@@ -1827,6 +2024,7 @@ const ROUND_NUMBER = 'roundNumber';
 const STRUCTURE_ID = 'structureId';
 const PARTICIPANT = 'participant';
 const MATCHUP_IDS = 'matchUpIds';
+const ENTRY_STAGE = 'entryStage';
 const POLICY_TYPE = 'policyType';
 const STRUCTURES = 'structures';
 const MATCHUP_ID = 'matchUpId';
@@ -1861,6 +2059,7 @@ const ONE_OF = '_oneOf';
 const validators = {
     [EVENT_TYPE]: (value) => [SINGLES$1, DOUBLES$1, TEAM$2].includes(value),
     [ONLINE_RESOURCE]: (value) => intersection(Object.keys(value), [RESOURCE_SUB_TYPE, RESOURCE_TYPE, IDENTIFIER]).length === 3,
+    [ENTRY_STAGE]: (value) => validStages.includes(value),
 };
 const errors = {
     [TOURNAMENT_RECORDS]: MISSING_TOURNAMENT_RECORDS,
@@ -2471,6 +2670,7 @@ const POLICY_TYPE_PARTICIPANT = 'participant';
 const POLICY_TYPE_PROGRESSION = 'progression';
 const POLICY_TYPE_SCHEDULING = 'scheduling';
 const POLICY_TYPE_AVOIDANCE = 'avoidance';
+const POLICY_TYPE_PRIVACY = 'participant';
 const POLICY_TYPE_DISPLAY = 'display';
 const POLICY_TYPE_SCORING = 'scoring';
 const POLICY_TYPE_SEEDING = 'seeding';
@@ -2490,6 +2690,7 @@ const policyConstants = {
     POLICY_TYPE_SCHEDULING,
     POLICY_TYPE_AVOIDANCE,
     POLICY_TYPE_DISPLAY,
+    POLICY_TYPE_PRIVACY,
     POLICY_TYPE_FEED_IN,
     POLICY_TYPE_SCORING,
     POLICY_TYPE_SEEDING,
@@ -3061,184 +3262,6 @@ const matchUpStatusConstants = {
     WALKOVER: WALKOVER$2,
 };
 
-const MAIN = 'MAIN';
-const QUALIFYING = 'QUALIFYING';
-const CONSOLATION = 'CONSOLATION';
-const VOLUNTARY_CONSOLATION = 'VOLUNTARY_CONSOLATION';
-const PLAY_OFF = 'PLAY_OFF';
-const validStages = [MAIN, QUALIFYING, CONSOLATION, PLAY_OFF, VOLUNTARY_CONSOLATION];
-const stageOrder$1 = {
-    [QUALIFYING]: 1,
-    [MAIN]: 2,
-    [PLAY_OFF]: 3,
-    [CONSOLATION]: 3,
-    [VOLUNTARY_CONSOLATION]: 4,
-};
-const FINISHING_POSITIONS = 'finishingPositions';
-const AGGREGATE_EVENT_STRUCTURES = 'aggregateEventStructures';
-const finishOrder = {
-    [MAIN]: 1,
-    [PLAY_OFF]: 2,
-    [CONSOLATION]: 3,
-    [QUALIFYING]: 4,
-    [VOLUNTARY_CONSOLATION]: 5,
-};
-const aggregateOrder = {
-    [PLAY_OFF]: 1,
-    [MAIN]: 2,
-    [CONSOLATION]: 3,
-    [QUALIFYING]: 4,
-    [VOLUNTARY_CONSOLATION]: 5,
-};
-const CLUSTER = 'CLUSTER';
-const SEPARATE = 'SEPARATE';
-const WATERFALL = 'WATERFALL';
-const ITEM = 'ITEM';
-const CONTAINER = 'CONTAINER';
-const DRAW = 'DRAW';
-const RANDOM = 'RANDOM';
-const TOP_DOWN = 'TOP_DOWN';
-const BOTTOM_UP = 'BOTTOM_UP';
-const POSITION = 'POSITION';
-const WINNER = 'WINNER';
-const LOSER = 'LOSER';
-const FIRST_MATCHUP = 'FIRST_MATCHUP';
-const AD_HOC = 'AD_HOC';
-const FLEX_ROUNDS = 'AD_HOC';
-const FEED_IN$1 = 'FEED_IN';
-const COMPASS = 'COMPASS';
-const OLYMPIC = 'OLYMPIC';
-const KNOCKOUT = 'SINGLE_ELIMINATION';
-const SINGLE_ELIMINATION = 'SINGLE_ELIMINATION';
-const DOUBLE_ELIMINATION = 'DOUBLE_ELIMINATION';
-const FIRST_MATCH_LOSER_CONSOLATION = 'FIRST_MATCH_LOSER_CONSOLATION';
-const FIRST_ROUND_LOSER_CONSOLATION = 'FIRST_ROUND_LOSER_CONSOLATION';
-const LUCKY_DRAW = 'LUCKY_DRAW';
-const CURTIS = 'CURTIS_CONSOLATION';
-const CURTIS_CONSOLATION = 'CURTIS_CONSOLATION';
-const FICSF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
-const FEED_IN_CHAMPIONSHIP_TO_SF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
-const FICQF = 'FEED_IN_CHAMPIONSHIP_TO_QF';
-const FEED_IN_CHAMPIONSHIP_TO_QF = 'FEED_IN_CHAMPIONSHIP_TO_QF';
-const FICR16 = 'FEED_IN_CHAMPIONSHIP_TO_R16';
-const FEED_IN_CHAMPIONSHIP_TO_R16 = 'FEED_IN_CHAMPIONSHIP_TO_R16';
-const MFIC = 'MODIFIED_FEED_IN_CHAMPIONSHIP';
-const MODIFIED_FEED_IN_CHAMPIONSHIP = 'MODIFIED_FEED_IN_CHAMPIONSHIP';
-const FEED_IN_CHAMPIONSHIP = 'FEED_IN_CHAMPIONSHIP';
-const DOUBLE_ROUND_ROBIN = 'DOUBLE_ROUND_ROBIN';
-const ROUND_ROBIN = 'ROUND_ROBIN';
-const ROUND_ROBIN_WITH_PLAYOFF = 'ROUND_ROBIN_WITH_PLAYOFF';
-const DECIDER = 'DECIDER';
-const BACKDRAW = 'BACKDRAW';
-const COMPASS_ATTRIBUTES = {
-    0: { name: 'East', abbreviation: 'E' },
-    '0-1': { name: 'West', abbreviation: 'W' },
-    '0-2': { name: 'North', abbreviation: 'N' },
-    '0-3': { name: 'Northeast', abbreviation: 'NE' },
-    '0-1-1': { name: 'South', abbreviation: 'S' },
-    '0-1-2': { name: 'Southwest', abbreviation: 'SW' },
-    '0-2-1': { name: 'Northwest', abbreviation: 'NW' },
-    '0-1-1-1': { name: 'Southeast', abbreviation: 'SE' },
-};
-const OLYMPIC_ATTRIBUTES = {
-    0: { name: 'East', abbreviation: 'E' },
-    '0-1': { name: 'West', abbreviation: 'W' },
-    '0-2': { name: 'North', abbreviation: 'N' },
-    '0-1-1': { name: 'South', abbreviation: 'S' },
-};
-const WIN_RATIO$1 = 'WIN_RATIO';
-const ROUND_OUTCOME = 'ROUND_OUTCOME';
-const MULTI_STRUCTURE_DRAWS = [
-    COMPASS,
-    CURTIS,
-    FEED_IN_CHAMPIONSHIP_TO_QF,
-    FEED_IN_CHAMPIONSHIP_TO_R16,
-    FEED_IN_CHAMPIONSHIP_TO_SF,
-    FEED_IN_CHAMPIONSHIP,
-    FICQF,
-    FICR16,
-    FICSF,
-    FIRST_MATCH_LOSER_CONSOLATION,
-    FIRST_ROUND_LOSER_CONSOLATION,
-    LUCKY_DRAW,
-    MODIFIED_FEED_IN_CHAMPIONSHIP,
-    OLYMPIC,
-    PLAY_OFF,
-    ROUND_ROBIN_WITH_PLAYOFF,
-];
-const generatedDrawTypes = [
-    AD_HOC,
-    COMPASS,
-    CURTIS,
-    DOUBLE_ELIMINATION,
-    FEED_IN_CHAMPIONSHIP_TO_QF,
-    FEED_IN_CHAMPIONSHIP_TO_R16,
-    FEED_IN_CHAMPIONSHIP_TO_SF,
-    FEED_IN_CHAMPIONSHIP,
-    FEED_IN$1,
-    FIRST_MATCH_LOSER_CONSOLATION,
-    FIRST_ROUND_LOSER_CONSOLATION,
-    LUCKY_DRAW,
-    MODIFIED_FEED_IN_CHAMPIONSHIP,
-    OLYMPIC,
-    PLAY_OFF,
-    ROUND_ROBIN,
-    ROUND_ROBIN_WITH_PLAYOFF,
-    SINGLE_ELIMINATION,
-];
-const drawDefinitionConstants = {
-    MAIN,
-    QUALIFYING,
-    CONSOLATION,
-    ITEM,
-    CONTAINER,
-    FIRST_MATCHUP,
-    WINNER,
-    LOSER,
-    AD_HOC,
-    FEED_IN: FEED_IN$1,
-    FLEX_ROUNDS,
-    COMPASS,
-    PLAY_OFF,
-    OLYMPIC,
-    KNOCKOUT,
-    SINGLE_ELIMINATION,
-    DOUBLE_ELIMINATION,
-    CURTIS,
-    FICSF,
-    FICQF,
-    FICR16,
-    MFIC,
-    VOLUNTARY_CONSOLATION,
-    FIRST_MATCH_LOSER_CONSOLATION,
-    FIRST_ROUND_LOSER_CONSOLATION,
-    MODIFIED_FEED_IN_CHAMPIONSHIP,
-    FEED_IN_CHAMPIONSHIP_TO_R16,
-    FEED_IN_CHAMPIONSHIP_TO_QF,
-    FEED_IN_CHAMPIONSHIP_TO_SF,
-    FEED_IN_CHAMPIONSHIP,
-    LUCKY_DRAW,
-    ROUND_ROBIN_WITH_PLAYOFF,
-    ROUND_ROBIN,
-    DECIDER,
-    BACKDRAW,
-    COMPASS_ATTRIBUTES,
-    OLYMPIC_ATTRIBUTES,
-    DRAW,
-    RANDOM,
-    TOP_DOWN,
-    BOTTOM_UP,
-    WATERFALL,
-    WIN_RATIO: WIN_RATIO$1,
-    ROUND_OUTCOME,
-    MULTI_STRUCTURE_DRAWS,
-    generatedDrawTypes,
-    stageOrder: stageOrder$1,
-    finishOrder,
-    AGGREGATE_EVENT_STRUCTURES,
-    FINISHING_POSITIONS,
-};
-
 function structureSort(a, b, config) {
     const getRoundTarget = (element) => findExtension({ element, name: ROUND_TARGET })?.extension?.value;
     const completed = config?.deprioritizeCompleted;
@@ -3414,9 +3437,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 +3468,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 +11563,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 +11667,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 };
@@ -12708,12 +12740,11 @@ function getStageSpace({ entryStatus = DIRECT_ACCEPTANCE, drawDefinition, stageS
 }
 
 function addDrawEntry(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [ENTRY_STAGE]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const { suppressDuplicateEntries = true, entryStatus = DIRECT_ACCEPTANCE, entryStageSequence, entryStage = MAIN, ignoreStageSpace, drawDefinition, entryPosition, participant, roundTarget, extensions, extension, drawType, event, } = params;
     const stack = 'addDrawEntry';
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!entryStage)
-        return { error: MISSING_STAGE };
     if (drawType !== AD_HOC && !getValidStage({ stage: entryStage, drawDefinition })) {
         return decorateResult({ result: { error: INVALID_STAGE }, stack });
     }
@@ -12794,7 +12825,7 @@ function addDrawEntry(params) {
 }
 function addDrawEntries$1(params) {
     const stack = 'addDrawEntries';
-    const { suppressDuplicateEntries = true, entryStatus = DIRECT_ACCEPTANCE, stage = MAIN, autoEntryPositions = true, ignoreStageSpace, participantIds, drawDefinition, stageSequence, roundTarget, extension, event, } = params;
+    const { suppressDuplicateEntries = true, entryStatus = DIRECT_ACCEPTANCE, autoEntryPositions = true, ignoreStageSpace, participantIds, drawDefinition, stageSequence, stage = MAIN, roundTarget, extension, event, } = params;
     if (!stage)
         return { error: MISSING_STAGE };
     if (!drawDefinition)
@@ -17497,117 +17528,26 @@ function resequenceStructures({ drawDefinition }) {
     return { ...SUCCESS };
 }
 
-function addTimeItem(params) {
-    const { duplicateValues = true, creationTime = true, removePriorValues, timeItem } = params;
-    if (!timeItem)
-        return { error: MISSING_TIME_ITEM };
-    const element = deriveElement(params);
-    if (element.error)
-        return element;
-    const validTimeItem = isObject(timeItem) && isString(timeItem.itemType) && Object.keys(timeItem).includes('itemValue');
-    if (!validTimeItem)
-        return { error: INVALID_TIME_ITEM };
-    if (!element.timeItems) {
-        element.timeItems = [];
-    }
-    else if (hasEquivalentTimeItem({ element, duplicateValues, timeItem })) {
-        return { ...SUCCESS };
-    }
-    if (timeItem.itemSubTypes && !timeItem.itemSubTypes.length)
-        delete timeItem.itemSubTypes;
-    if (creationTime) {
-        const createdAt = new Date().toISOString();
-        Object.assign(timeItem, { createdAt });
-    }
-    if (removePriorValues)
-        element.timeItems = element.timeItems.filter(({ itemType }) => timeItem.itemType !== itemType);
-    const doNotAdd = removePriorValues && !timeItem.itemValue;
-    if (!doNotAdd)
-        element.timeItems.push(timeItem);
-    return { ...SUCCESS };
-}
-function hasEquivalentTimeItem({ element, duplicateValues, timeItem }) {
-    const { itemType, itemSubTypes, itemValue } = timeItem;
-    const existingTimeItem = itemType &&
-        getTimeItem({
-            itemSubTypes,
-            itemType,
-            element,
-        })?.timeItem;
-    return (existingTimeItem && JSON.stringify(existingTimeItem?.itemValue) === JSON.stringify(itemValue) && !duplicateValues);
-}
-function addParticipantTimeItem({ creationTime = true, removePriorValues, tournamentRecord, duplicateValues, participantId, timeItem, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    const result = findTournamentParticipant({ tournamentRecord, participantId });
-    if (result.error)
-        return result;
-    return addTimeItem({
-        element: result.participant,
-        removePriorValues,
-        duplicateValues,
-        creationTime,
-        timeItem,
-    });
-}
-function addTournamentTimeItem(params) {
-    const { removePriorValues, tournamentRecord, duplicateValues, creationTime, timeItem } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    return addTimeItem({
-        element: tournamentRecord,
-        removePriorValues,
-        duplicateValues,
-        creationTime,
-        timeItem,
-    });
-}
-function addEventTimeItem(params) {
-    const { removePriorValues, duplicateValues, creationTime, timeItem, event } = params;
-    if (!event)
-        return { error: EVENT_NOT_FOUND };
-    return addTimeItem({
-        removePriorValues,
-        duplicateValues,
-        element: event,
-        creationTime,
-        timeItem,
-    });
-}
-
-function attachQualifyingStructure({ tournamentRecord, drawDefinition, structure, link }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    const result = attachQualifying({
+function attachQualifyingStructure(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true, [DRAW_DEFINITION]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, drawDefinition, structure, link } = params;
+    return attachQualifying({
         tournamentId: tournamentRecord.tournamentId,
         drawDefinition,
         structure,
         link,
     });
-    if (result.error)
-        return result;
-    const qualifyingDetails = {
-        structureId: structure.structureId,
-        drawId: drawDefinition.drawId,
-    };
-    const timeItem = {
-        itemType: 'attachQualifyingStructures',
-        itemValue: qualifyingDetails,
-    };
-    addTournamentTimeItem({ tournamentRecord, timeItem });
-    return result;
 }
-function attachQualifying({ drawDefinition, tournamentId, structure, eventId, link }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structure)
-        return { error: MISSING_STRUCTURE };
-    if (!link)
-        return { error: MISSING_TARGET_LINK };
+function attachQualifying(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [DRAW_DEFINITION]: true, [STRUCTURE]: true },
+        { link: true, [OF_TYPE]: OBJECT, [ERROR$1]: MISSING_TARGET_LINK },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, tournamentId, structure, eventId, link } = params;
     const targetStructureId = link.target.structureId;
     const result = findStructure({
         drawDefinition,
@@ -18492,22 +18432,6 @@ function addQualifyingStructure(params) {
     const result = addQualifying(params);
     if (result.error)
         return result;
-    const { qualifyingRoundNumber, qualifyingPositions, targetStructureId, drawDefinition, structureName, matchUpType, drawSize, drawType, } = params;
-    const qualifyingDetails = definedAttributes({
-        drawId: drawDefinition.drawId,
-        qualifyingRoundNumber,
-        qualifyingPositions,
-        targetStructureId,
-        structureName,
-        matchUpType,
-        drawSize,
-        drawType,
-    });
-    const timeItem = {
-        itemType: 'addQualifyingStructures',
-        itemValue: qualifyingDetails,
-    };
-    addTournamentTimeItem({ tournamentRecord, timeItem });
     return result;
 }
 function addQualifying(params) {
@@ -21875,30 +21799,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 +21854,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;
@@ -22892,6 +22820,107 @@ function generateAndPopulatePlayoffStructures(params) {
     };
 }
 
+function getTimeItemValues({ element }) {
+    if (!element)
+        return { error: INVALID_VALUES };
+    if (!element.timeItems)
+        return {};
+    if (!Array.isArray(element.timeItems))
+        return { error: INVALID_VALUES };
+    const mapItem = (key, value) => (a, i) => {
+        if (!i[key])
+            return a;
+        a[i[key]] = i[value];
+        return a;
+    };
+    return element.timeItems.reduce(mapItem('itemType', 'itemValue'), {});
+}
+
+function addTimeItem(params) {
+    const { duplicateValues = true, creationTime = true, removePriorValues, timeItem } = params;
+    if (!timeItem)
+        return { error: MISSING_TIME_ITEM };
+    const element = deriveElement(params);
+    if (element.error)
+        return element;
+    const validTimeItem = isObject(timeItem) && isString(timeItem.itemType) && Object.keys(timeItem).includes('itemValue');
+    if (!validTimeItem)
+        return { error: INVALID_TIME_ITEM };
+    if (!element.timeItems) {
+        element.timeItems = [];
+    }
+    else if (hasEquivalentTimeItem({ element, duplicateValues, timeItem })) {
+        return { ...SUCCESS };
+    }
+    if (timeItem.itemSubTypes && !timeItem.itemSubTypes.length)
+        delete timeItem.itemSubTypes;
+    if (creationTime) {
+        const createdAt = new Date().toISOString();
+        Object.assign(timeItem, { createdAt });
+    }
+    if (removePriorValues)
+        element.timeItems = element.timeItems.filter(({ itemType }) => timeItem.itemType !== itemType);
+    const doNotAdd = removePriorValues && !timeItem.itemValue;
+    if (!doNotAdd)
+        element.timeItems.push(timeItem);
+    return { ...SUCCESS };
+}
+function hasEquivalentTimeItem({ element, duplicateValues, timeItem }) {
+    const { itemType, itemSubTypes, itemValue } = timeItem;
+    const existingTimeItem = itemType &&
+        getTimeItem({
+            itemSubTypes,
+            itemType,
+            element,
+        })?.timeItem;
+    return (existingTimeItem && JSON.stringify(existingTimeItem?.itemValue) === JSON.stringify(itemValue) && !duplicateValues);
+}
+function addParticipantTimeItem({ creationTime = true, removePriorValues, tournamentRecord, duplicateValues, participantId, timeItem, }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    const result = findTournamentParticipant({ tournamentRecord, participantId });
+    if (result.error)
+        return result;
+    return addTimeItem({
+        element: result.participant,
+        removePriorValues,
+        duplicateValues,
+        creationTime,
+        timeItem,
+    });
+}
+function addTournamentTimeItem(params) {
+    const { removePriorValues, tournamentRecord, duplicateValues, creationTime, timeItem } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const result = addTimeItem({
+        element: tournamentRecord,
+        removePriorValues,
+        duplicateValues,
+        creationTime,
+        timeItem,
+    });
+    if (result.error)
+        return result;
+    const timeItemValues = getTimeItemValues({ element: tournamentRecord });
+    addNotice({ topic: MODIFY_TOURNAMENT_DETAIL, payload: { timeItemValues } });
+    return result;
+}
+function addEventTimeItem(params) {
+    const { removePriorValues, duplicateValues, creationTime, timeItem, event } = params;
+    if (!event)
+        return { error: EVENT_NOT_FOUND };
+    return addTimeItem({
+        removePriorValues,
+        duplicateValues,
+        element: event,
+        creationTime,
+        timeItem,
+    });
+}
+
 function attachConsolationStructures(params) {
     return attachStructures({
         ...params,
@@ -33621,7 +33650,7 @@ function getTournamentInfo(params) {
     const { tournamentRecord } = params ?? {};
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    const tournamentInfo = (({ tournamentId, tournamentRank, tournamentStatus, formalName, tournamentName, promotionalName, onlineResources, localTimeZone, startDate, endDate, hostCountryCode, venues, notes, updatedAt, }) => ({
+    const tournamentInfo = (({ tournamentId, tournamentRank, tournamentStatus, formalName, tournamentName, promotionalName, onlineResources, localTimeZone, activeDates, startDate, endDate, hostCountryCode, venues, notes, updatedAt, }) => ({
         tournamentId,
         tournamentRank,
         tournamentStatus,
@@ -33630,6 +33659,7 @@ function getTournamentInfo(params) {
         promotionalName,
         onlineResources,
         localTimeZone,
+        activeDates,
         startDate,
         endDate,
         hostCountryCode,
@@ -33654,9 +33684,11 @@ function getTournamentInfo(params) {
                 eventInfo.push(info);
         }
     }
+    tournamentInfo.timeItemValues = getTimeItemValues({ element: tournamentRecord });
+    tournamentInfo.publishState = publishState?.tournament;
     tournamentInfo.eventInfo = eventInfo;
     return {
-        tournamentInfo: makeDeepCopy(tournamentInfo, false, true),
+        tournamentInfo: makeDeepCopy(definedAttributes(tournamentInfo), false, true),
         ...SUCCESS,
     };
 }
@@ -34608,6 +34640,7 @@ var query$5 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData
 };
 
@@ -35257,13 +35290,54 @@ function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentReco
     return { profileRounds, segmentedRounds };
 }
 
+function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
+    if (!Array.isArray(courtsData))
+        return { error: INVALID_VALUES };
+    const maxCourtOrder = courtsData?.reduce((order, court) => {
+        const matchUps = court.matchUps || [];
+        const courtOrder = Math.max(0, ...matchUps.map((m) => m.schedule.courtOrder || 0));
+        return courtOrder > order ? courtOrder : order;
+    }, 1);
+    const rowsCount = minRowsCount ? Math.max(minRowsCount, maxCourtOrder) : maxCourtOrder;
+    const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
+        matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
+            const courtInfo = courtsData[courtIndex];
+            const { courtId, venueId } = courtInfo;
+            return {
+                schedule: {
+                    courtOrder: rowIndex + 1,
+                    venueId,
+                    courtId,
+                },
+            };
+        }),
+    }));
+    courtsData.forEach((courtInfo, i) => {
+        for (const matchUp of courtInfo.matchUps) {
+            const courtOrder = matchUp.schedule?.courtOrder;
+            if (courtOrder) {
+                rowBuilder[courtOrder - 1].matchUps[i] = matchUp;
+            }
+        }
+    });
+    return {
+        courtPrefix,
+        rows: rowBuilder.map((row, i) => Object.assign({ rowId: `rowId-${i + 1}` }, ...row.matchUps.map((matchUp, i) => ({
+            [`${courtPrefix}${i}`]: matchUp,
+        })))),
+    };
+}
+
 var query$4 = {
     __proto__: null,
+    courtGridRows: courtGridRows,
+    findVenue: findVenue,
     getPersonRequests: getPersonRequests,
     getProfileRounds: getProfileRounds,
     getScheduledRoundsDetails: getScheduledRoundsDetails,
     getSchedulingProfile: getSchedulingProfile,
-    getSchedulingProfileIssues: getSchedulingProfileIssues
+    getSchedulingProfileIssues: getSchedulingProfileIssues,
+    publicFindCourt: publicFindCourt
 };
 
 function getEntriesAndSeedsCount({ policyDefinitions, drawDefinition, drawSize, drawId, event, stage, }) {
@@ -35762,44 +35836,6 @@ function scheduledSortedMatchUps({ schedulingProfile, matchUps = [] }) {
     return sortedMatchUps;
 }
 
-function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
-    if (!Array.isArray(courtsData))
-        return { error: INVALID_VALUES };
-    const maxCourtOrder = courtsData?.reduce((order, court) => {
-        const matchUps = court.matchUps || [];
-        const courtOrder = Math.max(0, ...matchUps.map((m) => m.schedule.courtOrder || 0));
-        return courtOrder > order ? courtOrder : order;
-    }, 1);
-    const rowsCount = minRowsCount ? Math.max(minRowsCount, maxCourtOrder) : maxCourtOrder;
-    const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
-        matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
-            const courtInfo = courtsData[courtIndex];
-            const { courtId, venueId } = courtInfo;
-            return {
-                schedule: {
-                    courtOrder: rowIndex + 1,
-                    venueId,
-                    courtId,
-                },
-            };
-        }),
-    }));
-    courtsData.forEach((courtInfo, i) => {
-        for (const matchUp of courtInfo.matchUps) {
-            const courtOrder = matchUp.schedule?.courtOrder;
-            if (courtOrder) {
-                rowBuilder[courtOrder - 1].matchUps[i] = matchUp;
-            }
-        }
-    });
-    return {
-        courtPrefix,
-        rows: rowBuilder.map((row, i) => Object.assign({ rowId: `rowId-${i + 1}` }, ...row.matchUps.map((matchUp, i) => ({
-            [`${courtPrefix}${i}`]: matchUp,
-        })))),
-    };
-}
-
 function eventMatchUps(params) {
     let { participants: tournamentParticipants, contextContent, participantMap } = params;
     const { tournamentAppliedPolicies, scheduleVisibilityFilters, participantsProfile, afterRecoveryTimes, policyDefinitions, useParticipantMap, tournamentRecord, usePublishState, contextFilters, matchUpFilters, contextProfile, nextMatchUps, tournamentId, inContext, context, event, } = params;
@@ -35991,11 +36027,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 +36041,7 @@ function competitionScheduleMatchUps(params) {
             contextFilters: params.contextFilters,
         }).completedMatchUps
         : [];
-    if (usePublishState && (!tournamentPublishStatus || !Object.keys(tournamentPublishStatus).length)) {
+    if (usePublishState && !tournamentPublishStatus?.orderOfPlay?.published) {
         return {
             completedMatchUps: allCompletedMatchUps,
             dateMatchUps: [],
@@ -37254,6 +37288,7 @@ var index$f = {
     checkValidEntries: checkValidEntries,
     compareTieFormats: compareTieFormats,
     competitionScheduleMatchUps: competitionScheduleMatchUps,
+    courtGridRows: courtGridRows,
     credits: credits,
     drawMatchUps: drawMatchUps,
     eventMatchUps: eventMatchUps,
@@ -37261,6 +37296,7 @@ var index$f = {
     filterParticipants: filterParticipants,
     findDrawDefinition: publicFindDrawDefinition,
     findExtension: findExtension,
+    findVenue: findVenue,
     getAllDrawMatchUps: getAllDrawMatchUps,
     getAllEventData: getAllEventData,
     getAllStructureMatchUps: getAllStructureMatchUps,
@@ -37345,6 +37381,7 @@ var index$f = {
     getTournamentInfo: getTournamentInfo,
     getTournamentPenalties: getTournamentPenalties,
     getTournamentPersons: getTournamentPersons,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
     getValidGroupSizes: getValidGroupSizes,
@@ -37358,6 +37395,7 @@ var index$f = {
     participantScaleItem: participantScaleItem,
     participantScheduledMatchUps: participantScheduledMatchUps,
     positionActions: positionActions,
+    publicFindCourt: publicFindCourt,
     publicFindVenue: publicFindVenue,
     tallyParticipantResults: tallyParticipantResults,
     tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
@@ -38588,7 +38626,16 @@ function deleteDrawDefinitions(params) {
             return { error: result.error };
     }
     if (auditTrail.length) {
-        addNotice({ topic: AUDIT, payload: auditTrail });
+        if (hasTopic(AUDIT)) {
+            const tournamentId = tournamentRecord.tournamentId;
+            addNotice({ topic: AUDIT, payload: { tournamentId, detail: auditTrail } });
+            const result = getTimeItem({ element: event, itemType: DRAW_DELETIONS });
+            const itemValue = (result?.timeItem?.itemValue || 0) + 1;
+            addTimeItem({ element: event, timeItem: { itemType: DRAW_DELETIONS, itemValue }, removePriorValues: true });
+        }
+        else {
+            addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
+        }
     }
     if (matchUpIds.length) {
         deleteMatchUpsNotice({
@@ -38597,7 +38644,6 @@ function deleteDrawDefinitions(params) {
         });
     }
     drawIds.forEach((drawId) => deleteDrawNotice({ drawId }));
-    addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
     if (autoPublish && publishedDrawsDeleted) {
         const result = publishEvent({
             ...params.eventDataParams,
@@ -38841,6 +38887,23 @@ function removeTiming({ event }) {
     return removeEventExtension({ event, name: SCHEDULE_TIMING });
 }
 
+const MON = 'MON';
+const TUE = 'TUE';
+const WED = 'WED';
+const THU = 'THU';
+const FRI = 'FRI';
+const SAT = 'SAT';
+const SUN = 'SUN';
+const weekdayConstants = { MON, TUE, WED, THU, FRI, SAT, SUN };
+
+function isValidWeekdaysValue(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (unique(value).length !== value.length)
+        return false;
+    return value.every((v) => Object.keys(weekdayConstants).includes(v));
+}
+
 function setEventStartDate({ tournamentRecord, event, startDate }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -38865,7 +38928,8 @@ function setEventStartDate({ tournamentRecord, event, startDate }) {
     event.startDate = startDate;
     return { ...SUCCESS };
 }
-function setEventEndDate({ tournamentRecord, event, endDate }) {
+function setEventEndDate(params) {
+    const { tournamentRecord, event, endDate } = params;
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     if (!event)
@@ -38889,23 +38953,42 @@ function setEventEndDate({ tournamentRecord, event, endDate }) {
     event.endDate = endDate;
     return { ...SUCCESS };
 }
-function setEventDates({ tournamentRecord, event, startDate, endDate }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!event)
-        return { error: MISSING_EVENT };
-    if (!startDate && !endDate)
-        return { error: MISSING_VALUE, info: 'missing date' };
-    if (startDate && !dateValidation.test(startDate))
-        return { error: INVALID_DATE };
-    if (endDate && !dateValidation.test(endDate))
-        return { error: INVALID_DATE };
+function setEventDates(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true, event: true },
+        {
+            [VALIDATE]: (value) => dateValidation.test(value),
+            [INVALID]: INVALID_DATE,
+            startDate: false,
+            endDate: false,
+        },
+        {
+            [VALIDATE]: (value) => value.every((d) => dateValidation.test(d)),
+            [INVALID]: INVALID_DATE,
+            activeDates: false,
+        },
+        {
+            [VALIDATE]: isValidWeekdaysValue,
+            weekdays: false,
+        },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, activeDates, weekdays, event, startDate, endDate } = params;
     if (startDate && endDate) {
         const newStartDate = new Date(extractDate(startDate)).getTime();
         const newEndDate = new Date(extractDate(endDate)).getTime();
         if (newStartDate > newEndDate)
             return { error: INVALID_VALUES };
     }
+    if (activeDates) {
+        const start = startDate || tournamentRecord.startDate;
+        const end = endDate || tournamentRecord.endDate;
+        const validStart = !start || activeDates.every((d) => new Date(d) >= new Date(start));
+        const validEnd = !end || activeDates.every((d) => new Date(d) <= new Date(end));
+        if (!validStart || !validEnd)
+            return { error: INVALID_DATE };
+    }
     if (startDate) {
         const result = setEventStartDate({ tournamentRecord, event, startDate });
         if (result.error)
@@ -38916,6 +38999,10 @@ function setEventDates({ tournamentRecord, event, startDate, endDate }) {
         if (result.error)
             return result;
     }
+    if (activeDates)
+        event.activeDates = activeDates;
+    if (weekdays)
+        event.weekdays = weekdays;
     return { ...SUCCESS };
 }
 function getTournamentDates(tournamentRecord) {
@@ -39478,13 +39565,14 @@ function removeSeeding({ tournamentRecord, drawDefinition, entryStatuses, scaleN
     });
 }
 
-function deleteEvents({ removePairParticipants, tournamentRecord, eventIds }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!tournamentRecord.events)
-        return { error: EVENT_NOT_FOUND };
-    if (!Array.isArray(eventIds))
-        return { error: MISSING_VALUE, info: mustBeAnArray('drawIds') };
+function deleteEvents(params) {
+    const paramCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true },
+        { eventIds: true, [OF_TYPE]: ARRAY },
+    ]);
+    if (paramCheck.error)
+        return paramCheck;
+    const { removePairParticipants, tournamentRecord, eventIds } = params;
     const auditTrail = [];
     const deletedEventDetails = [];
     const activePairParticipantIds = [];
@@ -39525,12 +39613,17 @@ function deleteEvents({ removePairParticipants, tournamentRecord, eventIds }) {
     }
     checkAndUpdateSchedulingProfile({ tournamentRecord });
     if (auditTrail.length) {
-        addNotice({ topic: AUDIT, payload: auditTrail });
-        const timeItem = {
-            itemType: DELETE_EVENTS,
-            itemValue: deletedEventDetails,
-        };
-        addTournamentTimeItem({ tournamentRecord, timeItem });
+        if (hasTopic(AUDIT)) {
+            const tournamentId = tournamentRecord.tournamentId;
+            addNotice({ topic: AUDIT, payload: { type: DELETE_EVENTS, tournamentId, detail: auditTrail } });
+        }
+        else {
+            const timeItem = {
+                itemValue: deletedEventDetails,
+                itemType: DELETE_EVENTS,
+            };
+            addTournamentTimeItem({ tournamentRecord, timeItem });
+        }
     }
     return { ...SUCCESS };
 }
@@ -39542,8 +39635,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 +39725,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 +39753,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, }) {
@@ -45990,7 +46167,16 @@ function auditAutoScheduling({ autoSchedulingAudit, tournamentRecords }) {
         itemValue,
     };
     for (const tournamentRecord of Object.values(tournamentRecords)) {
-        addTournamentTimeItem({ tournamentRecord, timeItem });
+        const tournamentId = tournamentRecord.tournamentId;
+        if (hasTopic(AUDIT)) {
+            addNotice({
+                payload: { type: AUTO_SCHEDULING_AUDIT, tournamentId, detail: itemValue },
+                topic: AUDIT,
+            });
+        }
+        else {
+            addTournamentTimeItem({ tournamentRecord, timeItem });
+        }
     }
 }
 
@@ -51796,39 +51982,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 +52048,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 +52155,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 +52172,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, }) {
@@ -52486,16 +52718,18 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
             [flight.drawId]: flight.flightNumber,
         }));
         const flightMap = flightNumbers && Object.assign({}, ...flightNumbers);
-        const drawDeletionsCount = extensions?.find((x) => x.name === DRAW_DELETIONS)?.value?.length || 0;
+        const drawDeletionsExtension = extensions?.find((x) => x.name === DRAW_DELETIONS);
+        const drawDeletionsTimeItem = eventTimeItems?.find((x) => x.itemType === DRAW_DELETIONS);
+        const drawDeletionsCount = drawDeletionsExtension?.value?.length || drawDeletionsTimeItem?.itemValue || 0;
         const mapValues = Object.values(flightMap);
         const minFlightNumber = flightMap && Math.min(...mapValues);
         const eventSeedingBasis = getSeedingBasis(eventTimeItems);
         eventStructureReports[eventId] = {
+            seedingBasis: eventSeedingBasis ? JSON.stringify(eventSeedingBasis) : undefined,
             totalPositionManipulations: 0,
             maxPositionManipulations: 0,
             generatedDrawsCount: 0,
             drawDeletionsCount,
-            seedingBasis: eventSeedingBasis ? JSON.stringify(eventSeedingBasis) : undefined,
             tournamentId,
             eventId,
         };
@@ -53805,16 +54039,13 @@ var mutate$3 = {
     calculateScheduleTimes: calculateScheduleTimes,
     clearMatchUpSchedule: clearMatchUpSchedule,
     clearScheduledMatchUps: clearScheduledMatchUps,
-    courtGridRows: courtGridRows,
     findMatchUpFormatTiming: findMatchUpFormatTiming,
-    findVenue: findVenue,
     generateBookings: generateBookings,
     generateVirtualCourts: generateVirtualCourts,
     matchUpScheduleChange: matchUpScheduleChange,
     modifyMatchUpFormatTiming: modifyMatchUpFormatTiming,
     proAutoSchedule: proAutoSchedule,
     proConflicts: proConflicts,
-    publicFindCourt: publicFindCourt,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,
@@ -55795,19 +56026,39 @@ function updateCourtAvailability({ tournamentRecord }) {
 }
 
 function setTournamentDates(params) {
-    const { tournamentRecord, startDate, endDate } = params;
+    const { tournamentRecord, startDate, endDate, activeDates, weekdays } = params;
     const paramsCheck = checkRequiredParameters(params, [
         { tournamentRecord: true },
         {
             [VALIDATE]: (value) => dateValidation.test(value),
-            [ANY_OF]: { startDate: false, endDate: false },
             [INVALID]: INVALID_DATE,
+            startDate: false,
+            endDate: false,
+        },
+        {
+            [VALIDATE]: (value) => value.every((d) => dateValidation.test(d)),
+            [INVALID]: INVALID_DATE,
+            activeDates: false,
+        },
+        {
+            [VALIDATE]: isValidWeekdaysValue,
+            weekdays: false,
         },
     ]);
     if (paramsCheck.error)
         return paramsCheck;
     if (endDate && startDate && new Date(endDate) < new Date(startDate))
         return { error: INVALID_VALUES };
+    if (endDate && startDate && new Date(startDate) > new Date(endDate))
+        return { error: INVALID_VALUES };
+    if (activeDates) {
+        const start = startDate || tournamentRecord.startDate;
+        const end = endDate || tournamentRecord.endDate;
+        const validStart = !start || activeDates.every((d) => new Date(d) >= new Date(start));
+        const validEnd = !end || activeDates.every((d) => new Date(d) <= new Date(end));
+        if (!validStart || !validEnd)
+            return { error: INVALID_DATE };
+    }
     let checkScheduling;
     if ((startDate && tournamentRecord.startDate && new Date(startDate) > new Date(tournamentRecord.startDate)) ||
         (endDate && tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate))) {
@@ -55837,23 +56088,33 @@ function setTournamentDates(params) {
     if (endDate && tournamentRecord.startDate && new Date(endDate) < new Date(tournamentRecord.startDate)) {
         tournamentRecord.startDate = endDate;
     }
+    if (activeDates)
+        tournamentRecord.activeDates = activeDates;
+    if (weekdays)
+        tournamentRecord.weekdays = weekdays;
     const unscheduledMatchUpIds = checkScheduling && removeInvalidScheduling({ tournamentRecord })?.unscheduledMatchUpIds;
     updateCourtAvailability({ tournamentRecord });
     addNotice({
-        payload: {
+        payload: definedAttributes({
             parentOrganisation: tournamentRecord.parentOrganisation,
             tournamentId: tournamentRecord.tournamentId,
+            activeDates,
             startDate,
+            weekdays,
             endDate,
-        },
+        }),
         topic: MODIFY_TOURNAMENT_DETAIL,
     });
     return { ...SUCCESS, unscheduledMatchUpIds, datesAdded, datesRemoved };
 }
 function setTournamentStartDate({ tournamentRecord, startDate }) {
+    if (!startDate)
+        return { error: INVALID_DATE };
     return setTournamentDates({ tournamentRecord, startDate });
 }
 function setTournamentEndDate({ tournamentRecord, endDate }) {
+    if (!endDate)
+        return { error: INVALID_DATE };
     return setTournamentDates({ tournamentRecord, endDate });
 }
 function removeInvalidScheduling({ tournamentRecord }) {
@@ -58643,7 +58904,8 @@ var index = {
     tournamentConstants: tournamentConstants,
     upcomingMatchUpStatuses: upcomingMatchUpStatuses,
     validMatchUpStatuses: validMatchUpStatuses,
-    venueConstants: venueConstants
+    venueConstants: venueConstants,
+    weekdayConstants: weekdayConstants
 };
 
 exports.activeMatchUpStatuses = activeMatchUpStatuses;
@@ -58721,4 +58983,5 @@ exports.validMatchUpStatuses = validMatchUpStatuses;
 exports.venueConstants = venueConstants;
 exports.venueGovernor = index$2;
 exports.version = factoryVersion;
+exports.weekdayConstants = weekdayConstants;
 //# sourceMappingURL=tods-competition-factory.development.cjs.js.map