tods-competition-factory 1.6.17 → 1.6.19

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.17";
+  return "1.6.19";
 }
 
 function getObjectTieFormat(obj) {
@@ -23475,8 +23475,9 @@ function getTargetMatchUps({
   return { drawPositions, matchUps, targetMatchUps };
 }
 
-function cleanupLineUps({
+function resetLineUps({
   inContextDrawMatchUps,
+  inheritance = true,
   tournamentRecord,
   drawDefinition,
   matchUpsMap,
@@ -23484,6 +23485,8 @@ function cleanupLineUps({
   structure,
   event
 }) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
   const { drawPositions, matchUps, targetMatchUps } = getTargetMatchUps({
     inContextDrawMatchUps,
     matchUpsMap,
@@ -23499,10 +23502,14 @@ function cleanupLineUps({
           ({ matchUpId }) => matchUpId === inContextMatchUp.matchUpId
         );
         if (matchUp?.sides?.[sideIndex]) {
-          delete matchUp?.sides[sideIndex].lineUp;
+          if (inheritance) {
+            delete matchUp.sides[sideIndex].lineUp;
+          } else {
+            matchUp.sides[sideIndex].lineUp = [];
+          }
           modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
-            context: "cleanupLineUps",
+            context: "resetLineUps",
             eventId: event?.eventId,
             drawDefinition,
             matchUp
@@ -23622,7 +23629,7 @@ function assignDrawPosition$1({
     if (drawPositionIsActive) {
       return decorateResult({ result: { error: DRAW_POSITION_ACTIVE }, stack });
     }
-    cleanupLineUps({
+    resetLineUps({
       assignments: [positionAssignment],
       inContextDrawMatchUps,
       tournamentRecord,
@@ -44527,7 +44534,7 @@ function eliminationParticipantSwap({
   structure.positionAssignments = structure.positionAssignments.map(
     (assignment) => newAssignments[assignment.drawPosition] || assignment
   );
-  cleanupLineUps({
+  resetLineUps({
     inContextDrawMatchUps,
     tournamentRecord,
     drawDefinition,
@@ -44559,7 +44566,7 @@ function roundRobinSwap({
     return { ...SUCCESS };
   if (assignments.filter(({ qualifier }) => qualifier).length === 2)
     return { ...SUCCESS };
-  cleanupLineUps({
+  resetLineUps({
     inContextDrawMatchUps,
     tournamentRecord,
     drawDefinition,
@@ -44590,6 +44597,40 @@ function roundRobinSwap({
   return { ...SUCCESS };
 }
 
+function resetMatchUpLineUps$1({
+  tournamentRecord,
+  drawDefinition,
+  inheritance,
+  matchUpId,
+  event
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const matchUp = findMatchUp$1({
+    drawDefinition,
+    matchUpId
+  })?.matchUp;
+  if (!matchUp?.tieMatchUps)
+    return { error: INVALID_MATCHUP };
+  let modificationsCount = 0;
+  (matchUp.sides || []).forEach((side) => {
+    modificationsCount += 1;
+    if (inheritance) {
+      delete side.lineUp;
+    } else {
+      side.lineUp = [];
+    }
+    modifyMatchUpNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      context: "resetLineUps",
+      eventId: event?.eventId,
+      drawDefinition,
+      matchUp
+    });
+  });
+  return { ...SUCCESS, modificationsCount };
+}
+
 function setSubOrder({
   tournamentRecord,
   drawDefinition,
@@ -44656,6 +44697,7 @@ const positionGovernor = {
   swapDrawPositionAssignments: swapDrawPositionAssignments$1,
   alternateDrawPositionAssignment: alternateDrawPositionAssignment$1,
   resolveDrawPositions,
+  resetMatchUpLineUps: resetMatchUpLineUps$1,
   // probably not part of drawEngine final
   initializeStructureSeedAssignments,
   getNextSeedBlock
@@ -51282,362 +51324,1500 @@ const publishingGovernor = {
   publishOrderOfPlay: publishOrderOfPlay$1
 };
 
-function convertPointEight({ tournament }) {
-  if (!tournament)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const {
-    providerTournamentID: tournamentId,
-    hostCountryCode,
-    tournamentLevel,
-    totalPrizeMoney,
-    tournamentName,
-    extensions,
-    startDate,
-    endDate
-  } = tournament;
-  const tournamentRecord = newTournamentRecord({
-    hostCountryCode,
-    tournamentLevel,
-    totalPrizeMoney,
-    tournamentName,
-    tournamentId,
-    extensions,
-    startDate,
-    endDate
-  });
-  tournamentRecord.events = [];
-  for (const legacyEvent of tournament.events || []) {
-    const {
-      extensions: extensions2,
-      ageCategory,
-      discipline,
-      eventType,
-      eventId,
-      gender,
-      stages
-    } = legacyEvent;
-    const event = {
-      drawDefinitions: deriveDraws(stages),
-      category: { ageCategory },
-      gender: ["M", MALE].includes(gender) && MALE || ["F", FEMALE].includes(gender) && FEMALE || void 0,
-      eventType: ["D", DOUBLES].includes(eventType) && DOUBLES || ["T", TEAM$1].includes(eventType) ? TEAM$1 : SINGLES,
-      extensions: extensions2,
-      discipline,
-      eventId
+function removeCollectionAssignments({
+  collectionPosition,
+  teamParticipantId,
+  dualMatchUpSide,
+  drawDefinition,
+  participantIds,
+  collectionId
+}) {
+  if (!collectionId || !collectionPosition || !Array.isArray(participantIds))
+    return {
+      modifiedLineUp: dualMatchUpSide?.lineUp || [],
+      error: INVALID_VALUES
     };
-    tournamentRecord.events.push(event);
-  }
-  return { ...SUCCESS, tournamentRecord };
-}
-function deriveDraws(stages) {
-  const drawDefinitions = [];
-  for (const legacyStage of stages || []) {
-    const { stageType } = legacyStage;
-    const stage = ["M", MAIN].includes(stageType) && MAIN || ["Q", QUALIFYING].includes(stageType) && QUALIFYING || ["C", CONSOLATION].includes(stageType) && CONSOLATION || ["P", PLAY_OFF].includes(stageType) && PLAY_OFF || void 0;
-    for (const draw of legacyStage.draws || []) {
-      const { drawId, drawSize, matchUps } = draw;
-      const drawDefinition = { stage, drawId, drawSize };
-      drawDefinitions.push(drawDefinition);
-      console.log(
-        matchUps.map(({ roundNumber, roundPosition }) => ({
-          roundNumber,
-          roundPosition
-        })),
-        { draw, drawDefinition }
-      );
+  const lineUp = dualMatchUpSide?.lineUp || getTeamLineUp({
+    participantId: teamParticipantId,
+    drawDefinition
+  })?.lineUp;
+  const previousParticipantIds = [];
+  const assignmentsRemoved = [];
+  const modifiedLineUp = lineUp?.map((teamCompetitor) => {
+    if (!participantIds.includes(teamCompetitor.participantId)) {
+      return teamCompetitor;
     }
-  }
-  return drawDefinitions;
-}
-
-const ABANDONED = "ABANDONED";
-const ACTIVE = "ACTIVE";
-const CANCELLED = "CANCELLED";
-const COMPLETED = "COMPLETED";
-const IN_PROGRESS = "IN_PROGRESS";
-const tournamentConstants = {
-  ABANDONED,
-  ACTIVE,
-  CANCELLED,
-  COMPLETED,
-  IN_PROGRESS
-};
-
-function setTournamentStatus({ tournamentRecord, status }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (status && !Object.keys(tournamentConstants).includes(status))
-    return { error: INVALID_VALUES, info: "Unknown status" };
-  tournamentRecord.tournamentStatus = status;
-  return { ...SUCCESS };
-}
-
-function analyzeDraws({ tournamentRecord }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const drawsAnalysis = {
-    positionsNoOutcomes: [],
-    // all positions assigned and no outcomes
-    canBePruned: [],
-    // partially assigned positions with outcomes => drawSizes can be reduced
-    matchPlay: [],
-    // only first round has active matchUps; some unassigned positions
-    inactive: [],
-    drawAnalysis: {}
-  };
-  const eventsMap = {};
-  const eventDraws = tournamentRecord.events?.map((event) => {
-    const eventId = event.eventId;
-    eventsMap[eventId] = event;
-    return (event?.drawDefinitions || []).map((drawDefinition) => ({
-      drawDefinition,
-      eventId
-    }));
-  }).flat().filter(Boolean);
-  eventDraws.forEach(({ drawDefinition, eventId }) => {
-    let positionsAssignedCount = 0;
-    let matchUpsWithWinningSideCount = 0;
-    let matchUpsNoOutcomeCount = 0;
-    const { allStructuresLinked } = getStructureGroups({ drawDefinition });
-    const event = eventsMap[eventId];
-    const structures = drawDefinition?.structures || [];
-    const structuresData = structures.map((structure) => {
-      const { stage, stageSequence, structureId } = structure;
-      const orderNumber = stageOrder$1[stage];
-      const { inContextStructureMatchUps } = getStructureDrawPositionProfiles({
-        drawDefinition,
-        structure,
-        event
-      });
-      const matchUpsWithWinningSide = inContextStructureMatchUps?.filter(
-        ({ winningSide }) => winningSide
-      );
-      const winningSideCount = matchUpsWithWinningSide.filter(Boolean).length || 0;
-      matchUpsWithWinningSideCount += winningSideCount;
-      matchUpsNoOutcomeCount += inContextStructureMatchUps.length - matchUpsWithWinningSideCount;
-      const maxWinningSideFirstRoundPosition = Math.max(
-        matchUpsWithWinningSide.filter(({ roundNumber }) => roundNumber === 1).map(({ roundPosition }) => roundPosition)
-      );
-      const { positionAssignments } = getPositionAssignments$1({ structure });
-      const positionsAssigned = positionAssignments?.filter(
-        ({ participantId }) => participantId
-      );
-      positionsAssignedCount += positionsAssigned?.length || 0;
-      const unassignedPositionsCount = (positionAssignments?.length || 0) - (positionsAssigned?.length || 0);
-      const { roundMatchUps, roundProfile, roundNumbers, maxMatchUpsCount } = getRoundMatchUps$1({ matchUps: inContextStructureMatchUps });
-      const activeRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => !roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
-      const inactiveRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
-      const inactiveStructure = roundProfile && Object.values(roundProfile).every((profile) => profile.inactiveRound);
-      return {
-        positionsAssignedCount: positionsAssigned?.length || 0,
-        maxWinningSideFirstRoundPosition,
-        unassignedPositionsCount,
-        inactiveStructure,
-        maxMatchUpsCount,
-        inactiveRounds,
-        roundMatchUps,
-        activeRounds,
-        roundNumbers,
-        roundProfile,
-        structureId,
-        stageSequence,
-        orderNumber,
-        stage
-      };
-    });
-    const mainStructure = structuresData.find(
-      (data) => data.orderNumber === 2 && data.stageSequence === 1
-    );
-    const activeStructuresCount = structuresData.filter(
-      ({ inactiveStructure }) => !inactiveStructure
-    ).length;
-    const { links } = getStructureLinks({
-      drawDefinition,
-      structureId: mainStructure.structureId
+    const collectionAssignments = teamCompetitor.collectionAssignments?.filter((assignment) => {
+      const target = assignment.collectionId === collectionId && assignment.collectionPosition === collectionPosition;
+      if (target) {
+        if (assignment.previousParticipantId) {
+          previousParticipantIds.push(assignment.previousParticipantId);
+        }
+        assignmentsRemoved.push({
+          participantId: teamCompetitor.participantId,
+          ...assignment
+        });
+      }
+      return !target;
     });
-    const isMatchPlay = ensureInt(mainStructure.activeRounds[0]) === 1 && mainStructure.activeRounds.length === 1 && activeStructuresCount === 1;
-    const inactiveDraw = structuresData?.every(
-      ({ inactiveStructure }) => inactiveStructure
-    );
-    const canBePruned = !links.length && mainStructure.activeRounds.length && (mainStructure.roundProfile[1].inactiveCount || mainStructure.inactiveRounds.length);
-    const drawId = drawDefinition.drawId;
-    if (positionsAssignedCount && !matchUpsWithWinningSideCount)
-      drawsAnalysis.positionsNoOutcomes.push(drawId);
-    if (inactiveDraw)
-      drawsAnalysis.inactive.push(drawId);
-    if (isMatchPlay)
-      drawsAnalysis.matchPlay.push(drawId);
-    if (canBePruned)
-      drawsAnalysis.canBePruned.push(drawId);
-    const drawAnalysis = {
-      matchUpsWithWinningSideCount,
-      matchUpsNoOutcomeCount,
-      positionsAssignedCount,
-      allStructuresLinked,
-      structuresData,
-      inactiveDraw,
-      isMatchPlay,
-      drawId
+    return {
+      participantId: teamCompetitor.participantId,
+      collectionAssignments
     };
-    drawsAnalysis.drawAnalysis[drawId] = drawAnalysis;
-  });
-  return { ...SUCCESS, drawsAnalysis };
-}
-
-function checkIsDual(tournamentRecord) {
-  const teamParticipants = tournamentRecord.participants?.filter(
-    ({ participantType }) => participantType === TEAM
-  );
-  const twoTeams = teamParticipants?.length === 2;
-  const event = tournamentRecord.events?.length === 1 && tournamentRecord.events[0];
-  const drawDefinition = event?.drawDefinitions?.length === 1 && event.drawDefinitions[0];
-  const structure = drawDefinition?.structures?.length === 1 && drawDefinition.structures[0];
-  const twoDrawPositions = structure?.positionAssignments?.length === 2;
-  return !!(event.tieFormat && twoTeams && twoDrawPositions);
-}
-
-function analyzeTournament({ tournamentRecord }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const { drawsAnalysis } = analyzeDraws({ tournamentRecord });
-  const analysis = {
-    isDual: checkIsDual(tournamentRecord),
-    drawsAnalysis
-  };
-  return { ...SUCCESS, analysis };
+  }).filter(Boolean) || [];
+  return { modifiedLineUp, assignmentsRemoved, previousParticipantIds };
 }
 
-function setTournamentName({
-  tournamentRecord,
-  promotionalName,
-  tournamentName,
-  formalName
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (tournamentName)
-    tournamentRecord.tournamentName = tournamentName;
-  if (promotionalName)
-    tournamentRecord.promotionalName = promotionalName;
-  if (formalName)
-    tournamentRecord.formalName = formalName;
-  if (tournamentRecord.promotionalName === tournamentRecord.tournamentName) {
-    delete tournamentRecord.promotionalName;
-  }
-  if (tournamentRecord.formalName === tournamentRecord.tournamentName) {
-    delete tournamentRecord.formalName;
+function validateLineUp({ lineUp, tieFormat }) {
+  const errors = [];
+  if (!Array.isArray(lineUp)) {
+    errors.push(mustBeAnArray("lineUp"));
+    return { valid: false, errors, error: INVALID_VALUES };
   }
-  return { ...SUCCESS };
-}
-function setTournamentNotes({ tournamentRecord, notes }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  return addNotes({ element: tournamentRecord, notes });
-}
-function setTournamentCategories({ tournamentRecord, categories }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  categories = (categories || []).filter((category) => {
-    return category.categoryName && category.type;
+  const validItems = lineUp.every((item) => {
+    if (typeof item !== "object") {
+      errors.push(`lineUp entries must be objects`);
+      return false;
+    }
+    const { participantId, collectionAssignments } = item;
+    if (!participantId) {
+      errors.push("Missing participantId");
+      return false;
+    }
+    if (typeof participantId !== "string") {
+      errors.push("participantIds must be strings");
+      return false;
+    }
+    if (!Array.isArray(collectionAssignments)) {
+      errors.push(mustBeAnArray("collectionAssignments"));
+      return false;
+    }
+    return collectionAssignments.every((collectionAssignment) => {
+      if (typeof collectionAssignment !== "object") {
+        errors.push("collectionAssignments must be objects");
+        return false;
+      }
+      const { collectionPosition } = collectionAssignment;
+      if (typeof collectionPosition !== "number") {
+        errors.push("collectionPosition must be a number");
+        return false;
+      }
+      return true;
+    });
   });
-  tournamentRecord.tournamentCategories = categories;
-  return { ...SUCCESS };
+  const noDuplicates = unique(lineUp.map(getParticipantId)).length === lineUp.length;
+  if (!noDuplicates)
+    errors.push("Duplicated participantId(s)");
+  const valid = validItems && noDuplicates;
+  return { valid, errors, error: errors.length ? INVALID_VALUES : void 0 };
 }
 
-function updateCourtAvailability({ tournamentRecord }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const { startDate, endDate } = tournamentRecord;
-  const tournamentDates = dateRange(startDate, endDate);
-  const courts = [];
-  for (const venue of tournamentRecord.venues || []) {
-    if (venue?.courts?.length)
-      courts.push(...venue.courts);
-  }
-  for (const court of courts) {
-    const { startTime, endTime } = (court.dateAvailability || []).reduce(
-      (extents, availability) => {
-        const startMinutes = timeStringMinutes(extents.startTime);
-        const endMinutes = timeStringMinutes(extents.endTime);
-        if (availability.startTime && timeStringMinutes(availability.startTime) < startMinutes)
-          extents.startTime = availability.startTime;
-        if (availability.endTime && timeStringMinutes(availability.endTime) > endMinutes)
-          extents.endTime = availability.endTime;
-        return extents;
-      },
-      { startTime: "08:00", endTime: "18:00" }
-    );
-    const updatedDateAvailability = tournamentDates.map((date) => {
-      const existing = court.dateAvailability?.find(
-        (availability) => availability.date === date
-      );
-      return existing || { date, startTime, endTime };
-    });
-    court.dateAvailability = updatedDateAvailability;
-  }
+function updateTeamLineUp({
+  drawDefinition,
+  participantId,
+  tieFormat,
+  lineUp
+}) {
+  if (typeof drawDefinition !== "object")
+    return { error: MISSING_DRAW_DEFINITION };
+  if (typeof participantId !== "string")
+    return { error: MISSING_PARTICIPANT_ID };
+  const validation = validateLineUp({ lineUp, tieFormat });
+  if (!validation.valid)
+    return validation;
+  const { extension: existingExtension } = findExtension({
+    element: drawDefinition,
+    name: LINEUPS
+  });
+  const value = existingExtension?.value || {};
+  value[participantId] = removeLineUpSubstitutions({ lineUp });
+  const extension = { name: LINEUPS, value };
+  addExtension$1({ element: drawDefinition, extension });
+  addDrawNotice({ drawDefinition });
   return { ...SUCCESS };
 }
 
-function setTournamentDates({
+function getTieMatchUpContext({
   tournamentRecord,
-  startDate,
-  endDate
+  drawDefinition,
+  tieMatchUpId,
+  event
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  if (startDate && !dateValidation.test(startDate) || endDate && !dateValidation.test(endDate))
-    return { error: INVALID_DATE };
-  if (!startDate && !endDate)
-    return { error: MISSING_DATE };
-  if (endDate && startDate && new Date(endDate) < new Date(startDate))
-    return { error: INVALID_VALUES };
-  let checkScheduling;
-  if (startDate && tournamentRecord.startDate && new Date(startDate) > new Date(tournamentRecord.startDate) || endDate && tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate)) {
-    checkScheduling = true;
-  }
-  if (startDate)
-    tournamentRecord.startDate = startDate;
-  if (endDate)
-    tournamentRecord.endDate = endDate;
-  if (startDate && tournamentRecord.endDate && new Date(startDate) > new Date(tournamentRecord.endDate)) {
-    tournamentRecord.endDate = startDate;
-  }
-  if (endDate && tournamentRecord.startDate && new Date(endDate) < new Date(tournamentRecord.startDate)) {
-    tournamentRecord.startDate = endDate;
-  }
-  const unscheduledMatchUpIds = checkScheduling && removeInvalidScheduling({ tournamentRecord })?.unscheduledMatchUpIds;
-  updateCourtAvailability({ tournamentRecord });
-  addNotice({
-    topic: MODIFY_TOURNAMENT_DETAIL,
-    payload: { startDate, endDate }
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_ID };
+  if (!event)
+    return { error: EVENT_NOT_FOUND };
+  const matchUpsMap = getMatchUpsMap({ drawDefinition });
+  const { matchUp: tieMatchUp } = findMatchUp$1({
+    matchUpId: tieMatchUpId,
+    drawDefinition,
+    matchUpsMap
   });
-  return { ...SUCCESS, unscheduledMatchUpIds };
-}
-function setTournamentStartDate({ tournamentRecord, startDate }) {
-  return setTournamentDates({ tournamentRecord, startDate });
-}
-function setTournamentEndDate({ tournamentRecord, endDate }) {
-  return setTournamentDates({ tournamentRecord, endDate });
-}
-function removeInvalidScheduling({ tournamentRecord }) {
-  const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
-  const startDate = tournamentRecord.startDate && new Date(tournamentRecord.startDate);
-  const endDate = tournamentRecord.endDate && new Date(tournamentRecord.endDate);
-  const invalidScheduledDates = [];
-  const invalidSchedulingMatchUpIds = [];
-  for (const matchUp of matchUps) {
-    const { schedule, matchUpId } = matchUp;
-    if (!schedule)
-      continue;
-    if (schedule.scheduledDate) {
-      const scheduledDate = new Date(schedule.scheduledDate);
-      if (startDate && scheduledDate < startDate || endDate && scheduledDate > endDate) {
-        invalidSchedulingMatchUpIds.push(matchUpId);
-        if (!invalidScheduledDates.includes(schedule.scheduledDate))
-          invalidScheduledDates.push(schedule.scheduledDate);
-      }
+  if (!tieMatchUp)
+    return { error: MATCHUP_NOT_FOUND };
+  const { matchUp: inContextTieMatchUp, structure } = findMatchUp$1({
+    tournamentParticipants: tournamentRecord.participants,
+    matchUpId: tieMatchUpId,
+    inContext: true,
+    drawDefinition,
+    matchUpsMap,
+    event
+  });
+  if (!inContextTieMatchUp)
+    return { error: MATCHUP_NOT_FOUND };
+  const {
+    collectionPosition,
+    drawPositions,
+    collectionId,
+    matchUpTieId,
+    matchUpType
+  } = inContextTieMatchUp;
+  if (matchUpType && ![SINGLES$1, DOUBLES$1].includes(matchUpType))
+    return { error: INVALID_MATCHUP };
+  const { positionAssignments } = getPositionAssignments$1({ structure });
+  const relevantAssignments = positionAssignments?.filter(
+    (assignment) => drawPositions?.includes(assignment.drawPosition)
+  );
+  const participantIds = relevantAssignments?.map(
+    extractAttributes("participantId")
+  );
+  const { tournamentParticipants: teamParticipants } = getTournamentParticipants({
+    tournamentRecord,
+    participantFilters: {
+      participantTypes: [TEAM],
+      participantIds
     }
-  }
+  });
+  const { matchUp: dualMatchUp } = findMatchUp$1({
+    matchUpId: matchUpTieId,
+    drawDefinition,
+    matchUpsMap
+  });
+  const { matchUp: inContextDualMatchUp } = findMatchUp$1({
+    matchUpId: matchUpTieId,
+    inContext: true,
+    drawDefinition,
+    matchUpsMap
+  });
+  const tieFormat = resolveTieFormat({
+    matchUp: dualMatchUp,
+    drawDefinition,
+    structure,
+    event
+  })?.tieFormat;
+  return {
+    inContextDualMatchUp,
+    inContextTieMatchUp,
+    relevantAssignments,
+    collectionPosition,
+    teamParticipants,
+    collectionId,
+    matchUpType,
+    dualMatchUp,
+    tieMatchUp,
+    tieFormat,
+    structure,
+    ...SUCCESS
+  };
+}
+
+function assignTieMatchUpParticipantId(params) {
+  const matchUpContext = getTieMatchUpContext(params);
+  if (matchUpContext.error)
+    return matchUpContext;
+  const stack = "assignTieMatchUpParticipantId";
+  let teamParticipantId = params.teamParticipantId;
+  const { tournamentRecord, drawDefinition, participantId, event } = params;
+  if (!participantId) {
+    return decorateResult({ result: { error: MISSING_PARTICIPANT_ID }, stack });
+  }
+  if (params.sideNumber && ![1, 2].includes(params.sideNumber)) {
+    return decorateResult({ result: { error: INVALID_SIDE_NUMBER }, stack });
+  }
+  const {
+    inContextDualMatchUp,
+    inContextTieMatchUp,
+    relevantAssignments,
+    collectionPosition,
+    teamParticipants,
+    collectionId,
+    matchUpType,
+    dualMatchUp,
+    tieFormat
+  } = matchUpContext;
+  const allTieIndividualParticipantIds = inContextTieMatchUp?.sides?.flatMap(
+    (side) => side.participant?.individualParticipantIds || side.participant?.participantId || []
+  );
+  if (allTieIndividualParticipantIds?.includes(participantId)) {
+    return decorateResult({ result: { ...SUCCESS }, stack });
+  }
+  teamParticipantId = teamParticipantId || params.sideNumber && inContextDualMatchUp?.sides?.find(
+    (side) => side.sideNumber === params.sideNumber
+  )?.participantId;
+  const {
+    tournamentParticipants: [participantToAssign]
+  } = getTournamentParticipants({
+    tournamentRecord,
+    participantFilters: {
+      participantIds: [participantId]
+    }
+  });
+  if (!participantToAssign) {
+    return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND }, stack });
+  }
+  const { appliedPolicies } = getAppliedPolicies({
+    tournamentRecord,
+    drawDefinition,
+    event
+  });
+  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] || appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] || POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  if (matchUpActionsPolicy?.participants?.enforceGender && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== participantToAssign.person?.sex) {
+    return { error: INVALID_PARTICIPANT, info: "Gender mismatch" };
+  }
+  const { individualParticipantIds, participantType } = participantToAssign;
+  if (matchUpType === SINGLES$1 && participantType !== INDIVIDUAL) {
+    return { error: INVALID_PARTICIPANT_TYPE };
+  }
+  const relevantParticipantIds = participantType === INDIVIDUAL ? [participantId] : individualParticipantIds;
+  const participantTeam = teamParticipantId && teamParticipants?.find(
+    ({ participantId: participantId2 }) => participantId2 === teamParticipantId
+  ) || teamParticipants?.find(
+    ({ individualParticipantIds: individualParticipantIds2 }) => overlap(relevantParticipantIds, individualParticipantIds2)
+  );
+  if (!participantTeam) {
+    return { error: TEAM_NOT_FOUND };
+  }
+  if (!teamParticipantId)
+    teamParticipantId = participantTeam.participantId;
+  if (!teamParticipantId)
+    return { error: PARTICIPANT_NOT_FOUND };
+  const teamAssignment = relevantAssignments?.find(
+    (assignment) => assignment.participantId === participantTeam?.participantId
+  );
+  const teamDrawPosition = teamAssignment?.drawPosition;
+  const teamSide = inContextTieMatchUp?.sides?.find(
+    (side) => side.drawPosition === teamDrawPosition
+  );
+  const sideNumber = params.sideNumber || teamSide?.sideNumber;
+  if (!tieFormat) {
+    return { error: MISSING_TIE_FORMAT };
+  }
+  const collectionDefinition = tieFormat.collectionDefinitions?.find(
+    (collectionDefinition2) => collectionDefinition2.collectionId === collectionId
+  );
+  if (!collectionDefinition)
+    return { error: MISSING_COLLECTION_DEFINITION };
+  if (!dualMatchUp?.sides?.length) {
+    const { extension } = findExtension$2({
+      element: drawDefinition,
+      name: LINEUPS
+    });
+    const lineUps = makeDeepCopy(extension?.value || {}, false, true);
+    const extractSideDetail = ({
+      displaySideNumber,
+      drawPosition,
+      sideNumber: sideNumber2
+    }) => ({ drawPosition, sideNumber: sideNumber2, displaySideNumber });
+    if (dualMatchUp) {
+      dualMatchUp.sides = inContextDualMatchUp?.sides?.map((side) => {
+        const participantId2 = side.participantId;
+        return {
+          ...extractSideDetail(side),
+          lineUp: participantId2 && lineUps[participantId2] || []
+        };
+      });
+    }
+  }
+  const dualMatchUpSide = dualMatchUp?.sides?.find(
+    (side) => side.sideNumber === sideNumber
+  );
+  const tieMatchUpSide = inContextTieMatchUp?.sides?.find(
+    (side) => side.sideNumber === sideNumber
+  );
+  const lineUp = dualMatchUpSide?.lineUp || getTeamLineUp({
+    participantId: teamParticipantId,
+    drawDefinition
+  })?.lineUp;
+  const targetAssignments = lineUp?.filter(
+    (participantAssignment) => participantAssignment.collectionAssignments?.find(
+      (assignment) => assignment.collectionPosition === collectionPosition && assignment.collectionId === collectionId && !assignment.previousParticipantId
+    )
+  );
+  const assignedParticipantIds = targetAssignments?.map(
+    (assignment) => assignment?.participantId
+  );
+  const participantIds = assignedParticipantIds?.length > 1 && assignedParticipantIds || (participantType === PAIR ? participantToAssign.individualParticipantIds : [participantId]);
+  const removeResult = removeCollectionAssignments({
+    collectionPosition,
+    teamParticipantId,
+    dualMatchUpSide,
+    drawDefinition,
+    participantIds,
+    collectionId
+  });
+  if (removeResult.error)
+    return decorateResult({ result: removeResult, stack });
+  const { modifiedLineUp } = removeResult;
+  let deleteParticipantId;
+  if (matchUpType === DOUBLES$1) {
+    if (participantType !== PAIR) {
+      let result = updateLineUp({
+        collectionPosition,
+        teamParticipantId,
+        drawDefinition,
+        modifiedLineUp,
+        participantId,
+        collectionId,
+        tieFormat
+      });
+      if (result?.error)
+        return decorateResult({ result, stack });
+      result = addParticipantId2Pair({
+        side: tieMatchUpSide
+      });
+      if (result.error)
+        return result;
+      deleteParticipantId = result.deleteParticipantId;
+      if (dualMatchUpSide)
+        dualMatchUpSide.lineUp = modifiedLineUp;
+      if (dualMatchUp) {
+        modifyMatchUpNotice({
+          tournamentId: tournamentRecord?.tournamentId,
+          matchUp: dualMatchUp,
+          context: stack,
+          drawDefinition
+        });
+      }
+    } else if (participantType === PAIR) {
+      for (const participantId2 of participantIds) {
+        updateLineUp({
+          collectionPosition,
+          teamParticipantId,
+          drawDefinition,
+          modifiedLineUp,
+          participantId: participantId2,
+          collectionId,
+          tieFormat
+        });
+      }
+    }
+  } else {
+    const result = updateLineUp({
+      collectionPosition,
+      teamParticipantId,
+      drawDefinition,
+      modifiedLineUp,
+      participantId,
+      collectionId,
+      tieFormat
+    });
+    if (result?.error)
+      return result;
+  }
+  if (dualMatchUpSide)
+    dualMatchUpSide.lineUp = modifiedLineUp;
+  if (dualMatchUp)
+    modifyMatchUpNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      matchUp: dualMatchUp,
+      context: stack,
+      drawDefinition
+    });
+  if (deleteParticipantId) {
+    const { error } = deleteParticipants({
+      participantIds: [deleteParticipantId],
+      tournamentRecord
+    });
+    if (error)
+      console.log("cleanup");
+  }
+  return { ...SUCCESS, modifiedLineUp };
+  function addParticipantId2Pair({ side }) {
+    let deleteParticipantId2;
+    if (!side.participant) {
+      const newPairParticipant = {
+        individualParticipantIds: [participantId],
+        participantRole: COMPETITOR,
+        participantType: PAIR
+      };
+      const result = addParticipant$1({
+        participant: newPairParticipant,
+        pairOverride: true,
+        tournamentRecord
+      });
+      if (result.error)
+        return result;
+    } else {
+      const individualParticipantIds2 = side.participant.individualParticipantIds || [];
+      const sideParticipantsCount = individualParticipantIds2.filter(Boolean).length;
+      if (sideParticipantsCount === 1) {
+        const { participant } = getPairedParticipant({
+          participantIds: individualParticipantIds2,
+          tournamentRecord
+        });
+        individualParticipantIds2.push(participantId);
+        const { participant: existingParticipant } = getPairedParticipant({
+          participantIds: individualParticipantIds2,
+          tournamentRecord
+        });
+        if (!existingParticipant && participant) {
+          participant.individualParticipantIds = individualParticipantIds2;
+          const result = modifyParticipant({
+            pairOverride: true,
+            tournamentRecord,
+            participant
+          });
+          if (result.error)
+            return result;
+        } else {
+          deleteParticipantId2 = participant?.participantId;
+        }
+      }
+    }
+    return { ...SUCCESS, deleteParticipantId: deleteParticipantId2 };
+  }
+}
+function updateLineUp({
+  collectionPosition,
+  teamParticipantId,
+  drawDefinition,
+  modifiedLineUp,
+  participantId,
+  collectionId,
+  tieFormat
+}) {
+  const templateTeamLineUp = getTeamLineUp({
+    participantId: teamParticipantId,
+    drawDefinition
+  })?.lineUp;
+  const participantCompetitiorProfile = (modifiedLineUp || templateTeamLineUp)?.find((teamCompetitor) => teamCompetitor?.participantId === participantId);
+  const newAssignment = { collectionId, collectionPosition };
+  if (participantCompetitiorProfile) {
+    participantCompetitiorProfile.collectionAssignments.push(newAssignment);
+  } else {
+    const teamCompetitor = {
+      collectionAssignments: [newAssignment],
+      participantId
+    };
+    modifiedLineUp.push(teamCompetitor);
+  }
+  return updateTeamLineUp({
+    participantId: teamParticipantId,
+    lineUp: modifiedLineUp,
+    drawDefinition,
+    tieFormat
+  });
+}
+
+const ASC = "ASC";
+const ASCENDING = "ASC";
+const DESC = "DESC";
+const DESCENDING = "DESC";
+const sortingConstants = { ASC, ASCENDING, DESC, DESCENDING };
+
+function generateLineUps(params) {
+  let { tieFormat } = params;
+  const {
+    useDefaultEventRanking,
+    tournamentRecord,
+    drawDefinition,
+    scaleAccessor,
+    // e.g. { scaleType: 'RANKINGS', scaleName: 'U18', accessor: 'wtnRating', sortOrder: 'ASC' }
+    singlesOnly,
+    // use singles scale for doubles events
+    attach,
+    // boolean - when true attach LINEUPS extension to drawDefinition and add new PAIR participants (where necessary)
+    event
+  } = params;
+  if (event?.eventType !== TEAM_EVENT)
+    return { error: INVALID_EVENT_TYPE };
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!tieFormat && !drawDefinition)
+    return { error: DRAW_DEFINITION_NOT_FOUND };
+  tieFormat = tieFormat || resolveTieFormat({ drawDefinition, event })?.tieFormat;
+  if (validateTieFormat({ tieFormat }).error)
+    return { error: INVALID_TIE_FORMAT };
+  if (typeof scaleAccessor !== "object" && !useDefaultEventRanking)
+    return { error: INVALID_VALUES, context: { scaleAccessor } };
+  const lineUps = {};
+  const targetEntries = (drawDefinition?.entries || event.entries).filter(
+    (entry) => entry?.entryStatus === DIRECT_ACCEPTANCE
+  );
+  const participantIds = targetEntries.map(getParticipantId);
+  const { participants = [] } = getParticipants$1({
+    withIndividualParticipants: true,
+    withScaleValues: true,
+    tournamentRecord
+  });
+  const teamParticipants = participants.filter(
+    ({ participantId }) => participantIds.includes(participantId)
+  );
+  const formatScaleType = (type) => type === RANKING$1 ? "rankings" : "ratings";
+  const defaultScaleName = event?.category?.categoryName || event?.category?.ageCategoryCode;
+  const {
+    scaleName = defaultScaleName,
+    scaleType = RANKING$1,
+    sortOrder,
+    accessor
+  } = scaleAccessor || {};
+  const formattedScaleType = formatScaleType(scaleType);
+  const getScaleValue = (individualParticipant, matchUpType) => {
+    let matchUpTypeScales = individualParticipant[formattedScaleType]?.[matchUpType];
+    if (!matchUpTypeScales && useDefaultEventRanking) {
+      matchUpTypeScales = individualParticipant[formattedScaleType]?.[SINGLES_MATCHUP];
+    }
+    if (Array.isArray(matchUpTypeScales)) {
+      const scaleValue = matchUpTypeScales.find(
+        (scale) => scale.scaleName === scaleName
+      )?.scaleValue;
+      if (isNumeric(scaleValue)) {
+        return scaleValue;
+      } else if (accessor && typeof scaleValue === "object")
+        return scaleValue[accessor];
+    }
+    return 0;
+  };
+  const sortMethod = (a, b, matchUpType) => {
+    const x = sortOrder === DESCENDING ? b : a;
+    const y = sortOrder === DESCENDING ? a : b;
+    return getScaleValue(x, matchUpType) - getScaleValue(y, matchUpType);
+  };
+  const singlesScaleSort = (a, b) => sortMethod(a, b, SINGLES_MATCHUP);
+  const doublesScaleSort = (a, b) => sortMethod(a, b, DOUBLES_MATCHUP);
+  const participantIdPairs = [];
+  const collectionDefinitions = tieFormat.collectionDefinitions || [];
+  for (const teamParticipant of teamParticipants) {
+    const singlesSort = teamParticipant.individualParticipants.sort(singlesScaleSort);
+    const doublesSort = singlesOnly ? singlesSort : teamParticipant.individualParticipants.sort(doublesScaleSort);
+    const participantAssignments = {};
+    for (const collectionDefinition of collectionDefinitions) {
+      const collectionParticipantIds = [];
+      const { collectionId, matchUpCount, matchUpType, gender } = collectionDefinition;
+      const singlesMatchUp = matchUpType === SINGLES_MATCHUP;
+      generateRange(0, matchUpCount).forEach((i) => {
+        const typeSort = singlesMatchUp ? singlesSort : doublesSort;
+        const collectionPosition = i + 1;
+        const participantIds2 = [];
+        generateRange(0, singlesMatchUp ? 1 : 2).forEach((i2) => {
+          const nextParticipantId = typeSort.find((participant) => {
+            const targetGender = [MALE, FEMALE].includes(gender) && gender || gender === MIXED && [MALE, FEMALE][i2];
+            return (!targetGender || targetGender === participant.person.sex) && !collectionParticipantIds.includes(participant.participantId);
+          }).participantId;
+          if (nextParticipantId) {
+            participantIds2.push(nextParticipantId);
+            collectionParticipantIds.push(nextParticipantId);
+            if (!participantAssignments[nextParticipantId])
+              participantAssignments[nextParticipantId] = [];
+            participantAssignments[nextParticipantId].push({
+              collectionPosition,
+              collectionId
+            });
+          }
+        });
+        if (!singlesMatchUp)
+          participantIdPairs.push(participantIds2);
+      });
+    }
+    const lineUp = Object.keys(participantAssignments).map((participantId) => ({
+      collectionAssignments: participantAssignments[participantId],
+      participantId
+    }));
+    lineUps[teamParticipant.participantId] = lineUp;
+  }
+  const participantsToAdd = [];
+  for (const pairParticipantIds of participantIdPairs) {
+    const { participant: existingPairParticipant } = getPairedParticipant({
+      tournamentParticipants: participants,
+      participantIds: pairParticipantIds
+    });
+    if (!existingPairParticipant) {
+      const newPairParticipant = {
+        individualParticipantIds: pairParticipantIds,
+        participantRole: COMPETITOR,
+        participantType: PAIR
+      };
+      participantsToAdd.push(newPairParticipant);
+    }
+  }
+  if (attach) {
+    while (participantsToAdd.length) {
+      addParticipant$1({
+        participant: participantsToAdd.pop(),
+        tournamentRecord
+      });
+    }
+    const extension = { name: LINEUPS, value: lineUps };
+    addExtension$1({ element: drawDefinition, extension });
+  }
+  return { ...SUCCESS, lineUps, participantsToAdd };
+}
+
+function generateOutcomeFromScoreString(params) {
+  const { matchUpFormat, matchUpStatus, winningSide, scoreString } = params;
+  if (!scoreString)
+    return {
+      outcome: {
+        ...toBePlayed,
+        winningSide,
+        matchUpStatus
+      }
+    };
+  if (winningSide && ![1, 2, void 0].includes(winningSide))
+    return { error: INVALID_VALUES, winningSide };
+  const neutralParsedSets = scoreString && parseScoreString({ scoreString });
+  const score = {};
+  const winningScoreString = generateScoreString({
+    sets: neutralParsedSets,
+    matchUpFormat
+  });
+  const losingScoreString = generateScoreString({
+    sets: neutralParsedSets,
+    reversed: true,
+    matchUpFormat
+  });
+  if (winningSide === 2) {
+    score.scoreStringSide1 = losingScoreString;
+    score.scoreStringSide2 = winningScoreString;
+  } else {
+    score.scoreStringSide1 = winningScoreString;
+    score.scoreStringSide2 = losingScoreString;
+  }
+  score.sets = parseScoreString({ scoreString: score.scoreStringSide1 });
+  return definedAttributes({
+    outcome: {
+      matchUpStatus,
+      winningSide,
+      score
+    }
+  });
+}
+
+const defaultStatusProfile = {
+  [WALKOVER$2]: 2,
+  [DOUBLE_WALKOVER]: 1,
+  [DOUBLE_DEFAULT]: 1,
+  [RETIRED$1]: 1,
+  [DEFAULTED]: 4
+};
+function generateOutcome(params) {
+  let { defaultWithScorePercent = 2, winningSide } = params;
+  const {
+    matchUpStatusProfile = defaultStatusProfile,
+    // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
+    matchUpFormat = FORMAT_STANDARD,
+    pointsPerMinute = 1,
+    sideWeight = 4
+  } = params;
+  if (!isValid(matchUpFormat))
+    return { error: INVALID_MATCHUP_FORMAT };
+  if (typeof matchUpStatusProfile !== "object")
+    return { error: INVALID_VALUES };
+  if (defaultWithScorePercent > 100)
+    defaultWithScorePercent = 100;
+  if (isNaN(defaultWithScorePercent) || isNaN(pointsPerMinute) || isNaN(sideWeight))
+    return { error: INVALID_VALUES };
+  const matchUpStatuses = Object.keys(matchUpStatusProfile).filter(
+    (matchUpStatus2) => Object.keys(matchUpStatusConstants).includes(matchUpStatus2) && matchUpStatus2 !== COMPLETED$1
+  );
+  const matchUpStatusTotals = Object.keys(matchUpStatuses).reduce(
+    (total, key) => total + matchUpStatusProfile[key],
+    0
+  );
+  if (matchUpStatusTotals > 100)
+    return { error: INVALID_VALUES, matchUpStatusProfile };
+  const matchUpStatusMap = matchUpStatuses.reduce(
+    (statusMap, matchUpStatus2) => {
+      statusMap.pointer = statusMap.pointer + matchUpStatusProfile[matchUpStatus2];
+      statusMap.valueMap.push([statusMap.pointer, matchUpStatus2]);
+      return statusMap;
+    },
+    { pointer: 0, valueMap: [] }
+  );
+  const outcomePointer = randomInt(1, 100);
+  const matchUpStatus = (matchUpStatusMap.valueMap.find(
+    (item) => outcomePointer <= item[0]
+  ) || [100, COMPLETED$1])[1];
+  const noScore = { sets: [], scoreStringSide1: "", side2ScoreString: "" };
+  if ([WALKOVER$2, DEFAULTED].includes(matchUpStatus)) {
+    winningSide = winningSide || randomInt(1, 2);
+    const outcome2 = {
+      score: noScore,
+      winningSide,
+      matchUpStatus
+    };
+    const scoreDefaulted = matchUpStatus === DEFAULTED && randomInt(1, 100) > 100 - defaultWithScorePercent;
+    if (!scoreDefaulted)
+      return { outcome: outcome2 };
+  } else if ([DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(matchUpStatus)) {
+    return { outcome: { score: noScore, matchUpStatus } };
+  }
+  const parsedFormat = parse(matchUpFormat);
+  const { bestOf, setFormat, finalSetFormat } = parsedFormat || {};
+  const sets = [];
+  const weightedSide = randomInt(0, 1);
+  const weightedRange = winningSide ? [winningSide - 1] : [
+    ...generateRange(0, sideWeight).map(() => weightedSide),
+    1 - weightedSide
+  ];
+  const incompleteSet = [RETIRED$1, DEFAULTED, INCOMPLETE, SUSPENDED].includes(
+    matchUpStatus
+  );
+  const incompleteAt = incompleteSet && (randomPop(generateRange(1, bestOf)) || 1);
+  let weightedWinningSide;
+  for (const setNumber of generateRange(1, (bestOf || 0) + 1)) {
+    const isFinalSet = setNumber === bestOf;
+    const { set, incomplete, winningSideNumber } = generateSet({
+      incomplete: incompleteAt === setNumber,
+      matchUpStatus,
+      pointsPerMinute,
+      setFormat: isFinalSet && finalSetFormat || setFormat,
+      setNumber,
+      weightedRange
+    });
+    sets.push(set);
+    if (incomplete) {
+      weightedWinningSide = winningSideNumber;
+      break;
+    }
+    const analysis2 = analyzeMatchUp({
+      matchUp: { score: { sets }, matchUpFormat }
+    });
+    if (analysis2.calculatedWinningSide)
+      break;
+  }
+  const analysis = analyzeMatchUp({
+    matchUp: { score: { sets }, matchUpFormat }
+  });
+  const matchUpWinningSide = weightedWinningSide ? winningSide || weightedWinningSide : analysis.calculatedWinningSide;
+  const { score } = matchUpScore({
+    score: { sets },
+    winningSide: matchUpWinningSide,
+    matchUpStatus
+  });
+  const outcome = {
+    score,
+    winningSide: matchUpWinningSide,
+    matchUpStatus
+  };
+  return { outcome };
+}
+function generateSet({
+  weightedRange = [0, 1],
+  pointsPerMinute,
+  matchUpStatus,
+  incomplete,
+  setFormat,
+  setNumber
+}) {
+  const set = { setNumber };
+  const { setTo, tiebreakFormat, tiebreakAt, tiebreakSet, timed, minutes } = setFormat;
+  const weightIndex = randomInt(0, weightedRange.length - 1);
+  const reverseScores = weightedRange[weightIndex];
+  let winningSideNumber;
+  if (timed) {
+    const calcPoints = minutes * pointsPerMinute;
+    const pointsVariation = Math.round(calcPoints * 0.2);
+    const totalPoints = calcPoints + randomPop([1, -1]) * pointsVariation;
+    const sidePoints = weightedRandom(totalPoints, 2);
+    const scores = [sidePoints, totalPoints - sidePoints];
+    if (reverseScores)
+      scores.reverse();
+    winningSideNumber = weightedRange[weightIndex] + 1;
+    let highSide = scores[0] > scores[1] && 1 || scores[1] > scores[0] && 2 || 0;
+    if (incomplete) {
+      const [side1Score2, side2Score2] = scores;
+      Object.assign(set, { side1Score: side1Score2, side2Score: side2Score2 });
+      if (completedMatchUpStatuses.includes(matchUpStatus)) {
+        return { set, incomplete, winningSideNumber };
+      }
+      return { set, incomplete };
+    }
+    if (!highSide)
+      scores[randomInt(0, 1)] += 1;
+    highSide = scores[0] > scores[1] ? 1 : 2;
+    if (highSide !== winningSideNumber)
+      scores.reverse();
+    const [side1Score, side2Score] = scores;
+    Object.assign(set, {
+      side1Score,
+      side2Score,
+      winningSide: winningSideNumber
+    });
+    return { set };
+  } else if (incomplete) {
+    set.side1Score = randomInt(0, tiebreakAt);
+    set.side2Score = randomInt(0, tiebreakAt);
+    if (completedMatchUpStatuses.includes(matchUpStatus)) {
+      winningSideNumber = weightedRange[weightIndex] + 1;
+    }
+    return { set, incomplete, winningSideNumber };
+  } else {
+    const range = generateRange(1, setTo + 1).map((value) => generateRange(0, setTo + 2 - value).map(() => value)).flat();
+    const lowValue = range[randomInt(0, range.length - 1)];
+    const scores = setTo && getSetComplement({
+      isSide1: true,
+      tiebreakAt,
+      lowValue,
+      setTo
+    });
+    const isTiebreakSet = !scores;
+    const specifiedWinningSide = weightedRange.length === 1 && weightedRange[weightIndex] + 1;
+    if (!isTiebreakSet) {
+      if (specifiedWinningSide) {
+        const highSide = scores[0] > scores[1] ? 1 : 2;
+        if (highSide !== specifiedWinningSide)
+          scores.reverse();
+      } else if (reverseScores) {
+        scores.reverse();
+      }
+      const [side1Score, side2Score] = scores;
+      Object.assign(set, { side1Score, side2Score });
+    }
+    const setAnalysis = analyzeSet({
+      matchUpScoringFormat: { setFormat },
+      setObject: set
+    });
+    let tiebreakWinningSide;
+    if (setAnalysis.hasTiebreakCondition || isTiebreakSet) {
+      const { NoAD: tiebreakNoAd, tiebreakTo } = tiebreakFormat || tiebreakSet || {};
+      const range2 = generateRange(1, tiebreakTo + 1).map(
+        (value) => generateRange(0, tiebreakTo + 2 - value).map(() => value)
+      ).flat();
+      const lowValue2 = range2[randomInt(0, range2.length - 1)];
+      const scores2 = getTiebreakComplement({
+        isSide1: true,
+        tiebreakNoAd,
+        tiebreakTo,
+        lowValue: lowValue2
+      });
+      if (scores2) {
+        if (isTiebreakSet) {
+          const highSide = scores2[0] > scores2[1] ? 1 : 2;
+          if (specifiedWinningSide) {
+            if (highSide !== specifiedWinningSide)
+              scores2.reverse();
+          } else if (reverseScores) {
+            scores2.reverse();
+          }
+          [set.side1TiebreakScore, set.side2TiebreakScore] = scores2;
+          tiebreakWinningSide = scores2[0] > scores2[1] && 1 || scores2[1] > scores2[0] && 2 || void 0;
+        } else if (setAnalysis.leadingSide === 2) {
+          [set.side1TiebreakScore, set.side2TiebreakScore] = scores2;
+        } else {
+          [set.side2TiebreakScore, set.side1TiebreakScore] = scores2;
+        }
+      }
+    }
+    set.winningSide = setAnalysis.winningSide || setAnalysis.leadingSide || specifiedWinningSide || tiebreakWinningSide;
+  }
+  return { set };
+}
+
+function completeDrawMatchUps(params) {
+  const {
+    matchUpStatusProfile,
+    // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
+    completeAllMatchUps,
+    // qualifyingProfiles, // CONSIDER: allowing completionGoal per structureProfile
+    randomWinningSide,
+    tournamentRecord,
+    completionGoal,
+    drawDefinition,
+    event
+  } = params;
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const matchUpFormat = params.matchUpFormat || drawDefinition.matchUpFormat || event?.matchUpFormat;
+  const sortedStructures = drawDefinition.structures.slice().sort(structureSort);
+  let completedCount = 0;
+  const { matchUps: firstRoundDualMatchUps, matchUpsMap } = getAllDrawMatchUps({
+    contextFilters: {
+      stages: [MAIN, QUALIFYING]
+    },
+    matchUpFilters: {
+      matchUpTypes: [TEAM$2],
+      roundNumbers: [1]
+    },
+    inContext: true,
+    drawDefinition
+  });
+  if (firstRoundDualMatchUps?.length) {
+    const categoryName = event?.category?.ageCategoryCode || event?.category?.categoryName;
+    if (categoryName) {
+      const scaleAccessor = {
+        scaleName: categoryName,
+        sortOrder: ASCENDING,
+        scaleType: RANKING$1
+      };
+      generateLineUps({
+        singlesOnly: true,
+        tournamentRecord,
+        drawDefinition,
+        scaleAccessor,
+        attach: true,
+        event
+      });
+    } else {
+      const structureId = firstRoundDualMatchUps[0]?.structureId;
+      const { positionAssignments } = getPositionAssignments$1({
+        drawDefinition,
+        structureId
+      });
+      if (positionAssignments?.length) {
+        const { tournamentParticipants: teamParticipants } = getTournamentParticipants({
+          participantFilters: { participantTypes: [TEAM$2] },
+          tournamentRecord
+        });
+        const assignParticipants = (dualMatchUp) => {
+          const singlesMatchUps = dualMatchUp.tieMatchUps.filter(
+            ({ matchUpType }) => matchUpType === SINGLES$1
+          );
+          const doublesMatchUps = dualMatchUp.tieMatchUps.filter(
+            ({ matchUpType }) => matchUpType === DOUBLES$1
+          );
+          singlesMatchUps.forEach((singlesMatchUp, i) => {
+            const tieMatchUpId = singlesMatchUp.matchUpId;
+            singlesMatchUp.sides.forEach((side) => {
+              const { drawPosition } = side;
+              const teamParticipant = teamParticipants?.find(
+                (teamParticipant2) => {
+                  const { participantId } = teamParticipant2;
+                  const assignment = positionAssignments.find(
+                    (assignment2) => assignment2.participantId === participantId
+                  );
+                  return assignment?.drawPosition === drawPosition;
+                }
+              );
+              if (teamParticipant) {
+                const individualParticipantId = teamParticipant.individualParticipantIds[i];
+                assignTieMatchUpParticipantId({
+                  teamParticipantId: teamParticipant.participantId,
+                  participantId: individualParticipantId,
+                  tournamentRecord,
+                  drawDefinition,
+                  tieMatchUpId,
+                  event
+                });
+              }
+            });
+          });
+          doublesMatchUps.forEach((doublesMatchUp, i) => {
+            const tieMatchUpId = doublesMatchUp.matchUpId;
+            doublesMatchUp.sides.forEach((side) => {
+              const { drawPosition } = side;
+              const teamParticipant = teamParticipants?.find(
+                (teamParticipant2) => {
+                  const { participantId } = teamParticipant2;
+                  const assignment = positionAssignments.find(
+                    (assignment2) => assignment2.participantId === participantId
+                  );
+                  return assignment?.drawPosition === drawPosition;
+                }
+              );
+              if (teamParticipant) {
+                const individualParticipantIds = teamParticipant.individualParticipantIds.slice(
+                  i * 2,
+                  i * 2 + 2
+                );
+                individualParticipantIds.forEach((individualParticipantId) => {
+                  assignTieMatchUpParticipantId({
+                    teamParticipantId: teamParticipant.participantId,
+                    participantId: individualParticipantId,
+                    tournamentRecord,
+                    drawDefinition,
+                    tieMatchUpId,
+                    event
+                  });
+                });
+              }
+            });
+          });
+        };
+        firstRoundDualMatchUps.forEach(assignParticipants);
+      }
+    }
+  }
+  const scoreString = typeof completeAllMatchUps === "string" && completeAllMatchUps;
+  const matchUpStatus = scoreString && COMPLETED$1;
+  for (const structure of sortedStructures) {
+    if (completedCount >= completionGoal)
+      break;
+    const { matchUps } = getAllStructureMatchUps({
+      matchUpFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
+      afterRecoveryTimes: false,
+      tournamentRecord,
+      inContext: true,
+      drawDefinition,
+      matchUpsMap,
+      structure,
+      event
+    });
+    const sortedMatchUpIds = matchUps.filter(({ winningSide }) => !winningSide).sort(matchUpSort).map(getMatchUpId);
+    for (const matchUpId of sortedMatchUpIds) {
+      if (!isNaN(completionGoal) && completedCount >= completionGoal)
+        break;
+      const { matchUps: matchUps2 } = getAllStructureMatchUps({
+        matchUpFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
+        afterRecoveryTimes: false,
+        tournamentRecord,
+        inContext: true,
+        drawDefinition,
+        matchUpsMap,
+        structure,
+        event
+      });
+      const targetMatchUp = matchUps2.find(
+        (matchUp) => matchUp.matchUpId === matchUpId
+      );
+      const isDoubleExit = [DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(
+        targetMatchUp.matchUpStatus
+      );
+      if (targetMatchUp?.readyToScore && !isDoubleExit) {
+        const result = smartComplete({
+          winningSide: !randomWinningSide && 1,
+          matchUpStatusProfile,
+          tournamentRecord,
+          drawDefinition,
+          targetMatchUp,
+          matchUpFormat,
+          matchUpStatus,
+          scoreString,
+          event
+        });
+        if (result?.error)
+          return result;
+        completedCount += 1;
+      }
+    }
+  }
+  return { ...SUCCESS, completedCount };
+}
+function completeDrawMatchUp(params) {
+  const {
+    matchUpStatusCodes,
+    policyDefinitions,
+    tournamentRecord,
+    drawDefinition,
+    targetMatchUp,
+    matchUpStatus,
+    matchUpFormat,
+    scoreString,
+    winningSide,
+    event
+  } = params;
+  if (!targetMatchUp || targetMatchUp.matchUpStatus === BYE) {
+    return;
+  }
+  const { matchUpId } = targetMatchUp || {};
+  const { outcome } = generateOutcomeFromScoreString({
+    matchUpFormat,
+    matchUpStatus,
+    scoreString,
+    winningSide
+  });
+  if (matchUpStatusCodes)
+    outcome.matchUpStatusCodes = matchUpStatusCodes;
+  return setMatchUpStatus$1({
+    tournamentRecord,
+    policyDefinitions,
+    drawDefinition,
+    matchUpFormat,
+    matchUpId,
+    outcome,
+    event
+  });
+}
+function smartComplete(params) {
+  const {
+    matchUpStatusProfile = {},
+    tournamentRecord,
+    policyDefinitions,
+    drawDefinition,
+    matchUpStatus,
+    matchUpFormat,
+    targetMatchUp,
+    scoreString,
+    winningSide,
+    event
+  } = params;
+  if (scoreString || matchUpStatus)
+    return completeDrawMatchUp(params);
+  const { matchUpId } = targetMatchUp || {};
+  const { outcome } = generateOutcome({
+    matchUpStatusProfile,
+    matchUpFormat,
+    winningSide
+  });
+  return setMatchUpStatus$1({
+    policyDefinitions,
+    tournamentRecord,
+    drawDefinition,
+    matchUpFormat,
+    matchUpId,
+    outcome,
+    event
+  });
+}
+
+function convertPointEight({ tournament }) {
+  if (!tournament)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const {
+    providerTournamentID: tournamentId,
+    hostCountryCode,
+    tournamentLevel,
+    totalPrizeMoney,
+    tournamentName,
+    extensions,
+    startDate,
+    endDate
+  } = tournament;
+  const tournamentRecord = newTournamentRecord({
+    hostCountryCode,
+    tournamentLevel,
+    totalPrizeMoney,
+    tournamentName,
+    tournamentId,
+    extensions,
+    startDate,
+    endDate
+  });
+  tournamentRecord.events = [];
+  for (const legacyEvent of tournament.events || []) {
+    const {
+      extensions: extensions2,
+      ageCategory,
+      discipline,
+      eventType,
+      eventId,
+      gender,
+      stages
+    } = legacyEvent;
+    const event = {
+      drawDefinitions: deriveDraws(stages),
+      category: { ageCategory },
+      gender: ["M", MALE].includes(gender) && MALE || ["F", FEMALE].includes(gender) && FEMALE || void 0,
+      eventType: ["D", DOUBLES].includes(eventType) && DOUBLES || ["T", TEAM$1].includes(eventType) ? TEAM$1 : SINGLES,
+      extensions: extensions2,
+      discipline,
+      eventId
+    };
+    tournamentRecord.events.push(event);
+  }
+  return { ...SUCCESS, tournamentRecord };
+}
+function deriveDraws(stages) {
+  const drawDefinitions = [];
+  for (const legacyStage of stages || []) {
+    const { stageType } = legacyStage;
+    const stage = ["M", MAIN].includes(stageType) && MAIN || ["Q", QUALIFYING].includes(stageType) && QUALIFYING || ["C", CONSOLATION].includes(stageType) && CONSOLATION || ["P", PLAY_OFF].includes(stageType) && PLAY_OFF || void 0;
+    for (const draw of legacyStage.draws || []) {
+      const { drawId, drawSize, matchUps } = draw;
+      const drawDefinition = { stage, drawId, drawSize };
+      drawDefinitions.push(drawDefinition);
+      console.log(
+        matchUps.map(({ roundNumber, roundPosition }) => ({
+          roundNumber,
+          roundPosition
+        })),
+        { draw, drawDefinition }
+      );
+    }
+  }
+  return drawDefinitions;
+}
+
+const ABANDONED = "ABANDONED";
+const ACTIVE = "ACTIVE";
+const CANCELLED = "CANCELLED";
+const COMPLETED = "COMPLETED";
+const IN_PROGRESS = "IN_PROGRESS";
+const tournamentConstants = {
+  ABANDONED,
+  ACTIVE,
+  CANCELLED,
+  COMPLETED,
+  IN_PROGRESS
+};
+
+function setTournamentStatus({ tournamentRecord, status }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (status && !Object.keys(tournamentConstants).includes(status))
+    return { error: INVALID_VALUES, info: "Unknown status" };
+  tournamentRecord.tournamentStatus = status;
+  return { ...SUCCESS };
+}
+
+function analyzeDraws({ tournamentRecord }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const drawsAnalysis = {
+    positionsNoOutcomes: [],
+    // all positions assigned and no outcomes
+    canBePruned: [],
+    // partially assigned positions with outcomes => drawSizes can be reduced
+    matchPlay: [],
+    // only first round has active matchUps; some unassigned positions
+    inactive: [],
+    drawAnalysis: {}
+  };
+  const eventsMap = {};
+  const eventDraws = tournamentRecord.events?.map((event) => {
+    const eventId = event.eventId;
+    eventsMap[eventId] = event;
+    return (event?.drawDefinitions || []).map((drawDefinition) => ({
+      drawDefinition,
+      eventId
+    }));
+  }).flat().filter(Boolean);
+  eventDraws.forEach(({ drawDefinition, eventId }) => {
+    let positionsAssignedCount = 0;
+    let matchUpsWithWinningSideCount = 0;
+    let matchUpsNoOutcomeCount = 0;
+    const { allStructuresLinked } = getStructureGroups({ drawDefinition });
+    const event = eventsMap[eventId];
+    const structures = drawDefinition?.structures || [];
+    const structuresData = structures.map((structure) => {
+      const { stage, stageSequence, structureId } = structure;
+      const orderNumber = stageOrder$1[stage];
+      const { inContextStructureMatchUps } = getStructureDrawPositionProfiles({
+        drawDefinition,
+        structure,
+        event
+      });
+      const matchUpsWithWinningSide = inContextStructureMatchUps?.filter(
+        ({ winningSide }) => winningSide
+      );
+      const winningSideCount = matchUpsWithWinningSide.filter(Boolean).length || 0;
+      matchUpsWithWinningSideCount += winningSideCount;
+      matchUpsNoOutcomeCount += inContextStructureMatchUps.length - matchUpsWithWinningSideCount;
+      const maxWinningSideFirstRoundPosition = Math.max(
+        matchUpsWithWinningSide.filter(({ roundNumber }) => roundNumber === 1).map(({ roundPosition }) => roundPosition)
+      );
+      const { positionAssignments } = getPositionAssignments$1({ structure });
+      const positionsAssigned = positionAssignments?.filter(
+        ({ participantId }) => participantId
+      );
+      positionsAssignedCount += positionsAssigned?.length || 0;
+      const unassignedPositionsCount = (positionAssignments?.length || 0) - (positionsAssigned?.length || 0);
+      const { roundMatchUps, roundProfile, roundNumbers, maxMatchUpsCount } = getRoundMatchUps$1({ matchUps: inContextStructureMatchUps });
+      const activeRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => !roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
+      const inactiveRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
+      const inactiveStructure = roundProfile && Object.values(roundProfile).every((profile) => profile.inactiveRound);
+      return {
+        positionsAssignedCount: positionsAssigned?.length || 0,
+        maxWinningSideFirstRoundPosition,
+        unassignedPositionsCount,
+        inactiveStructure,
+        maxMatchUpsCount,
+        inactiveRounds,
+        roundMatchUps,
+        activeRounds,
+        roundNumbers,
+        roundProfile,
+        structureId,
+        stageSequence,
+        orderNumber,
+        stage
+      };
+    });
+    const mainStructure = structuresData.find(
+      (data) => data.orderNumber === 2 && data.stageSequence === 1
+    );
+    const activeStructuresCount = structuresData.filter(
+      ({ inactiveStructure }) => !inactiveStructure
+    ).length;
+    const { links } = getStructureLinks({
+      drawDefinition,
+      structureId: mainStructure.structureId
+    });
+    const isMatchPlay = ensureInt(mainStructure.activeRounds[0]) === 1 && mainStructure.activeRounds.length === 1 && activeStructuresCount === 1;
+    const inactiveDraw = structuresData?.every(
+      ({ inactiveStructure }) => inactiveStructure
+    );
+    const canBePruned = !links.length && mainStructure.activeRounds.length && (mainStructure.roundProfile[1].inactiveCount || mainStructure.inactiveRounds.length);
+    const drawId = drawDefinition.drawId;
+    if (positionsAssignedCount && !matchUpsWithWinningSideCount)
+      drawsAnalysis.positionsNoOutcomes.push(drawId);
+    if (inactiveDraw)
+      drawsAnalysis.inactive.push(drawId);
+    if (isMatchPlay)
+      drawsAnalysis.matchPlay.push(drawId);
+    if (canBePruned)
+      drawsAnalysis.canBePruned.push(drawId);
+    const drawAnalysis = {
+      matchUpsWithWinningSideCount,
+      matchUpsNoOutcomeCount,
+      positionsAssignedCount,
+      allStructuresLinked,
+      structuresData,
+      inactiveDraw,
+      isMatchPlay,
+      drawId
+    };
+    drawsAnalysis.drawAnalysis[drawId] = drawAnalysis;
+  });
+  return { ...SUCCESS, drawsAnalysis };
+}
+
+function checkIsDual(tournamentRecord) {
+  const teamParticipants = tournamentRecord.participants?.filter(
+    ({ participantType }) => participantType === TEAM
+  );
+  const twoTeams = teamParticipants?.length === 2;
+  const event = tournamentRecord.events?.length === 1 && tournamentRecord.events[0];
+  const drawDefinition = event?.drawDefinitions?.length === 1 && event.drawDefinitions[0];
+  const structure = drawDefinition?.structures?.length === 1 && drawDefinition.structures[0];
+  const twoDrawPositions = structure?.positionAssignments?.length === 2;
+  return !!(event.tieFormat && twoTeams && twoDrawPositions);
+}
+
+function analyzeTournament({ tournamentRecord }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const { drawsAnalysis } = analyzeDraws({ tournamentRecord });
+  const analysis = {
+    isDual: checkIsDual(tournamentRecord),
+    drawsAnalysis
+  };
+  return { ...SUCCESS, analysis };
+}
+
+function setTournamentName({
+  tournamentRecord,
+  promotionalName,
+  tournamentName,
+  formalName
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (tournamentName)
+    tournamentRecord.tournamentName = tournamentName;
+  if (promotionalName)
+    tournamentRecord.promotionalName = promotionalName;
+  if (formalName)
+    tournamentRecord.formalName = formalName;
+  if (tournamentRecord.promotionalName === tournamentRecord.tournamentName) {
+    delete tournamentRecord.promotionalName;
+  }
+  if (tournamentRecord.formalName === tournamentRecord.tournamentName) {
+    delete tournamentRecord.formalName;
+  }
+  return { ...SUCCESS };
+}
+function setTournamentNotes({ tournamentRecord, notes }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  return addNotes({ element: tournamentRecord, notes });
+}
+function setTournamentCategories({ tournamentRecord, categories }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  categories = (categories || []).filter((category) => {
+    return category.categoryName && category.type;
+  });
+  tournamentRecord.tournamentCategories = categories;
+  return { ...SUCCESS };
+}
+
+function updateCourtAvailability({ tournamentRecord }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const { startDate, endDate } = tournamentRecord;
+  const tournamentDates = dateRange(startDate, endDate);
+  const courts = [];
+  for (const venue of tournamentRecord.venues || []) {
+    if (venue?.courts?.length)
+      courts.push(...venue.courts);
+  }
+  for (const court of courts) {
+    const { startTime, endTime } = (court.dateAvailability || []).reduce(
+      (extents, availability) => {
+        const startMinutes = timeStringMinutes(extents.startTime);
+        const endMinutes = timeStringMinutes(extents.endTime);
+        if (availability.startTime && timeStringMinutes(availability.startTime) < startMinutes)
+          extents.startTime = availability.startTime;
+        if (availability.endTime && timeStringMinutes(availability.endTime) > endMinutes)
+          extents.endTime = availability.endTime;
+        return extents;
+      },
+      { startTime: "08:00", endTime: "18:00" }
+    );
+    const updatedDateAvailability = tournamentDates.map((date) => {
+      const existing = court.dateAvailability?.find(
+        (availability) => availability.date === date
+      );
+      return existing || { date, startTime, endTime };
+    });
+    court.dateAvailability = updatedDateAvailability;
+  }
+  return { ...SUCCESS };
+}
+
+function setTournamentDates({
+  tournamentRecord,
+  startDate,
+  endDate
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (startDate && !dateValidation.test(startDate) || endDate && !dateValidation.test(endDate))
+    return { error: INVALID_DATE };
+  if (!startDate && !endDate)
+    return { error: MISSING_DATE };
+  if (endDate && startDate && new Date(endDate) < new Date(startDate))
+    return { error: INVALID_VALUES };
+  let checkScheduling;
+  if (startDate && tournamentRecord.startDate && new Date(startDate) > new Date(tournamentRecord.startDate) || endDate && tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate)) {
+    checkScheduling = true;
+  }
+  if (startDate)
+    tournamentRecord.startDate = startDate;
+  if (endDate)
+    tournamentRecord.endDate = endDate;
+  if (startDate && tournamentRecord.endDate && new Date(startDate) > new Date(tournamentRecord.endDate)) {
+    tournamentRecord.endDate = startDate;
+  }
+  if (endDate && tournamentRecord.startDate && new Date(endDate) < new Date(tournamentRecord.startDate)) {
+    tournamentRecord.startDate = endDate;
+  }
+  const unscheduledMatchUpIds = checkScheduling && removeInvalidScheduling({ tournamentRecord })?.unscheduledMatchUpIds;
+  updateCourtAvailability({ tournamentRecord });
+  addNotice({
+    topic: MODIFY_TOURNAMENT_DETAIL,
+    payload: { startDate, endDate }
+  });
+  return { ...SUCCESS, unscheduledMatchUpIds };
+}
+function setTournamentStartDate({ tournamentRecord, startDate }) {
+  return setTournamentDates({ tournamentRecord, startDate });
+}
+function setTournamentEndDate({ tournamentRecord, endDate }) {
+  return setTournamentDates({ tournamentRecord, endDate });
+}
+function removeInvalidScheduling({ tournamentRecord }) {
+  const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
+  const startDate = tournamentRecord.startDate && new Date(tournamentRecord.startDate);
+  const endDate = tournamentRecord.endDate && new Date(tournamentRecord.endDate);
+  const invalidScheduledDates = [];
+  const invalidSchedulingMatchUpIds = [];
+  for (const matchUp of matchUps) {
+    const { schedule, matchUpId } = matchUp;
+    if (!schedule)
+      continue;
+    if (schedule.scheduledDate) {
+      const scheduledDate = new Date(schedule.scheduledDate);
+      if (startDate && scheduledDate < startDate || endDate && scheduledDate > endDate) {
+        invalidSchedulingMatchUpIds.push(matchUpId);
+        if (!invalidScheduledDates.includes(schedule.scheduledDate))
+          invalidScheduledDates.push(schedule.scheduledDate);
+      }
+    }
+  }
   if (invalidScheduledDates.length) {
     const result = clearScheduledMatchUps$1({
       scheduledDates: invalidScheduledDates,
@@ -51654,6 +52834,7 @@ const tournamentGovernor = {
   removeNotes,
   analyzeDraws,
   analyzeTournament,
+  completeDrawMatchUps,
   getRounds,
   getProfileRounds,
   setTournamentName,
@@ -52472,161 +53653,6 @@ function removeMatchUpSideParticipant({
   return { ...SUCCESS };
 }
 
-function validateLineUp({ lineUp, tieFormat }) {
-  const errors = [];
-  if (!Array.isArray(lineUp)) {
-    errors.push(mustBeAnArray("lineUp"));
-    return { valid: false, errors, error: INVALID_VALUES };
-  }
-  const validItems = lineUp.every((item) => {
-    if (typeof item !== "object") {
-      errors.push(`lineUp entries must be objects`);
-      return false;
-    }
-    const { participantId, collectionAssignments } = item;
-    if (!participantId) {
-      errors.push("Missing participantId");
-      return false;
-    }
-    if (typeof participantId !== "string") {
-      errors.push("participantIds must be strings");
-      return false;
-    }
-    if (!Array.isArray(collectionAssignments)) {
-      errors.push(mustBeAnArray("collectionAssignments"));
-      return false;
-    }
-    return collectionAssignments.every((collectionAssignment) => {
-      if (typeof collectionAssignment !== "object") {
-        errors.push("collectionAssignments must be objects");
-        return false;
-      }
-      const { collectionPosition } = collectionAssignment;
-      if (typeof collectionPosition !== "number") {
-        errors.push("collectionPosition must be a number");
-        return false;
-      }
-      return true;
-    });
-  });
-  const noDuplicates = unique(lineUp.map(getParticipantId)).length === lineUp.length;
-  if (!noDuplicates)
-    errors.push("Duplicated participantId(s)");
-  const valid = validItems && noDuplicates;
-  return { valid, errors, error: errors.length ? INVALID_VALUES : void 0 };
-}
-
-function updateTeamLineUp({
-  drawDefinition,
-  participantId,
-  tieFormat,
-  lineUp
-}) {
-  if (typeof drawDefinition !== "object")
-    return { error: MISSING_DRAW_DEFINITION };
-  if (typeof participantId !== "string")
-    return { error: MISSING_PARTICIPANT_ID };
-  const validation = validateLineUp({ lineUp, tieFormat });
-  if (!validation.valid)
-    return validation;
-  const { extension: existingExtension } = findExtension({
-    element: drawDefinition,
-    name: LINEUPS
-  });
-  const value = existingExtension?.value || {};
-  value[participantId] = removeLineUpSubstitutions({ lineUp });
-  const extension = { name: LINEUPS, value };
-  addExtension$1({ element: drawDefinition, extension });
-  addDrawNotice({ drawDefinition });
-  return { ...SUCCESS };
-}
-
-function getTieMatchUpContext({
-  tournamentRecord,
-  drawDefinition,
-  tieMatchUpId,
-  event
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_ID };
-  if (!event)
-    return { error: EVENT_NOT_FOUND };
-  const matchUpsMap = getMatchUpsMap({ drawDefinition });
-  const { matchUp: tieMatchUp } = findMatchUp$1({
-    matchUpId: tieMatchUpId,
-    drawDefinition,
-    matchUpsMap
-  });
-  if (!tieMatchUp)
-    return { error: MATCHUP_NOT_FOUND };
-  const { matchUp: inContextTieMatchUp, structure } = findMatchUp$1({
-    tournamentParticipants: tournamentRecord.participants,
-    matchUpId: tieMatchUpId,
-    inContext: true,
-    drawDefinition,
-    matchUpsMap,
-    event
-  });
-  if (!inContextTieMatchUp)
-    return { error: MATCHUP_NOT_FOUND };
-  const {
-    collectionPosition,
-    drawPositions,
-    collectionId,
-    matchUpTieId,
-    matchUpType
-  } = inContextTieMatchUp;
-  if (matchUpType && ![SINGLES$1, DOUBLES$1].includes(matchUpType))
-    return { error: INVALID_MATCHUP };
-  const { positionAssignments } = getPositionAssignments$1({ structure });
-  const relevantAssignments = positionAssignments?.filter(
-    (assignment) => drawPositions?.includes(assignment.drawPosition)
-  );
-  const participantIds = relevantAssignments?.map(
-    extractAttributes("participantId")
-  );
-  const { tournamentParticipants: teamParticipants } = getTournamentParticipants({
-    tournamentRecord,
-    participantFilters: {
-      participantTypes: [TEAM],
-      participantIds
-    }
-  });
-  const { matchUp: dualMatchUp } = findMatchUp$1({
-    matchUpId: matchUpTieId,
-    drawDefinition,
-    matchUpsMap
-  });
-  const { matchUp: inContextDualMatchUp } = findMatchUp$1({
-    matchUpId: matchUpTieId,
-    inContext: true,
-    drawDefinition,
-    matchUpsMap
-  });
-  const tieFormat = resolveTieFormat({
-    matchUp: dualMatchUp,
-    drawDefinition,
-    structure,
-    event
-  })?.tieFormat;
-  return {
-    inContextDualMatchUp,
-    inContextTieMatchUp,
-    relevantAssignments,
-    collectionPosition,
-    teamParticipants,
-    collectionId,
-    matchUpType,
-    dualMatchUp,
-    tieMatchUp,
-    tieFormat,
-    structure,
-    ...SUCCESS
-  };
-}
-
 function replaceTieMatchUpParticipantId(params) {
   const matchUpContext = getTieMatchUpContext(params);
   if (matchUpContext.error)
@@ -52880,338 +53906,6 @@ function replaceTieMatchUpParticipantId(params) {
   return { ...SUCCESS, modifiedLineUp, participantRemoved, participantAdded };
 }
 
-function removeCollectionAssignments({
-  collectionPosition,
-  teamParticipantId,
-  dualMatchUpSide,
-  drawDefinition,
-  participantIds,
-  collectionId
-}) {
-  if (!collectionId || !collectionPosition || !Array.isArray(participantIds))
-    return {
-      modifiedLineUp: dualMatchUpSide?.lineUp || [],
-      error: INVALID_VALUES
-    };
-  const lineUp = dualMatchUpSide?.lineUp || getTeamLineUp({
-    participantId: teamParticipantId,
-    drawDefinition
-  })?.lineUp;
-  const previousParticipantIds = [];
-  const assignmentsRemoved = [];
-  const modifiedLineUp = lineUp?.map((teamCompetitor) => {
-    if (!participantIds.includes(teamCompetitor.participantId)) {
-      return teamCompetitor;
-    }
-    const collectionAssignments = teamCompetitor.collectionAssignments?.filter((assignment) => {
-      const target = assignment.collectionId === collectionId && assignment.collectionPosition === collectionPosition;
-      if (target) {
-        if (assignment.previousParticipantId) {
-          previousParticipantIds.push(assignment.previousParticipantId);
-        }
-        assignmentsRemoved.push({
-          participantId: teamCompetitor.participantId,
-          ...assignment
-        });
-      }
-      return !target;
-    });
-    return {
-      participantId: teamCompetitor.participantId,
-      collectionAssignments
-    };
-  }).filter(Boolean) || [];
-  return { modifiedLineUp, assignmentsRemoved, previousParticipantIds };
-}
-
-function assignTieMatchUpParticipantId(params) {
-  const matchUpContext = getTieMatchUpContext(params);
-  if (matchUpContext.error)
-    return matchUpContext;
-  const stack = "assignTieMatchUpParticipantId";
-  let teamParticipantId = params.teamParticipantId;
-  const { tournamentRecord, drawDefinition, participantId, event } = params;
-  if (!participantId) {
-    return decorateResult({ result: { error: MISSING_PARTICIPANT_ID }, stack });
-  }
-  if (params.sideNumber && ![1, 2].includes(params.sideNumber)) {
-    return decorateResult({ result: { error: INVALID_SIDE_NUMBER }, stack });
-  }
-  const {
-    inContextDualMatchUp,
-    inContextTieMatchUp,
-    relevantAssignments,
-    collectionPosition,
-    teamParticipants,
-    collectionId,
-    matchUpType,
-    dualMatchUp,
-    tieFormat
-  } = matchUpContext;
-  const allTieIndividualParticipantIds = inContextTieMatchUp?.sides?.flatMap(
-    (side) => side.participant?.individualParticipantIds || side.participant?.participantId || []
-  );
-  if (allTieIndividualParticipantIds?.includes(participantId)) {
-    return decorateResult({ result: { ...SUCCESS }, stack });
-  }
-  teamParticipantId = teamParticipantId || params.sideNumber && inContextDualMatchUp?.sides?.find(
-    (side) => side.sideNumber === params.sideNumber
-  )?.participantId;
-  const {
-    tournamentParticipants: [participantToAssign]
-  } = getTournamentParticipants({
-    tournamentRecord,
-    participantFilters: {
-      participantIds: [participantId]
-    }
-  });
-  if (!participantToAssign) {
-    return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND }, stack });
-  }
-  const { appliedPolicies } = getAppliedPolicies({
-    tournamentRecord,
-    drawDefinition,
-    event
-  });
-  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] || appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] || POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
-  if (matchUpActionsPolicy?.participants?.enforceGender && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== participantToAssign.person?.sex) {
-    return { error: INVALID_PARTICIPANT, info: "Gender mismatch" };
-  }
-  const { individualParticipantIds, participantType } = participantToAssign;
-  if (matchUpType === SINGLES$1 && participantType !== INDIVIDUAL) {
-    return { error: INVALID_PARTICIPANT_TYPE };
-  }
-  const relevantParticipantIds = participantType === INDIVIDUAL ? [participantId] : individualParticipantIds;
-  const participantTeam = teamParticipantId && teamParticipants?.find(
-    ({ participantId: participantId2 }) => participantId2 === teamParticipantId
-  ) || teamParticipants?.find(
-    ({ individualParticipantIds: individualParticipantIds2 }) => overlap(relevantParticipantIds, individualParticipantIds2)
-  );
-  if (!participantTeam) {
-    return { error: TEAM_NOT_FOUND };
-  }
-  if (!teamParticipantId)
-    teamParticipantId = participantTeam.participantId;
-  if (!teamParticipantId)
-    return { error: PARTICIPANT_NOT_FOUND };
-  const teamAssignment = relevantAssignments?.find(
-    (assignment) => assignment.participantId === participantTeam?.participantId
-  );
-  const teamDrawPosition = teamAssignment?.drawPosition;
-  const teamSide = inContextTieMatchUp?.sides?.find(
-    (side) => side.drawPosition === teamDrawPosition
-  );
-  const sideNumber = params.sideNumber || teamSide?.sideNumber;
-  if (!tieFormat) {
-    return { error: MISSING_TIE_FORMAT };
-  }
-  const collectionDefinition = tieFormat.collectionDefinitions?.find(
-    (collectionDefinition2) => collectionDefinition2.collectionId === collectionId
-  );
-  if (!collectionDefinition)
-    return { error: MISSING_COLLECTION_DEFINITION };
-  if (!dualMatchUp?.sides?.length) {
-    const { extension } = findExtension$2({
-      element: drawDefinition,
-      name: LINEUPS
-    });
-    const lineUps = makeDeepCopy(extension?.value || {}, false, true);
-    const extractSideDetail = ({
-      displaySideNumber,
-      drawPosition,
-      sideNumber: sideNumber2
-    }) => ({ drawPosition, sideNumber: sideNumber2, displaySideNumber });
-    if (dualMatchUp) {
-      dualMatchUp.sides = inContextDualMatchUp?.sides?.map((side) => {
-        const participantId2 = side.participantId;
-        return {
-          ...extractSideDetail(side),
-          lineUp: participantId2 && lineUps[participantId2] || []
-        };
-      });
-    }
-  }
-  const dualMatchUpSide = dualMatchUp?.sides?.find(
-    (side) => side.sideNumber === sideNumber
-  );
-  const tieMatchUpSide = inContextTieMatchUp?.sides?.find(
-    (side) => side.sideNumber === sideNumber
-  );
-  const lineUp = dualMatchUpSide?.lineUp || getTeamLineUp({
-    participantId: teamParticipantId,
-    drawDefinition
-  })?.lineUp;
-  const targetAssignments = lineUp?.filter(
-    (participantAssignment) => participantAssignment.collectionAssignments?.find(
-      (assignment) => assignment.collectionPosition === collectionPosition && assignment.collectionId === collectionId && !assignment.previousParticipantId
-    )
-  );
-  const assignedParticipantIds = targetAssignments?.map(
-    (assignment) => assignment?.participantId
-  );
-  const participantIds = assignedParticipantIds?.length > 1 && assignedParticipantIds || (participantType === PAIR ? participantToAssign.individualParticipantIds : [participantId]);
-  const removeResult = removeCollectionAssignments({
-    collectionPosition,
-    teamParticipantId,
-    dualMatchUpSide,
-    drawDefinition,
-    participantIds,
-    collectionId
-  });
-  if (removeResult.error)
-    return decorateResult({ result: removeResult, stack });
-  const { modifiedLineUp } = removeResult;
-  let deleteParticipantId;
-  if (matchUpType === DOUBLES$1) {
-    if (participantType !== PAIR) {
-      let result = updateLineUp({
-        collectionPosition,
-        teamParticipantId,
-        drawDefinition,
-        modifiedLineUp,
-        participantId,
-        collectionId,
-        tieFormat
-      });
-      if (result?.error)
-        return decorateResult({ result, stack });
-      result = addParticipantId2Pair({
-        side: tieMatchUpSide
-      });
-      if (result.error)
-        return result;
-      deleteParticipantId = result.deleteParticipantId;
-      if (dualMatchUpSide)
-        dualMatchUpSide.lineUp = modifiedLineUp;
-      if (dualMatchUp) {
-        modifyMatchUpNotice({
-          tournamentId: tournamentRecord?.tournamentId,
-          matchUp: dualMatchUp,
-          context: stack,
-          drawDefinition
-        });
-      }
-    } else if (participantType === PAIR) {
-      for (const participantId2 of participantIds) {
-        updateLineUp({
-          collectionPosition,
-          teamParticipantId,
-          drawDefinition,
-          modifiedLineUp,
-          participantId: participantId2,
-          collectionId,
-          tieFormat
-        });
-      }
-    }
-  } else {
-    const result = updateLineUp({
-      collectionPosition,
-      teamParticipantId,
-      drawDefinition,
-      modifiedLineUp,
-      participantId,
-      collectionId,
-      tieFormat
-    });
-    if (result?.error)
-      return result;
-  }
-  if (dualMatchUpSide)
-    dualMatchUpSide.lineUp = modifiedLineUp;
-  if (dualMatchUp)
-    modifyMatchUpNotice({
-      tournamentId: tournamentRecord?.tournamentId,
-      matchUp: dualMatchUp,
-      context: stack,
-      drawDefinition
-    });
-  if (deleteParticipantId) {
-    const { error } = deleteParticipants({
-      participantIds: [deleteParticipantId],
-      tournamentRecord
-    });
-    if (error)
-      console.log("cleanup");
-  }
-  return { ...SUCCESS, modifiedLineUp };
-  function addParticipantId2Pair({ side }) {
-    let deleteParticipantId2;
-    if (!side.participant) {
-      const newPairParticipant = {
-        individualParticipantIds: [participantId],
-        participantRole: COMPETITOR,
-        participantType: PAIR
-      };
-      const result = addParticipant$1({
-        participant: newPairParticipant,
-        pairOverride: true,
-        tournamentRecord
-      });
-      if (result.error)
-        return result;
-    } else {
-      const individualParticipantIds2 = side.participant.individualParticipantIds || [];
-      const sideParticipantsCount = individualParticipantIds2.filter(Boolean).length;
-      if (sideParticipantsCount === 1) {
-        const { participant } = getPairedParticipant({
-          participantIds: individualParticipantIds2,
-          tournamentRecord
-        });
-        individualParticipantIds2.push(participantId);
-        const { participant: existingParticipant } = getPairedParticipant({
-          participantIds: individualParticipantIds2,
-          tournamentRecord
-        });
-        if (!existingParticipant && participant) {
-          participant.individualParticipantIds = individualParticipantIds2;
-          const result = modifyParticipant({
-            pairOverride: true,
-            tournamentRecord,
-            participant
-          });
-          if (result.error)
-            return result;
-        } else {
-          deleteParticipantId2 = participant?.participantId;
-        }
-      }
-    }
-    return { ...SUCCESS, deleteParticipantId: deleteParticipantId2 };
-  }
-}
-function updateLineUp({
-  collectionPosition,
-  teamParticipantId,
-  drawDefinition,
-  modifiedLineUp,
-  participantId,
-  collectionId,
-  tieFormat
-}) {
-  const templateTeamLineUp = getTeamLineUp({
-    participantId: teamParticipantId,
-    drawDefinition
-  })?.lineUp;
-  const participantCompetitiorProfile = (modifiedLineUp || templateTeamLineUp)?.find((teamCompetitor) => teamCompetitor?.participantId === participantId);
-  const newAssignment = { collectionId, collectionPosition };
-  if (participantCompetitiorProfile) {
-    participantCompetitiorProfile.collectionAssignments.push(newAssignment);
-  } else {
-    const teamCompetitor = {
-      collectionAssignments: [newAssignment],
-      participantId
-    };
-    modifiedLineUp.push(teamCompetitor);
-  }
-  return updateTeamLineUp({
-    participantId: teamParticipantId,
-    lineUp: modifiedLineUp,
-    drawDefinition,
-    tieFormat
-  });
-}
-
 function removeTieMatchUpParticipantId(params) {
   const { tournamentRecord, drawDefinition, participantId, event } = params;
   const stack = "removeTieMatchUpParticiapantId";
@@ -55713,150 +56407,6 @@ function setOrderOfFinish(params) {
   return setOrderOfFinish$1(params);
 }
 
-const ASC = "ASC";
-const ASCENDING = "ASC";
-const DESC = "DESC";
-const DESCENDING = "DESC";
-const sortingConstants = { ASC, ASCENDING, DESC, DESCENDING };
-
-function generateLineUps(params) {
-  let { tieFormat } = params;
-  const {
-    useDefaultEventRanking,
-    tournamentRecord,
-    drawDefinition,
-    scaleAccessor,
-    // e.g. { scaleType: 'RANKINGS', scaleName: 'U18', accessor: 'wtnRating', sortOrder: 'ASC' }
-    singlesOnly,
-    // use singles scale for doubles events
-    attach,
-    // boolean - when true attach LINEUPS extension to drawDefinition and add new PAIR participants (where necessary)
-    event
-  } = params;
-  if (event?.eventType !== TEAM_EVENT)
-    return { error: INVALID_EVENT_TYPE };
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!tieFormat && !drawDefinition)
-    return { error: DRAW_DEFINITION_NOT_FOUND };
-  tieFormat = tieFormat || resolveTieFormat({ drawDefinition, event })?.tieFormat;
-  if (validateTieFormat({ tieFormat }).error)
-    return { error: INVALID_TIE_FORMAT };
-  if (typeof scaleAccessor !== "object" && !useDefaultEventRanking)
-    return { error: INVALID_VALUES, context: { scaleAccessor } };
-  const lineUps = {};
-  const targetEntries = (drawDefinition?.entries || event.entries).filter(
-    (entry) => entry?.entryStatus === DIRECT_ACCEPTANCE
-  );
-  const participantIds = targetEntries.map(getParticipantId);
-  const { participants = [] } = getParticipants$1({
-    withIndividualParticipants: true,
-    withScaleValues: true,
-    tournamentRecord
-  });
-  const teamParticipants = participants.filter(
-    ({ participantId }) => participantIds.includes(participantId)
-  );
-  const formatScaleType = (type) => type === RANKING$1 ? "rankings" : "ratings";
-  const defaultScaleName = event?.category?.categoryName || event?.category?.ageCategoryCode;
-  const {
-    scaleName = defaultScaleName,
-    scaleType = RANKING$1,
-    sortOrder,
-    accessor
-  } = scaleAccessor || {};
-  const formattedScaleType = formatScaleType(scaleType);
-  const getScaleValue = (individualParticipant, matchUpType) => {
-    let matchUpTypeScales = individualParticipant[formattedScaleType]?.[matchUpType];
-    if (!matchUpTypeScales && useDefaultEventRanking) {
-      matchUpTypeScales = individualParticipant[formattedScaleType]?.[SINGLES_MATCHUP];
-    }
-    if (Array.isArray(matchUpTypeScales)) {
-      const scaleValue = matchUpTypeScales.find(
-        (scale) => scale.scaleName === scaleName
-      )?.scaleValue;
-      if (isNumeric(scaleValue)) {
-        return scaleValue;
-      } else if (accessor && typeof scaleValue === "object")
-        return scaleValue[accessor];
-    }
-    return 0;
-  };
-  const sortMethod = (a, b, matchUpType) => {
-    const x = sortOrder === DESCENDING ? b : a;
-    const y = sortOrder === DESCENDING ? a : b;
-    return getScaleValue(x, matchUpType) - getScaleValue(y, matchUpType);
-  };
-  const singlesScaleSort = (a, b) => sortMethod(a, b, SINGLES_MATCHUP);
-  const doublesScaleSort = (a, b) => sortMethod(a, b, DOUBLES_MATCHUP);
-  const participantIdPairs = [];
-  const collectionDefinitions = tieFormat.collectionDefinitions || [];
-  for (const teamParticipant of teamParticipants) {
-    const singlesSort = teamParticipant.individualParticipants.sort(singlesScaleSort);
-    const doublesSort = singlesOnly ? singlesSort : teamParticipant.individualParticipants.sort(doublesScaleSort);
-    const participantAssignments = {};
-    for (const collectionDefinition of collectionDefinitions) {
-      const collectionParticipantIds = [];
-      const { collectionId, matchUpCount, matchUpType, gender } = collectionDefinition;
-      const singlesMatchUp = matchUpType === SINGLES_MATCHUP;
-      generateRange(0, matchUpCount).forEach((i) => {
-        const typeSort = singlesMatchUp ? singlesSort : doublesSort;
-        const collectionPosition = i + 1;
-        const participantIds2 = [];
-        generateRange(0, singlesMatchUp ? 1 : 2).forEach((i2) => {
-          const nextParticipantId = typeSort.find((participant) => {
-            const targetGender = [MALE, FEMALE].includes(gender) && gender || gender === MIXED && [MALE, FEMALE][i2];
-            return (!targetGender || targetGender === participant.person.sex) && !collectionParticipantIds.includes(participant.participantId);
-          }).participantId;
-          if (nextParticipantId) {
-            participantIds2.push(nextParticipantId);
-            collectionParticipantIds.push(nextParticipantId);
-            if (!participantAssignments[nextParticipantId])
-              participantAssignments[nextParticipantId] = [];
-            participantAssignments[nextParticipantId].push({
-              collectionPosition,
-              collectionId
-            });
-          }
-        });
-        if (!singlesMatchUp)
-          participantIdPairs.push(participantIds2);
-      });
-    }
-    const lineUp = Object.keys(participantAssignments).map((participantId) => ({
-      collectionAssignments: participantAssignments[participantId],
-      participantId
-    }));
-    lineUps[teamParticipant.participantId] = lineUp;
-  }
-  const participantsToAdd = [];
-  for (const pairParticipantIds of participantIdPairs) {
-    const { participant: existingPairParticipant } = getPairedParticipant({
-      tournamentParticipants: participants,
-      participantIds: pairParticipantIds
-    });
-    if (!existingPairParticipant) {
-      const newPairParticipant = {
-        individualParticipantIds: pairParticipantIds,
-        participantRole: COMPETITOR,
-        participantType: PAIR
-      };
-      participantsToAdd.push(newPairParticipant);
-    }
-  }
-  if (attach) {
-    while (participantsToAdd.length) {
-      addParticipant$1({
-        participant: participantsToAdd.pop(),
-        tournamentRecord
-      });
-    }
-    const extension = { name: LINEUPS, value: lineUps };
-    addExtension$1({ element: drawDefinition, extension });
-  }
-  return { ...SUCCESS, lineUps, participantsToAdd };
-}
-
 function modifyDrawName({ event, drawId, drawDefinition, drawName }) {
   if (!drawName || typeof drawName !== "string")
     return { error: INVALID_VALUES, drawName };
@@ -57148,6 +57698,12 @@ function enableTieAutoCalc(params) {
   return enableTieAutoCalc$1(params);
 }
 
+function resetMatchUpLineUps(params) {
+  if (!params.tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  return resetMatchUpLineUps$1(params);
+}
+
 const eventGovernor = {
   generateQualifyingStructure,
   attachQualifyingStructure,
@@ -57260,6 +57816,7 @@ const eventGovernor = {
   assignTieMatchUpParticipantId,
   removeTieMatchUpParticipantId,
   replaceTieMatchUpParticipantId,
+  resetMatchUpLineUps,
   updateTeamLineUp,
   validateLineUp,
   getTeamLineUp
@@ -60008,513 +60565,6 @@ function generatePairParticipantName({
   return participantName;
 }
 
-function generateOutcomeFromScoreString(params) {
-  const { matchUpFormat, matchUpStatus, winningSide, scoreString } = params;
-  if (!scoreString)
-    return {
-      outcome: {
-        ...toBePlayed,
-        winningSide,
-        matchUpStatus
-      }
-    };
-  if (winningSide && ![1, 2, void 0].includes(winningSide))
-    return { error: INVALID_VALUES, winningSide };
-  const neutralParsedSets = scoreString && parseScoreString({ scoreString });
-  const score = {};
-  const winningScoreString = generateScoreString({
-    sets: neutralParsedSets,
-    matchUpFormat
-  });
-  const losingScoreString = generateScoreString({
-    sets: neutralParsedSets,
-    reversed: true,
-    matchUpFormat
-  });
-  if (winningSide === 2) {
-    score.scoreStringSide1 = losingScoreString;
-    score.scoreStringSide2 = winningScoreString;
-  } else {
-    score.scoreStringSide1 = winningScoreString;
-    score.scoreStringSide2 = losingScoreString;
-  }
-  score.sets = parseScoreString({ scoreString: score.scoreStringSide1 });
-  return definedAttributes({
-    outcome: {
-      matchUpStatus,
-      winningSide,
-      score
-    }
-  });
-}
-
-const defaultStatusProfile = {
-  [WALKOVER$2]: 2,
-  [DOUBLE_WALKOVER]: 1,
-  [DOUBLE_DEFAULT]: 1,
-  [RETIRED$1]: 1,
-  [DEFAULTED]: 4
-};
-function generateOutcome(params) {
-  let { defaultWithScorePercent = 2, winningSide } = params;
-  const {
-    matchUpStatusProfile = defaultStatusProfile,
-    // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
-    matchUpFormat = FORMAT_STANDARD,
-    pointsPerMinute = 1,
-    sideWeight = 4
-  } = params;
-  if (!isValid(matchUpFormat))
-    return { error: INVALID_MATCHUP_FORMAT };
-  if (typeof matchUpStatusProfile !== "object")
-    return { error: INVALID_VALUES };
-  if (defaultWithScorePercent > 100)
-    defaultWithScorePercent = 100;
-  if (isNaN(defaultWithScorePercent) || isNaN(pointsPerMinute) || isNaN(sideWeight))
-    return { error: INVALID_VALUES };
-  const matchUpStatuses = Object.keys(matchUpStatusProfile).filter(
-    (matchUpStatus2) => Object.keys(matchUpStatusConstants).includes(matchUpStatus2) && matchUpStatus2 !== COMPLETED$1
-  );
-  const matchUpStatusTotals = Object.keys(matchUpStatuses).reduce(
-    (total, key) => total + matchUpStatusProfile[key],
-    0
-  );
-  if (matchUpStatusTotals > 100)
-    return { error: INVALID_VALUES, matchUpStatusProfile };
-  const matchUpStatusMap = matchUpStatuses.reduce(
-    (statusMap, matchUpStatus2) => {
-      statusMap.pointer = statusMap.pointer + matchUpStatusProfile[matchUpStatus2];
-      statusMap.valueMap.push([statusMap.pointer, matchUpStatus2]);
-      return statusMap;
-    },
-    { pointer: 0, valueMap: [] }
-  );
-  const outcomePointer = randomInt(1, 100);
-  const matchUpStatus = (matchUpStatusMap.valueMap.find(
-    (item) => outcomePointer <= item[0]
-  ) || [100, COMPLETED$1])[1];
-  const noScore = { sets: [], scoreStringSide1: "", side2ScoreString: "" };
-  if ([WALKOVER$2, DEFAULTED].includes(matchUpStatus)) {
-    winningSide = winningSide || randomInt(1, 2);
-    const outcome2 = {
-      score: noScore,
-      winningSide,
-      matchUpStatus
-    };
-    const scoreDefaulted = matchUpStatus === DEFAULTED && randomInt(1, 100) > 100 - defaultWithScorePercent;
-    if (!scoreDefaulted)
-      return { outcome: outcome2 };
-  } else if ([DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(matchUpStatus)) {
-    return { outcome: { score: noScore, matchUpStatus } };
-  }
-  const parsedFormat = parse(matchUpFormat);
-  const { bestOf, setFormat, finalSetFormat } = parsedFormat || {};
-  const sets = [];
-  const weightedSide = randomInt(0, 1);
-  const weightedRange = winningSide ? [winningSide - 1] : [
-    ...generateRange(0, sideWeight).map(() => weightedSide),
-    1 - weightedSide
-  ];
-  const incompleteSet = [RETIRED$1, DEFAULTED, INCOMPLETE, SUSPENDED].includes(
-    matchUpStatus
-  );
-  const incompleteAt = incompleteSet && (randomPop(generateRange(1, bestOf)) || 1);
-  let weightedWinningSide;
-  for (const setNumber of generateRange(1, (bestOf || 0) + 1)) {
-    const isFinalSet = setNumber === bestOf;
-    const { set, incomplete, winningSideNumber } = generateSet({
-      incomplete: incompleteAt === setNumber,
-      matchUpStatus,
-      pointsPerMinute,
-      setFormat: isFinalSet && finalSetFormat || setFormat,
-      setNumber,
-      weightedRange
-    });
-    sets.push(set);
-    if (incomplete) {
-      weightedWinningSide = winningSideNumber;
-      break;
-    }
-    const analysis2 = analyzeMatchUp({
-      matchUp: { score: { sets }, matchUpFormat }
-    });
-    if (analysis2.calculatedWinningSide)
-      break;
-  }
-  const analysis = analyzeMatchUp({
-    matchUp: { score: { sets }, matchUpFormat }
-  });
-  const matchUpWinningSide = weightedWinningSide ? winningSide || weightedWinningSide : analysis.calculatedWinningSide;
-  const { score } = matchUpScore({
-    score: { sets },
-    winningSide: matchUpWinningSide,
-    matchUpStatus
-  });
-  const outcome = {
-    score,
-    winningSide: matchUpWinningSide,
-    matchUpStatus
-  };
-  return { outcome };
-}
-function generateSet({
-  weightedRange = [0, 1],
-  pointsPerMinute,
-  matchUpStatus,
-  incomplete,
-  setFormat,
-  setNumber
-}) {
-  const set = { setNumber };
-  const { setTo, tiebreakFormat, tiebreakAt, tiebreakSet, timed, minutes } = setFormat;
-  const weightIndex = randomInt(0, weightedRange.length - 1);
-  const reverseScores = weightedRange[weightIndex];
-  let winningSideNumber;
-  if (timed) {
-    const calcPoints = minutes * pointsPerMinute;
-    const pointsVariation = Math.round(calcPoints * 0.2);
-    const totalPoints = calcPoints + randomPop([1, -1]) * pointsVariation;
-    const sidePoints = weightedRandom(totalPoints, 2);
-    const scores = [sidePoints, totalPoints - sidePoints];
-    if (reverseScores)
-      scores.reverse();
-    winningSideNumber = weightedRange[weightIndex] + 1;
-    let highSide = scores[0] > scores[1] && 1 || scores[1] > scores[0] && 2 || 0;
-    if (incomplete) {
-      const [side1Score2, side2Score2] = scores;
-      Object.assign(set, { side1Score: side1Score2, side2Score: side2Score2 });
-      if (completedMatchUpStatuses.includes(matchUpStatus)) {
-        return { set, incomplete, winningSideNumber };
-      }
-      return { set, incomplete };
-    }
-    if (!highSide)
-      scores[randomInt(0, 1)] += 1;
-    highSide = scores[0] > scores[1] ? 1 : 2;
-    if (highSide !== winningSideNumber)
-      scores.reverse();
-    const [side1Score, side2Score] = scores;
-    Object.assign(set, {
-      side1Score,
-      side2Score,
-      winningSide: winningSideNumber
-    });
-    return { set };
-  } else if (incomplete) {
-    set.side1Score = randomInt(0, tiebreakAt);
-    set.side2Score = randomInt(0, tiebreakAt);
-    if (completedMatchUpStatuses.includes(matchUpStatus)) {
-      winningSideNumber = weightedRange[weightIndex] + 1;
-    }
-    return { set, incomplete, winningSideNumber };
-  } else {
-    const range = generateRange(1, setTo + 1).map((value) => generateRange(0, setTo + 2 - value).map(() => value)).flat();
-    const lowValue = range[randomInt(0, range.length - 1)];
-    const scores = setTo && getSetComplement({
-      isSide1: true,
-      tiebreakAt,
-      lowValue,
-      setTo
-    });
-    const isTiebreakSet = !scores;
-    const specifiedWinningSide = weightedRange.length === 1 && weightedRange[weightIndex] + 1;
-    if (!isTiebreakSet) {
-      if (specifiedWinningSide) {
-        const highSide = scores[0] > scores[1] ? 1 : 2;
-        if (highSide !== specifiedWinningSide)
-          scores.reverse();
-      } else if (reverseScores) {
-        scores.reverse();
-      }
-      const [side1Score, side2Score] = scores;
-      Object.assign(set, { side1Score, side2Score });
-    }
-    const setAnalysis = analyzeSet({
-      matchUpScoringFormat: { setFormat },
-      setObject: set
-    });
-    let tiebreakWinningSide;
-    if (setAnalysis.hasTiebreakCondition || isTiebreakSet) {
-      const { NoAD: tiebreakNoAd, tiebreakTo } = tiebreakFormat || tiebreakSet || {};
-      const range2 = generateRange(1, tiebreakTo + 1).map(
-        (value) => generateRange(0, tiebreakTo + 2 - value).map(() => value)
-      ).flat();
-      const lowValue2 = range2[randomInt(0, range2.length - 1)];
-      const scores2 = getTiebreakComplement({
-        isSide1: true,
-        tiebreakNoAd,
-        tiebreakTo,
-        lowValue: lowValue2
-      });
-      if (scores2) {
-        if (isTiebreakSet) {
-          const highSide = scores2[0] > scores2[1] ? 1 : 2;
-          if (specifiedWinningSide) {
-            if (highSide !== specifiedWinningSide)
-              scores2.reverse();
-          } else if (reverseScores) {
-            scores2.reverse();
-          }
-          [set.side1TiebreakScore, set.side2TiebreakScore] = scores2;
-          tiebreakWinningSide = scores2[0] > scores2[1] && 1 || scores2[1] > scores2[0] && 2 || void 0;
-        } else if (setAnalysis.leadingSide === 2) {
-          [set.side1TiebreakScore, set.side2TiebreakScore] = scores2;
-        } else {
-          [set.side2TiebreakScore, set.side1TiebreakScore] = scores2;
-        }
-      }
-    }
-    set.winningSide = setAnalysis.winningSide || setAnalysis.leadingSide || specifiedWinningSide || tiebreakWinningSide;
-  }
-  return { set };
-}
-
-function completeDrawMatchUps(params) {
-  const {
-    matchUpStatusProfile,
-    // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
-    completeAllMatchUps,
-    // qualifyingProfiles, // CONSIDER: allowing completionGoal per structureProfile
-    randomWinningSide,
-    tournamentRecord,
-    completionGoal,
-    drawDefinition,
-    event
-  } = params;
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
-  const matchUpFormat = params.matchUpFormat || drawDefinition.matchUpFormat || event?.matchUpFormat;
-  const sortedStructures = drawDefinition.structures.slice().sort(structureSort);
-  let completedCount = 0;
-  const { matchUps: firstRoundDualMatchUps, matchUpsMap } = getAllDrawMatchUps({
-    contextFilters: {
-      stages: [MAIN, QUALIFYING]
-    },
-    matchUpFilters: {
-      matchUpTypes: [TEAM$2],
-      roundNumbers: [1]
-    },
-    inContext: true,
-    drawDefinition
-  });
-  if (firstRoundDualMatchUps?.length) {
-    const categoryName = event?.category?.ageCategoryCode || event?.category?.categoryName;
-    if (categoryName) {
-      const scaleAccessor = {
-        scaleName: categoryName,
-        sortOrder: ASCENDING,
-        scaleType: RANKING$1
-      };
-      generateLineUps({
-        singlesOnly: true,
-        tournamentRecord,
-        drawDefinition,
-        scaleAccessor,
-        attach: true,
-        event
-      });
-    } else {
-      const structureId = firstRoundDualMatchUps[0]?.structureId;
-      const { positionAssignments } = getPositionAssignments$1({
-        drawDefinition,
-        structureId
-      });
-      if (positionAssignments?.length) {
-        const { tournamentParticipants: teamParticipants } = getTournamentParticipants({
-          participantFilters: { participantTypes: [TEAM$2] },
-          tournamentRecord
-        });
-        const assignParticipants = (dualMatchUp) => {
-          const singlesMatchUps = dualMatchUp.tieMatchUps.filter(
-            ({ matchUpType }) => matchUpType === SINGLES$1
-          );
-          const doublesMatchUps = dualMatchUp.tieMatchUps.filter(
-            ({ matchUpType }) => matchUpType === DOUBLES$1
-          );
-          singlesMatchUps.forEach((singlesMatchUp, i) => {
-            const tieMatchUpId = singlesMatchUp.matchUpId;
-            singlesMatchUp.sides.forEach((side) => {
-              const { drawPosition } = side;
-              const teamParticipant = teamParticipants?.find(
-                (teamParticipant2) => {
-                  const { participantId } = teamParticipant2;
-                  const assignment = positionAssignments.find(
-                    (assignment2) => assignment2.participantId === participantId
-                  );
-                  return assignment?.drawPosition === drawPosition;
-                }
-              );
-              if (teamParticipant) {
-                const individualParticipantId = teamParticipant.individualParticipantIds[i];
-                assignTieMatchUpParticipantId({
-                  teamParticipantId: teamParticipant.participantId,
-                  participantId: individualParticipantId,
-                  tournamentRecord,
-                  drawDefinition,
-                  tieMatchUpId,
-                  event
-                });
-              }
-            });
-          });
-          doublesMatchUps.forEach((doublesMatchUp, i) => {
-            const tieMatchUpId = doublesMatchUp.matchUpId;
-            doublesMatchUp.sides.forEach((side) => {
-              const { drawPosition } = side;
-              const teamParticipant = teamParticipants?.find(
-                (teamParticipant2) => {
-                  const { participantId } = teamParticipant2;
-                  const assignment = positionAssignments.find(
-                    (assignment2) => assignment2.participantId === participantId
-                  );
-                  return assignment?.drawPosition === drawPosition;
-                }
-              );
-              if (teamParticipant) {
-                const individualParticipantIds = teamParticipant.individualParticipantIds.slice(
-                  i * 2,
-                  i * 2 + 2
-                );
-                individualParticipantIds.forEach((individualParticipantId) => {
-                  assignTieMatchUpParticipantId({
-                    teamParticipantId: teamParticipant.participantId,
-                    participantId: individualParticipantId,
-                    tournamentRecord,
-                    drawDefinition,
-                    tieMatchUpId,
-                    event
-                  });
-                });
-              }
-            });
-          });
-        };
-        firstRoundDualMatchUps.forEach(assignParticipants);
-      }
-    }
-  }
-  const scoreString = typeof completeAllMatchUps === "string" && completeAllMatchUps;
-  const matchUpStatus = scoreString && COMPLETED$1;
-  for (const structure of sortedStructures) {
-    if (completedCount >= completionGoal)
-      break;
-    const { matchUps } = getAllStructureMatchUps({
-      matchUpFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
-      afterRecoveryTimes: false,
-      tournamentRecord,
-      inContext: true,
-      drawDefinition,
-      matchUpsMap,
-      structure,
-      event
-    });
-    const sortedMatchUpIds = matchUps.filter(({ winningSide }) => !winningSide).sort(matchUpSort).map(getMatchUpId);
-    for (const matchUpId of sortedMatchUpIds) {
-      if (!isNaN(completionGoal) && completedCount >= completionGoal)
-        break;
-      const { matchUps: matchUps2 } = getAllStructureMatchUps({
-        matchUpFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
-        afterRecoveryTimes: false,
-        tournamentRecord,
-        inContext: true,
-        drawDefinition,
-        matchUpsMap,
-        structure,
-        event
-      });
-      const targetMatchUp = matchUps2.find(
-        (matchUp) => matchUp.matchUpId === matchUpId
-      );
-      const isDoubleExit = [DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(
-        targetMatchUp.matchUpStatus
-      );
-      if (targetMatchUp?.readyToScore && !isDoubleExit) {
-        const result = smartComplete({
-          winningSide: !randomWinningSide && 1,
-          matchUpStatusProfile,
-          tournamentRecord,
-          drawDefinition,
-          targetMatchUp,
-          matchUpFormat,
-          matchUpStatus,
-          scoreString,
-          event
-        });
-        if (result?.error)
-          return result;
-        completedCount += 1;
-      }
-    }
-  }
-  return { ...SUCCESS, completedCount };
-}
-function completeDrawMatchUp(params) {
-  const {
-    matchUpStatusCodes,
-    policyDefinitions,
-    tournamentRecord,
-    drawDefinition,
-    targetMatchUp,
-    matchUpStatus,
-    matchUpFormat,
-    scoreString,
-    winningSide,
-    event
-  } = params;
-  if (!targetMatchUp || targetMatchUp.matchUpStatus === BYE) {
-    return;
-  }
-  const { matchUpId } = targetMatchUp || {};
-  const { outcome } = generateOutcomeFromScoreString({
-    matchUpFormat,
-    matchUpStatus,
-    scoreString,
-    winningSide
-  });
-  if (matchUpStatusCodes)
-    outcome.matchUpStatusCodes = matchUpStatusCodes;
-  return setMatchUpStatus$1({
-    tournamentRecord,
-    policyDefinitions,
-    drawDefinition,
-    matchUpFormat,
-    matchUpId,
-    outcome,
-    event
-  });
-}
-function smartComplete(params) {
-  const {
-    matchUpStatusProfile = {},
-    tournamentRecord,
-    policyDefinitions,
-    drawDefinition,
-    matchUpStatus,
-    matchUpFormat,
-    targetMatchUp,
-    scoreString,
-    winningSide,
-    event
-  } = params;
-  if (scoreString || matchUpStatus)
-    return completeDrawMatchUp(params);
-  const { matchUpId } = targetMatchUp || {};
-  const { outcome } = generateOutcome({
-    matchUpStatusProfile,
-    matchUpFormat,
-    winningSide
-  });
-  return setMatchUpStatus$1({
-    policyDefinitions,
-    tournamentRecord,
-    drawDefinition,
-    matchUpFormat,
-    matchUpId,
-    outcome,
-    event
-  });
-}
-
 function generateFlightDrawDefinitions({
   matchUpStatusProfile,
   completeAllMatchUps,
@@ -62513,7 +62563,6 @@ const mocksGovernor = {
   generateOutcomeFromScoreString,
   generateTournamentRecord,
   generateEventWithDraw,
-  completeDrawMatchUps,
   generateParticipants,
   parseScoreString,
   generateOutcome,