tods-competition-factory 2.1.0 → 2.1.2

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.0';
+    return '2.1.2';
 }
 
 function isFunction(obj) {
@@ -1095,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 };
 }
@@ -1640,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);
 }
@@ -1737,6 +1745,7 @@ var globalState$1 = {
     getTournamentRecords: getTournamentRecords,
     globalLog: globalLog$1,
     handleCaughtError: handleCaughtError,
+    hasTopic: hasTopic,
     removeTournamentRecord: removeTournamentRecord,
     setDeepCopy: setDeepCopy,
     setDevContext: setDevContext,
@@ -1823,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';
@@ -1837,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';
@@ -1871,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,
@@ -2481,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';
@@ -2500,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,
@@ -3071,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;
@@ -12727,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 });
     }
@@ -12813,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)
@@ -17516,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,
@@ -18511,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) {
@@ -22915,6 +22820,110 @@ 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({
+        payload: { timeItemValues, tournamentId: tournamentRecord.tournamentId },
+        topic: MODIFY_TOURNAMENT_DETAIL,
+    });
+    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,
@@ -33644,7 +33653,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,
@@ -33653,6 +33662,7 @@ function getTournamentInfo(params) {
         promotionalName,
         onlineResources,
         localTimeZone,
+        activeDates,
         startDate,
         endDate,
         hostCountryCode,
@@ -33677,10 +33687,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,
     };
 }
@@ -35282,13 +35293,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, }) {
@@ -35787,44 +35839,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;
@@ -37277,6 +37291,7 @@ var index$f = {
     checkValidEntries: checkValidEntries,
     compareTieFormats: compareTieFormats,
     competitionScheduleMatchUps: competitionScheduleMatchUps,
+    courtGridRows: courtGridRows,
     credits: credits,
     drawMatchUps: drawMatchUps,
     eventMatchUps: eventMatchUps,
@@ -37284,6 +37299,7 @@ var index$f = {
     filterParticipants: filterParticipants,
     findDrawDefinition: publicFindDrawDefinition,
     findExtension: findExtension,
+    findVenue: findVenue,
     getAllDrawMatchUps: getAllDrawMatchUps,
     getAllEventData: getAllEventData,
     getAllStructureMatchUps: getAllStructureMatchUps,
@@ -37382,6 +37398,7 @@ var index$f = {
     participantScaleItem: participantScaleItem,
     participantScheduledMatchUps: participantScheduledMatchUps,
     positionActions: positionActions,
+    publicFindCourt: publicFindCourt,
     publicFindVenue: publicFindVenue,
     tallyParticipantResults: tallyParticipantResults,
     tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
@@ -38612,7 +38629,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({
@@ -38621,7 +38647,6 @@ function deleteDrawDefinitions(params) {
         });
     }
     drawIds.forEach((drawId) => deleteDrawNotice({ drawId }));
-    addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
     if (autoPublish && publishedDrawsDeleted) {
         const result = publishEvent({
             ...params.eventDataParams,
@@ -38865,6 +38890,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 };
@@ -38889,7 +38931,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)
@@ -38913,23 +38956,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)
@@ -38940,6 +39002,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) {
@@ -39502,13 +39568,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 = [];
@@ -39549,12 +39616,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 };
 }
@@ -46098,7 +46170,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 });
+        }
     }
 }
 
@@ -52640,16 +52721,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,
         };
@@ -53959,16 +54042,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,
@@ -55949,19 +56029,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))) {
@@ -55991,23 +56091,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 }) {
@@ -58797,7 +58907,8 @@ var index = {
     tournamentConstants: tournamentConstants,
     upcomingMatchUpStatuses: upcomingMatchUpStatuses,
     validMatchUpStatuses: validMatchUpStatuses,
-    venueConstants: venueConstants
+    venueConstants: venueConstants,
+    weekdayConstants: weekdayConstants
 };
 
 exports.activeMatchUpStatuses = activeMatchUpStatuses;
@@ -58875,4 +58986,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