tods-competition-factory 2.0.31 → 2.0.33

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.31';
+    return '2.0.33';
 }
 
 function isFunction(obj) {
@@ -2704,7 +2704,6 @@ function findExtension({ discover, element, name, ...params }) {
 
 const ACTIVE_SUSPENSION = 'activeSuspension';
 const APPLIED_POLICIES = 'appliedPolicies';
-const AUDIT_POSITION_ACTIONS = 'positionActions';
 const CONTEXT = 'context';
 const DELEGATED_OUTCOME = 'delegatedOutcome';
 const DISABLED = 'disabled';
@@ -2723,6 +2722,7 @@ const LINKED_TOURNAMENTS = 'linkedTournamentsIds';
 const MATCHUP_HISTORY = 'matchUpHistory';
 const PARTICIPANT_REPRESENTATIVES = 'participantRepresentatives';
 const PERSON_REQUESTS = 'personRequests';
+const POSITION_ACTIONS = 'positionActions';
 const RANKING_POINTS = 'rankingPoints';
 const ROUND_TARGET = 'roundTarget';
 const SCHEDULE_LIMITS = 'scheduleLimits';
@@ -2735,7 +2735,6 @@ const TIE_FORMAT_MODIFICATIONS = 'tieFormatModification';
 const extensionConstants = {
     ACTIVE_SUSPENSION,
     APPLIED_POLICIES,
-    AUDIT_POSITION_ACTIONS,
     CONTEXT,
     DELEGATED_OUTCOME,
     DISABLED,
@@ -2753,6 +2752,7 @@ const extensionConstants = {
     MATCHUP_HISTORY,
     PARTICIPANT_REPRESENTATIVES,
     PERSON_REQUESTS,
+    POSITION_ACTIONS,
     RANKING_POINTS,
     ROUND_TARGET,
     SCHEDULE_LIMITS,
@@ -3094,6 +3094,7 @@ 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';
@@ -3618,9 +3619,12 @@ function conditionallyDisableLinkPositioning({ drawPositions, structure }) {
     });
 }
 
-function addPositionActionTelemetry({ drawDefinition, positionAction }) {
+function addPositionActionTelemetry(params) {
+    const { appliedPolicies, positionAction, drawDefinition } = params;
+    if (appliedPolicies?.audit?.[POSITION_ACTIONS] === false)
+        return;
     const { extension } = findExtension({
-        name: AUDIT_POSITION_ACTIONS,
+        name: POSITION_ACTIONS,
         element: drawDefinition,
     });
     const existingValue = Array.isArray(extension?.value) ? extension?.value ?? [] : [];
@@ -3642,8 +3646,8 @@ function addPositionActionTelemetry({ drawDefinition, positionAction }) {
         }
     }
     const updatedExtension = {
-        name: AUDIT_POSITION_ACTIONS,
         value: existingValue.concat(positionAction),
+        name: POSITION_ACTIONS,
     };
     addExtension({ element: drawDefinition, extension: updatedExtension });
 }
@@ -5607,9 +5611,23 @@ function findTournamentParticipant(params) {
     return { error: PARTICIPANT_NOT_FOUND };
 }
 
-function getTimeItem({ returnPreviousValues, itemSubTypes, itemType, element, }) {
-    if (!element)
-        return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
+function deriveElement(params) {
+    const { tournamentRecord, participantId } = params;
+    if (participantId) {
+        const result = findTournamentParticipant({ tournamentRecord, participantId });
+        return result.participant ?? result;
+    }
+    const element = params.element || params.drawDefinition || params.event || params.tournamentRecord;
+    if (element)
+        return element;
+    return { error: MISSING_VALUE };
+}
+
+function getTimeItem(params) {
+    const { returnPreviousValues, itemSubTypes, itemType } = params;
+    const element = deriveElement(params);
+    if (element.error)
+        return element;
     if (itemSubTypes && !Array.isArray(itemSubTypes))
         return { error: INVALID_VALUES, context: { itemSubTypes } };
     if (!Array.isArray(element.timeItems))
@@ -6357,6 +6375,7 @@ const ASSIGN_COURT = 'SCHEDULE.ASSIGNMENT.COURT';
 const COURT_ORDER = 'SCHEDULE.COURT.ORDER';
 const SCHEDULED_DATE = 'SCHEDULE.DATE';
 const COMPLETED_DATE = 'COMPLETED.DATE';
+const HOME_PARTICIPANT_ID = 'HOME_PARTICIPANT_ID';
 const ASSIGN_OFFICIAL = 'SCHEDULE.ASSIGN.OFFICIAL';
 const SCHEDULED_TIME = 'SCHEDULE.TIME.SCHEDULED';
 const START_TIME = 'SCHEDULE.TIME.START';
@@ -6711,7 +6730,7 @@ function matchUpAssignedCourtId({ visibilityThreshold, timeStamp, schedule, matc
         : schedule;
 }
 
-function matchUpAssignedVenueId({ visibilityThreshold, timeStamp, schedule, matchUp, }) {
+function matchUpAssignedVenueId({ visibilityThreshold, timeStamp, schedule, matchUp }) {
     const { itemValue: venueId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
         timeItems: matchUp?.timeItems || [],
         itemType: ASSIGN_VENUE,
@@ -7147,6 +7166,17 @@ function findEvent(params) {
     };
 }
 
+function getHomeParticipantId({ visibilityThreshold, timeStamp, schedule, matchUp }) {
+    const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: HOME_PARTICIPANT_ID,
+        visibilityThreshold,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { homeParticipantId }
+        : schedule;
+}
+
 function getMatchUpScheduleDetails(params) {
     let event = params.event;
     let matchUpType = params.matchUpType;
@@ -7180,12 +7210,13 @@ function getMatchUpScheduleDetails(params) {
     if ((!eventIds || eventIds.includes(matchUp.eventId)) && (!drawIds || drawIds.includes(matchUp.drawId))) {
         const scheduleSource = { matchUp, visibilityThreshold };
         const { allocatedCourts } = matchUpAllocatedCourts(scheduleSource);
+        const { homeParticipantId } = getHomeParticipantId(scheduleSource);
         const { scheduledTime } = scheduledMatchUpTime(scheduleSource);
+        const { timeModifiers } = matchUpTimeModifiers(scheduleSource);
         let { scheduledDate } = scheduledMatchUpDate(scheduleSource);
         const { venueId } = matchUpAssignedVenueId(scheduleSource);
         const { courtId } = matchUpAssignedCourtId(scheduleSource);
         const { courtOrder } = matchUpCourtOrder(scheduleSource);
-        const { timeModifiers } = matchUpTimeModifiers(scheduleSource);
         let timeAfterRecovery, averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes, typeChangeTimeAfterRecovery;
         const eventType = matchUp.matchUpType ?? matchUpType;
         if (scheduleTiming && scheduledTime && afterRecoveryTimes && eventType) {
@@ -7243,6 +7274,7 @@ function getMatchUpScheduleDetails(params) {
             scheduledTime,
             isoDateString,
             allocatedCourts,
+            homeParticipantId,
             timeModifiers,
             venueAbbreviation,
             venueName,
@@ -10395,6 +10427,11 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     if (filled && !containsBye) {
         return decorateResult({ result: { error: DRAW_POSITION_ASSIGNED }, stack });
     }
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    }).appliedPolicies ?? {};
     const inContextDrawMatchUps = getAllDrawMatchUps({
         inContext: true,
         drawDefinition,
@@ -10429,6 +10466,7 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
         return successNotice({
             assignedParticipantId,
             isPositionAction,
+            appliedPolicies,
             drawDefinition,
             drawPosition,
             structureId,
@@ -10470,13 +10508,14 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     return successNotice({
         assignedParticipantId,
         isPositionAction,
+        appliedPolicies,
         drawDefinition,
         drawPosition,
         structureId,
         stack,
     });
 }
-function successNotice({ assignedParticipantId, isPositionAction, drawDefinition, drawPosition, structureId, stack }) {
+function successNotice({ assignedParticipantId, isPositionAction, appliedPolicies, drawDefinition, drawPosition, structureId, stack, }) {
     if (isPositionAction) {
         const positionAction = {
             removedParticipantId: assignedParticipantId,
@@ -10484,7 +10523,7 @@ function successNotice({ assignedParticipantId, isPositionAction, drawDefinition
             structureId,
             name: stack,
         };
-        addPositionActionTelemetry({ drawDefinition, positionAction });
+        addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
     }
     return decorateResult({ result: { ...SUCCESS }, stack });
 }
@@ -13540,6 +13579,11 @@ function removeDrawPositionAssignment(params) {
         return decorateResult({ result, stack });
     const { participantId } = result;
     const { drawPosition, event, structureId } = params;
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    }).appliedPolicies ?? {};
     if ([ALTERNATE, WITHDRAWN].includes(entryStatus) && participantId) {
         const { tournamentRecord } = params;
         const { participant } = findTournamentParticipant({
@@ -13601,7 +13645,7 @@ function removeDrawPositionAssignment(params) {
         entryStatus,
         structureId,
     };
-    addPositionActionTelemetry({ drawDefinition, positionAction });
+    addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
     return result;
 }
 
@@ -15178,6 +15222,11 @@ function positionParticipantAction(params) {
     const stack = 'positionParticipantAction';
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    }).appliedPolicies ?? {};
     let { inContextDrawMatchUps, matchUpsMap } = params;
     if (!matchUpsMap) {
         matchUpsMap = getMatchUpsMap({ drawDefinition });
@@ -15211,9 +15260,7 @@ function positionParticipantAction(params) {
         if (!result.success) {
             return decorateResult({ result, stack });
         }
-        return successNotice({
-            removedParticipantId,
-        });
+        return successNotice({ appliedPolicies, removedParticipantId });
     }
     const result = clearDrawPosition({
         inContextDrawMatchUps,
@@ -15240,8 +15287,8 @@ function positionParticipantAction(params) {
     });
     if (!assignResult.success)
         return decorateResult({ result: assignResult, stack });
-    return successNotice({ removedParticipantId });
-    function successNotice({ removedParticipantId }) {
+    return successNotice({ appliedPolicies, removedParticipantId });
+    function successNotice({ appliedPolicies, removedParticipantId }) {
         const { structure } = findStructure({ drawDefinition, structureId });
         conditionallyDisableLinkPositioning({
             drawPositions: [drawPosition],
@@ -15253,7 +15300,7 @@ function positionParticipantAction(params) {
             drawPosition,
             structureId,
         };
-        addPositionActionTelemetry({ drawDefinition, positionAction });
+        addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
         return decorateResult({
             context: { removedParticipantId },
             result: { ...SUCCESS },
@@ -15489,9 +15536,8 @@ function swapDrawPositionAssignments$1({ tournamentRecord, drawDefinition, drawP
         return { error: MISSING_DRAW_DEFINITION };
     if (!structureId)
         return { error: MISSING_STRUCTURE_ID };
-    if (drawPositions?.length !== 2) {
+    if (drawPositions?.length !== 2)
         return { error: INVALID_VALUES, drawPositions };
-    }
     const matchUpsMap = getMatchUpsMap({ drawDefinition });
     const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
         inContext: true,
@@ -15501,6 +15547,11 @@ function swapDrawPositionAssignments$1({ tournamentRecord, drawDefinition, drawP
     const { structure } = findStructure({ drawDefinition, structureId });
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    }).appliedPolicies ?? {};
     let result;
     if (structure.structureType === CONTAINER) {
         result = roundRobinSwap({
@@ -15532,7 +15583,7 @@ function swapDrawPositionAssignments$1({ tournamentRecord, drawDefinition, drawP
         drawPositions,
         structureId,
     };
-    addPositionActionTelemetry({ drawDefinition, positionAction });
+    addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
     modifyPositionAssignmentsNotice({
         tournamentId: tournamentRecord?.tournamentId,
         drawDefinition,
@@ -17653,50 +17704,44 @@ function resequenceStructures({ drawDefinition }) {
 }
 
 function addTimeItem(params) {
-    const { duplicateValues = true, creationTime = true, removePriorValues, timeItem, element } = params;
+    const { duplicateValues = true, creationTime = true, removePriorValues, timeItem } = params;
     if (!timeItem)
         return { error: MISSING_TIME_ITEM };
-    if (!element)
-        return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
-    const timeItemAttributes = timeItem && Object.keys(timeItem);
-    const requiredAttributes = ['itemType', 'itemValue'];
-    const validTimeItem = requiredAttributes.filter((attribute) => timeItemAttributes.includes(attribute)).length ===
-        requiredAttributes.length;
+    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 {
-        const { itemType, itemSubTypes, itemValue } = timeItem;
-        const existingTimeItem = itemType &&
-            getTimeItem({
-                itemSubTypes,
-                itemType,
-                element,
-            })?.timeItem;
-        if (existingTimeItem &&
-            JSON.stringify(existingTimeItem?.itemValue) === JSON.stringify(itemValue) &&
-            !duplicateValues) {
-            return { ...SUCCESS };
-        }
+    else if (hasEquivalentTimeItem({ element, duplicateValues, timeItem })) {
+        return { ...SUCCESS };
     }
-    if (timeItem.itemSubTypes && !timeItem.itemSubTypes.length) {
+    if (timeItem.itemSubTypes && !timeItem.itemSubTypes.length)
         delete timeItem.itemSubTypes;
-    }
     if (creationTime) {
         const createdAt = new Date().toISOString();
         Object.assign(timeItem, { createdAt });
     }
-    if (removePriorValues) {
+    if (removePriorValues)
         element.timeItems = element.timeItems.filter(({ itemType }) => timeItem.itemType !== itemType);
-    }
     const doNotAdd = removePriorValues && !timeItem.itemValue;
-    if (!doNotAdd) {
+    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 };
@@ -38229,10 +38274,8 @@ function deleteDrawDefinitions(params) {
             matchUpIds,
         });
     }
-    drawIds.forEach((drawId) => {
-        deleteDrawNotice({ drawId });
-    });
-    addDrawDeletionTelemetry({ event, deletedDrawsDetail, auditData });
+    drawIds.forEach((drawId) => deleteDrawNotice({ drawId }));
+    addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
     if (autoPublish && publishedDrawsDeleted) {
         const result = publishEvent({
             drawIdsToRemove: drawIds,
@@ -38245,15 +38288,17 @@ function deleteDrawDefinitions(params) {
     }
     return { ...SUCCESS };
 }
-function addDrawDeletionTelemetry({ event, deletedDrawsDetail, auditData }) {
+function addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData }) {
+    if (appliedPolicies?.audit?.[DRAW_DELETIONS] === false)
+        return;
     const { extension } = findExtension({
         name: DRAW_DELETIONS,
         element: event,
     });
     const deletionData = { ...auditData, deletedDrawsDetail };
     const updatedExtension = {
-        name: DRAW_DELETIONS,
         value: Array.isArray(extension?.value) ? extension?.value.concat(deletionData) : [deletionData],
+        name: DRAW_DELETIONS,
     };
     addExtension({ element: event, extension: updatedExtension });
 }
@@ -39167,25 +39212,25 @@ function deleteEvents({ removePairParticipants, tournamentRecord, eventIds }) {
     return { ...SUCCESS };
 }
 
-function modifyEvent({ tournamentRecord, eventUpdates, eventId, event }) {
+function modifyEvent(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true, eventId: true, event: true },
+        { eventUpdates: true, _ofType: OBJECT },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, eventUpdates, event } = params;
     const stack = 'modifyEvent';
-    if (!tournamentRecord)
-        return decorateResult({
-            result: { error: MISSING_TOURNAMENT_RECORD },
-            stack,
-        });
-    if (!isString(eventId))
-        return decorateResult({
-            result: { error: MISSING_EVENT },
-            context: { eventId },
-            stack,
-        });
-    if (!isObject(eventUpdates))
-        return decorateResult({
-            result: { error: INVALID_VALUES },
-            context: { eventUpdates },
-            stack,
+    if (eventUpdates.startDate || eventUpdates.endDate) {
+        const result = setEventDates({
+            startDate: eventUpdates.startDate,
+            endDate: eventUpdates.endDate,
+            tournamentRecord,
+            event,
         });
+        if (result.error)
+            return decorateResult({ result, stack });
+    }
     const enteredParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => {
         const status = entryStatus;
@@ -42616,30 +42661,21 @@ function scoreModification(params) {
     return decorateResult({ result, stack });
 }
 
-function getProjectedDualWinningSide({ drawDefinition, matchUpStatus, matchUpsMap, winningSide, dualMatchUp, tieFormat, structure, matchUp, event, score, }) {
-    const projectedDualMatchUp = makeDeepCopy(dualMatchUp, undefined, true);
-    for (const tieMatchUp of projectedDualMatchUp?.tieMatchUps || []) {
-        if (tieMatchUp.matchUpId === matchUp.matchUpId) {
-            tieMatchUp.winningSide = winningSide;
-            tieMatchUp.score = score;
-            if (!checkScoreHasValue({ score }) && !matchUpStatus) {
-                Object.assign(tieMatchUp, { ...toBePlayed });
-            }
-            else if (matchUpStatus) {
-                tieMatchUp.matchUpStatus = matchUpStatus;
-            }
-        }
-    }
-    tieFormat = tieFormat ?? resolveTieFormat({ matchUp, structure, drawDefinition, event })?.tieFormat;
-    const { winningSide: projectedWinningSide } = generateTieMatchUpScore({
-        matchUp: projectedDualMatchUp,
+function setMatchUpHomeParticipantId(params) {
+    const { disableNotice = true, homeParticipantId, removePriorValues, tournamentRecord, drawDefinition, matchUpId, } = params;
+    const timeItem = {
+        itemValue: homeParticipantId,
+        itemType: HOME_PARTICIPANT_ID,
+    };
+    return addMatchUpTimeItem({
+        duplicateValues: false,
+        removePriorValues,
+        tournamentRecord,
         drawDefinition,
-        matchUpsMap,
-        structure,
-        tieFormat,
-        event,
+        disableNotice,
+        matchUpId,
+        timeItem,
     });
-    return { projectedWinningSide };
 }
 
 function addMatchUpScheduledTime(params) {
@@ -42739,6 +42775,28 @@ function addMatchUpTimeModifiers({ removePriorValues, tournamentRecord, drawDefi
     });
 }
 
+function addMatchUpScheduledDate({ scheduledDate: dateToSchedule, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, }) {
+    if (!matchUpId)
+        return { error: MISSING_MATCHUP_ID };
+    const validDate = dateToSchedule && dateValidation.test(dateToSchedule);
+    if (dateToSchedule && !validDate)
+        return { error: INVALID_DATE };
+    const scheduledDate = extractDate(dateToSchedule);
+    const timeItem = {
+        itemValue: scheduledDate,
+        itemType: SCHEDULED_DATE,
+    };
+    return addMatchUpTimeItem({
+        duplicateValues: false,
+        removePriorValues,
+        tournamentRecord,
+        drawDefinition,
+        disableNotice,
+        matchUpId,
+        timeItem,
+    });
+}
+
 function allocateTeamMatchUpCourts({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, courtDayDate, matchUpId, courtIds, }) {
     if (!tournamentRecord && !tournamentRecords)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -42866,14 +42924,16 @@ function timeDate(value, scheduledDate) {
     const date = extractDate(value) || extractDate(scheduledDate) || formatDate(new Date());
     return new Date(`${date}T${time}`).getTime();
 }
-function addMatchUpScheduleItems({ errorOnAnachronism = false, checkChronology = true, matchUpDependencies, inContextMatchUps, removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, drawMatchUps, matchUpId, schedule, event, }) {
-    if (!schedule)
-        return { error: MISSING_VALUE, info: 'Missing schedule' };
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
+function addMatchUpScheduleItems(params) {
     const stack = 'addMatchUpScheduleItems';
+    const paramsCheck = checkRequiredParameters(params, [
+        { drawDefinition: true, matchUpId: true },
+        { schedule: true, [OF_TYPE]: OBJECT },
+    ], stack);
+    if (paramsCheck.error)
+        return paramsCheck;
+    let { matchUpDependencies, inContextMatchUps } = params;
+    const { errorOnAnachronism = false, checkChronology = true, removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, drawMatchUps, matchUpId, schedule, event, } = params;
     let matchUp, warning;
     if (!drawMatchUps) {
         const result = findDrawMatchUp({ drawDefinition, event, matchUpId });
@@ -42884,7 +42944,7 @@ function addMatchUpScheduleItems({ errorOnAnachronism = false, checkChronology =
     else {
         matchUp = drawMatchUps.find((drawMatchUp) => drawMatchUp.matchUpId === matchUpId);
     }
-    const { endTime, courtId, courtIds, courtOrder, resumeTime, scheduledDate, scheduledTime, startTime, stopTime, timeModifiers, venueId, } = schedule;
+    const { endTime, courtId, courtIds, courtOrder, resumeTime, homeParticipantId, scheduledDate, scheduledTime, startTime, stopTime, timeModifiers, venueId, } = schedule;
     if (checkChronology && (!matchUpDependencies || !inContextMatchUps)) {
         ({ matchUpDependencies, matchUps: inContextMatchUps } = getMatchUpDependencies({
             drawDefinition,
@@ -43054,6 +43114,16 @@ function addMatchUpScheduleItems({ errorOnAnachronism = false, checkChronology =
         if (result?.error)
             return decorateResult({ result, stack, context: { timeModifiers } });
     }
+    if (isString(homeParticipantId)) {
+        setMatchUpHomeParticipantId({
+            disableNotice: true,
+            homeParticipantId,
+            removePriorValues,
+            tournamentRecord,
+            drawDefinition,
+            matchUpId,
+        });
+    }
     if (!disableNotice) {
         modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
@@ -43065,27 +43135,6 @@ function addMatchUpScheduleItems({ errorOnAnachronism = false, checkChronology =
     }
     return warning ? { ...SUCCESS, warnings: [warning] } : { ...SUCCESS };
 }
-function addMatchUpScheduledDate({ scheduledDate: dateToSchedule, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, }) {
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
-    const validDate = dateToSchedule && dateValidation.test(dateToSchedule);
-    if (dateToSchedule && !validDate)
-        return { error: INVALID_DATE };
-    const scheduledDate = extractDate(dateToSchedule);
-    const timeItem = {
-        itemValue: scheduledDate,
-        itemType: SCHEDULED_DATE,
-    };
-    return addMatchUpTimeItem({
-        duplicateValues: false,
-        removePriorValues,
-        tournamentRecord,
-        drawDefinition,
-        disableNotice,
-        matchUpId,
-        timeItem,
-    });
-}
 function addMatchUpCourtOrder({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, courtOrder, matchUpId, }) {
     if (!matchUpId)
         return { error: MISSING_MATCHUP_ID };
@@ -43299,6 +43348,32 @@ function addMatchUpResumeTime({ removePriorValues, tournamentRecord, drawDefinit
     }
 }
 
+function getProjectedDualWinningSide({ drawDefinition, matchUpStatus, matchUpsMap, winningSide, dualMatchUp, tieFormat, structure, matchUp, event, score, }) {
+    const projectedDualMatchUp = makeDeepCopy(dualMatchUp, undefined, true);
+    for (const tieMatchUp of projectedDualMatchUp?.tieMatchUps || []) {
+        if (tieMatchUp.matchUpId === matchUp.matchUpId) {
+            tieMatchUp.winningSide = winningSide;
+            tieMatchUp.score = score;
+            if (!checkScoreHasValue({ score }) && !matchUpStatus) {
+                Object.assign(tieMatchUp, { ...toBePlayed });
+            }
+            else if (matchUpStatus) {
+                tieMatchUp.matchUpStatus = matchUpStatus;
+            }
+        }
+    }
+    tieFormat = tieFormat ?? resolveTieFormat({ matchUp, structure, drawDefinition, event })?.tieFormat;
+    const { winningSide: projectedWinningSide } = generateTieMatchUpScore({
+        matchUp: projectedDualMatchUp,
+        drawDefinition,
+        matchUpsMap,
+        structure,
+        tieFormat,
+        event,
+    });
+    return { projectedWinningSide };
+}
+
 function swapWinnerLoser(params) {
     const { tournamentRecord, inContextMatchUp, structure, drawDefinition } = params;
     const matchUpRoundNumber = inContextMatchUp.roundNumber;
@@ -46797,6 +46872,11 @@ function postalCodeMocks({ count = 1, participantsCount = 32 } = {}) {
     return { postalCodes };
 }
 
+function genParticipantId({ idPrefix, participantType, index, uuids }) {
+    const type = participantType === INDIVIDUAL ? 'I' : 'P' ;
+    return idPrefix ? `${idPrefix}-${type}-${index}` : uuids?.pop() || UUID();
+}
+
 function generateAddress(addressAttributes) {
     const { cities, states, postalCodes, nationalityCode, participantIndex } = addressAttributes;
     return {
@@ -47294,11 +47374,6 @@ function nameMocks({ nameRoot = 'TEAM', count = 1 } = {}) {
     return { names };
 }
 
-function genParticipantId({ idPrefix, participantType, index, uuids }) {
-    const type = participantType === INDIVIDUAL ? 'I' : 'P' ;
-    return idPrefix ? `${idPrefix}-${type}-${index}` : uuids?.pop() || UUID();
-}
-
 function generateParticipants(params) {
     let { rankingRange, scaledParticipantsCount, } = params;
     const { ratingsParameters: ratingsParameters$1 = ratingsParameters, valuesInstanceLimit, consideredDate, category, nationalityCodesCount, nationalityCodeType, nationalityCodes, participantsCount = 32, participantType, personIds, idPrefix, uuids, personExtensions, addressProps, gendersCount, matchUpType, personData, sex, inContext, withISO2, withIOC, scaleAllParticipants, } = params;
@@ -47551,12 +47626,13 @@ function addScaleItem({ scaleValue: itemValue, participant, eventType, scaleType
     }
 }
 
-function processTieFormat({ alternatesCount = 0, tieFormatName, tieFormat, drawSize }) {
+function processTieFormat(params) {
+    const { alternatesCount = 0, tieFormatName, drawSize } = params;
     let maxDoublesCount = 0, maxSinglesCount = 0;
     let singlesMatchUpTotal = 0, doublesMatchUpTotal = 0;
     const categories = {};
     const genders = { [MALE]: 0, [FEMALE]: 0, [MIXED]: 0, [OTHER$2]: 0, [ANY]: 0 };
-    tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({ namedFormat: tieFormatName });
+    const tieFormat = isObject(params.tieFormat) ? params.tieFormat : tieFormatDefaults({ namedFormat: tieFormatName });
     tieFormat?.collectionDefinitions?.filter(Boolean).forEach((collectionDefinition) => {
         const { category, collectionId, matchUpType, matchUpCount, gender } = collectionDefinition;
         if ([MALE, FEMALE].includes(gender)) {
@@ -47709,12 +47785,12 @@ function addTournamentParticipants({ participantsProfile, tournamentRecord, even
     });
     const teamKey = participantsProfile?.teamKey;
     const participants = generateParticipants({
-        uuids,
-        ...participantsProfile,
         consideredDate: startDate,
+        ...participantsProfile,
         participantsCount,
         participantType,
         gendersCount,
+        uuids,
     }).participants;
     let addedCount = 0;
     let result = addParticipants({ tournamentRecord, participants });
@@ -48699,7 +48775,7 @@ function generateEventWithDraw(params) {
     const eventId = drawProfileCopy.eventId || UUID();
     const eventType = drawProfile.eventType || drawProfile.matchUpType || SINGLES$1;
     const participantType = eventType === DOUBLES$1 ? PAIR : INDIVIDUAL;
-    const tieFormat = (typeof drawProfile.tieFormat === 'object' && drawProfile.tieFormat) ||
+    const tieFormat = (isObject(drawProfile.tieFormat) && drawProfile.tieFormat) ||
         (eventType === TEAM &&
             tieFormatDefaults({
                 event: { eventId, category, gender },
@@ -49353,7 +49429,7 @@ function courtsAdd({ courtNameRoot = 'Court', dateAvailability = [], venueAbbrev
     return { ...SUCCESS, courts: makeDeepCopy(courtRecords) };
 }
 
-function generateVenues({ tournamentRecord, venueProfiles, uuids }) {
+function generateVenues({ tournamentRecord, ignoreExistingVenues, venueProfiles, uuids }) {
     const { startDate, endDate } = tournamentRecord;
     const venueIds = [];
     for (const [index, venueProfile] of venueProfiles.entries()) {
@@ -49364,8 +49440,11 @@ function generateVenues({ tournamentRecord, venueProfiles, uuids }) {
             venueId,
         };
         const result = addVenue({ tournamentRecord, venue: newVenue });
-        if (result.error)
+        if (result.error) {
+            if (ignoreExistingVenues)
+                continue;
             return result;
+        }
         venueIds.push(venueId);
         const dates = generateDateRange(startDate, endDate);
         const generatedDateAvailability = !Array.isArray(dateAvailability) &&
@@ -49374,39 +49453,142 @@ function generateVenues({ tournamentRecord, venueProfiles, uuids }) {
                 startTime,
                 endTime,
             })));
-        const addResult = addCourts({
-            dateAvailability: dateAvailability || generatedDateAvailability,
-            tournamentRecord,
-            courtTimings,
-            courtsCount,
-            courtNames,
-            startTime,
-            idPrefix,
-            courtIds,
-            endTime,
-            venueId,
-            dates,
-        });
-        if (addResult.error)
-            return addResult;
+        if (courtsCount || courtNames) {
+            const addResult = addCourts({
+                dateAvailability: dateAvailability || generatedDateAvailability,
+                tournamentRecord,
+                courtTimings,
+                courtsCount,
+                courtNames,
+                startTime,
+                idPrefix,
+                courtIds,
+                endTime,
+                venueId,
+                dates,
+            });
+            if (addResult.error)
+                return addResult;
+        }
     }
     return venueIds;
 }
 
+function processLeagueProfiles(params) {
+    const { tournamentRecord, leagueProfiles, eventIds, venueIds, drawIds, allUniqueParticipantIds, uuids } = params;
+    let leaguesCount = 0;
+    for (const leagueProfile of leagueProfiles) {
+        const entries = [];
+        const { tieFormatName = COLLEGE_DEFAULT$1, teamProfiles = [], teamsCount = 0, category, idPrefix, gender, } = leagueProfile;
+        const eventName = leagueProfile.leagueName ?? leagueProfile.eventName ?? `League ${leaguesCount + 1}`;
+        const eventId = leagueProfile.leagueId ?? leagueProfile.eventId ?? uuids?.pop() ?? UUID();
+        eventIds.push(eventId);
+        const tieFormat = (isObject(leagueProfile.tieFormat) && leagueProfile.tieFormat) ||
+            tieFormatDefaults({
+                event: { eventId, category, gender },
+                namedFormat: tieFormatName,
+                isMock: params.isMock,
+            }) ||
+            undefined;
+        if (!tieFormat)
+            return { error: MISSING_TIE_FORMAT };
+        const drawSize = Math.max(teamsCount, teamProfiles.length);
+        const teamsRange = generateRange(0, drawSize);
+        const { genders, teamSize } = processTieFormat({ tieFormat, drawSize });
+        const gendersCount = { [FEMALE]: 0, [MIXED]: 0, [OTHER$2]: 0, [MALE]: 0, [ANY]: 0 };
+        Object.keys(genders).forEach((key) => (gendersCount[key] += genders[key]));
+        for (const index of teamsRange) {
+            const teamName = teamProfiles?.[index]?.teamName ?? `Team ${index + 1}`;
+            const teamId = teamProfiles?.[index]?.teamId || uuids?.pop() || UUID();
+            const consideredDate = leagueProfile.startDate ?? params.startDate;
+            const participants = generateParticipants({
+                ...leagueProfile?.participantsProfile,
+                participantsCount: teamSize,
+                consideredDate,
+                gendersCount,
+                category,
+                gender,
+                uuids,
+            }).participants;
+            const individualParticipantIds = participants.map((participant) => participant.participantId);
+            const participantType = TEAM;
+            const teamParticipantId = teamId ??
+                genParticipantId({
+                    participantType,
+                    idPrefix,
+                    index,
+                    uuids,
+                });
+            entries.push({ participantId: teamParticipantId, entryStatus: DIRECT_ACCEPTANCE, entryStage: MAIN });
+            const homeVenueIds = teamProfiles?.[index]?.venueIds ?? [];
+            const teamParticipant = {
+                participantId: teamParticipantId,
+                participantRole: COMPETITOR,
+                participantName: teamName,
+                individualParticipantIds,
+                participantType,
+                homeVenueIds,
+            };
+            homeVenueIds.forEach((venueId) => !venueIds.includes(venueId) && venueIds.push(venueId));
+            allUniqueParticipantIds.push(...individualParticipantIds);
+            allUniqueParticipantIds.push(teamParticipantId);
+            const result = addParticipants({
+                participants: [teamParticipant, ...participants],
+                tournamentRecord,
+            });
+            if (result.error)
+                return result;
+        }
+        const eventType = TEAM;
+        const event = { eventName, entries, eventType, tieFormat, category, eventId, gender };
+        if (!tournamentRecord.events)
+            tournamentRecord.events = [];
+        tournamentRecord.events.push(event);
+        if (entries.length) {
+            const roundsCount = isNumeric(leagueProfile.roundsCount)
+                ? leagueProfile.roundsCount
+                : leagueProfile.roundsCount === DOUBLE_ROUND_ROBIN
+                    ? (drawSize - 1) * 2
+                    : drawSize - 1;
+            const result = generateDrawDefinition({
+                automated: leagueProfile.automated,
+                tournamentRecord,
+                drawType: AD_HOC,
+                roundsCount,
+                drawSize,
+                event,
+            });
+            if (result.error)
+                return result;
+            const { drawDefinition } = result;
+            if (drawDefinition) {
+                const drawId = drawDefinition?.drawId;
+                addDrawDefinition({ drawDefinition, event, suppressNotifications: true });
+                drawIds.push(drawId);
+            }
+        }
+        leaguesCount++;
+    }
+    const venueProfiles = venueIds.map((venueId) => ({ venueId }));
+    generateVenues({ tournamentRecord, ignoreExistingVenues: true, venueProfiles, uuids });
+}
+
 const mockTournamentNames = [
-    'Mock Tournament',
-    'CourtHive Challenge',
-    'Racket Rally',
     'Generated Tournament',
-    'Factory Follies',
+    'CourtHive Challenge',
     'Open Competition',
+    'Factory Follies',
+    'Mock Tournament',
+    'Racket Rally',
 ];
 function generateTournamentRecord(params) {
-    let { tournamentAttributes, startDate, endDate } = params ?? {};
-    const { tournamentName = randomPop(mockTournamentNames), ratingsParameters: ratingsParameters$1 = ratingsParameters, scheduleCompletedMatchUps, tournamentExtensions, matchUpStatusProfile, completeAllMatchUps, participantsProfile, autoEntryPositions, hydrateCollections, randomWinningSide, policyDefinitions, schedulingProfile, periodLength, autoSchedule, eventProfiles, venueProfiles, drawProfiles, uuids, } = params ?? {};
+    let { startDate, endDate } = params ?? {};
+    const { tournamentName = randomPop(mockTournamentNames), ratingsParameters: ratingsParameters$1 = ratingsParameters, tournamentExtensions, policyDefinitions, schedulingProfile, venueProfiles, uuids, } = params ?? {};
     if ((startDate && !isValidDateString(startDate)) || (endDate && !isValidDateString(endDate)))
         return { error: INVALID_DATE };
-    if (eventProfiles && !Array.isArray(eventProfiles))
+    if ((params.leagueProfiles && !Array.isArray(params.leagueProfiles)) ||
+        (params.eventProfiles && !Array.isArray(params.eventProfiles)) ||
+        (params.drawProfiles && !Array.isArray(params.drawProfiles)))
         return { error: INVALID_VALUES };
     if (!startDate) {
         const tournamentDate = new Date();
@@ -49417,15 +49599,14 @@ function generateTournamentRecord(params) {
         const tournamentDate = new Date(startDate);
         endDate = formatDate(tournamentDate.setDate(tournamentDate.getDate() + 7));
     }
-    if (typeof tournamentAttributes !== 'object')
-        tournamentAttributes = {};
     const tournamentRecord = newTournamentRecord({
-        ...tournamentAttributes,
+        ...(params.tournamentAttributes ?? {}),
         tournamentName,
         isMock: true,
         startDate,
         endDate,
     });
+    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles, uuids }) : [];
     if (tournamentExtensions?.length && Array.isArray(tournamentExtensions)) {
         const extensions = tournamentExtensions.filter((extension) => isValidExtension({ extension }));
         if (extensions?.length)
@@ -49439,105 +49620,57 @@ function generateTournamentRecord(params) {
             });
         }
     }
-    const result = addTournamentParticipants({
-        participantsProfile,
-        tournamentRecord,
-        eventProfiles,
-        drawProfiles,
-        startDate,
-        uuids,
-    });
-    if (!result.success)
-        return result;
+    if (!params?.leagueProfiles?.length ||
+        params.eventProfiles?.length ||
+        params.drawProfiles?.length ||
+        params.participantsProfile) {
+        const result = addTournamentParticipants({
+            tournamentRecord,
+            ...params,
+        });
+        if (!result.success)
+            return result;
+    }
     const allUniqueParticipantIds = [], eventIds = [], drawIds = [];
-    if (Array.isArray(drawProfiles)) {
-        let drawIndex = 0;
-        for (const drawProfile of drawProfiles) {
-            let result = generateEventWithDraw({
-                allUniqueParticipantIds,
-                matchUpStatusProfile,
-                completeAllMatchUps,
-                autoEntryPositions,
-                hydrateCollections,
-                participantsProfile,
-                randomWinningSide,
-                ratingsParameters: ratingsParameters$1,
-                tournamentRecord,
-                isMock: true,
-                drawProfile,
-                startDate,
-                drawIndex,
-                uuids,
-            });
-            if (result.error)
-                return result;
-            const { drawId, eventId, event, uniqueParticipantIds } = result;
-            result = addEvent({
-                suppressNotifications: false,
-                internalUse: true,
-                tournamentRecord,
-                event,
-            });
-            if (result.error)
-                return result;
-            if (drawId)
-                drawIds.push(drawId);
-            eventIds.push(eventId);
-            if (uniqueParticipantIds?.length)
-                allUniqueParticipantIds.push(...uniqueParticipantIds);
-            drawIndex += 1;
-        }
+    if (params.leagueProfiles) {
+        const result = processLeagueProfiles({
+            allUniqueParticipantIds,
+            tournamentRecord,
+            ...params,
+            eventIds,
+            venueIds,
+            drawIds,
+        });
+        if (result?.error)
+            return result;
     }
-    if (eventProfiles) {
-        let eventIndex = 0;
-        for (const eventProfile of eventProfiles) {
-            const result = generateEventWithFlights({
-                allUniqueParticipantIds,
-                matchUpStatusProfile,
-                participantsProfile,
-                completeAllMatchUps,
-                autoEntryPositions,
-                hydrateCollections,
-                randomWinningSide,
-                ratingsParameters: ratingsParameters$1,
-                tournamentRecord,
-                eventProfile,
-                eventIndex,
-                startDate,
-                uuids,
-            });
-            if (result.error)
-                return result;
-            const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
-            if (generatedDrawIds)
-                drawIds.push(...generatedDrawIds);
-            eventIds.push(eventId);
-            if (uniqueParticipantIds?.length)
-                allUniqueParticipantIds.push(...uniqueParticipantIds);
-            eventIndex += 1;
-        }
+    if (params.drawProfiles) {
+        const result = processDrawProfiles({
+            allUniqueParticipantIds,
+            ratingsParameters: ratingsParameters$1,
+            tournamentRecord,
+            ...params,
+            eventIds,
+            drawIds,
+        });
+        if (result?.error)
+            return result;
     }
-    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles, uuids }) : [];
-    let scheduledRounds;
-    let schedulerResult = {};
-    if (schedulingProfile) {
-        const result = generateScheduledRounds({
-            schedulingProfile,
+    if (params.eventProfiles) {
+        const result = processEventProfiles({
+            allUniqueParticipantIds,
+            ratingsParameters: ratingsParameters$1,
             tournamentRecord,
+            ...params,
+            eventIds,
+            drawIds,
         });
-        if (result.error)
+        if (result?.error)
             return result;
-        scheduledRounds = result.scheduledRounds;
-        if (autoSchedule) {
-            const { tournamentId } = tournamentRecord;
-            const tournamentRecords = { [tournamentId]: tournamentRecord };
-            schedulerResult = scheduleProfileRounds({
-                scheduleCompletedMatchUps,
-                tournamentRecords,
-                periodLength,
-            });
-        }
     }
+    const { scheduledRounds = undefined, schedulerResult = {} } = schedulingProfile
+        ? scheduleRounds({ ...params, tournamentRecord })
+        : {};
     cycleMutationStatus();
     return definedAttributes({
         ...SUCCESS,
@@ -49549,6 +49682,73 @@ function generateTournamentRecord(params) {
         drawIds,
     });
 }
+function processDrawProfiles(params) {
+    const { tournamentRecord, drawProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
+    let drawIndex = 0;
+    for (const drawProfile of drawProfiles) {
+        let result = generateEventWithDraw({
+            allUniqueParticipantIds,
+            tournamentRecord,
+            drawProfile,
+            drawIndex,
+            ...params,
+        });
+        if (result.error)
+            return result;
+        const { drawId, eventId, event, uniqueParticipantIds } = result;
+        result = addEvent({
+            suppressNotifications: false,
+            internalUse: true,
+            tournamentRecord,
+            event,
+        });
+        if (result.error)
+            return result;
+        if (drawId)
+            drawIds.push(drawId);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds?.length)
+            allUniqueParticipantIds.push(...uniqueParticipantIds);
+        drawIndex += 1;
+    }
+}
+function processEventProfiles(params) {
+    const { eventProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
+    let eventIndex = 0;
+    for (const eventProfile of eventProfiles) {
+        const result = generateEventWithFlights({ ...params, eventIndex, eventProfile });
+        if (result.error)
+            return result;
+        const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
+        if (generatedDrawIds)
+            drawIds.push(...generatedDrawIds);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds?.length)
+            allUniqueParticipantIds.push(...uniqueParticipantIds);
+        eventIndex += 1;
+    }
+}
+function scheduleRounds(params) {
+    const { schedulingProfile, tournamentRecord, autoSchedule, periodLength, scheduleCompletedMatchUps } = params;
+    const result = generateScheduledRounds({
+        schedulingProfile,
+        tournamentRecord,
+    });
+    if (result.error)
+        return result;
+    const scheduledRounds = result.scheduledRounds;
+    if (autoSchedule) {
+        const { tournamentId } = tournamentRecord;
+        const tournamentRecords = { [tournamentId]: tournamentRecord };
+        const schedulerResult = scheduleProfileRounds({
+            scheduleCompletedMatchUps,
+            tournamentRecords,
+            periodLength,
+        });
+        return { schedulerResult, scheduledRounds };
+    }
+    return { scheduledRounds };
+}
 
 var generate$1 = {
     __proto__: null,
@@ -51944,7 +52144,7 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
     };
 }
 function getPositionManipulations({ extensions }) {
-    return extensions?.find(({ name }) => name === AUDIT_POSITION_ACTIONS)?.value?.slice(1);
+    return extensions?.find(({ name }) => name === POSITION_ACTIONS)?.value?.slice(1);
 }
 
 function getVenuesReport({ ignoreDisabled = true, tournamentRecords, tournamentId, venueIds = [], dates = [], }) {
@@ -53119,8 +53319,8 @@ function setMatchUpDailyLimits(params) {
     for (const currentTournamentId of tournamentIds) {
         const tournamentRecord = tournamentRecords[currentTournamentId];
         const result = addExtension({
-            element: tournamentRecord,
             extension: { name: SCHEDULE_LIMITS, value: { dailyLimits } },
+            element: tournamentRecord,
         });
         if (result.error)
             return result;
@@ -53166,6 +53366,7 @@ var mutate$3 = {
     scheduleMatchUps: scheduleMatchUps,
     scheduleProfileRounds: scheduleProfileRounds,
     setMatchUpDailyLimits: setMatchUpDailyLimits,
+    setMatchUpHomeParticipantId: setMatchUpHomeParticipantId,
     setSchedulingProfile: setSchedulingProfile,
     toggleParticipantCheckInState: toggleParticipantCheckInState,
     validateSchedulingProfile: validateSchedulingProfile
@@ -53216,6 +53417,7 @@ var index$5 = {
     scheduleMatchUps: scheduleMatchUps,
     scheduleProfileRounds: scheduleProfileRounds,
     setMatchUpDailyLimits: setMatchUpDailyLimits,
+    setMatchUpHomeParticipantId: setMatchUpHomeParticipantId,
     setSchedulingProfile: setSchedulingProfile,
     toggleParticipantCheckInState: toggleParticipantCheckInState,
     validateSchedulingProfile: validateSchedulingProfile
@@ -53577,14 +53779,16 @@ function getMatchUpChangesArePossible({ check, matchUp }) {
     return { changesArePossible, changes, cannotChangeReaon };
 }
 
-function tieFormatTelemetry({ drawDefinition, auditData }) {
+function tieFormatTelemetry({ appliedPolicies, drawDefinition, auditData }) {
+    if (!appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS])
+        return;
     const { extension } = findExtension({
         name: TIE_FORMAT_MODIFICATIONS,
         element: drawDefinition,
     });
     const updatedExtension = {
-        name: TIE_FORMAT_MODIFICATIONS,
         value: Array.isArray(extension?.value) ? extension?.value.concat(auditData) : [auditData],
+        name: TIE_FORMAT_MODIFICATIONS,
     };
     addExtension({ element: drawDefinition, extension: updatedExtension });
 }
@@ -53790,17 +53994,15 @@ function modifyCollectionDefinition({ updateInProgressMatchUps = false, tourname
     });
     if (!result.error) {
         const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
-        if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
-            const auditData = definedAttributes({
-                collectionDefinition: targetCollectionDefinition,
-                drawId: drawDefinition?.drawId,
-                action: stack,
-                structureId,
-                matchUpId,
-                eventId,
-            });
-            tieFormatTelemetry({ drawDefinition, auditData });
-        }
+        const auditData = definedAttributes({
+            collectionDefinition: targetCollectionDefinition,
+            drawId: drawDefinition?.drawId,
+            action: stack,
+            structureId,
+            matchUpId,
+            eventId,
+        });
+        tieFormatTelemetry({ appliedPolicies, drawDefinition, auditData });
     }
     return decorateResult({ result: { ...result, modifications }, stack });
 }
@@ -53969,17 +54171,15 @@ function removeCollectionGroup({ updateInProgressMatchUps = true, collectionGrou
     });
     if (!result.error) {
         const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
-        if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
-            const auditData = definedAttributes({
-                drawId: drawDefinition?.drawId,
-                collectionGroupNumber,
-                action: stack,
-                structureId,
-                matchUpId,
-                eventId,
-            });
-            tieFormatTelemetry({ drawDefinition, auditData });
-        }
+        const auditData = definedAttributes({
+            drawId: drawDefinition?.drawId,
+            collectionGroupNumber,
+            action: stack,
+            structureId,
+            matchUpId,
+            eventId,
+        });
+        tieFormatTelemetry({ appliedPolicies, drawDefinition, auditData });
     }
     return decorateResult({
         result: { ...result, modifiedCollectionIds },
@@ -54322,17 +54522,15 @@ function removeCollectionDefinition({ updateInProgressMatchUps = true, tieFormat
         return { error: MISSING_DRAW_DEFINITION };
     }
     modifyDrawNotice({ drawDefinition, eventId: event?.eventId });
-    if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
-        const auditData = definedAttributes({
-            drawId: drawDefinition?.drawId,
-            action: stack,
-            collectionId,
-            structureId,
-            matchUpId,
-            eventId,
-        });
-        tieFormatTelemetry({ drawDefinition, auditData });
-    }
+    const auditData = definedAttributes({
+        drawId: drawDefinition?.drawId,
+        action: stack,
+        collectionId,
+        structureId,
+        matchUpId,
+        eventId,
+    });
+    tieFormatTelemetry({ appliedPolicies, drawDefinition, auditData });
     return {
         tieFormat: prunedTieFormat,
         deletedMatchUpIds,
@@ -54578,17 +54776,15 @@ function addCollectionDefinition({ updateInProgressMatchUps = true, collectionDe
     else {
         return { error: MISSING_DRAW_DEFINITION };
     }
-    if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
-        const auditData = definedAttributes({
-            drawId: drawDefinition?.drawId,
-            collectionDefinition,
-            action: stack,
-            structureId,
-            matchUpId,
-            eventId,
-        });
-        tieFormatTelemetry({ drawDefinition, auditData });
-    }
+    const auditData = definedAttributes({
+        drawId: drawDefinition?.drawId,
+        collectionDefinition,
+        action: stack,
+        structureId,
+        matchUpId,
+        eventId,
+    });
+    tieFormatTelemetry({ appliedPolicies, drawDefinition, auditData });
     return {
         tieFormat: prunedTieFormat,
         targetMatchUps,
@@ -55041,9 +55237,9 @@ function setTournamentDates(params) {
     const paramsCheck = checkRequiredParameters(params, [
         { tournamentRecord: true },
         {
+            [VALIDATE]: (value) => dateValidation.test(value),
             [ANY_OF]: { startDate: false, endDate: false },
             [INVALID]: INVALID_DATE,
-            [VALIDATE]: (value) => dateValidation.test(value),
         },
     ]);
     if (paramsCheck.error)