tods-competition-factory 1.8.6 → 1.8.7

package/dist/forge/query.mjs

@@ -9867,26 +9867,161 @@ function getCompetitionVenues({
   );
 }
 
-function getParticipantEventDetails({
-  tournamentRecord,
-  participantId
+function validateSchedulingProfile({
+  tournamentRecords,
+  schedulingProfile
 }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!participantId)
-    return { error: MISSING_PARTICIPANT_ID };
-  const relevantParticipantIds = [participantId].concat(
-    (tournamentRecord.participants || []).filter(
-      (participant) => participant?.participantType && [TEAM$2, PAIR].includes(participant.participantType) && participant.individualParticipantIds?.includes(participantId)
-    ).map((participant) => participant.participantId)
+  if (!schedulingProfile)
+    return { valid: true };
+  if (!Array.isArray(schedulingProfile))
+    return { valid: false, error: INVALID_VALUES };
+  const { venueIds, tournamentsMap } = getAllRelevantSchedulingIds({
+    tournamentRecords
+  });
+  let error, info;
+  const isValid = schedulingProfile.every((dateSchedule) => {
+    const { scheduleDate, venues } = dateSchedule;
+    if (!isValidDateString(scheduleDate)) {
+      return false;
+    }
+    return venues.every((venueProfile) => {
+      const { venueId, rounds } = venueProfile;
+      if (typeof venueId !== "string") {
+        info = "venueId should be a string";
+        return false;
+      }
+      if (!Array.isArray(rounds)) {
+        info = "rounds should be an array";
+        return false;
+      }
+      if (!venueIds.includes(venueId)) {
+        error = VENUE_NOT_FOUND;
+        return false;
+      }
+      const validRounds = rounds.every((round) => {
+        if (!round) {
+          info = "empty round";
+          return false;
+        }
+        const {
+          roundSegment,
+          tournamentId,
+          structureId,
+          roundNumber,
+          eventId,
+          drawId
+        } = round;
+        const rounds2 = tournamentsMap?.[tournamentId]?.[eventId]?.[drawId]?.[structureId];
+        const validRound = rounds2?.includes(roundNumber);
+        if (!validRound)
+          info = "Invalid rounds";
+        const { segmentNumber, segmentsCount } = roundSegment || {};
+        const validSegment = !roundSegment || isConvertableInteger(segmentNumber) && isPowerOf2(segmentsCount) && segmentNumber <= segmentsCount;
+        if (!validSegment)
+          info = "Invalid segment";
+        return validRound && validSegment;
+      });
+      return !validRounds ? false : true;
+    });
+  });
+  if (!isValid && !error) {
+    error = INVALID_VALUES;
+  }
+  return { valid: !!isValid, error, info };
+}
+function tournamentRelevantSchedulingIds(params) {
+  const { tournamentRecord = {}, tournamentMap = {}, requireCourts } = params;
+  const tournamentIds = [];
+  const structureIds = [];
+  const eventIds = [];
+  const drawIds = [];
+  const venueIds = (tournamentRecord?.venues || []).map(
+    ({ venueId, courts }) => (!requireCourts || courts?.length) && venueId
   );
-  const relevantEvents = (tournamentRecord.events || []).filter((event) => {
-    const enteredParticipantIds = (event?.entries || []).map(
-      (entry) => entry.participantId
-    );
-    return overlap(enteredParticipantIds, relevantParticipantIds);
-  }).map((event) => ({ eventName: event.eventName, eventId: event.eventId }));
-  return { eventDetails: relevantEvents };
+  const tournamentId = tournamentRecord?.tournamentId;
+  if (tournamentId) {
+    tournamentIds.push(tournamentId);
+    tournamentMap[tournamentId] = {};
+    const events = tournamentRecord?.events || [];
+    events.forEach((event) => {
+      const eventId = event.eventId;
+      eventIds.push(eventId);
+      tournamentMap[tournamentId][eventId] = {};
+      (event.drawDefinitions || []).forEach((drawDefinition) => {
+        const drawId = drawDefinition.drawId;
+        drawIds.push(drawId);
+        tournamentMap[tournamentId][eventId][drawId] = {};
+        const { structures } = getDrawStructures({ drawDefinition });
+        (structures || []).forEach((structure) => {
+          const structureId = structure.structureId;
+          const { matchUps } = getAllStructureMatchUps({ structure });
+          const { roundMatchUps } = getRoundMatchUps({ matchUps });
+          const rounds = roundMatchUps && Object.keys(roundMatchUps).map(
+            (roundNumber) => parseInt(roundNumber)
+          );
+          tournamentMap[tournamentId][eventId][drawId][structureId] = rounds;
+          structureIds.push(structureId);
+          if (structure.structures?.length) {
+            structure.structures.forEach((itemStructure) => {
+              structureIds.push(itemStructure.structureId);
+              tournamentMap[tournamentId][eventId][drawId][itemStructure.structureId] = rounds;
+            });
+          }
+        });
+      });
+    });
+  }
+  return {
+    tournamentMap,
+    tournamentIds,
+    structureIds,
+    venueIds,
+    eventIds,
+    drawIds
+  };
+}
+function getAllRelevantSchedulingIds(params) {
+  const records = params?.tournamentRecords && Object.values(params?.tournamentRecords) || [];
+  const tournamentsMap = {};
+  const { venueIds, eventIds, drawIds, structureIds, tournamentIds } = records.reduce(
+    (aggregator, tournamentRecord) => {
+      const {
+        tournamentIds: tournamentIds2,
+        tournamentMap,
+        structureIds: structureIds2,
+        venueIds: venueIds2,
+        eventIds: eventIds2,
+        drawIds: drawIds2
+      } = tournamentRelevantSchedulingIds({
+        tournamentRecord
+      });
+      venueIds2.forEach((venueId) => {
+        if (!aggregator.venueIds.includes(venueId))
+          aggregator.venueIds.push(venueId);
+      });
+      aggregator.tournamentIds.push(...tournamentIds2);
+      aggregator.structureIds.push(...structureIds2);
+      aggregator.eventIds.push(...eventIds2);
+      aggregator.drawIds.push(...drawIds2);
+      Object.assign(tournamentsMap, tournamentMap);
+      return aggregator;
+    },
+    {
+      tournamentIds: [],
+      structureIds: [],
+      venueIds: [],
+      eventIds: [],
+      drawIds: []
+    }
+  );
+  return {
+    tournamentsMap,
+    tournamentIds,
+    structureIds,
+    venueIds,
+    eventIds,
+    drawIds
+  };
 }
 
 function getTournamentInfo({ tournamentRecord }) {
@@ -9956,449 +10091,502 @@ function getCompetitionDateRange({
   return { startDate, endDate };
 }
 
-function getEliminationDrawSize({
-  participantsCount,
-  participantCount
-  // TODO: to be deprecated
+function getEventIdsAndDrawIds({
+  tournamentRecords
 }) {
-  participantsCount = participantsCount || participantCount;
-  if (!participantsCount)
-    return { error: INVALID_VALUES };
-  const drawSize = nextPowerOf2(participantsCount);
-  if (!drawSize)
-    return decorateResult({
-      result: { error: INVALID_VALUES },
-      stack: "getEliminationDrawSize",
-      context: { participantsCount }
-    });
-  return { drawSize };
+  if (!tournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const tournamentIds = Object.keys(tournamentRecords);
+  return tournamentIds.reduce(
+    (aggregator, tournamentId) => {
+      aggregator.tournamentIdMap[tournamentId] = [];
+      const tournamentRecord = tournamentRecords[tournamentId];
+      const events = tournamentRecord.events || [];
+      const eventIds = events.map(({ eventId }) => eventId);
+      const drawIds = events.map(
+        (event) => (event.drawDefinitions || []).map(({ drawId }) => drawId)
+      ).flat();
+      aggregator.tournamentIdMap[tournamentId].push(...eventIds, ...drawIds);
+      aggregator.eventIds.push(...eventIds);
+      aggregator.drawIds.push(...drawIds);
+      return aggregator;
+    },
+    { eventIds: [], drawIds: [], tournamentIdMap: {} }
+  );
 }
 
-function getStageEntries({
-  selected = true,
-  drawDefinition,
-  entryStatuses,
-  drawId,
-  event,
-  stage
+function getSchedulingProfile({
+  tournamentRecords
 }) {
-  let entries = event.entries ?? [];
-  if (drawId) {
-    const { flightProfile } = getFlightProfile({ event });
-    const flight = flightProfile?.flights?.find(
-      (flight2) => flight2.drawId === drawId
-    );
-    if (flight) {
-      entries = flight.drawEntries;
-    } else if (drawDefinition.entries) {
-      entries = drawDefinition?.entries;
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const { extension } = findExtension$1({
+    name: SCHEDULING_PROFILE,
+    tournamentRecords
+  });
+  let schedulingProfile = extension?.value || [];
+  if (schedulingProfile.length) {
+    const { venueIds } = getCompetitionVenues({
+      requireCourts: true,
+      tournamentRecords
+    });
+    const { eventIds, drawIds } = getEventIdsAndDrawIds({ tournamentRecords });
+    const { updatedSchedulingProfile, modifications, issues } = getUpdatedSchedulingProfile({
+      schedulingProfile,
+      venueIds,
+      eventIds,
+      drawIds
+    });
+    if (modifications) {
+      schedulingProfile = updatedSchedulingProfile;
+      const result = setSchedulingProfile({
+        tournamentRecords,
+        schedulingProfile
+      });
+      if (result.error)
+        return result;
+      return { schedulingProfile, modifications, issues };
     }
   }
-  const stageEntries = entries.filter(
-    (entry) => (!entryStatuses?.length || !entry.entryStatus || entryStatuses.includes(entry.entryStatus)) && (!stage || !entry.entryStage || entry.entryStage === stage) && (!selected || entry.entryStatus && STRUCTURE_SELECTED_STATUSES.includes(entry.entryStatus))
-  );
-  return { entries, stageEntries };
+  return { schedulingProfile, modifications: 0 };
 }
-
-function getSeedsCount(params) {
-  let {
-    drawSizeProgression = false,
-    policyDefinitions,
-    drawSize
-  } = params || {};
-  const {
-    requireParticipantCount = true,
-    tournamentRecord,
-    drawDefinition,
-    event
-  } = params || {};
-  const stack = "getSeedsCount";
-  const participantsCount = params?.participantsCount || params?.participantCount;
-  if (!policyDefinitions) {
-    const result = getPolicyDefinitions({
-      tournamentRecord,
-      drawDefinition,
-      event
-    });
-    if (result.error)
-      return decorateResult({ result, stack });
-    policyDefinitions = result.policyDefinitions;
-  }
-  const validParticpantCount = isConvertableInteger(participantsCount);
-  if (participantsCount && !validParticpantCount)
-    return decorateResult({
-      result: { error: INVALID_VALUES },
-      context: { participantsCount },
-      stack
-    });
-  if (requireParticipantCount && !validParticpantCount)
-    return decorateResult({
-      result: { error: MISSING_PARTICIPANT_COUNT },
-      stack
-    });
-  if (isNaN(drawSize)) {
-    if (participantsCount) {
-      ({ drawSize } = getEliminationDrawSize({
-        participantsCount
-      }));
-    } else {
-      return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
-    }
-  }
-  const consideredParticipantCount = requireParticipantCount && participantsCount || drawSize;
-  if (consideredParticipantCount > drawSize)
-    return { error: PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE };
-  const policy = policyDefinitions[POLICY_TYPE_SEEDING];
-  if (!policy)
-    return { error: INVALID_POLICY_DEFINITION };
-  const seedsCountThresholds = policy.seedsCountThresholds;
-  if (!seedsCountThresholds)
-    return { error: MISSING_SEEDCOUNT_THRESHOLDS };
-  if (policy.drawSizeProgression !== void 0)
-    drawSizeProgression = policy.drawSizeProgression;
-  const relevantThresholds = seedsCountThresholds.filter((threshold) => {
-    return drawSizeProgression ? threshold.drawSize <= drawSize : drawSize === threshold.drawSize;
+function setSchedulingProfile({ tournamentRecords, schedulingProfile }) {
+  const profileValidity = validateSchedulingProfile({
+    tournamentRecords,
+    schedulingProfile
   });
-  const seedsCount = relevantThresholds.reduce((seedsCount2, threshold) => {
-    return participantsCount >= threshold.minimumParticipantCount ? threshold.seedsCount : seedsCount2;
-  }, 0);
-  return { seedsCount };
+  if (profileValidity.error)
+    return profileValidity;
+  if (!schedulingProfile)
+    return removeExtension({ tournamentRecords, name: SCHEDULING_PROFILE });
+  const extension = {
+    name: SCHEDULING_PROFILE,
+    value: schedulingProfile
+  };
+  return addExtension({ tournamentRecords, extension });
 }
-
-function getEntriesAndSeedsCount({
-  policyDefinitions,
-  drawDefinition,
-  drawSize,
-  drawId,
-  event,
-  stage
+function getUpdatedSchedulingProfile({
+  schedulingProfile,
+  venueIds,
+  eventIds,
+  drawIds
 }) {
-  if (!event)
-    return { error: MISSING_EVENT };
-  const { entries, stageEntries } = getStageEntries({
-    drawDefinition,
-    drawId,
-    stage,
-    event
-  });
-  const participantsCount = stageEntries.length;
-  const { drawSize: eliminationDrawSize } = getEliminationDrawSize({
-    participantsCount
-  });
-  const result = getSeedsCount({
-    drawSize: drawSize ?? eliminationDrawSize,
-    participantsCount,
-    policyDefinitions
-  });
-  if (result.error)
-    return decorateResult({ result, stack: "getEntriesAndSeedsCount" });
-  const { seedsCount } = result;
-  return { entries, seedsCount, stageEntries };
-}
-
-function getMatchUpDailyLimits$1({ tournamentRecord }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const { policy } = findPolicy({
-    policyType: POLICY_TYPE_SCHEDULING,
-    tournamentRecord
-  });
-  const { extension } = findTournamentExtension({
-    name: SCHEDULE_LIMITS,
-    tournamentRecord
-  });
-  const tournamentDailyLimits = extension?.value?.dailyLimits;
-  const policyDailyLimits = policy?.defaultDailyLimits;
-  return { matchUpDailyLimits: tournamentDailyLimits || policyDailyLimits };
+  const issues = [];
+  const updatedSchedulingProfile = schedulingProfile?.map((dateSchedulingProfile) => {
+    const date = extractDate(dateSchedulingProfile?.scheduleDate);
+    if (!date) {
+      issues.push(`Invalid date: ${dateSchedulingProfile?.scheduledDate}`);
+      return;
+    }
+    const venues = (dateSchedulingProfile?.venues || []).map((venue) => {
+      const { rounds, venueId } = venue;
+      const venueExists = venueIds.includes(venueId);
+      if (!venueExists) {
+        issues.push(`Missing venueId: ${venueId}`);
+        return;
+      }
+      const filteredRounds = rounds.filter((round) => {
+        const validEventIdAndDrawId = eventIds.includes(round.eventId) && drawIds.includes(round.drawId);
+        if (!validEventIdAndDrawId)
+          issues.push(
+            `Invalid eventId: ${round.eventId} or drawId: ${round.drawId}`
+          );
+        return validEventIdAndDrawId;
+      });
+      if (!filteredRounds.length)
+        return;
+      return { venueId, rounds: filteredRounds };
+    }).filter(Boolean);
+    return venues.length && date && { ...dateSchedulingProfile, venues };
+  }).filter(Boolean);
+  const modifications = issues.length;
+  return { updatedSchedulingProfile, modifications, issues };
 }
 
-function getMatchUpDailyLimits({
+function findMatchUpFormatTiming({
+  defaultRecoveryMinutes = 0,
+  defaultAverageMinutes,
   tournamentRecords,
-  tournamentId
+  matchUpFormat,
+  categoryName,
+  categoryType,
+  tournamentId,
+  eventType,
+  eventId
 }) {
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
+  if (!isValid(matchUpFormat))
+    return { error: UNRECOGNIZED_MATCHUP_FORMAT };
   const tournamentIds = Object.keys(tournamentRecords).filter(
     (currentTournamentId) => !tournamentId || currentTournamentId === tournamentId
   );
-  let dailyLimits;
-  tournamentIds.forEach((tournamentId2) => {
-    const tournamentRecord = tournamentRecords[tournamentId2];
-    const { matchUpDailyLimits } = getMatchUpDailyLimits$1({
-      tournamentRecord
+  let timing;
+  tournamentIds.forEach((currentTournamentId) => {
+    if (timing)
+      return;
+    const tournamentRecord = tournamentRecords[currentTournamentId];
+    const event = eventId ? findEvent({ tournamentRecord, eventId })?.event : void 0;
+    timing = getMatchUpFormatTiming({
+      tournamentRecord,
+      matchUpFormat,
+      categoryName,
+      categoryType,
+      eventType,
+      event
     });
-    dailyLimits = matchUpDailyLimits;
+    return timing?.averageMinutes || timing?.recoveryMinutes;
   });
-  return { matchUpDailyLimits: dailyLimits };
+  return {
+    recoveryMinutes: timing?.recoveryMinutes || defaultRecoveryMinutes,
+    averageMinutes: timing?.averageMinutes || defaultAverageMinutes,
+    typeChangeRecoveryMinutes: timing?.typeChangeRecoveryMinutes || timing?.recoveryMinutes || defaultRecoveryMinutes
+  };
 }
 
-function validateSchedulingProfile({
-  tournamentRecords,
-  schedulingProfile
-}) {
-  if (!schedulingProfile)
-    return { valid: true };
-  if (!Array.isArray(schedulingProfile))
-    return { valid: false, error: INVALID_VALUES };
-  const { venueIds, tournamentsMap } = getAllRelevantSchedulingIds({
-    tournamentRecords
+function getRoundId(obj) {
+  const {
+    containerStructureId,
+    roundSegment,
+    isRoundRobin,
+    tournamentId,
+    roundNumber,
+    structureId,
+    eventId,
+    drawId
+  } = obj;
+  const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
+  const id = [
+    tournamentId,
+    // 1
+    eventId,
+    // 2
+    drawId,
+    // 3
+    relevantStructureId,
+    // 4
+    roundNumber
+    // 5
+  ].join("|");
+  return definedAttributes({
+    structureId: relevantStructureId,
+    roundSegment,
+    tournamentId,
+    roundNumber,
+    eventId,
+    drawId,
+    id
   });
-  let error, info;
-  const isValid = schedulingProfile.every((dateSchedule) => {
-    const { scheduleDate, venues } = dateSchedule;
-    if (!isValidDateString(scheduleDate)) {
-      return false;
-    }
-    return venues.every((venueProfile) => {
-      const { venueId, rounds } = venueProfile;
-      if (typeof venueId !== "string") {
-        info = "venueId should be a string";
-        return false;
-      }
-      if (!Array.isArray(rounds)) {
-        info = "rounds should be an array";
-        return false;
-      }
-      if (!venueIds.includes(venueId)) {
-        error = VENUE_NOT_FOUND;
-        return false;
-      }
-      const validRounds = rounds.every((round) => {
-        if (!round) {
-          info = "empty round";
-          return false;
-        }
-        const {
-          roundSegment,
-          tournamentId,
-          structureId,
-          roundNumber,
-          eventId,
-          drawId
-        } = round;
-        const rounds2 = tournamentsMap?.[tournamentId]?.[eventId]?.[drawId]?.[structureId];
-        const validRound = rounds2?.includes(roundNumber);
-        if (!validRound)
-          info = "Invalid rounds";
-        const { segmentNumber, segmentsCount } = roundSegment || {};
-        const validSegment = !roundSegment || isConvertableInteger(segmentNumber) && isPowerOf2(segmentsCount) && segmentNumber <= segmentsCount;
-        if (!validSegment)
-          info = "Invalid segment";
-        return validRound && validSegment;
-      });
-      return !validRounds ? false : true;
-    });
-  });
-  if (!isValid && !error) {
-    error = INVALID_VALUES;
-  }
-  return { valid: !!isValid, error, info };
 }
-function tournamentRelevantSchedulingIds(params) {
-  const { tournamentRecord = {}, tournamentMap = {}, requireCourts } = params;
-  const tournamentIds = [];
-  const structureIds = [];
-  const eventIds = [];
-  const drawIds = [];
-  const venueIds = (tournamentRecord?.venues || []).map(
-    ({ venueId, courts }) => (!requireCourts || courts?.length) && venueId
+function getRoundTiming({ round, matchUps, events, tournamentRecords }) {
+  const event = events.find((event2) => event2.eventId === round.eventId);
+  const { eventType, category, categoryType } = event || {};
+  const { categoryName, ageCategoryCode } = category || {};
+  const formatCounts = instanceCount(
+    matchUps.map(({ matchUpFormat }) => matchUpFormat)
   );
-  const tournamentId = tournamentRecord?.tournamentId;
-  if (tournamentId) {
-    tournamentIds.push(tournamentId);
-    tournamentMap[tournamentId] = {};
-    const events = tournamentRecord?.events || [];
-    events.forEach((event) => {
-      const eventId = event.eventId;
-      eventIds.push(eventId);
-      tournamentMap[tournamentId][eventId] = {};
-      (event.drawDefinitions || []).forEach((drawDefinition) => {
-        const drawId = drawDefinition.drawId;
-        drawIds.push(drawId);
-        tournamentMap[tournamentId][eventId][drawId] = {};
-        const { structures } = getDrawStructures({ drawDefinition });
-        (structures || []).forEach((structure) => {
-          const structureId = structure.structureId;
-          const { matchUps } = getAllStructureMatchUps({ structure });
-          const { roundMatchUps } = getRoundMatchUps({ matchUps });
-          const rounds = roundMatchUps && Object.keys(roundMatchUps).map(
-            (roundNumber) => parseInt(roundNumber)
-          );
-          tournamentMap[tournamentId][eventId][drawId][structureId] = rounds;
-          structureIds.push(structureId);
-          if (structure.structures?.length) {
-            structure.structures.forEach((itemStructure) => {
-              structureIds.push(itemStructure.structureId);
-              tournamentMap[tournamentId][eventId][drawId][itemStructure.structureId] = rounds;
-            });
-          }
-        });
-      });
+  let roundMinutes = 0;
+  Object.keys(formatCounts).forEach((matchUpFormat) => {
+    const formatCount = formatCounts[matchUpFormat];
+    const result = findMatchUpFormatTiming({
+      categoryName: categoryName || ageCategoryCode,
+      tournamentId: round.tournamentId,
+      eventId: round.eventId,
+      tournamentRecords,
+      matchUpFormat,
+      categoryType,
+      eventType
     });
-  }
-  return {
-    tournamentMap,
-    tournamentIds,
-    structureIds,
-    venueIds,
-    eventIds,
-    drawIds
-  };
+    if (result.error)
+      return result;
+    const formatMinutes = result.averageMinutes * formatCount;
+    if (!isNaN(roundMinutes))
+      roundMinutes += formatMinutes;
+    return void 0;
+  });
+  return { roundMinutes };
 }
-function getAllRelevantSchedulingIds(params) {
-  const records = params?.tournamentRecords && Object.values(params?.tournamentRecords) || [];
-  const tournamentsMap = {};
-  const { venueIds, eventIds, drawIds, structureIds, tournamentIds } = records.reduce(
-    (aggregator, tournamentRecord) => {
-      const {
-        tournamentIds: tournamentIds2,
-        tournamentMap,
-        structureIds: structureIds2,
-        venueIds: venueIds2,
-        eventIds: eventIds2,
-        drawIds: drawIds2
-      } = tournamentRelevantSchedulingIds({
-        tournamentRecord
-      });
-      venueIds2.forEach((venueId) => {
-        if (!aggregator.venueIds.includes(venueId))
-          aggregator.venueIds.push(venueId);
-      });
-      aggregator.tournamentIds.push(...tournamentIds2);
-      aggregator.structureIds.push(...structureIds2);
-      aggregator.eventIds.push(...eventIds2);
-      aggregator.drawIds.push(...drawIds2);
-      Object.assign(tournamentsMap, tournamentMap);
-      return aggregator;
+function getFinishingPositionDetails(matchUps) {
+  return (matchUps || []).reduce(
+    (foo, matchUp) => {
+      const sum = (matchUp.finishingPositionRange?.winner || []).reduce(
+        (a, b) => a + b,
+        0
+      );
+      const winnerFinishingPositionRange = (matchUp.finishingPositionRange?.winner || []).join("-") || "";
+      return !foo.minFinishingSum || sum < foo.minFinishingSum ? { minFinishingSum: sum, winnerFinishingPositionRange } : foo;
     },
-    {
-      tournamentIds: [],
-      structureIds: [],
-      venueIds: [],
-      eventIds: [],
-      drawIds: []
-    }
+    { minFinishingSum: 0, winnerFinishingPositionRange: "" }
   );
+}
+function getRoundProfile(matchUps) {
+  const matchUpsCount = matchUps.length;
+  const byeCount = matchUps.filter(({ sides }) => sides?.some(({ bye }) => bye)).length || 0;
+  const completedCount = matchUps.filter(
+    ({ winningSide, matchUpStatus }) => winningSide || completedMatchUpStatuses.includes(matchUpStatus)
+  ).length || 0;
+  const scheduledCount = matchUps.filter(
+    ({ schedule }) => schedule?.scheduledDate && schedule?.scheduledTime
+  ).length || 0;
+  const consideredCount = matchUpsCount - byeCount;
+  const isComplete = consideredCount === completedCount;
+  const unscheduledCount = consideredCount - scheduledCount;
+  const incompleteCount = consideredCount - scheduledCount;
+  const isScheduled = consideredCount === scheduledCount;
   return {
-    tournamentsMap,
-    tournamentIds,
-    structureIds,
-    venueIds,
-    eventIds,
-    drawIds
+    unscheduledCount,
+    incompleteCount,
+    scheduledCount,
+    completedCount,
+    matchUpsCount,
+    isScheduled,
+    isComplete,
+    byeCount
   };
 }
 
-function getEventIdsAndDrawIds({
-  tournamentRecords
+function getProfileRounds({
+  tournamentRecords,
+  schedulingProfile,
+  tournamentRecord,
+  withRoundId
 }) {
-  if (!tournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  const tournamentIds = Object.keys(tournamentRecords);
-  return tournamentIds.reduce(
-    (aggregator, tournamentId) => {
-      aggregator.tournamentIdMap[tournamentId] = [];
-      const tournamentRecord = tournamentRecords[tournamentId];
-      const events = tournamentRecord.events || [];
-      const eventIds = events.map(({ eventId }) => eventId);
-      const drawIds = events.map(
-        (event) => (event.drawDefinitions || []).map(({ drawId }) => drawId)
-      ).flat();
-      aggregator.tournamentIdMap[tournamentId].push(...eventIds, ...drawIds);
-      aggregator.eventIds.push(...eventIds);
-      aggregator.drawIds.push(...drawIds);
-      return aggregator;
-    },
-    { eventIds: [], drawIds: [], tournamentIdMap: {} }
-  );
+  if (tournamentRecord && !tournamentRecords) {
+    if (typeof tournamentRecord !== "object") {
+      return { error: INVALID_TOURNAMENT_RECORD };
+    } else {
+      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
+    }
+  }
+  if (schedulingProfile) {
+    const profileValidity = validateSchedulingProfile({
+      tournamentRecords,
+      schedulingProfile
+    });
+    if (profileValidity.error)
+      return profileValidity;
+  }
+  if (!schedulingProfile && tournamentRecords) {
+    const result = getSchedulingProfile({ tournamentRecords });
+    if (result.error)
+      return result;
+    schedulingProfile = result.schedulingProfile;
+  }
+  if (!schedulingProfile)
+    return { error: NOT_FOUND };
+  const segmentedRounds = {};
+  const profileRounds = schedulingProfile.map(
+    ({ venues, scheduleDate }) => venues.map(
+      ({ rounds }) => rounds.map((round) => {
+        const roundRef = getRoundId(round);
+        if (roundRef.roundSegment?.segmentsCount) {
+          segmentedRounds[roundRef.id] = roundRef.roundSegment.segmentsCount;
+        }
+        return definedAttributes({
+          id: withRoundId ? roundRef.id : void 0,
+          scheduleDate,
+          ...roundRef
+        });
+      })
+    )
+  ).flat(Infinity);
+  return { profileRounds, segmentedRounds };
 }
 
-function getSchedulingProfile({
-  tournamentRecords
+function getParticipantEventDetails({
+  tournamentRecord,
+  participantId
 }) {
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  const { extension } = findExtension$1({
-    name: SCHEDULING_PROFILE,
-    tournamentRecords
-  });
-  let schedulingProfile = extension?.value || [];
-  if (schedulingProfile.length) {
-    const { venueIds } = getCompetitionVenues({
-      requireCourts: true,
-      tournamentRecords
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!participantId)
+    return { error: MISSING_PARTICIPANT_ID };
+  const relevantParticipantIds = [participantId].concat(
+    (tournamentRecord.participants || []).filter(
+      (participant) => participant?.participantType && [TEAM$2, PAIR].includes(participant.participantType) && participant.individualParticipantIds?.includes(participantId)
+    ).map((participant) => participant.participantId)
+  );
+  const relevantEvents = (tournamentRecord.events || []).filter((event) => {
+    const enteredParticipantIds = (event?.entries || []).map(
+      (entry) => entry.participantId
+    );
+    return overlap(enteredParticipantIds, relevantParticipantIds);
+  }).map((event) => ({ eventName: event.eventName, eventId: event.eventId }));
+  return { eventDetails: relevantEvents };
+}
+
+function getEliminationDrawSize({
+  participantsCount,
+  participantCount
+  // TODO: to be deprecated
+}) {
+  participantsCount = participantsCount || participantCount;
+  if (!participantsCount)
+    return { error: INVALID_VALUES };
+  const drawSize = nextPowerOf2(participantsCount);
+  if (!drawSize)
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      stack: "getEliminationDrawSize",
+      context: { participantsCount }
     });
-    const { eventIds, drawIds } = getEventIdsAndDrawIds({ tournamentRecords });
-    const { updatedSchedulingProfile, modifications, issues } = getUpdatedSchedulingProfile({
-      schedulingProfile,
-      venueIds,
-      eventIds,
-      drawIds
+  return { drawSize };
+}
+
+function getStageEntries({
+  selected = true,
+  drawDefinition,
+  entryStatuses,
+  drawId,
+  event,
+  stage
+}) {
+  let entries = event.entries ?? [];
+  if (drawId) {
+    const { flightProfile } = getFlightProfile({ event });
+    const flight = flightProfile?.flights?.find(
+      (flight2) => flight2.drawId === drawId
+    );
+    if (flight) {
+      entries = flight.drawEntries;
+    } else if (drawDefinition.entries) {
+      entries = drawDefinition?.entries;
+    }
+  }
+  const stageEntries = entries.filter(
+    (entry) => (!entryStatuses?.length || !entry.entryStatus || entryStatuses.includes(entry.entryStatus)) && (!stage || !entry.entryStage || entry.entryStage === stage) && (!selected || entry.entryStatus && STRUCTURE_SELECTED_STATUSES.includes(entry.entryStatus))
+  );
+  return { entries, stageEntries };
+}
+
+function getSeedsCount(params) {
+  let {
+    drawSizeProgression = false,
+    policyDefinitions,
+    drawSize
+  } = params || {};
+  const {
+    requireParticipantCount = true,
+    tournamentRecord,
+    drawDefinition,
+    event
+  } = params || {};
+  const stack = "getSeedsCount";
+  const participantsCount = params?.participantsCount || params?.participantCount;
+  if (!policyDefinitions) {
+    const result = getPolicyDefinitions({
+      tournamentRecord,
+      drawDefinition,
+      event
     });
-    if (modifications) {
-      schedulingProfile = updatedSchedulingProfile;
-      const result = setSchedulingProfile({
-        tournamentRecords,
-        schedulingProfile
-      });
-      if (result.error)
-        return result;
-      return { schedulingProfile, modifications, issues };
+    if (result.error)
+      return decorateResult({ result, stack });
+    policyDefinitions = result.policyDefinitions;
+  }
+  const validParticpantCount = isConvertableInteger(participantsCount);
+  if (participantsCount && !validParticpantCount)
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { participantsCount },
+      stack
+    });
+  if (requireParticipantCount && !validParticpantCount)
+    return decorateResult({
+      result: { error: MISSING_PARTICIPANT_COUNT },
+      stack
+    });
+  if (isNaN(drawSize)) {
+    if (participantsCount) {
+      ({ drawSize } = getEliminationDrawSize({
+        participantsCount
+      }));
+    } else {
+      return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
     }
   }
-  return { schedulingProfile, modifications: 0 };
+  const consideredParticipantCount = requireParticipantCount && participantsCount || drawSize;
+  if (consideredParticipantCount > drawSize)
+    return { error: PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE };
+  const policy = policyDefinitions[POLICY_TYPE_SEEDING];
+  if (!policy)
+    return { error: INVALID_POLICY_DEFINITION };
+  const seedsCountThresholds = policy.seedsCountThresholds;
+  if (!seedsCountThresholds)
+    return { error: MISSING_SEEDCOUNT_THRESHOLDS };
+  if (policy.drawSizeProgression !== void 0)
+    drawSizeProgression = policy.drawSizeProgression;
+  const relevantThresholds = seedsCountThresholds.filter((threshold) => {
+    return drawSizeProgression ? threshold.drawSize <= drawSize : drawSize === threshold.drawSize;
+  });
+  const seedsCount = relevantThresholds.reduce((seedsCount2, threshold) => {
+    return participantsCount >= threshold.minimumParticipantCount ? threshold.seedsCount : seedsCount2;
+  }, 0);
+  return { seedsCount };
 }
-function setSchedulingProfile({ tournamentRecords, schedulingProfile }) {
-  const profileValidity = validateSchedulingProfile({
-    tournamentRecords,
-    schedulingProfile
+
+function getEntriesAndSeedsCount({
+  policyDefinitions,
+  drawDefinition,
+  drawSize,
+  drawId,
+  event,
+  stage
+}) {
+  if (!event)
+    return { error: MISSING_EVENT };
+  const { entries, stageEntries } = getStageEntries({
+    drawDefinition,
+    drawId,
+    stage,
+    event
   });
-  if (profileValidity.error)
-    return profileValidity;
-  if (!schedulingProfile)
-    return removeExtension({ tournamentRecords, name: SCHEDULING_PROFILE });
-  const extension = {
-    name: SCHEDULING_PROFILE,
-    value: schedulingProfile
-  };
-  return addExtension({ tournamentRecords, extension });
+  const participantsCount = stageEntries.length;
+  const { drawSize: eliminationDrawSize } = getEliminationDrawSize({
+    participantsCount
+  });
+  const result = getSeedsCount({
+    drawSize: drawSize ?? eliminationDrawSize,
+    participantsCount,
+    policyDefinitions
+  });
+  if (result.error)
+    return decorateResult({ result, stack: "getEntriesAndSeedsCount" });
+  const { seedsCount } = result;
+  return { entries, seedsCount, stageEntries };
 }
-function getUpdatedSchedulingProfile({
-  schedulingProfile,
-  venueIds,
-  eventIds,
-  drawIds
+
+function getMatchUpDailyLimits$1({ tournamentRecord }) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const { policy } = findPolicy({
+    policyType: POLICY_TYPE_SCHEDULING,
+    tournamentRecord
+  });
+  const { extension } = findTournamentExtension({
+    name: SCHEDULE_LIMITS,
+    tournamentRecord
+  });
+  const tournamentDailyLimits = extension?.value?.dailyLimits;
+  const policyDailyLimits = policy?.defaultDailyLimits;
+  return { matchUpDailyLimits: tournamentDailyLimits || policyDailyLimits };
+}
+
+function getMatchUpDailyLimits({
+  tournamentRecords,
+  tournamentId
 }) {
-  const issues = [];
-  const updatedSchedulingProfile = schedulingProfile?.map((dateSchedulingProfile) => {
-    const date = extractDate(dateSchedulingProfile?.scheduleDate);
-    if (!date) {
-      issues.push(`Invalid date: ${dateSchedulingProfile?.scheduledDate}`);
-      return;
-    }
-    const venues = (dateSchedulingProfile?.venues || []).map((venue) => {
-      const { rounds, venueId } = venue;
-      const venueExists = venueIds.includes(venueId);
-      if (!venueExists) {
-        issues.push(`Missing venueId: ${venueId}`);
-        return;
-      }
-      const filteredRounds = rounds.filter((round) => {
-        const validEventIdAndDrawId = eventIds.includes(round.eventId) && drawIds.includes(round.drawId);
-        if (!validEventIdAndDrawId)
-          issues.push(
-            `Invalid eventId: ${round.eventId} or drawId: ${round.drawId}`
-          );
-        return validEventIdAndDrawId;
-      });
-      if (!filteredRounds.length)
-        return;
-      return { venueId, rounds: filteredRounds };
-    }).filter(Boolean);
-    return venues.length && date && { ...dateSchedulingProfile, venues };
-  }).filter(Boolean);
-  const modifications = issues.length;
-  return { updatedSchedulingProfile, modifications, issues };
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const tournamentIds = Object.keys(tournamentRecords).filter(
+    (currentTournamentId) => !tournamentId || currentTournamentId === tournamentId
+  );
+  let dailyLimits;
+  tournamentIds.forEach((tournamentId2) => {
+    const tournamentRecord = tournamentRecords[tournamentId2];
+    const { matchUpDailyLimits } = getMatchUpDailyLimits$1({
+      tournamentRecord
+    });
+    dailyLimits = matchUpDailyLimits;
+  });
+  return { matchUpDailyLimits: dailyLimits };
 }
 
 function scheduledSortedMatchUps({
@@ -10734,9 +10922,203 @@ function getCompetitionPublishedDrawIds({
   return { drawIds };
 }
 
-function filterParticipants({
-  participantFilters = {},
-  tournamentRecord,
+const { stageOrder } = drawDefinitionConstants;
+function roundSort(a, b) {
+  return a.eventName.localeCompare(b.eventName) || a.eventId.localeCompare(b.eventId) || (stageOrder[a?.stage] || 0) - (stageOrder[b?.stage] || 0) || b.matchUpsCount - a.matchUpsCount || `${a.stageSequence}-${a.roundNumber}-${a.minFinishingSum}`.localeCompare(
+    `${b.stageSequence}-${b.roundNumber}-${b.minFinishingSum}`
+  );
+}
+
+function getRounds({
+  excludeScheduleDateProfileRounds,
+  excludeScheduledRounds,
+  excludeCompletedRounds,
+  inContextMatchUps,
+  tournamentRecords,
+  schedulingProfile,
+  tournamentRecord,
+  withSplitRounds,
+  matchUpFilters,
+  scheduleDate,
+  withRoundId,
+  venueId,
+  context
+}) {
+  if (inContextMatchUps && !Array.isArray(
+    inContextMatchUps || typeof inContextMatchUps[0] !== "object"
+  )) {
+    return { error: INVALID_VALUES, inContextMatchUps };
+  }
+  if (tournamentRecord && !tournamentRecords) {
+    if (typeof tournamentRecord !== "object") {
+      return { error: INVALID_TOURNAMENT_RECORD };
+    } else {
+      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
+    }
+  }
+  const noTournamentRecords = typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length;
+  const needsTournamentRecords = venueId || scheduleDate || !inContextMatchUps || !schedulingProfile && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds);
+  if (needsTournamentRecords && noTournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const tournamentVenueIds = Object.assign(
+    {},
+    ...Object.values(tournamentRecords ?? {}).map(
+      ({ venues = [], tournamentId }) => ({
+        [tournamentId]: venues?.map(({ venueId: venueId2 }) => venueId2)
+      })
+    )
+  );
+  const events = Object.values(tournamentRecords ?? {}).map(
+    ({ events: events2 = [], tournamentId, startDate, endDate }) => events2.map((event) => ({
+      ...event,
+      validVenueIds: tournamentVenueIds[tournamentId],
+      startDate: event.startDate ?? startDate,
+      endDate: event.endDate ?? endDate
+    }))
+  ).flat();
+  const { segmentedRounds, profileRounds } = tournamentRecords && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds) && getProfileRounds({ tournamentRecords, schedulingProfile }) || {};
+  const profileRoundsMap = excludeScheduleDateProfileRounds && Object.assign(
+    {},
+    ...profileRounds.map((profile) => ({ [profile.id]: profile }))
+  );
+  const consideredMatchUps = inContextMatchUps || tournamentRecords && allCompetitionMatchUps({ tournamentRecords, matchUpFilters })?.matchUps || [];
+  const excludedRounds = [];
+  const rounds = consideredMatchUps && Object.values(
+    consideredMatchUps.reduce((rounds2, matchUp) => {
+      const id = getRoundId(matchUp).id;
+      const segmentsCount = segmentedRounds?.[id];
+      const matchUps = [...rounds2[id]?.matchUps ?? [], matchUp];
+      const {
+        containerStructureId,
+        stageSequence,
+        structureName,
+        tournamentId,
+        isRoundRobin,
+        matchUpType,
+        roundNumber,
+        roundOffset,
+        structureId,
+        eventName,
+        roundName,
+        drawName,
+        eventId,
+        drawId
+      } = matchUp;
+      const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
+      return {
+        ...rounds2,
+        [id]: {
+          id: withRoundId ? id : void 0,
+          structureId: relevantStructureId,
+          stageSequence,
+          segmentsCount,
+          structureName,
+          tournamentId,
+          matchUpType,
+          roundNumber,
+          roundOffset,
+          eventName,
+          roundName,
+          drawName,
+          matchUps,
+          eventId,
+          drawId
+        }
+      };
+    }, {})
+  ).map((round) => {
+    const { minFinishingSum, winnerFinishingPositionRange } = getFinishingPositionDetails(round.matchUps);
+    const segmentsCount = round.segmentsCount;
+    if (segmentsCount) {
+      const chunkSize = round.matchUps.length / segmentsCount;
+      const sortedMatchUps = chunkArray(
+        round.matchUps.sort((a, b) => a.roundPosition - b.roundPosition),
+        chunkSize
+      );
+      return sortedMatchUps.map((matchUps, i) => {
+        const {
+          unscheduledCount: unscheduledCount2,
+          incompleteCount: incompleteCount2,
+          matchUpsCount: matchUpsCount2,
+          isScheduled: isScheduled2,
+          isComplete: isComplete2,
+          byeCount: byeCount2
+        } = getRoundProfile(matchUps);
+        const roundTiming2 = getRoundTiming({
+          matchUps: round.matchUps,
+          tournamentRecords,
+          events,
+          round
+        });
+        return definedAttributes({
+          ...round,
+          ...context,
+          roundSegment: { segmentsCount, segmentNumber: i + 1 },
+          winnerFinishingPositionRange,
+          unscheduledCount: unscheduledCount2,
+          incompleteCount: incompleteCount2,
+          minFinishingSum,
+          matchUpsCount: matchUpsCount2,
+          isScheduled: isScheduled2,
+          roundTiming: roundTiming2,
+          isComplete: isComplete2,
+          byeCount: byeCount2,
+          matchUps
+        });
+      });
+    }
+    const {
+      unscheduledCount,
+      incompleteCount,
+      matchUpsCount,
+      isScheduled,
+      isComplete,
+      byeCount
+    } = getRoundProfile(round.matchUps);
+    const roundTiming = getRoundTiming({
+      matchUps: round.matchUps,
+      tournamentRecords,
+      events,
+      round
+    });
+    return definedAttributes({
+      ...round,
+      ...context,
+      winnerFinishingPositionRange,
+      unscheduledCount,
+      incompleteCount,
+      minFinishingSum,
+      matchUpsCount,
+      isScheduled,
+      roundTiming,
+      isComplete,
+      byeCount
+    });
+  }).flat().filter((round) => {
+    if (excludeScheduleDateProfileRounds) {
+      const scheduleDate2 = extractDate(excludeScheduleDateProfileRounds);
+      const roundId = withRoundId ? round.id : getRoundId(round).id;
+      if (scheduleDate2 && profileRoundsMap[roundId] && extractDate(profileRoundsMap[roundId].scheduleDate) === scheduleDate2) {
+        return false;
+      }
+    }
+    const { isComplete, isScheduled } = round;
+    const keepComplete = !excludeCompletedRounds || !isComplete;
+    const keepScheduled = !excludeScheduledRounds || !isScheduled;
+    const event = venueId || scheduleDate ? events?.find(({ eventId }) => eventId === round.eventId) : void 0;
+    const validDate = !scheduleDate || event?.startDate && event?.endDate && new Date(scheduleDate) >= new Date(event?.startDate) && new Date(scheduleDate) <= new Date(event?.endDate);
+    const validVenue = !venueId || event?.validVenueIds.includes(venueId);
+    const keepRound = keepComplete && keepScheduled && validVenue && validDate;
+    if (!keepRound)
+      excludedRounds.push(round);
+    return keepRound;
+  }).sort(roundSort) || [];
+  return { ...SUCCESS, rounds, excludedRounds };
+}
+
+function filterParticipants({
+  participantFilters = {},
+  tournamentRecord,
   participants = []
 }) {
   if (!Object.keys(participantFilters).length) {
@@ -15432,364 +15814,5 @@ function getEventData(params) {
   return { ...SUCCESS, eventData };
 }
 
-function findMatchUpFormatTiming({
-  defaultRecoveryMinutes = 0,
-  defaultAverageMinutes,
-  tournamentRecords,
-  matchUpFormat,
-  categoryName,
-  categoryType,
-  tournamentId,
-  eventType,
-  eventId
-}) {
-  if (!isValid(matchUpFormat))
-    return { error: UNRECOGNIZED_MATCHUP_FORMAT };
-  const tournamentIds = Object.keys(tournamentRecords).filter(
-    (currentTournamentId) => !tournamentId || currentTournamentId === tournamentId
-  );
-  let timing;
-  tournamentIds.forEach((currentTournamentId) => {
-    if (timing)
-      return;
-    const tournamentRecord = tournamentRecords[currentTournamentId];
-    const event = eventId ? findEvent({ tournamentRecord, eventId })?.event : void 0;
-    timing = getMatchUpFormatTiming({
-      tournamentRecord,
-      matchUpFormat,
-      categoryName,
-      categoryType,
-      eventType,
-      event
-    });
-    return timing?.averageMinutes || timing?.recoveryMinutes;
-  });
-  return {
-    recoveryMinutes: timing?.recoveryMinutes || defaultRecoveryMinutes,
-    averageMinutes: timing?.averageMinutes || defaultAverageMinutes,
-    typeChangeRecoveryMinutes: timing?.typeChangeRecoveryMinutes || timing?.recoveryMinutes || defaultRecoveryMinutes
-  };
-}
-
-const { stageOrder } = drawDefinitionConstants;
-function getProfileRounds({
-  tournamentRecords,
-  schedulingProfile,
-  tournamentRecord,
-  withRoundId
-}) {
-  if (tournamentRecord && !tournamentRecords) {
-    if (typeof tournamentRecord !== "object") {
-      return { error: INVALID_TOURNAMENT_RECORD };
-    } else {
-      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
-    }
-  }
-  if (schedulingProfile) {
-    const profileValidity = validateSchedulingProfile({
-      tournamentRecords,
-      schedulingProfile
-    });
-    if (profileValidity.error)
-      return profileValidity;
-  }
-  if (!schedulingProfile && tournamentRecords) {
-    const result = getSchedulingProfile({ tournamentRecords });
-    if (result.error)
-      return result;
-    schedulingProfile = result.schedulingProfile;
-  }
-  if (!schedulingProfile)
-    return { error: NOT_FOUND };
-  const segmentedRounds = {};
-  const profileRounds = schedulingProfile.map(
-    ({ venues, scheduleDate }) => venues.map(
-      ({ rounds }) => rounds.map((round) => {
-        const roundRef = getRoundId(round);
-        if (roundRef.roundSegment?.segmentsCount) {
-          segmentedRounds[roundRef.id] = roundRef.roundSegment.segmentsCount;
-        }
-        return definedAttributes({
-          id: withRoundId ? roundRef.id : void 0,
-          scheduleDate,
-          ...roundRef
-        });
-      })
-    )
-  ).flat(Infinity);
-  return { profileRounds, segmentedRounds };
-}
-function getRoundId(obj) {
-  const {
-    containerStructureId,
-    roundSegment,
-    isRoundRobin,
-    tournamentId,
-    roundNumber,
-    structureId,
-    eventId,
-    drawId
-  } = obj;
-  const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
-  const id = [
-    tournamentId,
-    // 1
-    eventId,
-    // 2
-    drawId,
-    // 3
-    relevantStructureId,
-    // 4
-    roundNumber
-    // 5
-  ].join("|");
-  return definedAttributes({
-    id,
-    roundSegment,
-    tournamentId,
-    eventId,
-    drawId,
-    structureId: relevantStructureId,
-    roundNumber
-  });
-}
-function getRoundProfile(matchUps) {
-  const matchUpsCount = matchUps.length;
-  const byeCount = matchUps.filter(({ sides }) => sides?.some(({ bye }) => bye)).length || 0;
-  const completedCount = matchUps.filter(
-    ({ winningSide, matchUpStatus }) => winningSide || completedMatchUpStatuses.includes(matchUpStatus)
-  ).length || 0;
-  const scheduledCount = matchUps.filter(
-    ({ schedule }) => schedule?.scheduledDate && schedule?.scheduledTime
-  ).length || 0;
-  const consideredCount = matchUpsCount - byeCount;
-  const isComplete = consideredCount === completedCount;
-  const unscheduledCount = consideredCount - scheduledCount;
-  const incompleteCount = consideredCount - scheduledCount;
-  const isScheduled = consideredCount === scheduledCount;
-  return {
-    unscheduledCount,
-    incompleteCount,
-    scheduledCount,
-    completedCount,
-    matchUpsCount,
-    isScheduled,
-    isComplete,
-    byeCount
-  };
-}
-function getRounds({
-  excludeScheduleDateProfileRounds,
-  excludeScheduledRounds,
-  excludeCompletedRounds,
-  inContextMatchUps,
-  tournamentRecords,
-  schedulingProfile,
-  tournamentRecord,
-  withSplitRounds,
-  matchUpFilters,
-  withRoundId,
-  context
-}) {
-  if (inContextMatchUps && !Array.isArray(
-    inContextMatchUps || typeof inContextMatchUps[0] !== "object"
-  )) {
-    return { error: INVALID_VALUES, inContextMatchUps };
-  }
-  if (tournamentRecord && !tournamentRecords) {
-    if (typeof tournamentRecord !== "object") {
-      return { error: INVALID_TOURNAMENT_RECORD };
-    } else {
-      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
-    }
-  }
-  const noTournamentRecords = typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length;
-  const needsTournamentRecords = !inContextMatchUps || !schedulingProfile && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds);
-  if (needsTournamentRecords && noTournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  const events = Object.values(tournamentRecords ?? {}).map(({ events: events2 }) => events2).flat();
-  const { segmentedRounds, profileRounds } = tournamentRecords && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds) && getProfileRounds({ tournamentRecords, schedulingProfile }) || {};
-  const profileRoundsMap = excludeScheduleDateProfileRounds && Object.assign(
-    {},
-    ...profileRounds.map((profile) => ({ [profile.id]: profile }))
-  );
-  const consideredMatchUps = inContextMatchUps || tournamentRecords && allCompetitionMatchUps({ tournamentRecords, matchUpFilters })?.matchUps || [];
-  const excludedRounds = [];
-  const rounds = consideredMatchUps && Object.values(
-    consideredMatchUps.reduce((rounds2, matchUp) => {
-      const id = getRoundId(matchUp).id;
-      const segmentsCount = segmentedRounds?.[id];
-      const matchUps = [...rounds2[id]?.matchUps ?? [], matchUp];
-      const {
-        containerStructureId,
-        stageSequence,
-        structureName,
-        tournamentId,
-        isRoundRobin,
-        matchUpType,
-        roundNumber,
-        roundOffset,
-        structureId,
-        eventName,
-        roundName,
-        drawName,
-        eventId,
-        drawId
-      } = matchUp;
-      const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
-      return {
-        ...rounds2,
-        [id]: {
-          id: withRoundId ? id : void 0,
-          structureId: relevantStructureId,
-          stageSequence,
-          segmentsCount,
-          structureName,
-          tournamentId,
-          matchUpType,
-          roundNumber,
-          roundOffset,
-          eventName,
-          roundName,
-          drawName,
-          matchUps,
-          eventId,
-          drawId
-        }
-      };
-    }, {})
-  ).map((round) => {
-    const { minFinishingSum, winnerFinishingPositionRange } = getFinishingPositionDetails(round.matchUps);
-    const segmentsCount = round.segmentsCount;
-    if (segmentsCount) {
-      const chunkSize = round.matchUps.length / segmentsCount;
-      const sortedMatchUps = chunkArray(
-        round.matchUps.sort((a, b) => a.roundPosition - b.roundPosition),
-        chunkSize
-      );
-      return sortedMatchUps.map((matchUps, i) => {
-        const {
-          unscheduledCount: unscheduledCount2,
-          incompleteCount: incompleteCount2,
-          matchUpsCount: matchUpsCount2,
-          isScheduled: isScheduled2,
-          isComplete: isComplete2,
-          byeCount: byeCount2
-        } = getRoundProfile(matchUps);
-        const roundTiming2 = getRoundTiming({
-          matchUps: round.matchUps,
-          tournamentRecords,
-          events,
-          round
-        });
-        return definedAttributes({
-          ...round,
-          ...context,
-          roundSegment: { segmentsCount, segmentNumber: i + 1 },
-          winnerFinishingPositionRange,
-          unscheduledCount: unscheduledCount2,
-          incompleteCount: incompleteCount2,
-          minFinishingSum,
-          matchUpsCount: matchUpsCount2,
-          isScheduled: isScheduled2,
-          roundTiming: roundTiming2,
-          isComplete: isComplete2,
-          byeCount: byeCount2,
-          matchUps
-        });
-      });
-    }
-    const {
-      unscheduledCount,
-      incompleteCount,
-      matchUpsCount,
-      isScheduled,
-      isComplete,
-      byeCount
-    } = getRoundProfile(round.matchUps);
-    const roundTiming = getRoundTiming({
-      matchUps: round.matchUps,
-      tournamentRecords,
-      events,
-      round
-    });
-    return definedAttributes({
-      ...round,
-      ...context,
-      winnerFinishingPositionRange,
-      unscheduledCount,
-      incompleteCount,
-      minFinishingSum,
-      matchUpsCount,
-      isScheduled,
-      roundTiming,
-      isComplete,
-      byeCount
-    });
-  }).flat().filter((round) => {
-    if (excludeScheduleDateProfileRounds) {
-      const scheduleDate = extractDate(excludeScheduleDateProfileRounds);
-      const roundId = withRoundId ? round.id : getRoundId(round).id;
-      if (scheduleDate && profileRoundsMap[roundId] && extractDate(profileRoundsMap[roundId].scheduleDate) === scheduleDate) {
-        return false;
-      }
-    }
-    const { isComplete, isScheduled } = round;
-    const keepComplete = !excludeCompletedRounds || !isComplete;
-    const keepScheduled = !excludeScheduledRounds || !isScheduled;
-    const keepRound = keepComplete && keepScheduled;
-    if (!keepRound)
-      excludedRounds.push(round);
-    return keepRound;
-  }).sort(roundSort) || [];
-  return { ...SUCCESS, rounds, excludedRounds };
-}
-function getRoundTiming({ round, matchUps, events, tournamentRecords }) {
-  const event = events.find((event2) => event2.eventId === round.eventId);
-  const { eventType, category, categoryType } = event || {};
-  const { categoryName, ageCategoryCode } = category || {};
-  const formatCounts = instanceCount(
-    matchUps.map(({ matchUpFormat }) => matchUpFormat)
-  );
-  let roundMinutes = 0;
-  Object.keys(formatCounts).forEach((matchUpFormat) => {
-    const formatCount = formatCounts[matchUpFormat];
-    const result = findMatchUpFormatTiming({
-      categoryName: categoryName || ageCategoryCode,
-      tournamentId: round.tournamentId,
-      eventId: round.eventId,
-      tournamentRecords,
-      matchUpFormat,
-      categoryType,
-      eventType
-    });
-    if (result.error)
-      return result;
-    const formatMinutes = result.averageMinutes * formatCount;
-    if (!isNaN(roundMinutes))
-      roundMinutes += formatMinutes;
-    return void 0;
-  });
-  return { roundMinutes };
-}
-function roundSort(a, b) {
-  return a.eventName.localeCompare(b.eventName) || a.eventId.localeCompare(b.eventId) || (stageOrder[a?.stage] || 0) - (stageOrder[b?.stage] || 0) || b.matchUpsCount - a.matchUpsCount || `${a.stageSequence}-${a.roundNumber}-${a.minFinishingSum}`.localeCompare(
-    `${b.stageSequence}-${b.roundNumber}-${b.minFinishingSum}`
-  );
-}
-function getFinishingPositionDetails(matchUps) {
-  return (matchUps || []).reduce(
-    (foo, matchUp) => {
-      const sum = (matchUp.finishingPositionRange?.winner || []).reduce(
-        (a, b) => a + b,
-        0
-      );
-      const winnerFinishingPositionRange = (matchUp.finishingPositionRange?.winner || []).join("-") || "";
-      return !foo.minFinishingSum || sum < foo.minFinishingSum ? { minFinishingSum: sum, winnerFinishingPositionRange } : foo;
-    },
-    { minFinishingSum: 0, winnerFinishingPositionRange: "" }
-  );
-}
-
 export { allCompetitionMatchUps, allDrawMatchUps, allEventMatchUps, allTournamentMatchUps, matchUpActions as competitionMatchUpActions, competitionMatchUps, competitionScheduleMatchUps, drawMatchUps, eventMatchUps, filterParticipants, findExtension, findMatchUp, publicFindParticipant as findParticipant, generateSeedingScaleItems, getCompetitionDateRange, getCompetitionParticipants, getCompetitionVenues, getVenuesAndCourts as getCompetitionVenuesAndCourts, getEligibleVoluntaryConsolationParticipants, getEntriesAndSeedsCount, getEventData, getEventMatchUpFormatTiming, getFlightProfile, getMatchUpDailyLimits, getMatchUpDailyLimitsUpdate, getMatchUpFormatTimingUpdate, getOrderedDrawPositions, getParticipantEventDetails, getParticipantScaleItem, getPolicyDefinitions, getPositionAssignments, getProfileRounds, getRoundContextProfile, getRoundMatchUps, getRounds, getSeedsCount, getTimeItem, getVenuesAndCourts$1 as getTournamentVenuesAndCourts, getValidGroupSizes, isValid as isValidMatchUpFormat, parse as parseMatchUpFormat, parseScoreString, participantScaleItem, positionActions, matchUpActions$1 as tournamentMatchUpActions, tournamentMatchUps, validateScore };
 //# sourceMappingURL=query.mjs.map