tods-competition-factory 2.1.9 → 2.1.11

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.9';
+    return '2.1.11';
 }
 
 function isFunction(obj) {
@@ -1573,9 +1573,8 @@ function enableNotifications() {
     _globalStateProvider.enableNotifications();
 }
 function setDeepCopy(value, attributes) {
-    if (typeof value === 'boolean') {
+    if (typeof value === 'boolean')
         globalState.deepCopy = value;
-    }
     if (typeof attributes === 'object') {
         if (Array.isArray(attributes.ignore))
             globalState.deepCopyAttributes.ignore = attributes.ignore;
@@ -6354,393 +6353,1038 @@ function getStructureSeedAssignments({ provisionalPositioning, returnAllProxies,
     };
 }
 
-const add = (a, b) => (a || 0) + (b || 0);
-function getBand(spread, bandProfiles) {
-    const spreadValue = Array.isArray(spread) ? spread[0] : spread;
-    return ((isNaN(spreadValue) && WALKOVER$1) ||
-        (spreadValue <= bandProfiles[DECISIVE] && DECISIVE) ||
-        (spreadValue <= bandProfiles[ROUTINE] && ROUTINE) ||
-        COMPETITIVE);
-}
-function getScoreComponents({ score }) {
-    const sets = score?.sets || [];
-    const games = sets.reduce((p, c) => {
-        p[0] += c.side1Score || 0;
-        p[1] += c.side2Score || 0;
-        return p;
-    }, [0, 0]);
-    const stb = sets.reduce((p, c) => {
-        p[0] += c.side1TiebreakScore || 0;
-        p[1] += c.side2TiebreakScore || 0;
-        return p;
-    }, [0, 0]);
-    if (stb.reduce(add)) {
-        games[stb[0] > stb[1] ? 0 : 1] += 1;
+function getObjectTieFormat(obj) {
+    if (!obj)
+        return;
+    const { tieFormatId, tieFormats } = obj;
+    if (obj.tieFormat) {
+        return obj.tieFormat;
+    }
+    else if (tieFormatId && Array.isArray(tieFormats)) {
+        return tieFormats.find((tf) => tf.tieFormatId === tieFormatId);
     }
-    return { sets, games, score };
-}
-function gamesPercent(scoreComponents) {
-    const minGames = Math.min(...scoreComponents.games);
-    const maxGames = Math.max(...scoreComponents.games);
-    return Math.round((minGames / maxGames) * 100);
-}
-function pctSpread(pcts) {
-    return pcts
-        .map(gamesPercent)
-        .sort()
-        .map((p) => parseFloat(p.toFixed(2)));
 }
 
-function getMatchUpCompetitiveProfile({ tournamentRecord, profileBands, matchUp, }) {
-    if (!matchUp)
-        return { error: MISSING_MATCHUP };
-    const { score, winningSide } = matchUp;
-    if (!winningSide)
-        return { error: INVALID_VALUES };
-    const policy = !profileBands &&
-        tournamentRecord &&
-        findPolicy({
-            policyType: POLICY_TYPE_COMPETITIVE_BANDS,
-            tournamentRecord,
-        }).policy;
-    const bandProfiles = profileBands ||
-        policy?.profileBands ||
-        POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
-    const scoreComponents = getScoreComponents({ score });
-    const spread = pctSpread([scoreComponents]);
-    const competitiveness = getBand(spread, bandProfiles);
-    const pctSpreadValue = Array.isArray(spread) ? spread[0] : spread;
-    return { ...SUCCESS, competitiveness, pctSpread: pctSpreadValue };
+function getItemTieFormat({ item, drawDefinition, structure, event }) {
+    if (!item)
+        return;
+    if (item.tieFormat)
+        return item.tieFormat;
+    if (item.tieFormatId) {
+        if (drawDefinition.tieFormat)
+            return drawDefinition.tieFormat;
+        const tieFormat = drawDefinition.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
+        if (tieFormat)
+            return tieFormat;
+        if (event.tieFormat)
+            return event.tieFormat;
+        return event.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
+    }
+    if (structure.tieFormat)
+        return structure.tieFormat;
+    if (structure.tieFormatId) {
+        const structureTieFormat = drawDefinition.tieFormats?.find((tf) => structure.tieFormatId === tf.tieFormatId);
+        if (structureTieFormat)
+            return structureTieFormat;
+    }
 }
 
-function getMatchUpParticipantIds({ matchUp }) {
-    if (!matchUp)
-        return { error: MISSING_MATCHUP };
-    if (matchUp && !matchUp.sides)
-        return { error: INVALID_MATCHUP };
-    if (matchUp && !matchUp.hasContext)
-        return { error: MISSING_CONTEXT };
-    const sideParticipantIds = (matchUp.sides ?? [])
-        ?.map((side) => side?.participantId)
-        .filter(Boolean);
-    const sideIndividualParticipantIds = matchUp.sides
-        ?.filter((side) => side.participant?.participantType === INDIVIDUAL)
-        .map((participant) => participant.participantId)
-        .filter(Boolean) ?? [];
-    const nestedIndividualParticipants = (matchUp.sides ?? [])
-        ?.map((side) => side.participant?.individualParticipants)
-        .filter(Boolean) ?? [];
-    const nestedIndividualParticipantIds = nestedIndividualParticipants.map((participants) => (participants ?? []).map((participant) => participant?.participantId).filter(Boolean));
-    const individualParticipantIds = [...sideIndividualParticipantIds, ...nestedIndividualParticipantIds.flat()].filter(Boolean) ?? [];
-    const allRelevantParticipantIds = unique(individualParticipantIds.concat(sideParticipantIds)).filter(Boolean) ?? [];
+function resolveTieFormat({ drawDefinition, structure, matchUp, event }) {
     return {
-        nestedIndividualParticipantIds,
-        allRelevantParticipantIds,
-        individualParticipantIds,
-        sideParticipantIds,
-        ...SUCCESS,
+        tieFormat: getItemTieFormat({
+            item: matchUp,
+            drawDefinition,
+            structure,
+            event,
+        }) ||
+            getItemTieFormat({
+                item: structure,
+                drawDefinition,
+                structure,
+                event,
+            }) ||
+            getObjectTieFormat(drawDefinition) ||
+            getObjectTieFormat(event),
     };
 }
 
-const CHECK_IN = 'CHECK_IN';
-const CHECK_OUT = 'CHECK_OUT';
-const SCHEDULE$1 = 'SCHEDULE';
-const ASSIGN_VENUE = 'SCHEDULE.ASSIGNMENT.VENUE';
-const ALLOCATE_COURTS = 'SCHEDULE.ALLOCATION.COURTS';
-const ASSIGN_COURT = 'SCHEDULE.ASSIGNMENT.COURT';
-const COURT_ORDER = 'SCHEDULE.COURT.ORDER';
-const SCHEDULED_DATE = 'SCHEDULE.DATE';
-const COMPLETED_DATE = 'COMPLETED.DATE';
-const HOME_PARTICIPANT_ID = 'HOME_PARTICIPANT_ID';
-const ASSIGN_OFFICIAL = 'SCHEDULE.ASSIGN.OFFICIAL';
-const SCHEDULED_TIME = 'SCHEDULE.TIME.SCHEDULED';
-const START_TIME = 'SCHEDULE.TIME.START';
-const STOP_TIME = 'SCHEDULE.TIME.STOP';
-const RESUME_TIME = 'SCHEDULE.TIME.RESUME';
-const END_TIME = 'SCHEDULE.TIME.END';
-const TIME_MODIFIERS = 'SCHEDULE.TIME.MODIFIERS';
-const TO_BE_ANNOUNCED = 'TO_BE_ANNOUNCED';
-const NEXT_AVAILABLE = 'NEXT_AVAILABLE';
-const FOLLOWED_BY = 'FOLLOWED_BY';
-const AFTER_REST = 'AFTER_REST';
-const RAIN_DELAY = 'RAIN_DELAY';
-const NOT_BEFORE = 'NOT_BEFORE';
-const MUTUALLY_EXCLUSIVE_TIME_MODIFIERS = [TO_BE_ANNOUNCED, NEXT_AVAILABLE, FOLLOWED_BY, AFTER_REST, RAIN_DELAY];
-const ELIGIBILITY = 'ELIGIBILITY';
-const REGISTRATION = 'REGISTRATION';
-const SUSPENSION = 'SUSPENSION';
-const MEDICAL$1 = 'MEDICAL';
-const PENALTY$1 = 'PENALTY';
-const SCALE = 'SCALE';
-const RATING = 'RATING';
-const RANKING = 'RANKING';
-const SEEDING = 'SEEDING';
-const PUBLISH = 'PUBLISH';
-const PUBLIC = 'PUBLIC';
-const STATUS$1 = 'STATUS';
-const MODIFICATION = 'MODIFICATION';
-const RETRIEVAL = 'RETRIEVAL';
-const OTHER$3 = 'other';
-const timeItemConstants = {
-    MUTUALLY_EXCLUSIVE_TIME_MODIFIERS,
-    AFTER_REST,
-    ALLOCATE_COURTS,
-    ASSIGN_COURT,
-    ASSIGN_OFFICIAL,
-    ASSIGN_VENUE,
-    CHECK_IN,
-    CHECK_OUT,
-    COMPLETED_DATE,
-    COURT_ORDER,
-    ELIGIBILITY,
-    END_TIME,
-    FOLLOWED_BY,
-    MEDICAL: MEDICAL$1,
-    MODIFICATION,
-    NEXT_AVAILABLE,
-    NOT_BEFORE,
-    OTHER: OTHER$3,
-    PENALTY: PENALTY$1,
-    PUBLIC,
-    PUBLISH,
-    RANKING,
-    RATING,
-    RAIN_DELAY,
-    REGISTRATION,
-    RESUME_TIME,
-    RETRIEVAL,
-    SCALE,
-    SCHEDULE: SCHEDULE$1,
-    SCHEDULED_DATE,
-    SCHEDULED_TIME,
-    SEEDING,
-    START_TIME,
-    STATUS: STATUS$1,
-    STOP_TIME,
-    SUSPENSION,
-    TIME_MODIFIERS,
-    TO_BE_ANNOUNCED,
-};
-
-function getCheckedInParticipantIds({ matchUp }) {
-    if (!matchUp)
-        return { error: MISSING_MATCHUP };
-    if (!matchUp.hasContext)
-        return { error: MISSING_CONTEXT };
-    if (!matchUp.sides || matchUp.sides.filter(Boolean).length !== 2) {
-        return { error: INVALID_MATCHUP };
-    }
-    const { nestedIndividualParticipantIds, allRelevantParticipantIds, sideParticipantIds } = getMatchUpParticipantIds({
-        matchUp,
-    });
-    const timeItems = matchUp.timeItems ?? [];
-    const checkInItems = timeItems
-        .filter((timeItem) => timeItem?.itemType && [CHECK_IN, CHECK_OUT].includes(timeItem.itemType))
-        .sort((a, b) => (a.createdAt ? new Date(a.createdAt).getTime() : 0) - (b.createdAt ? new Date(b.createdAt).getTime() : 0));
-    const timeItemParticipantIds = checkInItems.map((timeItem) => timeItem.itemValue);
-    const checkedInParticipantIds = timeItemParticipantIds.filter((participantId) => {
-        return checkInItems.filter((timeItem) => timeItem?.itemValue === participantId).reverse()[0].itemType === CHECK_IN;
+function getCollectionPositionMatchUps({ matchUps }) {
+    const collectionPositionMatchUpsArray = matchUps
+        .reduce((collectionPositions, matchUp) => {
+        return !matchUp.collectionPosition || collectionPositions.includes(matchUp.collectionPosition)
+            ? collectionPositions
+            : collectionPositions.concat(matchUp.collectionPosition);
+    }, [])
+        .map((collectionPosition) => {
+        return {
+            [collectionPosition]: matchUps.filter((matchUp) => matchUp.collectionPosition === collectionPosition),
+        };
     });
-    nestedIndividualParticipantIds?.forEach((sideIndividualParticipantIds, sideIndex) => {
-        const sideParticipantId = sideParticipantIds?.[sideIndex];
-        const allIndividualsCheckedIn = sideIndividualParticipantIds?.length &&
-            sideIndividualParticipantIds.every((participantId) => checkedInParticipantIds.includes(participantId));
-        if (sideParticipantId && allIndividualsCheckedIn && !checkedInParticipantIds.includes(sideParticipantId)) {
-            checkedInParticipantIds.push(sideParticipantId);
+    const collectionPositionMatchUps = Object.assign({}, ...collectionPositionMatchUpsArray);
+    return { collectionPositionMatchUps };
+}
+
+function getMatchUpsMap({ drawDefinition, structure }) {
+    const mappedMatchUps = {};
+    const drawMatchUps = [];
+    (drawDefinition?.structures ?? [structure])
+        .filter((structure) => structure && typeof structure === 'object')
+        .forEach((structure) => {
+        if (!structure)
+            return;
+        const { structureId, matchUps, structures } = structure;
+        const isRoundRobin = Array.isArray(structures);
+        if (!isRoundRobin) {
+            const filteredMatchUps = matchUps;
+            mappedMatchUps[structureId] = {
+                matchUps: filteredMatchUps,
+                itemStructureIds: [],
+            };
+            filteredMatchUps?.forEach((matchUp) => {
+                drawMatchUps.push(matchUp);
+                if (matchUp.tieMatchUps)
+                    drawMatchUps.push(...matchUp.tieMatchUps);
+            });
         }
-    });
-    sideParticipantIds?.forEach((sideParticipantId, sideIndex) => {
-        if (checkedInParticipantIds.includes(sideParticipantId)) {
-            (nestedIndividualParticipantIds?.[sideIndex] ?? []).forEach((participantId) => {
-                if (participantId && !checkedInParticipantIds.includes(participantId)) {
-                    checkedInParticipantIds.push(participantId);
+        else if (isRoundRobin) {
+            structures.forEach((itemStructure) => {
+                const { structureName } = itemStructure;
+                const filteredMatchUps = itemStructure.matchUps;
+                mappedMatchUps[itemStructure.structureId] = {
+                    matchUps: filteredMatchUps,
+                    itemStructureIds: [],
+                    structureName,
+                };
+                if (filteredMatchUps) {
+                    drawMatchUps.push(...filteredMatchUps);
+                    filteredMatchUps.forEach((matchUp) => {
+                        if (matchUp.tieMatchUps)
+                            drawMatchUps.push(...matchUp.tieMatchUps);
+                    });
                 }
+                if (!mappedMatchUps[structureId])
+                    mappedMatchUps[structureId] = {
+                        itemStructureIds: [],
+                        matchUps: [],
+                    };
+                if (!mappedMatchUps[structureId].itemStructureIds)
+                    mappedMatchUps[structureId].itemStructureIds = [];
+                mappedMatchUps[structureId].itemStructureIds.push(itemStructure.structureId);
             });
         }
     });
-    const allParticipantsCheckedIn = sideParticipantIds?.reduce((checkedIn, participantId) => {
-        return checkedInParticipantIds.includes(participantId) && checkedIn;
-    }, true);
-    return {
-        allRelevantParticipantIds,
-        allParticipantsCheckedIn,
-        checkedInParticipantIds,
-        ...SUCCESS,
-    };
-}
-
-const matchUpEventTypeMap = {
-    [SINGLES]: [SINGLES, 'S'],
-    [DOUBLES]: [DOUBLES, 'D'],
-    [TEAM$1]: [TEAM$1, 'T'],
-    S: [SINGLES, 'S'],
-    D: [DOUBLES, 'D'],
-    T: [TEAM$1, 'T'],
-};
-
-const isMatchUpEventType = (type) => (params) => {
-    const matchUpEventType = (isObject(params) && params?.matchUpType) || (isString(params) && params);
-    return matchUpEventType && matchUpEventTypeMap[type].includes(matchUpEventType);
-};
-
-function findMatchupFormatAverageTimes(params) {
-    const { matchUpAverageTimes, matchUpFormat } = params || {};
-    const codeMatches = matchUpAverageTimes
-        ?.map(({ matchUpFormatCodes }) => {
-        return matchUpFormatCodes?.filter((code) => code === matchUpFormat);
-    })
-        .flat()
-        .filter(Boolean)
-        .sort((a, b) => (a?.length || 0) - (b?.length || 0)) || [];
-    const exactCodeMatch = codeMatches.includes(matchUpFormat);
-    const targetCode = exactCodeMatch ? matchUpFormat : codeMatches[0];
-    const targetDefinition = matchUpAverageTimes?.find(({ matchUpFormatCodes, averageTimes }) => matchUpFormatCodes?.find((code) => targetCode === code) && averageTimes);
-    return targetDefinition?.averageTimes;
+    return { mappedMatchUps, drawMatchUps };
 }
-function findMatchupFormatRecoveryTimes(params) {
-    const { matchUpRecoveryTimes, averageMinutes, matchUpFormat } = params || {};
-    return matchUpRecoveryTimes?.find(({ matchUpFormatCodes, averageTimes, recoveryTimes }) => {
-        if (averageTimes && averageMinutes) {
-            const { greaterThan = 0, lessThan = 360 } = averageTimes;
-            if (averageMinutes > greaterThan && averageMinutes < lessThan)
-                return true;
+function getMappedStructureMatchUps({ mappedMatchUps, matchUpsMap, structureId, inContext, }) {
+    mappedMatchUps = matchUpsMap?.mappedMatchUps ?? mappedMatchUps;
+    const structureMatchUpsMap = mappedMatchUps[structureId];
+    const itemStructureMatchUps = (structureMatchUpsMap?.itemStructureIds || [])
+        .map((itemStructureId) => {
+        const { matchUps, structureName } = mappedMatchUps[itemStructureId];
+        if (inContext) {
+            return matchUps.map((matchUp) => {
+                return Object.assign(makeDeepCopy(matchUp, true, true), {
+                    containerStructureId: structureId,
+                    structureId: itemStructureId,
+                    structureName,
+                });
+            });
         }
-        return matchUpFormatCodes?.find((code) => code === matchUpFormat) && recoveryTimes;
-    })?.recoveryTimes;
+        else {
+            return matchUps;
+        }
+    })
+        .flat();
+    return (structureMatchUpsMap?.matchUps || []).concat(...itemStructureMatchUps);
 }
 
-function findCategoryTiming({ timesBlockArray, categoryName, categoryType }) {
-    return timesBlockArray
-        .filter((f) => Array.isArray(f))
-        .map((times) => times
-        .sort((a, b) => (b.categoryNames?.length || 0) - (a.categoryNames?.length || 0))
-        .find(({ categoryTypes, categoryNames }) => (!categoryNames?.length && !categoryTypes?.length) ||
-        categoryNames?.includes(categoryName) ||
-        categoryTypes?.includes(categoryType)))
-        .find(Boolean);
+function reduceGroupedOrder({ groupedOrder, roundPositionsCount }) {
+    if (!groupedOrder || groupedOrder?.length <= roundPositionsCount) {
+        return groupedOrder;
+    }
+    const groupChunks = chunkArray(groupedOrder, groupedOrder.length / roundPositionsCount);
+    const chunkValues = groupChunks.map((chunk) => chunk.reduce((a, b) => a + b));
+    const sortedChunks = chunkValues.slice().sort(numericSort);
+    return chunkValues.map((chunkValue) => sortedChunks.indexOf(chunkValue) + 1);
 }
 
-function getMatchUpFormatRecoveryTimes({ tournamentScheduling, eventScheduling, averageMinutes, defaultTiming, matchUpFormat, categoryName, categoryType, policy, }) {
-    const eventRecoveryTimes = eventScheduling?.matchUpRecoveryTimes &&
-        findMatchupFormatRecoveryTimes({
-            ...eventScheduling,
-            averageMinutes,
-            matchUpFormat,
-        });
-    const tournamentRecoveryTimes = tournamentScheduling?.matchUpRecoveryTimes &&
-        findMatchupFormatRecoveryTimes({
-            ...tournamentScheduling,
-            averageMinutes,
-            matchUpFormat,
-        });
-    const policyRecoveryTimes = policy?.matchUpRecoveryTimes &&
-        findMatchupFormatRecoveryTimes({
-            ...policy,
-            averageMinutes,
-            matchUpFormat,
-        });
-    const timesBlockArray = [
-        eventRecoveryTimes,
-        tournamentRecoveryTimes,
-        policyRecoveryTimes,
-        policy?.defaultTimes?.recoveryTimes,
-        defaultTiming?.recoveryTimes,
-    ];
-    return findCategoryTiming({
-        categoryName,
-        categoryType,
-        timesBlockArray,
-    });
+function validMatchUp(matchUp) {
+    if (!isObject(matchUp))
+        return false;
+    const { matchUpId, drawPositions } = matchUp;
+    const validMatchUpId = typeof matchUpId === 'string';
+    const validDrawPositions = !drawPositions ||
+        (Array.isArray(drawPositions) &&
+            drawPositions.length <= 2 &&
+            drawPositions.every((dp) => isConvertableInteger(dp) || dp === undefined || dp === null));
+    return validMatchUpId && validDrawPositions;
 }
-
-function getMatchUpFormatAverageTimes({ matchUpFormat, categoryName, categoryType, defaultTiming, tournamentScheduling, eventScheduling, policy, }) {
-    const eventAverageTimes = eventScheduling?.matchUpAverageTimes &&
-        findMatchupFormatAverageTimes({
-            ...eventScheduling,
-            matchUpFormat,
-        });
-    const tournamentAverageTimes = tournamentScheduling?.matchUpAverageTimes &&
-        findMatchupFormatAverageTimes({
-            ...tournamentScheduling,
-            matchUpFormat,
-        });
-    const policyAverageTimes = policy?.matchUpAverageTimes &&
-        findMatchupFormatAverageTimes({
-            ...policy,
-            matchUpFormat,
-        });
-    const timesBlockArray = [
-        eventAverageTimes,
-        tournamentAverageTimes,
-        policyAverageTimes,
-        policy?.defaultTimes?.averageTimes,
-        defaultTiming?.averageTimes,
-    ];
-    return findCategoryTiming({
-        categoryName,
-        categoryType,
-        timesBlockArray,
-    });
+function validMatchUps(matchUps) {
+    if (!Array.isArray(matchUps))
+        return false;
+    return matchUps.every(validMatchUp);
 }
 
-const DOUBLES_SINGLES = 'DOUBLES_SINGLES';
-const SINGLES_DOUBLES = 'SINGLES_DOUBLES';
-const TOTAL = 'total';
-const CONFLICT_PARTICIPANTS = 'participantConflict';
-const CONFLICT_MATCHUP_ORDER = 'matchUpConflict';
-const SCHEDULE_ISSUE_IDS = 'ISSUE_IDS';
-const SCHEDULE_CONFLICT = 'CONFLICT';
-const SCHEDULE_WARNING = 'WARNING';
-const SCHEDULE_ERROR = 'ERROR';
-const SCHEDULE_ISSUE = 'ISSUE';
-const SCHEDULE_STATE = 'STATE';
-const scheduleConstants = {
-    SINGLES_DOUBLES,
-    DOUBLES_SINGLES,
-    TOTAL,
-    CONFLICT_MATCHUP_ORDER,
-    CONFLICT_PARTICIPANTS,
-    SCHEDULE_ISSUE_IDS,
-    SCHEDULE_CONFLICT,
-    SCHEDULE_WARNING,
-    SCHEDULE_ERROR,
-    SCHEDULE_ISSUE,
-    SCHEDULE_STATE,
-};
-
-function getMatchUpFormatTiming({ defaultAverageMinutes = 90, defaultRecoveryMinutes = 0, tournamentRecord, matchUpFormat, categoryName, categoryType, eventType, event, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    eventType = eventType ?? event?.eventType ?? SINGLES_EVENT;
-    const defaultTiming = {
-        averageTimes: [{ minutes: { default: defaultAverageMinutes } }],
-        recoveryTimes: [{ minutes: { default: defaultRecoveryMinutes } }],
-    };
-    const { scheduleTiming } = getScheduleTiming({
-        tournamentRecord,
-        categoryName,
-        categoryType,
-        event,
-    });
-    const timingDetails = {
-        ...scheduleTiming,
-        matchUpFormat,
-        categoryType,
-        defaultTiming,
-    };
-    return matchUpFormatTimes({ eventType, timingDetails });
-}
-function matchUpFormatTimes({ timingDetails, eventType }) {
-    const averageTimes = getMatchUpFormatAverageTimes(timingDetails);
-    const averageKeys = Object.keys(averageTimes?.minutes || {});
-    const averageMinutes = averageTimes?.minutes &&
-        ((averageKeys?.includes(eventType) && averageTimes.minutes[eventType]) || averageTimes.minutes.default);
-    const recoveryTimes = getMatchUpFormatRecoveryTimes({
-        ...timingDetails,
-        averageMinutes,
-    });
-    const recoveryKeys = Object.keys(recoveryTimes?.minutes || {});
-    const recoveryMinutes = recoveryTimes?.minutes &&
+function getRoundMatchUps({ matchUps = [], interpolate }) {
+    if (!validMatchUps(matchUps))
+        return { roundMatchUps: [], error: INVALID_VALUES };
+    const roundMatchUpsArray = matchUps
+        .reduce((roundNumbers, matchUp) => {
+        const roundNumber = typeof matchUp.roundNumber === 'string' ? ensureInt(matchUp.roundNumber) : matchUp.roundNumber;
+        return !matchUp.roundNumber || roundNumbers.includes(roundNumber)
+            ? roundNumbers
+            : roundNumbers.concat(roundNumber);
+    }, [])
+        .sort(numericSort)
+        .map((roundNumber) => {
+        const roundMatchUps = matchUps.filter((matchUp) => matchUp.roundNumber === roundNumber);
+        const hasTeamMatchUps = roundMatchUps.find(({ matchUpType }) => matchUpType === TEAM$1);
+        const consideredMatchUps = hasTeamMatchUps
+            ? roundMatchUps.filter(({ matchUpType }) => matchUpType === TEAM$1)
+            : roundMatchUps;
+        const getSorted = (items) => items.sort((a, b) => numericSort(a.roundPosition, b.roundPosition));
+        return {
+            [roundNumber]: getSorted(consideredMatchUps),
+        };
+    });
+    const finishingRoundMap = matchUps.reduce((mapping, matchUp) => {
+        const roundNumber = typeof matchUp.roundNumber === 'string' ? ensureInt(matchUp.roundNumber) : matchUp.roundNumber;
+        if (!mapping[roundNumber])
+            mapping[roundNumber] = definedAttributes({
+                abbreviatedRoundName: matchUp.abbreviatedRoundName,
+                finishingRound: matchUp.finishingRound,
+                roundName: matchUp.roundName,
+            });
+        return mapping;
+    }, {});
+    const roundMatchUps = Object.assign({}, ...roundMatchUpsArray);
+    if (interpolate) {
+        const maxRoundNumber = Math.max(...Object.keys(roundMatchUps)
+            .map((key) => ensureInt(key))
+            .filter((f) => !isNaN(f)));
+        const maxRoundMatchUpsCount = roundMatchUps[maxRoundNumber]?.length;
+        if (maxRoundMatchUpsCount > 1 && isPowerOf2(maxRoundMatchUpsCount)) {
+            const nextRound = maxRoundNumber + 1;
+            const lastRound = nextRound + maxRoundMatchUpsCount / 2;
+            const roundsToInterpolate = generateRange(nextRound, lastRound);
+            roundsToInterpolate.forEach((roundNumber, i) => {
+                roundMatchUps[roundNumber] = generateRange(0, maxRoundMatchUpsCount / (2 + i * 2)).map(() => ({}));
+            });
+        }
+    }
+    let maxMatchUpsCount = 0;
+    const roundProfile = Object.assign({}, ...Object.keys(roundMatchUps).map((roundNumber) => {
+        const matchUpsCount = roundMatchUps[roundNumber]?.length;
+        const inactiveCount = roundMatchUps[roundNumber]?.filter((matchUp) => !completedMatchUpStatuses.includes(matchUp.matchUpStatus) && !matchUp.score?.scoreStringSide1)?.length;
+        const inactiveRound = matchUpsCount && matchUpsCount === inactiveCount;
+        maxMatchUpsCount = Math.max(maxMatchUpsCount, matchUpsCount);
+        return { [roundNumber]: { matchUpsCount, inactiveCount, inactiveRound } };
+    }));
+    let roundIndex = 0;
+    let feedRoundIndex = 0;
+    const roundNumbers = Object.keys(roundMatchUps)
+        .map((key) => ensureInt(key))
+        .filter((f) => !isNaN(f));
+    roundNumbers.forEach((roundNumber) => {
+        const currentRoundMatchUps = roundMatchUps[roundNumber].sort((a, b) => a.roundPosition - b.roundPosition);
+        const currentRoundDrawPositions = currentRoundMatchUps.map((matchUp) => matchUp?.drawPositions || []).flat();
+        roundProfile[roundNumber].roundNumber = roundNumber;
+        roundProfile[roundNumber].roundFactor = roundProfile[roundNumber].matchUpsCount
+            ? maxMatchUpsCount / roundProfile[roundNumber].matchUpsCount
+            : 1;
+        roundProfile[roundNumber].finishingRound = finishingRoundMap[roundNumber]?.finishingRound;
+        roundProfile[roundNumber].roundName = finishingRoundMap[roundNumber]?.roundName;
+        roundProfile[roundNumber].abbreviatedRoundName = finishingRoundMap[roundNumber]?.abbreviatedRoundName;
+        roundProfile[roundNumber].finishingPositionRange = roundMatchUps[roundNumber]?.[0]?.finishingPositionRange;
+        if (roundNumber === 1 || !roundProfile[roundNumber - 1]) {
+            const orderedDrawPositions = currentRoundDrawPositions.sort(numericSort);
+            const pairedDrawPositions = chunkArray(orderedDrawPositions, 2);
+            roundProfile[roundNumber].drawPositions = orderedDrawPositions;
+            roundProfile[roundNumber].pairedDrawPositions = pairedDrawPositions;
+        }
+        else {
+            const priorRound = roundProfile[roundNumber - 1];
+            const priorRoundDrawPositions = priorRound.drawPositions;
+            const chunkFactor = priorRound.matchUpsCount / roundProfile[roundNumber].matchUpsCount;
+            const priorRoundDrawPositionChunks = chunkArray(priorRoundDrawPositions, chunkFactor);
+            const roundDrawPositions = currentRoundMatchUps.map((matchUp) => {
+                const { roundPosition } = matchUp;
+                const drawPositions = [...(matchUp.drawPositions || []), undefined, undefined].slice(0, 2);
+                if (!roundPosition)
+                    return drawPositions;
+                const filteredDrawPositions = drawPositions?.filter(Boolean) || [];
+                if (!filteredDrawPositions?.length)
+                    return [undefined, undefined];
+                if (roundNumber < 3 && filteredDrawPositions?.length === 2) {
+                    return drawPositions?.slice().sort(numericSort);
+                }
+                const isFeedRound = intersection(priorRoundDrawPositions, filteredDrawPositions).length !== filteredDrawPositions?.length;
+                if (filteredDrawPositions?.length && isFeedRound) {
+                    if (filteredDrawPositions?.length === 1) {
+                        return [filteredDrawPositions[0], undefined];
+                    }
+                    else {
+                        return drawPositions?.slice().sort(numericSort);
+                    }
+                }
+                const targetChunkIndex = (roundPosition - 1) * 2;
+                const targetChunks = priorRoundDrawPositionChunks.slice(targetChunkIndex, targetChunkIndex + 2);
+                return targetChunks.map((chunk) => {
+                    return filteredDrawPositions?.find((drawPosition) => chunk.includes(drawPosition));
+                });
+            });
+            roundProfile[roundNumber].drawPositions = roundDrawPositions?.flat();
+            roundProfile[roundNumber].pairedDrawPositions = roundDrawPositions;
+        }
+        if (roundProfile[roundNumber + 1] &&
+            roundProfile[roundNumber + 1].matchUpsCount === roundProfile[roundNumber].matchUpsCount) {
+            roundProfile[roundNumber + 1].feedRound = true;
+            roundProfile[roundNumber + 1].feedRoundIndex = feedRoundIndex;
+            roundProfile[roundNumber].preFeedRound = true;
+            feedRoundIndex += 1;
+        }
+        if (roundProfile[roundNumber] && !roundProfile[roundNumber].feedRound) {
+            roundProfile[roundNumber].roundIndex = roundIndex;
+            roundIndex += 1;
+        }
+    });
+    const roundsNotPowerOf2 = !!Object.values(roundProfile).find(({ matchUpsCount }) => !isPowerOf2(matchUpsCount));
+    const hasNoRoundPositions = matchUps.some((matchUp) => !matchUp.roundPosition);
+    return {
+        hasNoRoundPositions,
+        roundsNotPowerOf2,
+        maxMatchUpsCount,
+        roundMatchUps,
+        roundNumbers,
+        roundProfile,
+        ...SUCCESS,
+    };
+}
+
+function getRangeString(arr) {
+    if (!Array.isArray(arr))
+        return '';
+    const numericArray = arr.filter(isNumeric);
+    if (!numericArray.length)
+        return '';
+    const range = unique([Math.min(...numericArray), Math.max(...numericArray)]);
+    return range.join('-');
+}
+
+function getSourceDrawPositionRanges({ drawDefinition, structureId, matchUpsMap }) {
+    if (!drawDefinition)
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId)
+        return { error: MISSING_STRUCTURE_ID };
+    const { structure } = findStructure({ drawDefinition, structureId });
+    if (structure?.stage !== CONSOLATION)
+        return { error: INVALID_STAGE, info: 'Structure is not CONSOLATION stage' };
+    const { links } = drawDefinition;
+    const relevantLinks = links?.filter((link) => link.target.structureId === structureId) || [];
+    const sourceStructureIds = relevantLinks?.reduce((sourceStructureIds, link) => {
+        const { structureId: sourceStructureId } = link.source;
+        return sourceStructureIds.includes(sourceStructureId)
+            ? sourceStructureIds
+            : sourceStructureIds.concat(sourceStructureId);
+    }, []) || [];
+    const sourceStructureProfiles = Object.assign({}, ...sourceStructureIds.map((sourceStructureId) => {
+        const structureMatchUps = getMappedStructureMatchUps({
+            structureId: sourceStructureId,
+            matchUpsMap,
+        });
+        const roundMatchUpsResult = getRoundMatchUps({
+            matchUps: structureMatchUps,
+        });
+        const roundProfile = roundMatchUpsResult.roundProfile;
+        return { [sourceStructureId]: roundProfile };
+    }));
+    const structureMatchUps = getMappedStructureMatchUps({
+        matchUpsMap,
+        structureId,
+    });
+    const { roundProfile: targetStructureProfile } = getRoundMatchUps({
+        matchUps: structureMatchUps,
+    });
+    const sourceDrawPositionRanges = {};
+    relevantLinks?.forEach((link) => {
+        const { structureId: sourceStructureId, roundNumber: sourceRoundNumber } = link.source;
+        const { feedProfile, groupedOrder, positionInterleave, roundNumber: targetRoundNumber } = link.target;
+        const sourceStructureProfile = sourceStructureProfiles[sourceStructureId];
+        const firstRoundDrawPositions = sourceStructureProfile[1]?.drawPositions;
+        const sourceRoundProfile = sourceStructureProfile[sourceRoundNumber];
+        const sourceRoundMatchUpsCount = sourceRoundProfile?.matchUpsCount;
+        if (!sourceRoundMatchUpsCount)
+            return;
+        const chunkSize = sourceRoundMatchUpsCount ? firstRoundDrawPositions.length / sourceRoundMatchUpsCount : 0;
+        const targetRoundMatchUpsCount = firstRoundDrawPositions.length / chunkSize;
+        let orderedPositions = firstRoundDrawPositions.slice();
+        const sizedGroupOrder = reduceGroupedOrder({
+            roundPositionsCount: targetRoundMatchUpsCount,
+            groupedOrder,
+        });
+        const groupsCount = sizedGroupOrder?.length || 1;
+        if (groupsCount <= targetRoundMatchUpsCount) {
+            const groupSize = firstRoundDrawPositions.length / groupsCount;
+            const groups = chunkArray(orderedPositions, groupSize);
+            if (feedProfile === BOTTOM_UP)
+                groups.forEach((group) => group.reverse());
+            orderedPositions =
+                (sizedGroupOrder?.length && sizedGroupOrder?.map((order) => groups[order - 1]).flat()) || orderedPositions;
+        }
+        let drawPositionBlocks = chunkArray(orderedPositions, chunkSize);
+        if (positionInterleave) {
+            const interleave = generateRange(0, positionInterleave.interleave).map(() => undefined);
+            const offset = generateRange(0, positionInterleave.offset).map(() => undefined);
+            drawPositionBlocks = drawPositionBlocks.map((block) => [block, ...interleave]);
+            drawPositionBlocks.unshift(offset);
+            drawPositionBlocks = drawPositionBlocks.flat(1);
+            const targetLength = drawPositionBlocks.length - positionInterleave.offset;
+            drawPositionBlocks = drawPositionBlocks.slice(0, targetLength);
+        }
+        if (!sourceDrawPositionRanges[targetRoundNumber])
+            sourceDrawPositionRanges[targetRoundNumber] = {};
+        const targetRoundProfile = targetStructureProfile?.[targetRoundNumber];
+        const increment = targetRoundProfile?.feedRound ? 2 : 1;
+        drawPositionBlocks.forEach((block, index) => {
+            const columnPosition = 1 + index * increment;
+            if (!sourceDrawPositionRanges[targetRoundNumber][columnPosition]) {
+                sourceDrawPositionRanges[targetRoundNumber][columnPosition] = getRangeString(block);
+            }
+        });
+    });
+    return { sourceDrawPositionRanges };
+}
+
+function getExitProfiles({ drawDefinition }) {
+    if (typeof drawDefinition !== 'object')
+        return { error: INVALID_DRAW_DEFINITION };
+    const exitProfiles = {};
+    const { structures = [], links = [] } = drawDefinition || {};
+    const stageStructures = structures.reduce((stageStructures, structure) => {
+        const { stage } = structure;
+        if (!stageStructures[stage]) {
+            stageStructures[stage] = [structure];
+        }
+        else {
+            stageStructures[stage].push(structure);
+        }
+        return stageStructures;
+    }, {});
+    for (const stage of Object.keys(stageStructures)) {
+        const initialStructure = stageStructures[stage].find(({ stageSequence }) => stageSequence === 1);
+        if (!initialStructure)
+            continue;
+        const { structureId } = initialStructure;
+        const exitProfile = '0';
+        addExitProfiles({
+            aggregator: {},
+            targetRound: 0,
+            exitProfiles,
+            exitProfile,
+            structureId,
+            stage,
+        });
+    }
+    return { exitProfiles };
+    function addExitProfiles({ exitProfiles, exitProfile, structureId, targetRound, aggregator, stage }) {
+        if (!exitProfiles[structureId])
+            exitProfiles[structureId] = [];
+        if (!(exitProfile === '0' && [CONSOLATION, PLAY_OFF].includes(stage)))
+            exitProfiles[structureId].push(exitProfile);
+        const relevantLinks = links.filter((link) => link.source.structureId === structureId && link.source.roundNumber >= targetRound);
+        for (const link of relevantLinks) {
+            const exitRound = link.source.roundNumber;
+            const targetRound = link.target.roundNumber;
+            const targetStructureId = link.target.structureId;
+            const stage = structures.find((structure) => structure.structureId === targetStructureId).stage;
+            const fp = [stage, targetStructureId, targetRound, exitRound].join('|');
+            if (aggregator[fp])
+                return;
+            aggregator[fp] = true;
+            addExitProfiles({
+                exitProfile: `${exitProfile}-${exitRound}`,
+                structureId: targetStructureId,
+                exitProfiles,
+                targetRound,
+                aggregator,
+                stage,
+            });
+        }
+    }
+}
+
+function getDrawPositionsRanges({ drawDefinition, roundProfile, structureId, matchUpsMap, }) {
+    if (!drawDefinition)
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId)
+        return { error: MISSING_STRUCTURE_ID };
+    if (!roundProfile) {
+        const structureMatchUps = getMappedStructureMatchUps({
+            matchUpsMap,
+            structureId,
+        });
+        ({ roundProfile } = getRoundMatchUps({
+            matchUps: structureMatchUps,
+        }));
+        if (!roundProfile)
+            return { error: MISSING_VALUE };
+    }
+    const firstRoundFirstDrawPosition = Math.min(...(roundProfile?.[1]?.drawPositions ?? []));
+    const firstRoundFirstDrawPositionOffset = (firstRoundFirstDrawPosition || 1) - 1;
+    const roundNumbers = Object.keys(roundProfile);
+    const drawPositionsRanges = Object.assign({}, ...(roundNumbers || []).map((roundNumber) => {
+        const matchUpsCount = roundProfile?.[roundNumber]?.matchUpsCount;
+        const firstRoundDrawPositions = roundProfile?.[1]?.drawPositions ?? [];
+        const firstRoundDrawPositionsChunks = chunkArray(firstRoundDrawPositions, firstRoundDrawPositions.length / matchUpsCount);
+        const firstRoundDrawPositionsRanges = firstRoundDrawPositionsChunks.map(getRangeString);
+        const firstRoundOffsetDrawPositionsRanges = firstRoundDrawPositionsChunks
+            .map((drawPositions) => {
+            return drawPositions.map((drawPosition) => drawPosition - firstRoundFirstDrawPositionOffset);
+        })
+            .map(getRangeString);
+        const currentRoundDrawPositionChunks = roundNumbers
+            .map((value) => {
+            if (value > roundNumber)
+                return undefined;
+            const drawPositions = roundProfile?.[value]?.drawPositions ?? [];
+            return chunkArray(drawPositions, drawPositions.length / matchUpsCount);
+        })
+            .filter(Boolean);
+        const possibleDrawPositions = generateRange(0, matchUpsCount)
+            .map((index) => {
+            return currentRoundDrawPositionChunks
+                .map((chunk) => chunk[index])
+                .flat()
+                .filter(Boolean)
+                .sort(numericSort);
+        })
+            .map((possible) => unique(possible));
+        const drawPositionsRanges = possibleDrawPositions.map((possible) => {
+            return groupConsecutiveNumbers(possible).map(getRangeString).join(', ');
+        });
+        const roundPositionsMap = Object.assign({}, ...generateRange(0, matchUpsCount).map((index) => {
+            const roundPosition = index + 1;
+            return {
+                [roundPosition]: {
+                    firstRoundDrawPositionsRange: firstRoundDrawPositionsRanges[index],
+                    firstRoundOffsetDrawPositionsRange: firstRoundOffsetDrawPositionsRanges[index],
+                    possibleDrawPositions: possibleDrawPositions[index],
+                    drawPositionsRange: drawPositionsRanges[index],
+                },
+            };
+        }));
+        return { [roundNumber]: roundPositionsMap };
+    }));
+    return { drawPositionsRanges };
+}
+
+function isLucky({ roundsNotPowerOf2, drawDefinition, structure, matchUps }) {
+    if (!structure)
+        return false;
+    matchUps = matchUps ?? structure.matchUps ?? [];
+    roundsNotPowerOf2 = roundsNotPowerOf2 ?? getRoundMatchUps({ matchUps }).roundsNotPowerOf2;
+    const hasDrawPositions = !!structure.positionAssignments?.find(({ drawPosition }) => drawPosition) ||
+        !!matchUps?.find(({ drawPositions }) => drawPositions?.length);
+    return ((!drawDefinition?.drawType || drawDefinition.drawType !== LUCKY_DRAW) &&
+        !structure?.structures &&
+        roundsNotPowerOf2 &&
+        hasDrawPositions);
+}
+
+function isAdHoc({ structure }) {
+    if (!structure)
+        return false;
+    const matchUps = structure.matchUps || (structure.roundMatchUps && Object.values(structure.roundMatchUps).flat());
+    const hasRoundPosition = !!matchUps?.find((matchUp) => matchUp?.roundPosition);
+    const hasDrawPosition = !!matchUps?.find((matchUp) => matchUp?.drawPositions?.length);
+    return (!structure?.structures &&
+        structure?.stage !== VOLUNTARY_CONSOLATION &&
+        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition)));
+}
+
+const POLICY_ROUND_NAMING_DEFAULT = {
+    [POLICY_TYPE_ROUND_NAMING]: {
+        policyName: 'Round Naming Default',
+        namingConventions: {
+            round: 'Round',
+            pre: 'Pre',
+        },
+        qualifyingFinishMap: {
+            1: 'Final',
+        },
+        abbreviatedRoundNamingMap: {
+            1: 'F',
+            2: 'SF',
+            4: 'QF',
+        },
+        roundNamingMap: {
+            1: 'Final',
+            2: 'Semifinal',
+            4: 'Quarterfinal',
+        },
+        affixes: {
+            roundNumber: 'R',
+            preFeedRound: 'Q',
+            preQualifying: 'P',
+        },
+        stageConstants: {
+            [MAIN]: '',
+            [PLAY_OFF]: 'P',
+            [QUALIFYING]: 'Q',
+            [CONSOLATION]: 'C',
+        },
+    },
+};
+
+function getRoundContextProfile({ roundNamingPolicy, drawDefinition, structure, matchUps, }) {
+    const { roundProfile, roundMatchUps } = getRoundMatchUps({ matchUps });
+    const { structureAbbreviation, stage } = structure;
+    const isAdHocStructure = isAdHoc({ structure });
+    const isLuckyStructure = isLucky({ structure });
+    const isRoundRobin = structure.structures;
+    const roundNamingProfile = {};
+    const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
+    const isQualifying = structure.stage === QUALIFYING;
+    const qualifyingStageSequences = isQualifying
+        ? Math.max(...(drawDefinition?.structures ?? [])
+            .filter((structure) => structure.stage === QUALIFYING)
+            .map(({ stageSequence }) => stageSequence ?? 1), 0)
+        : 0;
+    const preQualifyingSequence = (structure.stageSequence ?? 1) < qualifyingStageSequences ? structure.stageSequence ?? 1 : '';
+    const preQualifyingAffix = preQualifyingSequence
+        ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || ''
+        : '';
+    const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
+    const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
+    const preFeedAffix = roundNamingPolicy?.affixes?.preFeedRound || defaultRoundNamingPolicy.affixes.preFeedRound;
+    const roundNumberAffix = roundNamingPolicy?.affixes?.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
+    const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
+    const roundNameFallback = namingConventions.round;
+    const stageInitial = stage && stage !== MAIN ? stage[0] : '';
+    const stageConstants = roundNamingPolicy?.stageConstants || defaultRoundNamingPolicy.stageConstants;
+    const stageIndicator = (stage && stageConstants?.[stage]) || stageInitial;
+    const stageConstant = `${preQualifyingAffix}${stageIndicator}${preQualifyingSequence}`;
+    const roundProfileKeys = roundProfile ? Object.keys(roundProfile) : [];
+    const qualifyingAffix = isQualifying && stageConstants?.[QUALIFYING] ? `${stageConstants?.[QUALIFYING]}-` : '';
+    if (isRoundRobin || isAdHocStructure || isLuckyStructure) {
+        Object.assign(roundNamingProfile, ...roundProfileKeys.map((key) => {
+            const roundName = `${qualifyingAffix}${roundNameFallback} ${key}`;
+            const abbreviatedRoundName = `${roundNumberAffix}${key}`;
+            return { [key]: { roundName, abbreviatedRoundName } };
+        }));
+    }
+    else {
+        const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
+        Object.assign(roundNamingProfile, ...roundProfileKeys.map((round) => {
+            if (!roundProfile?.[round])
+                return undefined;
+            const { matchUpsCount, preFeedRound } = roundProfile[round];
+            const participantsCount = matchUpsCount * 2;
+            const sizedRoundName = qualifyingFinishgMap?.[roundProfile?.[round].finishingRound] ||
+                (qualifyingFinishgMap && `${roundNumberAffix}${participantsCount}`) ||
+                roundNamingMap[matchUpsCount] ||
+                `${roundNumberAffix}${participantsCount}`;
+            const suffix = preFeedRound ? `-${preFeedAffix}` : '';
+            const profileRoundName = `${sizedRoundName}${suffix}`;
+            const roundName = [stageConstant, structureAbbreviation, profileRoundName].filter(Boolean).join('-');
+            const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
+            const profileAbbreviation = `${sizedAbbreviation}${suffix}`;
+            const abbreviatedRoundName = [stageConstant, structureAbbreviation, profileAbbreviation]
+                .filter(Boolean)
+                .join('-');
+            return { [round]: { abbreviatedRoundName, roundName } };
+        }));
+    }
+    return { roundNamingProfile, roundProfile, roundMatchUps };
+}
+
+const add = (a, b) => (a || 0) + (b || 0);
+function getBand(spread, bandProfiles) {
+    const spreadValue = Array.isArray(spread) ? spread[0] : spread;
+    return ((isNaN(spreadValue) && WALKOVER$1) ||
+        (spreadValue <= bandProfiles[DECISIVE] && DECISIVE) ||
+        (spreadValue <= bandProfiles[ROUTINE] && ROUTINE) ||
+        COMPETITIVE);
+}
+function getScoreComponents({ score }) {
+    const sets = score?.sets || [];
+    const games = sets.reduce((p, c) => {
+        p[0] += c.side1Score || 0;
+        p[1] += c.side2Score || 0;
+        return p;
+    }, [0, 0]);
+    const stb = sets.reduce((p, c) => {
+        p[0] += c.side1TiebreakScore || 0;
+        p[1] += c.side2TiebreakScore || 0;
+        return p;
+    }, [0, 0]);
+    if (stb.reduce(add)) {
+        games[stb[0] > stb[1] ? 0 : 1] += 1;
+    }
+    return { sets, games, score };
+}
+function gamesPercent(scoreComponents) {
+    const minGames = Math.min(...scoreComponents.games);
+    const maxGames = Math.max(...scoreComponents.games);
+    return Math.round((minGames / maxGames) * 100);
+}
+function pctSpread(pcts) {
+    return pcts
+        .map(gamesPercent)
+        .sort()
+        .map((p) => parseFloat(p.toFixed(2)));
+}
+
+function getMatchUpCompetitiveProfile({ tournamentRecord, profileBands, matchUp, }) {
+    if (!matchUp)
+        return { error: MISSING_MATCHUP };
+    const { score, winningSide } = matchUp;
+    if (!winningSide)
+        return { error: INVALID_VALUES };
+    const policy = !profileBands &&
+        tournamentRecord &&
+        findPolicy({
+            policyType: POLICY_TYPE_COMPETITIVE_BANDS,
+            tournamentRecord,
+        }).policy;
+    const bandProfiles = profileBands ||
+        policy?.profileBands ||
+        POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
+    const scoreComponents = getScoreComponents({ score });
+    const spread = pctSpread([scoreComponents]);
+    const competitiveness = getBand(spread, bandProfiles);
+    const pctSpreadValue = Array.isArray(spread) ? spread[0] : spread;
+    return { ...SUCCESS, competitiveness, pctSpread: pctSpreadValue };
+}
+
+function getMatchUpParticipantIds({ matchUp }) {
+    if (!matchUp)
+        return { error: MISSING_MATCHUP };
+    if (matchUp && !matchUp.sides)
+        return { error: INVALID_MATCHUP };
+    if (matchUp && !matchUp.hasContext)
+        return { error: MISSING_CONTEXT };
+    const sideParticipantIds = (matchUp.sides ?? [])
+        ?.map((side) => side?.participantId)
+        .filter(Boolean);
+    const sideIndividualParticipantIds = matchUp.sides
+        ?.filter((side) => side.participant?.participantType === INDIVIDUAL)
+        .map((participant) => participant.participantId)
+        .filter(Boolean) ?? [];
+    const nestedIndividualParticipants = (matchUp.sides ?? [])
+        ?.map((side) => side.participant?.individualParticipants)
+        .filter(Boolean) ?? [];
+    const nestedIndividualParticipantIds = nestedIndividualParticipants.map((participants) => (participants ?? []).map((participant) => participant?.participantId).filter(Boolean));
+    const individualParticipantIds = [...sideIndividualParticipantIds, ...nestedIndividualParticipantIds.flat()].filter(Boolean) ?? [];
+    const allRelevantParticipantIds = unique(individualParticipantIds.concat(sideParticipantIds)).filter(Boolean) ?? [];
+    return {
+        nestedIndividualParticipantIds,
+        allRelevantParticipantIds,
+        individualParticipantIds,
+        sideParticipantIds,
+        ...SUCCESS,
+    };
+}
+
+const CHECK_IN = 'CHECK_IN';
+const CHECK_OUT = 'CHECK_OUT';
+const SCHEDULE$1 = 'SCHEDULE';
+const ASSIGN_VENUE = 'SCHEDULE.ASSIGNMENT.VENUE';
+const ALLOCATE_COURTS = 'SCHEDULE.ALLOCATION.COURTS';
+const ASSIGN_COURT = 'SCHEDULE.ASSIGNMENT.COURT';
+const COURT_ORDER = 'SCHEDULE.COURT.ORDER';
+const SCHEDULED_DATE = 'SCHEDULE.DATE';
+const COMPLETED_DATE = 'COMPLETED.DATE';
+const HOME_PARTICIPANT_ID = 'HOME_PARTICIPANT_ID';
+const ASSIGN_OFFICIAL = 'SCHEDULE.ASSIGN.OFFICIAL';
+const SCHEDULED_TIME = 'SCHEDULE.TIME.SCHEDULED';
+const START_TIME = 'SCHEDULE.TIME.START';
+const STOP_TIME = 'SCHEDULE.TIME.STOP';
+const RESUME_TIME = 'SCHEDULE.TIME.RESUME';
+const END_TIME = 'SCHEDULE.TIME.END';
+const TIME_MODIFIERS = 'SCHEDULE.TIME.MODIFIERS';
+const TO_BE_ANNOUNCED = 'TO_BE_ANNOUNCED';
+const NEXT_AVAILABLE = 'NEXT_AVAILABLE';
+const FOLLOWED_BY = 'FOLLOWED_BY';
+const AFTER_REST = 'AFTER_REST';
+const RAIN_DELAY = 'RAIN_DELAY';
+const NOT_BEFORE = 'NOT_BEFORE';
+const MUTUALLY_EXCLUSIVE_TIME_MODIFIERS = [TO_BE_ANNOUNCED, NEXT_AVAILABLE, FOLLOWED_BY, AFTER_REST, RAIN_DELAY];
+const ELIGIBILITY = 'ELIGIBILITY';
+const REGISTRATION = 'REGISTRATION';
+const SUSPENSION = 'SUSPENSION';
+const MEDICAL$1 = 'MEDICAL';
+const PENALTY$1 = 'PENALTY';
+const SCALE = 'SCALE';
+const RATING = 'RATING';
+const RANKING = 'RANKING';
+const SEEDING = 'SEEDING';
+const PUBLISH = 'PUBLISH';
+const PUBLIC = 'PUBLIC';
+const STATUS$1 = 'STATUS';
+const MODIFICATION = 'MODIFICATION';
+const RETRIEVAL = 'RETRIEVAL';
+const OTHER$3 = 'other';
+const timeItemConstants = {
+    MUTUALLY_EXCLUSIVE_TIME_MODIFIERS,
+    AFTER_REST,
+    ALLOCATE_COURTS,
+    ASSIGN_COURT,
+    ASSIGN_OFFICIAL,
+    ASSIGN_VENUE,
+    CHECK_IN,
+    CHECK_OUT,
+    COMPLETED_DATE,
+    COURT_ORDER,
+    ELIGIBILITY,
+    END_TIME,
+    FOLLOWED_BY,
+    MEDICAL: MEDICAL$1,
+    MODIFICATION,
+    NEXT_AVAILABLE,
+    NOT_BEFORE,
+    OTHER: OTHER$3,
+    PENALTY: PENALTY$1,
+    PUBLIC,
+    PUBLISH,
+    RANKING,
+    RATING,
+    RAIN_DELAY,
+    REGISTRATION,
+    RESUME_TIME,
+    RETRIEVAL,
+    SCALE,
+    SCHEDULE: SCHEDULE$1,
+    SCHEDULED_DATE,
+    SCHEDULED_TIME,
+    SEEDING,
+    START_TIME,
+    STATUS: STATUS$1,
+    STOP_TIME,
+    SUSPENSION,
+    TIME_MODIFIERS,
+    TO_BE_ANNOUNCED,
+};
+
+function getCheckedInParticipantIds({ matchUp }) {
+    if (!matchUp)
+        return { error: MISSING_MATCHUP };
+    if (!matchUp.hasContext)
+        return { error: MISSING_CONTEXT };
+    if (!matchUp.sides || matchUp.sides.filter(Boolean).length !== 2) {
+        return { error: INVALID_MATCHUP };
+    }
+    const { nestedIndividualParticipantIds, allRelevantParticipantIds, sideParticipantIds } = getMatchUpParticipantIds({
+        matchUp,
+    });
+    const timeItems = matchUp.timeItems ?? [];
+    const checkInItems = timeItems
+        .filter((timeItem) => timeItem?.itemType && [CHECK_IN, CHECK_OUT].includes(timeItem.itemType))
+        .sort((a, b) => (a.createdAt ? new Date(a.createdAt).getTime() : 0) - (b.createdAt ? new Date(b.createdAt).getTime() : 0));
+    const timeItemParticipantIds = checkInItems.map((timeItem) => timeItem.itemValue);
+    const checkedInParticipantIds = timeItemParticipantIds.filter((participantId) => {
+        return checkInItems.filter((timeItem) => timeItem?.itemValue === participantId).reverse()[0].itemType === CHECK_IN;
+    });
+    nestedIndividualParticipantIds?.forEach((sideIndividualParticipantIds, sideIndex) => {
+        const sideParticipantId = sideParticipantIds?.[sideIndex];
+        const allIndividualsCheckedIn = sideIndividualParticipantIds?.length &&
+            sideIndividualParticipantIds.every((participantId) => checkedInParticipantIds.includes(participantId));
+        if (sideParticipantId && allIndividualsCheckedIn && !checkedInParticipantIds.includes(sideParticipantId)) {
+            checkedInParticipantIds.push(sideParticipantId);
+        }
+    });
+    sideParticipantIds?.forEach((sideParticipantId, sideIndex) => {
+        if (checkedInParticipantIds.includes(sideParticipantId)) {
+            (nestedIndividualParticipantIds?.[sideIndex] ?? []).forEach((participantId) => {
+                if (participantId && !checkedInParticipantIds.includes(participantId)) {
+                    checkedInParticipantIds.push(participantId);
+                }
+            });
+        }
+    });
+    const allParticipantsCheckedIn = sideParticipantIds?.reduce((checkedIn, participantId) => {
+        return checkedInParticipantIds.includes(participantId) && checkedIn;
+    }, true);
+    return {
+        allRelevantParticipantIds,
+        allParticipantsCheckedIn,
+        checkedInParticipantIds,
+        ...SUCCESS,
+    };
+}
+
+const matchUpEventTypeMap = {
+    [SINGLES]: [SINGLES, 'S'],
+    [DOUBLES]: [DOUBLES, 'D'],
+    [TEAM$1]: [TEAM$1, 'T'],
+    S: [SINGLES, 'S'],
+    D: [DOUBLES, 'D'],
+    T: [TEAM$1, 'T'],
+};
+
+const isMatchUpEventType = (type) => (params) => {
+    const matchUpEventType = (isObject(params) && params?.matchUpType) || (isString(params) && params);
+    return matchUpEventType && matchUpEventTypeMap[type].includes(matchUpEventType);
+};
+
+function findMatchupFormatAverageTimes(params) {
+    const { matchUpAverageTimes, matchUpFormat } = params || {};
+    const codeMatches = matchUpAverageTimes
+        ?.map(({ matchUpFormatCodes }) => {
+        return matchUpFormatCodes?.filter((code) => code === matchUpFormat);
+    })
+        .flat()
+        .filter(Boolean)
+        .sort((a, b) => (a?.length || 0) - (b?.length || 0)) || [];
+    const exactCodeMatch = codeMatches.includes(matchUpFormat);
+    const targetCode = exactCodeMatch ? matchUpFormat : codeMatches[0];
+    const targetDefinition = matchUpAverageTimes?.find(({ matchUpFormatCodes, averageTimes }) => matchUpFormatCodes?.find((code) => targetCode === code) && averageTimes);
+    return targetDefinition?.averageTimes;
+}
+function findMatchupFormatRecoveryTimes(params) {
+    const { matchUpRecoveryTimes, averageMinutes, matchUpFormat } = params || {};
+    return matchUpRecoveryTimes?.find(({ matchUpFormatCodes, averageTimes, recoveryTimes }) => {
+        if (averageTimes && averageMinutes) {
+            const { greaterThan = 0, lessThan = 360 } = averageTimes;
+            if (averageMinutes > greaterThan && averageMinutes < lessThan)
+                return true;
+        }
+        return matchUpFormatCodes?.find((code) => code === matchUpFormat) && recoveryTimes;
+    })?.recoveryTimes;
+}
+
+function findCategoryTiming({ timesBlockArray, categoryName, categoryType }) {
+    return timesBlockArray
+        .filter((f) => Array.isArray(f))
+        .map((times) => times
+        .sort((a, b) => (b.categoryNames?.length || 0) - (a.categoryNames?.length || 0))
+        .find(({ categoryTypes, categoryNames }) => (!categoryNames?.length && !categoryTypes?.length) ||
+        categoryNames?.includes(categoryName) ||
+        categoryTypes?.includes(categoryType)))
+        .find(Boolean);
+}
+
+function getMatchUpFormatRecoveryTimes({ tournamentScheduling, eventScheduling, averageMinutes, defaultTiming, matchUpFormat, categoryName, categoryType, policy, }) {
+    const eventRecoveryTimes = eventScheduling?.matchUpRecoveryTimes &&
+        findMatchupFormatRecoveryTimes({
+            ...eventScheduling,
+            averageMinutes,
+            matchUpFormat,
+        });
+    const tournamentRecoveryTimes = tournamentScheduling?.matchUpRecoveryTimes &&
+        findMatchupFormatRecoveryTimes({
+            ...tournamentScheduling,
+            averageMinutes,
+            matchUpFormat,
+        });
+    const policyRecoveryTimes = policy?.matchUpRecoveryTimes &&
+        findMatchupFormatRecoveryTimes({
+            ...policy,
+            averageMinutes,
+            matchUpFormat,
+        });
+    const timesBlockArray = [
+        eventRecoveryTimes,
+        tournamentRecoveryTimes,
+        policyRecoveryTimes,
+        policy?.defaultTimes?.recoveryTimes,
+        defaultTiming?.recoveryTimes,
+    ];
+    return findCategoryTiming({
+        categoryName,
+        categoryType,
+        timesBlockArray,
+    });
+}
+
+function getMatchUpFormatAverageTimes({ matchUpFormat, categoryName, categoryType, defaultTiming, tournamentScheduling, eventScheduling, policy, }) {
+    const eventAverageTimes = eventScheduling?.matchUpAverageTimes &&
+        findMatchupFormatAverageTimes({
+            ...eventScheduling,
+            matchUpFormat,
+        });
+    const tournamentAverageTimes = tournamentScheduling?.matchUpAverageTimes &&
+        findMatchupFormatAverageTimes({
+            ...tournamentScheduling,
+            matchUpFormat,
+        });
+    const policyAverageTimes = policy?.matchUpAverageTimes &&
+        findMatchupFormatAverageTimes({
+            ...policy,
+            matchUpFormat,
+        });
+    const timesBlockArray = [
+        eventAverageTimes,
+        tournamentAverageTimes,
+        policyAverageTimes,
+        policy?.defaultTimes?.averageTimes,
+        defaultTiming?.averageTimes,
+    ];
+    return findCategoryTiming({
+        categoryName,
+        categoryType,
+        timesBlockArray,
+    });
+}
+
+const DOUBLES_SINGLES = 'DOUBLES_SINGLES';
+const SINGLES_DOUBLES = 'SINGLES_DOUBLES';
+const TOTAL = 'total';
+const CONFLICT_PARTICIPANTS = 'participantConflict';
+const CONFLICT_MATCHUP_ORDER = 'matchUpConflict';
+const SCHEDULE_ISSUE_IDS = 'ISSUE_IDS';
+const SCHEDULE_CONFLICT = 'CONFLICT';
+const SCHEDULE_WARNING = 'WARNING';
+const SCHEDULE_ERROR = 'ERROR';
+const SCHEDULE_ISSUE = 'ISSUE';
+const SCHEDULE_STATE = 'STATE';
+const scheduleConstants = {
+    SINGLES_DOUBLES,
+    DOUBLES_SINGLES,
+    TOTAL,
+    CONFLICT_MATCHUP_ORDER,
+    CONFLICT_PARTICIPANTS,
+    SCHEDULE_ISSUE_IDS,
+    SCHEDULE_CONFLICT,
+    SCHEDULE_WARNING,
+    SCHEDULE_ERROR,
+    SCHEDULE_ISSUE,
+    SCHEDULE_STATE,
+};
+
+function getMatchUpFormatTiming({ defaultAverageMinutes = 90, defaultRecoveryMinutes = 0, tournamentRecord, matchUpFormat, categoryName, categoryType, eventType, event, }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    eventType = eventType ?? event?.eventType ?? SINGLES_EVENT;
+    const defaultTiming = {
+        averageTimes: [{ minutes: { default: defaultAverageMinutes } }],
+        recoveryTimes: [{ minutes: { default: defaultRecoveryMinutes } }],
+    };
+    const { scheduleTiming } = getScheduleTiming({
+        tournamentRecord,
+        categoryName,
+        categoryType,
+        event,
+    });
+    const timingDetails = {
+        ...scheduleTiming,
+        matchUpFormat,
+        categoryType,
+        defaultTiming,
+    };
+    return matchUpFormatTimes({ eventType, timingDetails });
+}
+function matchUpFormatTimes({ timingDetails, eventType }) {
+    const averageTimes = getMatchUpFormatAverageTimes(timingDetails);
+    const averageKeys = Object.keys(averageTimes?.minutes || {});
+    const averageMinutes = averageTimes?.minutes &&
+        ((averageKeys?.includes(eventType) && averageTimes.minutes[eventType]) || averageTimes.minutes.default);
+    const recoveryTimes = getMatchUpFormatRecoveryTimes({
+        ...timingDetails,
+        averageMinutes,
+    });
+    const recoveryKeys = Object.keys(recoveryTimes?.minutes || {});
+    const recoveryMinutes = recoveryTimes?.minutes &&
         ((recoveryKeys?.includes(eventType) && recoveryTimes.minutes[eventType]) || recoveryTimes.minutes.default);
     const formatChangeKey = isMatchUpEventType(SINGLES_EVENT)(eventType) ? SINGLES_DOUBLES : DOUBLES_SINGLES;
     const typeChangeRecoveryMinutes = recoveryTimes?.minutes &&
@@ -6908,6 +7552,21 @@ function matchUpCourtOrder({ visibilityThreshold, timeStamp, schedule, matchUp }
         : schedule;
 }
 
+function getHomeParticipantId(params) {
+    const { visibilityThreshold, timeStamp, schedule, matchUp } = params;
+    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: HOME_PARTICIPANT_ID,
+        visibilityThreshold,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { homeParticipantId }
+        : schedule;
+}
+
 function matchUpStartTime({ matchUp }) {
     const timeItems = matchUp?.timeItems || [];
     const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
@@ -6920,10 +7579,10 @@ function matchUpStartTime({ matchUp }) {
     return { startTime };
 }
 
-function UUIDS(count = 1) {
-    return generateRange(0, count).map(UUID);
+function UUIDS(count = 1, pre) {
+    return generateRange(0, count).map(() => UUID(pre));
 }
-function UUID() {
+function UUID(pre) {
     const lut = [];
     for (let i = 0; i < 256; i++) {
         lut[i] = (i < 16 ? '0' : '') + i.toString(16);
@@ -6932,7 +7591,7 @@ function UUID() {
     const d1 = (Math.random() * 0xffffffff) | 0;
     const d2 = (Math.random() * 0xffffffff) | 0;
     const d3 = (Math.random() * 0xffffffff) | 0;
-    return (lut[d0 & 0xff] +
+    const uuid = lut[d0 & 0xff] +
         lut[(d0 >> 8) & 0xff] +
         lut[(d0 >> 16) & 0xff] +
         lut[(d0 >> 24) & 0xff] +
@@ -6951,7 +7610,8 @@ function UUID() {
         lut[d3 & 0xff] +
         lut[(d3 >> 8) & 0xff] +
         lut[(d3 >> 16) & 0xff] +
-        lut[(d3 >> 24) & 0xff]);
+        lut[(d3 >> 24) & 0xff];
+    return typeof pre === 'string' ? `${pre}_${uuid.replace(/-/g, '')}` : uuid;
 }
 
 function addVenue(params) {
@@ -7207,601 +7867,184 @@ function findEvent(params) {
                     return {
                         entries: flight.drawEntries,
                         drawName: flight.drawName,
-                        tournamentId,
-                        drawId,
-                    };
-                }
-            }
-            return targetDrawDefinition;
-        });
-        if (event)
-            return { event, drawDefinition, tournamentId };
-    }
-    if (eventId) {
-        const event = events.find((event) => event?.eventId === eventId);
-        if (!event) {
-            return {
-                event: undefined,
-                drawDefinition: undefined,
-                ...decorateResult({ result: { error: EVENT_NOT_FOUND }, stack }),
-            };
-        }
-        else {
-            tournamentId = eventIdsMap[event.eventId].tournamentId;
-        }
-        return { event, drawDefinition: undefined, tournamentId };
-    }
-    return {
-        event: undefined,
-        drawDefinition: undefined,
-        ...decorateResult({
-            result: { error: DRAW_DEFINITION_NOT_FOUND },
-            context: { drawId, eventId },
-            stack,
-        }),
-    };
-}
-
-function getHomeParticipantId(params) {
-    const { visibilityThreshold, timeStamp, schedule, matchUp } = params;
-    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
-    if (paramsCheck.error)
-        return paramsCheck;
-    const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: HOME_PARTICIPANT_ID,
-        visibilityThreshold,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { homeParticipantId }
-        : schedule;
-}
-
-function getMatchUpScheduleDetails(params) {
-    let event = params.event;
-    let matchUpType = params.matchUpType;
-    const { scheduleVisibilityFilters, afterRecoveryTimes, tournamentRecord, usePublishState, scheduleTiming, matchUpFormat, publishStatus, matchUp, } = params;
-    if (!matchUp)
-        return { error: MISSING_MATCHUP };
-    if (afterRecoveryTimes &&
-        !matchUp.matchUpType &&
-        !params.matchUpType &&
-        (event || tournamentRecord) &&
-        matchUp.drawId) {
-        let drawDefinition = event?.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === matchUp.drawId);
-        if (!drawDefinition && tournamentRecord) {
-            ({ drawDefinition, event } = findEvent({
-                tournamentRecord,
-                drawId: matchUp.drawId,
-            }));
-        }
-        const structure = matchUp.structureId && drawDefinition?.structures?.find(({ structureId }) => structureId === matchUp.structureId);
-        matchUpType =
-            params.matchUpType ||
-                structure?.matchUpType ||
-                drawDefinition?.matchUpType ||
-                (event?.eventType !== TEAM$2 && event?.eventType);
-    }
-    const { milliseconds, time } = matchUpDuration({ matchUp });
-    const { startTime } = matchUpStartTime({ matchUp });
-    const { endTime } = matchUpEndTime({ matchUp });
-    let schedule;
-    const { visibilityThreshold, eventIds, drawIds } = scheduleVisibilityFilters ?? {};
-    if ((!eventIds || eventIds.includes(matchUp.eventId)) && (!drawIds || drawIds.includes(matchUp.drawId))) {
-        const scheduleSource = { matchUp, visibilityThreshold };
-        const { allocatedCourts } = matchUpAllocatedCourts(scheduleSource);
-        const { homeParticipantId } = getHomeParticipantId(scheduleSource);
-        const { scheduledTime } = scheduledMatchUpTime(scheduleSource);
-        const { timeModifiers } = matchUpTimeModifiers(scheduleSource);
-        let { scheduledDate } = scheduledMatchUpDate(scheduleSource);
-        const { venueId } = matchUpAssignedVenueId(scheduleSource);
-        const { courtId } = matchUpAssignedCourtId(scheduleSource);
-        const { courtOrder } = matchUpCourtOrder(scheduleSource);
-        let timeAfterRecovery, averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes, typeChangeTimeAfterRecovery;
-        const eventType = matchUp.matchUpType ?? matchUpType;
-        if (scheduleTiming && scheduledTime && afterRecoveryTimes && eventType) {
-            const timingDetails = {
-                matchUpFormat: matchUp.matchUpFormat ?? matchUpFormat,
-                ...scheduleTiming,
-            };
-            ({
-                averageMinutes = 0,
-                recoveryMinutes = 0,
-                typeChangeRecoveryMinutes = 0,
-            } = matchUpFormatTimes({
-                timingDetails,
-                eventType,
-            }));
-            if (averageMinutes || recoveryMinutes) {
-                timeAfterRecovery = endTime
-                    ? addMinutesToTimeString(extractTime$1(endTime), recoveryMinutes)
-                    : addMinutesToTimeString(scheduledTime, averageMinutes + recoveryMinutes);
-            }
-            if (typeChangeRecoveryMinutes) {
-                typeChangeTimeAfterRecovery = endTime
-                    ? addMinutesToTimeString(extractTime$1(endTime), typeChangeRecoveryMinutes)
-                    : addMinutesToTimeString(scheduledTime, averageMinutes + typeChangeRecoveryMinutes);
-            }
-        }
-        if (!scheduledDate && scheduledTime)
-            scheduledDate = extractDate(scheduledTime);
-        const isoDateString = getIsoDateString({ scheduledDate, scheduledTime });
-        const venueDataMap = {};
-        const venueData = (tournamentRecord && venueId && getVenueData({ tournamentRecord, venueId }))?.venueData || {};
-        if (venueId)
-            venueDataMap[venueId] = venueData;
-        const { venueName, venueAbbreviation, courtsInfo } = venueData;
-        const courtInfo = courtId && courtsInfo?.find((courtInfo) => courtInfo.courtId === courtId);
-        const courtName = courtInfo?.courtName;
-        for (const allocatedCourt of allocatedCourts || []) {
-            if (!tournamentRecord)
-                break;
-            if (allocatedCourt.venueId && !venueDataMap[allocatedCourt.venueid]) {
-                venueDataMap[allocatedCourt.venueId] = getVenueData({
-                    venueId: allocatedCourt.venueId,
-                    tournamentRecord,
-                })?.venueData;
-            }
-            const vData = venueDataMap[allocatedCourt.venueId];
-            allocatedCourt.venueName = vData?.venueName;
-            const courtInfo = vData?.courtsInfo?.find((courtInfo) => courtInfo.courtId === allocatedCourt.courtId);
-            allocatedCourt.courtName = courtInfo?.courtName;
-        }
-        schedule = definedAttributes({
-            typeChangeTimeAfterRecovery,
-            timeAfterRecovery,
-            scheduledDate,
-            scheduledTime,
-            isoDateString,
-            allocatedCourts,
-            homeParticipantId,
-            timeModifiers,
-            venueAbbreviation,
-            venueName,
-            venueId,
-            courtOrder,
-            courtName,
-            courtId,
-            typeChangeRecoveryMinutes,
-            recoveryMinutes,
-            averageMinutes,
-            milliseconds,
-            startTime,
-            endTime,
-            time,
-        });
-    }
-    else {
-        schedule = definedAttributes({
-            milliseconds,
-            startTime,
-            endTime,
-            time,
-        });
-    }
-    const { scheduledDate } = scheduledMatchUpDate({ matchUp });
-    const { scheduledTime } = scheduledMatchUpTime({ matchUp });
-    if (usePublishState && publishStatus?.displaySettings?.draws) {
-        const drawSettings = publishStatus.displaySettings.draws;
-        const scheduleDetails = (drawSettings?.[matchUp.drawId] ?? drawSettings?.default)?.scheduleDetails;
-        if (scheduleDetails) {
-            const scheduleAttributes = (scheduleDetails.find((details) => scheduledDate && details.dates?.includes(scheduledDate)) ??
-                scheduleDetails.find((details) => !details.dates?.length))?.attributes;
-            if (scheduleAttributes) {
-                const template = Object.assign({}, ...Object.keys(schedule).map((key) => ({ [key]: true })), scheduleAttributes);
-                schedule = attributeFilter({
-                    source: schedule,
-                    template,
-                });
-            }
-        }
-    }
-    const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
-    const endDate = (hasCompletedStatus && (extractDate(endTime) || extractDate(scheduledDate) || extractDate(scheduledTime))) ||
-        undefined;
-    return { schedule, endDate };
-}
-
-function getObjectTieFormat(obj) {
-    if (!obj)
-        return;
-    const { tieFormatId, tieFormats } = obj;
-    if (obj.tieFormat) {
-        return obj.tieFormat;
-    }
-    else if (tieFormatId && Array.isArray(tieFormats)) {
-        return tieFormats.find((tf) => tf.tieFormatId === tieFormatId);
-    }
-}
-
-function getItemTieFormat({ item, drawDefinition, structure, event }) {
-    if (!item)
-        return;
-    if (item.tieFormat)
-        return item.tieFormat;
-    if (item.tieFormatId) {
-        if (drawDefinition.tieFormat)
-            return drawDefinition.tieFormat;
-        const tieFormat = drawDefinition.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
-        if (tieFormat)
-            return tieFormat;
-        if (event.tieFormat)
-            return event.tieFormat;
-        return event.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
-    }
-    if (structure.tieFormat)
-        return structure.tieFormat;
-    if (structure.tieFormatId) {
-        const structureTieFormat = drawDefinition.tieFormats?.find((tf) => structure.tieFormatId === tf.tieFormatId);
-        if (structureTieFormat)
-            return structureTieFormat;
-    }
-}
-
-function resolveTieFormat({ drawDefinition, structure, matchUp, event }) {
-    return {
-        tieFormat: getItemTieFormat({
-            item: matchUp,
-            drawDefinition,
-            structure,
-            event,
-        }) ||
-            getItemTieFormat({
-                item: structure,
-                drawDefinition,
-                structure,
-                event,
-            }) ||
-            getObjectTieFormat(drawDefinition) ||
-            getObjectTieFormat(event),
-    };
-}
-
-function getCollectionPositionMatchUps({ matchUps }) {
-    const collectionPositionMatchUpsArray = matchUps
-        .reduce((collectionPositions, matchUp) => {
-        return !matchUp.collectionPosition || collectionPositions.includes(matchUp.collectionPosition)
-            ? collectionPositions
-            : collectionPositions.concat(matchUp.collectionPosition);
-    }, [])
-        .map((collectionPosition) => {
-        return {
-            [collectionPosition]: matchUps.filter((matchUp) => matchUp.collectionPosition === collectionPosition),
-        };
-    });
-    const collectionPositionMatchUps = Object.assign({}, ...collectionPositionMatchUpsArray);
-    return { collectionPositionMatchUps };
-}
-
-function getMatchUpsMap({ drawDefinition, structure }) {
-    const mappedMatchUps = {};
-    const drawMatchUps = [];
-    (drawDefinition?.structures ?? [structure])
-        .filter((structure) => structure && typeof structure === 'object')
-        .forEach((structure) => {
-        if (!structure)
-            return;
-        const { structureId, matchUps, structures } = structure;
-        const isRoundRobin = Array.isArray(structures);
-        if (!isRoundRobin) {
-            const filteredMatchUps = matchUps;
-            mappedMatchUps[structureId] = {
-                matchUps: filteredMatchUps,
-                itemStructureIds: [],
-            };
-            filteredMatchUps?.forEach((matchUp) => {
-                drawMatchUps.push(matchUp);
-                if (matchUp.tieMatchUps)
-                    drawMatchUps.push(...matchUp.tieMatchUps);
-            });
-        }
-        else if (isRoundRobin) {
-            structures.forEach((itemStructure) => {
-                const { structureName } = itemStructure;
-                const filteredMatchUps = itemStructure.matchUps;
-                mappedMatchUps[itemStructure.structureId] = {
-                    matchUps: filteredMatchUps,
-                    itemStructureIds: [],
-                    structureName,
-                };
-                if (filteredMatchUps) {
-                    drawMatchUps.push(...filteredMatchUps);
-                    filteredMatchUps.forEach((matchUp) => {
-                        if (matchUp.tieMatchUps)
-                            drawMatchUps.push(...matchUp.tieMatchUps);
-                    });
-                }
-                if (!mappedMatchUps[structureId])
-                    mappedMatchUps[structureId] = {
-                        itemStructureIds: [],
-                        matchUps: [],
-                    };
-                if (!mappedMatchUps[structureId].itemStructureIds)
-                    mappedMatchUps[structureId].itemStructureIds = [];
-                mappedMatchUps[structureId].itemStructureIds.push(itemStructure.structureId);
-            });
-        }
-    });
-    return { mappedMatchUps, drawMatchUps };
-}
-function getMappedStructureMatchUps({ mappedMatchUps, matchUpsMap, structureId, inContext, }) {
-    mappedMatchUps = matchUpsMap?.mappedMatchUps ?? mappedMatchUps;
-    const structureMatchUpsMap = mappedMatchUps[structureId];
-    const itemStructureMatchUps = (structureMatchUpsMap?.itemStructureIds || [])
-        .map((itemStructureId) => {
-        const { matchUps, structureName } = mappedMatchUps[itemStructureId];
-        if (inContext) {
-            return matchUps.map((matchUp) => {
-                return Object.assign(makeDeepCopy(matchUp, true, true), {
-                    containerStructureId: structureId,
-                    structureId: itemStructureId,
-                    structureName,
-                });
-            });
-        }
-        else {
-            return matchUps;
-        }
-    })
-        .flat();
-    return (structureMatchUpsMap?.matchUps || []).concat(...itemStructureMatchUps);
-}
-
-function reduceGroupedOrder({ groupedOrder, roundPositionsCount }) {
-    if (!groupedOrder || groupedOrder?.length <= roundPositionsCount) {
-        return groupedOrder;
-    }
-    const groupChunks = chunkArray(groupedOrder, groupedOrder.length / roundPositionsCount);
-    const chunkValues = groupChunks.map((chunk) => chunk.reduce((a, b) => a + b));
-    const sortedChunks = chunkValues.slice().sort(numericSort);
-    return chunkValues.map((chunkValue) => sortedChunks.indexOf(chunkValue) + 1);
-}
-
-function validMatchUp(matchUp) {
-    if (!isObject(matchUp))
-        return false;
-    const { matchUpId, drawPositions } = matchUp;
-    const validMatchUpId = typeof matchUpId === 'string';
-    const validDrawPositions = !drawPositions ||
-        (Array.isArray(drawPositions) &&
-            drawPositions.length <= 2 &&
-            drawPositions.every((dp) => isConvertableInteger(dp) || dp === undefined || dp === null));
-    return validMatchUpId && validDrawPositions;
-}
-function validMatchUps(matchUps) {
-    if (!Array.isArray(matchUps))
-        return false;
-    return matchUps.every(validMatchUp);
-}
-
-function getRoundMatchUps({ matchUps = [], interpolate }) {
-    if (!validMatchUps(matchUps))
-        return { roundMatchUps: [], error: INVALID_VALUES };
-    const roundMatchUpsArray = matchUps
-        .reduce((roundNumbers, matchUp) => {
-        const roundNumber = typeof matchUp.roundNumber === 'string' ? ensureInt(matchUp.roundNumber) : matchUp.roundNumber;
-        return !matchUp.roundNumber || roundNumbers.includes(roundNumber)
-            ? roundNumbers
-            : roundNumbers.concat(roundNumber);
-    }, [])
-        .sort(numericSort)
-        .map((roundNumber) => {
-        const roundMatchUps = matchUps.filter((matchUp) => matchUp.roundNumber === roundNumber);
-        const hasTeamMatchUps = roundMatchUps.find(({ matchUpType }) => matchUpType === TEAM$1);
-        const consideredMatchUps = hasTeamMatchUps
-            ? roundMatchUps.filter(({ matchUpType }) => matchUpType === TEAM$1)
-            : roundMatchUps;
-        const getSorted = (items) => items.sort((a, b) => numericSort(a.roundPosition, b.roundPosition));
-        return {
-            [roundNumber]: getSorted(consideredMatchUps),
-        };
-    });
-    const finishingRoundMap = matchUps.reduce((mapping, matchUp) => {
-        const roundNumber = typeof matchUp.roundNumber === 'string' ? ensureInt(matchUp.roundNumber) : matchUp.roundNumber;
-        if (!mapping[roundNumber])
-            mapping[roundNumber] = definedAttributes({
-                abbreviatedRoundName: matchUp.abbreviatedRoundName,
-                finishingRound: matchUp.finishingRound,
-                roundName: matchUp.roundName,
-            });
-        return mapping;
-    }, {});
-    const roundMatchUps = Object.assign({}, ...roundMatchUpsArray);
-    if (interpolate) {
-        const maxRoundNumber = Math.max(...Object.keys(roundMatchUps)
-            .map((key) => ensureInt(key))
-            .filter((f) => !isNaN(f)));
-        const maxRoundMatchUpsCount = roundMatchUps[maxRoundNumber]?.length;
-        if (maxRoundMatchUpsCount > 1 && isPowerOf2(maxRoundMatchUpsCount)) {
-            const nextRound = maxRoundNumber + 1;
-            const lastRound = nextRound + maxRoundMatchUpsCount / 2;
-            const roundsToInterpolate = generateRange(nextRound, lastRound);
-            roundsToInterpolate.forEach((roundNumber, i) => {
-                roundMatchUps[roundNumber] = generateRange(0, maxRoundMatchUpsCount / (2 + i * 2)).map(() => ({}));
-            });
-        }
-    }
-    let maxMatchUpsCount = 0;
-    const roundProfile = Object.assign({}, ...Object.keys(roundMatchUps).map((roundNumber) => {
-        const matchUpsCount = roundMatchUps[roundNumber]?.length;
-        const inactiveCount = roundMatchUps[roundNumber]?.filter((matchUp) => !completedMatchUpStatuses.includes(matchUp.matchUpStatus) && !matchUp.score?.scoreStringSide1)?.length;
-        const inactiveRound = matchUpsCount && matchUpsCount === inactiveCount;
-        maxMatchUpsCount = Math.max(maxMatchUpsCount, matchUpsCount);
-        return { [roundNumber]: { matchUpsCount, inactiveCount, inactiveRound } };
-    }));
-    let roundIndex = 0;
-    let feedRoundIndex = 0;
-    const roundNumbers = Object.keys(roundMatchUps)
-        .map((key) => ensureInt(key))
-        .filter((f) => !isNaN(f));
-    roundNumbers.forEach((roundNumber) => {
-        const currentRoundMatchUps = roundMatchUps[roundNumber].sort((a, b) => a.roundPosition - b.roundPosition);
-        const currentRoundDrawPositions = currentRoundMatchUps.map((matchUp) => matchUp?.drawPositions || []).flat();
-        roundProfile[roundNumber].roundNumber = roundNumber;
-        roundProfile[roundNumber].roundFactor = roundProfile[roundNumber].matchUpsCount
-            ? maxMatchUpsCount / roundProfile[roundNumber].matchUpsCount
-            : 1;
-        roundProfile[roundNumber].finishingRound = finishingRoundMap[roundNumber]?.finishingRound;
-        roundProfile[roundNumber].roundName = finishingRoundMap[roundNumber]?.roundName;
-        roundProfile[roundNumber].abbreviatedRoundName = finishingRoundMap[roundNumber]?.abbreviatedRoundName;
-        roundProfile[roundNumber].finishingPositionRange = roundMatchUps[roundNumber]?.[0]?.finishingPositionRange;
-        if (roundNumber === 1 || !roundProfile[roundNumber - 1]) {
-            const orderedDrawPositions = currentRoundDrawPositions.sort(numericSort);
-            const pairedDrawPositions = chunkArray(orderedDrawPositions, 2);
-            roundProfile[roundNumber].drawPositions = orderedDrawPositions;
-            roundProfile[roundNumber].pairedDrawPositions = pairedDrawPositions;
-        }
-        else {
-            const priorRound = roundProfile[roundNumber - 1];
-            const priorRoundDrawPositions = priorRound.drawPositions;
-            const chunkFactor = priorRound.matchUpsCount / roundProfile[roundNumber].matchUpsCount;
-            const priorRoundDrawPositionChunks = chunkArray(priorRoundDrawPositions, chunkFactor);
-            const roundDrawPositions = currentRoundMatchUps.map((matchUp) => {
-                const { roundPosition } = matchUp;
-                const drawPositions = [...(matchUp.drawPositions || []), undefined, undefined].slice(0, 2);
-                if (!roundPosition)
-                    return drawPositions;
-                const filteredDrawPositions = drawPositions?.filter(Boolean) || [];
-                if (!filteredDrawPositions?.length)
-                    return [undefined, undefined];
-                if (roundNumber < 3 && filteredDrawPositions?.length === 2) {
-                    return drawPositions?.slice().sort(numericSort);
-                }
-                const isFeedRound = intersection(priorRoundDrawPositions, filteredDrawPositions).length !== filteredDrawPositions?.length;
-                if (filteredDrawPositions?.length && isFeedRound) {
-                    if (filteredDrawPositions?.length === 1) {
-                        return [filteredDrawPositions[0], undefined];
-                    }
-                    else {
-                        return drawPositions?.slice().sort(numericSort);
-                    }
-                }
-                const targetChunkIndex = (roundPosition - 1) * 2;
-                const targetChunks = priorRoundDrawPositionChunks.slice(targetChunkIndex, targetChunkIndex + 2);
-                return targetChunks.map((chunk) => {
-                    return filteredDrawPositions?.find((drawPosition) => chunk.includes(drawPosition));
-                });
-            });
-            roundProfile[roundNumber].drawPositions = roundDrawPositions?.flat();
-            roundProfile[roundNumber].pairedDrawPositions = roundDrawPositions;
-        }
-        if (roundProfile[roundNumber + 1] &&
-            roundProfile[roundNumber + 1].matchUpsCount === roundProfile[roundNumber].matchUpsCount) {
-            roundProfile[roundNumber + 1].feedRound = true;
-            roundProfile[roundNumber + 1].feedRoundIndex = feedRoundIndex;
-            roundProfile[roundNumber].preFeedRound = true;
-            feedRoundIndex += 1;
+                        tournamentId,
+                        drawId,
+                    };
+                }
+            }
+            return targetDrawDefinition;
+        });
+        if (event)
+            return { event, drawDefinition, tournamentId };
+    }
+    if (eventId) {
+        const event = events.find((event) => event?.eventId === eventId);
+        if (!event) {
+            return {
+                event: undefined,
+                drawDefinition: undefined,
+                ...decorateResult({ result: { error: EVENT_NOT_FOUND }, stack }),
+            };
         }
-        if (roundProfile[roundNumber] && !roundProfile[roundNumber].feedRound) {
-            roundProfile[roundNumber].roundIndex = roundIndex;
-            roundIndex += 1;
+        else {
+            tournamentId = eventIdsMap[event.eventId].tournamentId;
         }
-    });
-    const roundsNotPowerOf2 = !!Object.values(roundProfile).find(({ matchUpsCount }) => !isPowerOf2(matchUpsCount));
-    const hasNoRoundPositions = matchUps.some((matchUp) => !matchUp.roundPosition);
+        return { event, drawDefinition: undefined, tournamentId };
+    }
     return {
-        hasNoRoundPositions,
-        roundsNotPowerOf2,
-        maxMatchUpsCount,
-        roundMatchUps,
-        roundNumbers,
-        roundProfile,
-        ...SUCCESS,
+        event: undefined,
+        drawDefinition: undefined,
+        ...decorateResult({
+            result: { error: DRAW_DEFINITION_NOT_FOUND },
+            context: { drawId, eventId },
+            stack,
+        }),
     };
 }
 
-function getRangeString(arr) {
-    if (!Array.isArray(arr))
-        return '';
-    const numericArray = arr.filter(isNumeric);
-    if (!numericArray.length)
-        return '';
-    const range = unique([Math.min(...numericArray), Math.max(...numericArray)]);
-    return range.join('-');
-}
-
-function getSourceDrawPositionRanges({ drawDefinition, structureId, matchUpsMap }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
-    const { structure } = findStructure({ drawDefinition, structureId });
-    if (structure?.stage !== CONSOLATION)
-        return { error: INVALID_STAGE, info: 'Structure is not CONSOLATION stage' };
-    const { links } = drawDefinition;
-    const relevantLinks = links?.filter((link) => link.target.structureId === structureId) || [];
-    const sourceStructureIds = relevantLinks?.reduce((sourceStructureIds, link) => {
-        const { structureId: sourceStructureId } = link.source;
-        return sourceStructureIds.includes(sourceStructureId)
-            ? sourceStructureIds
-            : sourceStructureIds.concat(sourceStructureId);
-    }, []) || [];
-    const sourceStructureProfiles = Object.assign({}, ...sourceStructureIds.map((sourceStructureId) => {
-        const structureMatchUps = getMappedStructureMatchUps({
-            structureId: sourceStructureId,
-            matchUpsMap,
-        });
-        const roundMatchUpsResult = getRoundMatchUps({
-            matchUps: structureMatchUps,
-        });
-        const roundProfile = roundMatchUpsResult.roundProfile;
-        return { [sourceStructureId]: roundProfile };
-    }));
-    const structureMatchUps = getMappedStructureMatchUps({
-        matchUpsMap,
-        structureId,
-    });
-    const { roundProfile: targetStructureProfile } = getRoundMatchUps({
-        matchUps: structureMatchUps,
-    });
-    const sourceDrawPositionRanges = {};
-    relevantLinks?.forEach((link) => {
-        const { structureId: sourceStructureId, roundNumber: sourceRoundNumber } = link.source;
-        const { feedProfile, groupedOrder, positionInterleave, roundNumber: targetRoundNumber } = link.target;
-        const sourceStructureProfile = sourceStructureProfiles[sourceStructureId];
-        const firstRoundDrawPositions = sourceStructureProfile[1]?.drawPositions;
-        const sourceRoundProfile = sourceStructureProfile[sourceRoundNumber];
-        const sourceRoundMatchUpsCount = sourceRoundProfile?.matchUpsCount;
-        if (!sourceRoundMatchUpsCount)
-            return;
-        const chunkSize = sourceRoundMatchUpsCount ? firstRoundDrawPositions.length / sourceRoundMatchUpsCount : 0;
-        const targetRoundMatchUpsCount = firstRoundDrawPositions.length / chunkSize;
-        let orderedPositions = firstRoundDrawPositions.slice();
-        const sizedGroupOrder = reduceGroupedOrder({
-            roundPositionsCount: targetRoundMatchUpsCount,
-            groupedOrder,
-        });
-        const groupsCount = sizedGroupOrder?.length || 1;
-        if (groupsCount <= targetRoundMatchUpsCount) {
-            const groupSize = firstRoundDrawPositions.length / groupsCount;
-            const groups = chunkArray(orderedPositions, groupSize);
-            if (feedProfile === BOTTOM_UP)
-                groups.forEach((group) => group.reverse());
-            orderedPositions =
-                (sizedGroupOrder?.length && sizedGroupOrder?.map((order) => groups[order - 1]).flat()) || orderedPositions;
+function getMatchUpScheduleDetails(params) {
+    let event = params.event;
+    let matchUpType = params.matchUpType;
+    const { scheduleVisibilityFilters, afterRecoveryTimes, tournamentRecord, usePublishState, scheduleTiming, matchUpFormat, publishStatus, matchUp, } = params;
+    if (!matchUp)
+        return { error: MISSING_MATCHUP };
+    if (afterRecoveryTimes &&
+        !matchUp.matchUpType &&
+        !params.matchUpType &&
+        (event || tournamentRecord) &&
+        matchUp.drawId) {
+        let drawDefinition = event?.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === matchUp.drawId);
+        if (!drawDefinition && tournamentRecord) {
+            ({ drawDefinition, event } = findEvent({
+                tournamentRecord,
+                drawId: matchUp.drawId,
+            }));
         }
-        let drawPositionBlocks = chunkArray(orderedPositions, chunkSize);
-        if (positionInterleave) {
-            const interleave = generateRange(0, positionInterleave.interleave).map(() => undefined);
-            const offset = generateRange(0, positionInterleave.offset).map(() => undefined);
-            drawPositionBlocks = drawPositionBlocks.map((block) => [block, ...interleave]);
-            drawPositionBlocks.unshift(offset);
-            drawPositionBlocks = drawPositionBlocks.flat(1);
-            const targetLength = drawPositionBlocks.length - positionInterleave.offset;
-            drawPositionBlocks = drawPositionBlocks.slice(0, targetLength);
+        const structure = matchUp.structureId && drawDefinition?.structures?.find(({ structureId }) => structureId === matchUp.structureId);
+        matchUpType =
+            params.matchUpType ||
+                structure?.matchUpType ||
+                drawDefinition?.matchUpType ||
+                (event?.eventType !== TEAM$2 && event?.eventType);
+    }
+    const { milliseconds, time } = matchUpDuration({ matchUp });
+    const { startTime } = matchUpStartTime({ matchUp });
+    const { endTime } = matchUpEndTime({ matchUp });
+    let schedule;
+    const { visibilityThreshold, eventIds, drawIds } = scheduleVisibilityFilters ?? {};
+    if ((!eventIds || eventIds.includes(matchUp.eventId)) && (!drawIds || drawIds.includes(matchUp.drawId))) {
+        const scheduleSource = { matchUp, visibilityThreshold };
+        const { allocatedCourts } = matchUpAllocatedCourts(scheduleSource);
+        const { homeParticipantId } = getHomeParticipantId(scheduleSource);
+        const { scheduledTime } = scheduledMatchUpTime(scheduleSource);
+        const { timeModifiers } = matchUpTimeModifiers(scheduleSource);
+        let { scheduledDate } = scheduledMatchUpDate(scheduleSource);
+        const { venueId } = matchUpAssignedVenueId(scheduleSource);
+        const { courtId } = matchUpAssignedCourtId(scheduleSource);
+        const { courtOrder } = matchUpCourtOrder(scheduleSource);
+        let timeAfterRecovery, averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes, typeChangeTimeAfterRecovery;
+        const eventType = matchUp.matchUpType ?? matchUpType;
+        if (scheduleTiming && scheduledTime && afterRecoveryTimes && eventType) {
+            const timingDetails = {
+                matchUpFormat: matchUp.matchUpFormat ?? matchUpFormat,
+                ...scheduleTiming,
+            };
+            ({
+                averageMinutes = 0,
+                recoveryMinutes = 0,
+                typeChangeRecoveryMinutes = 0,
+            } = matchUpFormatTimes({
+                timingDetails,
+                eventType,
+            }));
+            if (averageMinutes || recoveryMinutes) {
+                timeAfterRecovery = endTime
+                    ? addMinutesToTimeString(extractTime$1(endTime), recoveryMinutes)
+                    : addMinutesToTimeString(scheduledTime, averageMinutes + recoveryMinutes);
+            }
+            if (typeChangeRecoveryMinutes) {
+                typeChangeTimeAfterRecovery = endTime
+                    ? addMinutesToTimeString(extractTime$1(endTime), typeChangeRecoveryMinutes)
+                    : addMinutesToTimeString(scheduledTime, averageMinutes + typeChangeRecoveryMinutes);
+            }
         }
-        if (!sourceDrawPositionRanges[targetRoundNumber])
-            sourceDrawPositionRanges[targetRoundNumber] = {};
-        const targetRoundProfile = targetStructureProfile?.[targetRoundNumber];
-        const increment = targetRoundProfile?.feedRound ? 2 : 1;
-        drawPositionBlocks.forEach((block, index) => {
-            const columnPosition = 1 + index * increment;
-            if (!sourceDrawPositionRanges[targetRoundNumber][columnPosition]) {
-                sourceDrawPositionRanges[targetRoundNumber][columnPosition] = getRangeString(block);
+        if (!scheduledDate && scheduledTime)
+            scheduledDate = extractDate(scheduledTime);
+        const isoDateString = getIsoDateString({ scheduledDate, scheduledTime });
+        const venueDataMap = {};
+        const venueData = (tournamentRecord && venueId && getVenueData({ tournamentRecord, venueId }))?.venueData || {};
+        if (venueId)
+            venueDataMap[venueId] = venueData;
+        const { venueName, venueAbbreviation, courtsInfo } = venueData;
+        const courtInfo = courtId && courtsInfo?.find((courtInfo) => courtInfo.courtId === courtId);
+        const courtName = courtInfo?.courtName;
+        for (const allocatedCourt of allocatedCourts || []) {
+            if (!tournamentRecord)
+                break;
+            if (allocatedCourt.venueId && !venueDataMap[allocatedCourt.venueid]) {
+                venueDataMap[allocatedCourt.venueId] = getVenueData({
+                    venueId: allocatedCourt.venueId,
+                    tournamentRecord,
+                })?.venueData;
             }
+            const vData = venueDataMap[allocatedCourt.venueId];
+            allocatedCourt.venueName = vData?.venueName;
+            const courtInfo = vData?.courtsInfo?.find((courtInfo) => courtInfo.courtId === allocatedCourt.courtId);
+            allocatedCourt.courtName = courtInfo?.courtName;
+        }
+        schedule = definedAttributes({
+            typeChangeTimeAfterRecovery,
+            timeAfterRecovery,
+            scheduledDate,
+            scheduledTime,
+            isoDateString,
+            allocatedCourts,
+            homeParticipantId,
+            timeModifiers,
+            venueAbbreviation,
+            venueName,
+            venueId,
+            courtOrder,
+            courtName,
+            courtId,
+            typeChangeRecoveryMinutes,
+            recoveryMinutes,
+            averageMinutes,
+            milliseconds,
+            startTime,
+            endTime,
+            time,
         });
-    });
-    return { sourceDrawPositionRanges };
+    }
+    else {
+        schedule = definedAttributes({
+            milliseconds,
+            startTime,
+            endTime,
+            time,
+        });
+    }
+    const { scheduledDate } = scheduledMatchUpDate({ matchUp });
+    const { scheduledTime } = scheduledMatchUpTime({ matchUp });
+    if (usePublishState && publishStatus?.displaySettings?.draws) {
+        const drawSettings = publishStatus.displaySettings.draws;
+        const scheduleDetails = (drawSettings?.[matchUp.drawId] ?? drawSettings?.default)?.scheduleDetails;
+        if (scheduleDetails) {
+            const scheduleAttributes = (scheduleDetails.find((details) => scheduledDate && details.dates?.includes(scheduledDate)) ??
+                scheduleDetails.find((details) => !details.dates?.length))?.attributes;
+            if (scheduleAttributes) {
+                const template = Object.assign({}, ...Object.keys(schedule).map((key) => ({ [key]: true })), scheduleAttributes);
+                schedule = attributeFilter({
+                    source: schedule,
+                    template,
+                });
+            }
+        }
+    }
+    const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
+    const endDate = (hasCompletedStatus && (extractDate(endTime) || extractDate(scheduledDate) || extractDate(scheduledTime))) ||
+        undefined;
+    return { schedule, endDate };
 }
 
 function getOrderedDrawPositions({ drawPositions, roundProfile, roundNumber }) {
@@ -7965,249 +8208,6 @@ function getCollectionAssignment({ tournamentParticipants, positionAssignments,
     return { drawPositionCollectionAssignment: Object.assign({}, ...drawPositionCollectionAssignment) };
 }
 
-function getExitProfiles({ drawDefinition }) {
-    if (typeof drawDefinition !== 'object')
-        return { error: INVALID_DRAW_DEFINITION };
-    const exitProfiles = {};
-    const { structures = [], links = [] } = drawDefinition || {};
-    const stageStructures = structures.reduce((stageStructures, structure) => {
-        const { stage } = structure;
-        if (!stageStructures[stage]) {
-            stageStructures[stage] = [structure];
-        }
-        else {
-            stageStructures[stage].push(structure);
-        }
-        return stageStructures;
-    }, {});
-    for (const stage of Object.keys(stageStructures)) {
-        const initialStructure = stageStructures[stage].find(({ stageSequence }) => stageSequence === 1);
-        if (!initialStructure)
-            continue;
-        const { structureId } = initialStructure;
-        const exitProfile = '0';
-        addExitProfiles({
-            aggregator: {},
-            targetRound: 0,
-            exitProfiles,
-            exitProfile,
-            structureId,
-            stage,
-        });
-    }
-    return { exitProfiles };
-    function addExitProfiles({ exitProfiles, exitProfile, structureId, targetRound, aggregator, stage }) {
-        if (!exitProfiles[structureId])
-            exitProfiles[structureId] = [];
-        if (!(exitProfile === '0' && [CONSOLATION, PLAY_OFF].includes(stage)))
-            exitProfiles[structureId].push(exitProfile);
-        const relevantLinks = links.filter((link) => link.source.structureId === structureId && link.source.roundNumber >= targetRound);
-        for (const link of relevantLinks) {
-            const exitRound = link.source.roundNumber;
-            const targetRound = link.target.roundNumber;
-            const targetStructureId = link.target.structureId;
-            const stage = structures.find((structure) => structure.structureId === targetStructureId).stage;
-            const fp = [stage, targetStructureId, targetRound, exitRound].join('|');
-            if (aggregator[fp])
-                return;
-            aggregator[fp] = true;
-            addExitProfiles({
-                exitProfile: `${exitProfile}-${exitRound}`,
-                structureId: targetStructureId,
-                exitProfiles,
-                targetRound,
-                aggregator,
-                stage,
-            });
-        }
-    }
-}
-
-function getDrawPositionsRanges({ drawDefinition, roundProfile, structureId, matchUpsMap, }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
-    if (!roundProfile) {
-        const structureMatchUps = getMappedStructureMatchUps({
-            matchUpsMap,
-            structureId,
-        });
-        ({ roundProfile } = getRoundMatchUps({
-            matchUps: structureMatchUps,
-        }));
-        if (!roundProfile)
-            return { error: MISSING_VALUE };
-    }
-    const firstRoundFirstDrawPosition = Math.min(...(roundProfile?.[1]?.drawPositions ?? []));
-    const firstRoundFirstDrawPositionOffset = (firstRoundFirstDrawPosition || 1) - 1;
-    const roundNumbers = Object.keys(roundProfile);
-    const drawPositionsRanges = Object.assign({}, ...(roundNumbers || []).map((roundNumber) => {
-        const matchUpsCount = roundProfile?.[roundNumber]?.matchUpsCount;
-        const firstRoundDrawPositions = roundProfile?.[1]?.drawPositions ?? [];
-        const firstRoundDrawPositionsChunks = chunkArray(firstRoundDrawPositions, firstRoundDrawPositions.length / matchUpsCount);
-        const firstRoundDrawPositionsRanges = firstRoundDrawPositionsChunks.map(getRangeString);
-        const firstRoundOffsetDrawPositionsRanges = firstRoundDrawPositionsChunks
-            .map((drawPositions) => {
-            return drawPositions.map((drawPosition) => drawPosition - firstRoundFirstDrawPositionOffset);
-        })
-            .map(getRangeString);
-        const currentRoundDrawPositionChunks = roundNumbers
-            .map((value) => {
-            if (value > roundNumber)
-                return undefined;
-            const drawPositions = roundProfile?.[value]?.drawPositions ?? [];
-            return chunkArray(drawPositions, drawPositions.length / matchUpsCount);
-        })
-            .filter(Boolean);
-        const possibleDrawPositions = generateRange(0, matchUpsCount)
-            .map((index) => {
-            return currentRoundDrawPositionChunks
-                .map((chunk) => chunk[index])
-                .flat()
-                .filter(Boolean)
-                .sort(numericSort);
-        })
-            .map((possible) => unique(possible));
-        const drawPositionsRanges = possibleDrawPositions.map((possible) => {
-            return groupConsecutiveNumbers(possible).map(getRangeString).join(', ');
-        });
-        const roundPositionsMap = Object.assign({}, ...generateRange(0, matchUpsCount).map((index) => {
-            const roundPosition = index + 1;
-            return {
-                [roundPosition]: {
-                    firstRoundDrawPositionsRange: firstRoundDrawPositionsRanges[index],
-                    firstRoundOffsetDrawPositionsRange: firstRoundOffsetDrawPositionsRanges[index],
-                    possibleDrawPositions: possibleDrawPositions[index],
-                    drawPositionsRange: drawPositionsRanges[index],
-                },
-            };
-        }));
-        return { [roundNumber]: roundPositionsMap };
-    }));
-    return { drawPositionsRanges };
-}
-
-function isLucky({ roundsNotPowerOf2, drawDefinition, structure, matchUps }) {
-    if (!structure)
-        return false;
-    matchUps = matchUps ?? structure.matchUps ?? [];
-    roundsNotPowerOf2 = roundsNotPowerOf2 ?? getRoundMatchUps({ matchUps }).roundsNotPowerOf2;
-    const hasDrawPositions = !!structure.positionAssignments?.find(({ drawPosition }) => drawPosition) ||
-        !!matchUps?.find(({ drawPositions }) => drawPositions?.length);
-    return ((!drawDefinition?.drawType || drawDefinition.drawType !== LUCKY_DRAW) &&
-        !structure?.structures &&
-        roundsNotPowerOf2 &&
-        hasDrawPositions);
-}
-
-function isAdHoc({ structure }) {
-    if (!structure)
-        return false;
-    const matchUps = structure.matchUps || (structure.roundMatchUps && Object.values(structure.roundMatchUps).flat());
-    const hasRoundPosition = !!matchUps?.find((matchUp) => matchUp?.roundPosition);
-    const hasDrawPosition = !!matchUps?.find((matchUp) => matchUp?.drawPositions?.length);
-    return (!structure?.structures &&
-        structure?.stage !== VOLUNTARY_CONSOLATION &&
-        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition)));
-}
-
-const POLICY_ROUND_NAMING_DEFAULT = {
-    [POLICY_TYPE_ROUND_NAMING]: {
-        policyName: 'Round Naming Default',
-        namingConventions: {
-            round: 'Round',
-            pre: 'Pre',
-        },
-        qualifyingFinishMap: {
-            1: 'Final',
-        },
-        abbreviatedRoundNamingMap: {
-            1: 'F',
-            2: 'SF',
-            4: 'QF',
-        },
-        roundNamingMap: {
-            1: 'Final',
-            2: 'Semifinal',
-            4: 'Quarterfinal',
-        },
-        affixes: {
-            roundNumber: 'R',
-            preFeedRound: 'Q',
-            preQualifying: 'P',
-        },
-        stageConstants: {
-            [MAIN]: '',
-            [PLAY_OFF]: 'P',
-            [QUALIFYING]: 'Q',
-            [CONSOLATION]: 'C',
-        },
-    },
-};
-
-function getRoundContextProfile({ roundNamingPolicy, drawDefinition, structure, matchUps, }) {
-    const { roundProfile, roundMatchUps } = getRoundMatchUps({ matchUps });
-    const { structureAbbreviation, stage } = structure;
-    const isAdHocStructure = isAdHoc({ structure });
-    const isLuckyStructure = isLucky({ structure });
-    const isRoundRobin = structure.structures;
-    const roundNamingProfile = {};
-    const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
-    const isQualifying = structure.stage === QUALIFYING;
-    const qualifyingStageSequences = isQualifying
-        ? Math.max(...(drawDefinition?.structures ?? [])
-            .filter((structure) => structure.stage === QUALIFYING)
-            .map(({ stageSequence }) => stageSequence ?? 1), 0)
-        : 0;
-    const preQualifyingSequence = (structure.stageSequence ?? 1) < qualifyingStageSequences ? structure.stageSequence ?? 1 : '';
-    const preQualifyingAffix = preQualifyingSequence
-        ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || ''
-        : '';
-    const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
-    const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
-    const preFeedAffix = roundNamingPolicy?.affixes?.preFeedRound || defaultRoundNamingPolicy.affixes.preFeedRound;
-    const roundNumberAffix = roundNamingPolicy?.affixes?.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
-    const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
-    const roundNameFallback = namingConventions.round;
-    const stageInitial = stage && stage !== MAIN ? stage[0] : '';
-    const stageConstants = roundNamingPolicy?.stageConstants || defaultRoundNamingPolicy.stageConstants;
-    const stageIndicator = (stage && stageConstants?.[stage]) || stageInitial;
-    const stageConstant = `${preQualifyingAffix}${stageIndicator}${preQualifyingSequence}`;
-    const roundProfileKeys = roundProfile ? Object.keys(roundProfile) : [];
-    const qualifyingAffix = isQualifying && stageConstants?.[QUALIFYING] ? `${stageConstants?.[QUALIFYING]}-` : '';
-    if (isRoundRobin || isAdHocStructure || isLuckyStructure) {
-        Object.assign(roundNamingProfile, ...roundProfileKeys.map((key) => {
-            const roundName = `${qualifyingAffix}${roundNameFallback} ${key}`;
-            const abbreviatedRoundName = `${roundNumberAffix}${key}`;
-            return { [key]: { roundName, abbreviatedRoundName } };
-        }));
-    }
-    else {
-        const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
-        Object.assign(roundNamingProfile, ...roundProfileKeys.map((round) => {
-            if (!roundProfile?.[round])
-                return;
-            const { matchUpsCount, preFeedRound } = roundProfile[round];
-            const participantsCount = matchUpsCount * 2;
-            const sizedRoundName = qualifyingFinishgMap?.[roundProfile?.[round].finishingRound] ||
-                (qualifyingFinishgMap && `${roundNumberAffix}${participantsCount}`) ||
-                roundNamingMap[matchUpsCount] ||
-                `${roundNumberAffix}${participantsCount}`;
-            const suffix = preFeedRound ? `-${preFeedAffix}` : '';
-            const profileRoundName = `${sizedRoundName}${suffix}`;
-            const roundName = [stageConstant, structureAbbreviation, profileRoundName].filter(Boolean).join('-');
-            const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
-            const profileAbbreviation = `${sizedAbbreviation}${suffix}`;
-            const abbreviatedRoundName = [stageConstant, structureAbbreviation, profileAbbreviation]
-                .filter(Boolean)
-                .join('-');
-            return { [round]: { abbreviatedRoundName, roundName } };
-        }));
-    }
-    return { roundNamingProfile, roundProfile, roundMatchUps };
-}
-
 function getMatchUpType(params) {
     const paramCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
     if (paramCheck.error)
@@ -8380,6 +8380,394 @@ function getNumber$1(formatstring) {
     return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
 }
 
+function getSide({ drawPositionCollectionAssignment, sideNumberCollectionAssignment, positionAssignments, displaySideNumber, seedAssignments, drawPosition, isFeedRound, sideNumber, }) {
+    const assignment = positionAssignments.find((assignment) => assignment.drawPosition && assignment.drawPosition === drawPosition);
+    const dpc = drawPosition && drawPositionCollectionAssignment;
+    const snc = sideNumber && sideNumberCollectionAssignment;
+    const participantId = dpc ? dpc[drawPosition]?.participantId : assignment?.participantId;
+    const sideValue = assignment
+        ? getSideValue$1({
+            displaySideNumber,
+            seedAssignments,
+            participantId,
+            assignment,
+            sideNumber,
+        })
+        : { ...snc?.[sideNumber] };
+    if (isFeedRound) {
+        if (sideNumber === 1) {
+            Object.assign(sideValue, { participantFed: true });
+        }
+        else {
+            Object.assign(sideValue, { participantAdvanced: true });
+        }
+    }
+    if (drawPosition && dpc) {
+        const teamParticipant = dpc[drawPosition]?.teamParticipant;
+        const participant = dpc[drawPosition]?.participant;
+        const substitutions = dpc[drawPosition]?.substitutions;
+        if (participant)
+            sideValue.participant = participant;
+        if (substitutions)
+            sideValue.substitutions = substitutions;
+        if (teamParticipant)
+            sideValue.teamParticipant = teamParticipant;
+    }
+    return sideValue;
+}
+function getSideValue$1({ displaySideNumber, seedAssignments, participantId, assignment, sideNumber }) {
+    const side = {
+        drawPosition: assignment.drawPosition,
+        displaySideNumber,
+        sideNumber,
+    };
+    if (participantId) {
+        const seeding = getSeeding({ seedAssignments, participantId });
+        Object.assign(side, seeding, { participantId });
+    }
+    else if (assignment.bye) {
+        Object.assign(side, { bye: true });
+    }
+    if (assignment.qualifier) {
+        Object.assign(side, { qualifier: true });
+    }
+    return side;
+}
+function getSeeding({ seedAssignments, participantId }) {
+    return seedAssignments?.find((assignment) => !assignment.seedProxy && assignment.participantId === participantId);
+}
+
+const ANY = 'ANY';
+const MALE = 'MALE';
+const MIXED = 'MIXED';
+const OTHER$2 = 'OTHER';
+const FEMALE = 'FEMALE';
+const genderConstants = {
+    ANY,
+    MALE,
+    FEMALE,
+    MIXED,
+    OTHER: OTHER$2,
+};
+
+function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges, tournamentParticipants, positionAssignments, drawPositionsRanges, afterRecoveryTimes, initialRoundOfPlay, additionalContext, roundNamingProfile, tournamentRecord, tieDrawPositions, appliedPolicies, isCollectionBye, seedAssignments, usePublishState, participantMap, contextContent, scheduleTiming, contextProfile, drawDefinition, publishStatus, scoringActive, matchUpTieId, isRoundRobin, roundProfile, sideLineUps, structure, context, matchUp, event, }) {
+    additionalContext = additionalContext ?? {};
+    const tieFormat = resolveTieFormat({
+        drawDefinition,
+        structure,
+        matchUp,
+        event,
+    })?.tieFormat;
+    const { roundOffset, structureId, structureName, stage, stageSequence } = structure;
+    const { drawId, drawName, drawType } = drawDefinition ?? {};
+    const collectionDefinitions = tieFormat?.collectionDefinitions;
+    const collectionDefinition = matchUp.collectionId &&
+        collectionDefinitions?.find((definition) => definition.collectionId === matchUp.collectionId);
+    const matchUpFormat = matchUp.collectionId
+        ? collectionDefinition?.matchUpFormat
+        : matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
+    const matchUpType = matchUp.matchUpType ||
+        collectionDefinition?.matchUpType ||
+        structure?.matchUpType ||
+        drawDefinition?.matchUpType ||
+        (!isMatchUpEventType(TEAM$2)(event?.eventType) && event?.eventType);
+    const matchUpStatus = isCollectionBye ? BYE : matchUp.matchUpStatus;
+    const { schedule, endDate } = getMatchUpScheduleDetails({
+        scheduleVisibilityFilters,
+        afterRecoveryTimes,
+        tournamentRecord,
+        usePublishState,
+        scheduleTiming,
+        matchUpFormat,
+        publishStatus,
+        matchUpType,
+        matchUp,
+        event,
+    });
+    const drawPositions = tieDrawPositions ?? matchUp.drawPositions ?? [];
+    const { collectionPosition, collectionId, roundPosition } = matchUp;
+    const roundNumber = matchUp.roundNumber ?? additionalContext.roundNumber;
+    const collectionAssignmentDetail = collectionId
+        ? getCollectionAssignment({
+            tournamentParticipants,
+            positionAssignments,
+            collectionPosition,
+            participantMap,
+            drawDefinition,
+            drawPositions,
+            collectionId,
+            sideLineUps,
+            matchUpType,
+        })
+        : undefined;
+    const roundName = roundNamingProfile?.[roundNumber]?.roundName || additionalContext.roundName;
+    const abbreviatedRoundName = roundNamingProfile?.[roundNumber]?.abbreviatedRoundName || additionalContext.abbreviatedRoundName;
+    const feedRound = roundProfile?.[roundNumber]?.feedRound;
+    const preFeedRound = roundProfile?.[roundNumber]?.preFeedRound;
+    const roundFactor = roundProfile?.[roundNumber]?.roundFactor;
+    const drawPositionsRoundRanges = drawPositionsRanges?.[roundNumber];
+    const drawPositionsRange = roundPosition ? drawPositionsRoundRanges?.[roundPosition] : undefined;
+    const sourceDrawPositionRoundRanges = sourceDrawPositionRanges?.[roundNumber];
+    const matchUpCategory = collectionDefinition?.category
+        ? {
+            ...(context?.category || {}),
+            ...collectionDefinition.category,
+        }
+        : context?.category ?? event?.category;
+    const processCodes = (matchUp.processCodes?.length && matchUp.processCodes) ||
+        (collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes) ||
+        (structure?.processCodes?.length && structure?.processCodes) ||
+        (drawDefinition?.processCodes?.length && drawDefinition?.processCodes) ||
+        (event?.processCodes?.length && event?.processCodes) ||
+        tournamentRecord?.processCodes;
+    const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
+    const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
+    const onlyDefined = (obj) => definedAttributes(obj, undefined, true);
+    const matchUpWithContext = {
+        ...onlyDefined(context),
+        ...onlyDefined({
+            matchUpFormat: matchUp.matchUpType === TEAM$2 ? undefined : matchUpFormat,
+            tieFormat: matchUp.matchUpType !== TEAM$2 ? undefined : tieFormat,
+            gender: collectionDefinition?.gender ?? event?.gender,
+            roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0),
+            endDate: matchUp.endDate ?? endDate,
+            discipline: event?.discipline,
+            category: matchUpCategory,
+            finishingPositionRange,
+            abbreviatedRoundName,
+            drawPositionsRange,
+            competitiveProfile,
+            structureName,
+            stageSequence,
+            drawPositions,
+            matchUpStatus,
+            processCodes,
+            isRoundRobin,
+            matchUpTieId,
+            preFeedRound,
+            matchUpType,
+            roundFactor,
+            roundOffset,
+            structureId,
+            roundNumber,
+            feedRound,
+            roundName,
+            drawName,
+            drawType,
+            schedule,
+            drawId,
+            stage,
+        }),
+        ...makeDeepCopy(onlyDefined(matchUp), true, true),
+    };
+    if (matchUpFormat && matchUp.score?.scoreStringSide1) {
+        const parsedFormat = parse(matchUpFormat);
+        const { bestOf, finalSetFormat, setFormat } = parsedFormat ?? {};
+        if (finalSetFormat?.tiebreakSet || setFormat?.tiebreakSet || setFormat?.timed) {
+            matchUpWithContext.score.sets = matchUpWithContext.score.sets
+                .sort((a, b) => a.setNumber - b.setNumber)
+                .map((set, i) => {
+                const setNumber = i + 1;
+                if (setNumber === bestOf) {
+                    if (finalSetFormat?.tiebreakSet || finalSetFormat?.timed)
+                        set.tiebreakSet = true;
+                }
+                else if (setFormat?.tiebreakSet || setFormat?.timed) {
+                    set.tiebreakSet = true;
+                }
+                return set;
+            });
+        }
+    }
+    if (Array.isArray(drawPositions)) {
+        const { orderedDrawPositions, displayOrder } = getOrderedDrawPositions({
+            drawPositions,
+            roundProfile,
+            roundNumber,
+        });
+        const isFeedRound = roundProfile?.[roundNumber]?.feedRound;
+        const reversedDisplayOrder = displayOrder[0] !== orderedDrawPositions[0];
+        const sideDrawPositions = orderedDrawPositions.concat(undefined, undefined).slice(0, 2);
+        const sides = sideDrawPositions.map((drawPosition, index) => {
+            const sideNumber = index + 1;
+            const displaySideNumber = reversedDisplayOrder ? 3 - sideNumber : sideNumber;
+            const side = getSide({
+                ...collectionAssignmentDetail,
+                positionAssignments,
+                displaySideNumber,
+                seedAssignments,
+                drawPosition,
+                isFeedRound,
+                sideNumber,
+            });
+            const existingSide = matchUp.sides?.find((existing) => existing.sideNumber === sideNumber);
+            const columnPosition = roundPosition ? (roundPosition - 1) * 2 + index + 1 : undefined;
+            const sourceDrawPositionRange = columnPosition ? sourceDrawPositionRoundRanges?.[columnPosition] : undefined;
+            return onlyDefined({
+                sourceDrawPositionRange,
+                ...existingSide,
+                ...side,
+            });
+        });
+        Object.assign(matchUpWithContext, makeDeepCopy({ sides }, true, true));
+    }
+    if (tournamentParticipants && matchUpWithContext.sides) {
+        const participantAttributes = appliedPolicies?.[POLICY_TYPE_PARTICIPANT];
+        const getMappedParticipant = (participantId) => {
+            const participant = participantMap?.[participantId]?.participant;
+            return (participant &&
+                attributeFilter({
+                    template: participantAttributes?.participant,
+                    source: participant,
+                }));
+        };
+        matchUpWithContext.sides.filter(Boolean).forEach((side) => {
+            if (side.participantId) {
+                const participant = makeDeepCopy(getMappedParticipant(side.participantId) ||
+                    (tournamentParticipants
+                        ? findParticipant({
+                            policyDefinitions: appliedPolicies,
+                            participantId: side.participantId,
+                            tournamentParticipants,
+                            internalUse: true,
+                            contextProfile,
+                        })
+                        : undefined), undefined, true);
+                if (participant) {
+                    if (drawDefinition?.entries) {
+                        const entry = drawDefinition.entries.find((entry) => entry.participantId === side.participantId);
+                        if (entry?.entryStatus) {
+                            participant.entryStatus = entry.entryStatus;
+                        }
+                        if (entry?.entryStage) {
+                            participant.entryStage = entry.entryStage;
+                        }
+                    }
+                    Object.assign(side, { participant });
+                }
+            }
+            if (side?.participant?.individualParticipantIds?.length && !side.participant.individualParticipants?.length) {
+                const individualParticipants = side.participant.individualParticipantIds.map((participantId) => {
+                    return (getMappedParticipant(participantId) ||
+                        (tournamentParticipants
+                            ? findParticipant({
+                                policyDefinitions: appliedPolicies,
+                                tournamentParticipants,
+                                internalUse: true,
+                                contextProfile,
+                                participantId,
+                            })
+                            : undefined));
+                });
+                Object.assign(side.participant, { individualParticipants });
+            }
+        });
+        if (!matchUpWithContext.matchUpType) {
+            const { matchUpType } = getMatchUpType({ matchUp: matchUpWithContext });
+            if (matchUpType)
+                Object.assign(matchUpWithContext, { matchUpType });
+        }
+        const inferGender = contextProfile?.inferGender &&
+            (!matchUpWithContext.gender || matchUpWithContext.gender === MIXED) &&
+            matchUpWithContext.sides?.length === 2 &&
+            matchUpWithContext.matchUpType !== TEAM$2;
+        if (inferGender) {
+            const sideGenders = matchUpWithContext.sides.map((side) => {
+                if (isMatchUpEventType(SINGLES)(matchUpWithContext.matchUpType))
+                    return side.participant?.person?.sex;
+                if (side.participant?.individualParticipants?.length === 2) {
+                    const pairGenders = unique(side.participant.individualParticipants.map((participant) => participant.person?.sex)).filter(Boolean);
+                    if (pairGenders.length === 1)
+                        return pairGenders[0];
+                }
+                return undefined;
+            });
+            if (sideGenders.filter(Boolean).length === 2 && unique(sideGenders).length === 1) {
+                const inferredGender = sideGenders[0];
+                matchUpWithContext.inferredGender = inferredGender;
+            }
+        }
+    }
+    if (matchUpWithContext.tieMatchUps) {
+        const isCollectionBye = matchUpWithContext.matchUpStatus === BYE;
+        const lineUps = matchUpWithContext.sides?.map(({ participant, drawPosition, sideNumber, lineUp }) => {
+            const teamParticipant = participant?.participantType === TEAM$2 && participant;
+            const teamParticipantValues = teamParticipant &&
+                definedAttributes({
+                    participantRoleResponsibilities: teamParticipant.participantRoleResponsibilities,
+                    participantOtherName: teamParticipant.participanOthertName,
+                    participantName: teamParticipant.participantName,
+                    participantId: teamParticipant.participantId,
+                    teamId: teamParticipant.teamId,
+                });
+            return {
+                teamParticipant: teamParticipantValues,
+                drawPosition,
+                sideNumber,
+                lineUp,
+            };
+        });
+        matchUpWithContext.tieMatchUps = matchUpWithContext.tieMatchUps.map((matchUp) => {
+            const matchUpTieId = matchUpWithContext.matchUpId;
+            const finishingPositionRange = matchUpWithContext.finishingPositionRange;
+            const additionalContext = {
+                finishingPositionRange,
+                abbreviatedRoundName,
+                roundNumber,
+                roundName,
+            };
+            return addMatchUpContext({
+                tieDrawPositions: drawPositions,
+                scheduleVisibilityFilters,
+                sourceDrawPositionRanges,
+                sideLineUps: lineUps,
+                drawPositionsRanges,
+                initialRoundOfPlay,
+                roundNamingProfile,
+                additionalContext,
+                appliedPolicies,
+                isCollectionBye,
+                usePublishState,
+                publishStatus,
+                matchUpTieId,
+                isRoundRobin,
+                roundProfile,
+                matchUp,
+                event,
+                tournamentParticipants,
+                positionAssignments,
+                tournamentRecord,
+                seedAssignments,
+                participantMap,
+                contextContent,
+                scheduleTiming,
+                contextProfile,
+                drawDefinition,
+                scoringActive,
+                structure,
+                context,
+            });
+        });
+    }
+    const hasParticipants = matchUpWithContext.sides && matchUpWithContext.sides.filter((side) => side?.participantId).length === 2;
+    const hasNoWinner = !matchUpWithContext.winningSide;
+    const readyToScore = scoringActive && hasParticipants && hasNoWinner;
+    Object.assign(matchUpWithContext, { readyToScore, hasContext: true });
+    if (hasParticipants) {
+        const { allParticipantsCheckedIn, checkedInParticipantIds } = getCheckedInParticipantIds({
+            matchUp: matchUpWithContext,
+        });
+        Object.assign(matchUpWithContext, {
+            allParticipantsCheckedIn,
+            checkedInParticipantIds,
+        });
+    }
+    if (Array.isArray(contextProfile?.exclude)) {
+        contextProfile?.exclude.forEach((attribute) => delete matchUpWithContext[attribute]);
+    }
+    return matchUpWithContext;
+}
+
 function includesMatchUpEventType(types, matchUpEventType) {
     if (!Array.isArray(types) || !isString(matchUpEventType))
         return false;
@@ -8524,79 +8912,10 @@ function filterMatchUps(params) {
     });
 }
 
-function getSide({ drawPositionCollectionAssignment, sideNumberCollectionAssignment, positionAssignments, displaySideNumber, seedAssignments, drawPosition, isFeedRound, sideNumber, }) {
-    const assignment = positionAssignments.find((assignment) => assignment.drawPosition && assignment.drawPosition === drawPosition);
-    const dpc = drawPosition && drawPositionCollectionAssignment;
-    const snc = sideNumber && sideNumberCollectionAssignment;
-    const participantId = dpc ? dpc[drawPosition]?.participantId : assignment?.participantId;
-    const sideValue = assignment
-        ? getSideValue$1({
-            displaySideNumber,
-            seedAssignments,
-            participantId,
-            assignment,
-            sideNumber,
-        })
-        : { ...snc?.[sideNumber] };
-    if (isFeedRound) {
-        if (sideNumber === 1) {
-            Object.assign(sideValue, { participantFed: true });
-        }
-        else {
-            Object.assign(sideValue, { participantAdvanced: true });
-        }
-    }
-    if (drawPosition && dpc) {
-        const teamParticipant = dpc[drawPosition]?.teamParticipant;
-        const participant = dpc[drawPosition]?.participant;
-        const substitutions = dpc[drawPosition]?.substitutions;
-        if (participant)
-            sideValue.participant = participant;
-        if (substitutions)
-            sideValue.substitutions = substitutions;
-        if (teamParticipant)
-            sideValue.teamParticipant = teamParticipant;
-    }
-    return sideValue;
-}
-function getSideValue$1({ displaySideNumber, seedAssignments, participantId, assignment, sideNumber }) {
-    const side = {
-        drawPosition: assignment.drawPosition,
-        displaySideNumber,
-        sideNumber,
-    };
-    if (participantId) {
-        const seeding = getSeeding({ seedAssignments, participantId });
-        Object.assign(side, seeding, { participantId });
-    }
-    else if (assignment.bye) {
-        Object.assign(side, { bye: true });
-    }
-    if (assignment.qualifier) {
-        Object.assign(side, { qualifier: true });
-    }
-    return side;
-}
-function getSeeding({ seedAssignments, participantId }) {
-    return seedAssignments?.find((assignment) => !assignment.seedProxy && assignment.participantId === participantId);
-}
-
-const ANY = 'ANY';
-const MALE = 'MALE';
-const MIXED = 'MIXED';
-const OTHER$2 = 'OTHER';
-const FEMALE = 'FEMALE';
-const genderConstants = {
-    ANY,
-    MALE,
-    FEMALE,
-    MIXED,
-    OTHER: OTHER$2,
-};
-
-function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedPolicies, provisionalPositioning, tournamentParticipants, afterRecoveryTimes, policyDefinitions, tournamentRecord, seedAssignments, usePublishState, contextFilters, contextContent, matchUpFilters, participantMap, scheduleTiming, contextProfile, drawDefinition, publishStatus, context = {}, exitProfiles, matchUpsMap, structure, inContext, event, }) {
+function getAllStructureMatchUps(params) {
+    const { provisionalPositioning, tournamentRecord, contextFilters, matchUpFilters, contextProfile, drawDefinition, context = {}, structure, inContext, event, } = params;
+    let { seedAssignments, contextContent, exitProfiles, matchUpsMap } = params;
     let collectionPositionMatchUps = {}, roundMatchUps = {};
-    tournamentParticipants = tournamentParticipants ?? tournamentRecord?.participants;
     if (!structure) {
         return {
             collectionPositionMatchUps,
@@ -8630,13 +8949,11 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
             drawDefinition,
         });
     }
-    const { appliedPolicies: drawAppliedPolicies } = getAppliedPolicies({
-        drawDefinition,
-    });
+    const { appliedPolicies: drawAppliedPolicies } = getAppliedPolicies({ drawDefinition });
     const appliedPolicies = {
-        ...tournamentAppliedPolicies,
+        ...params.tournamentAppliedPolicies,
         ...drawAppliedPolicies,
-        ...policyDefinitions,
+        ...params.policyDefinitions,
     };
     const structureScoringPolicies = appliedPolicies?.scoring?.structures;
     const stageSpecificPolicies = structure.stage && structureScoringPolicies?.stage && structureScoringPolicies?.stage[structure.stage];
@@ -8657,8 +8974,7 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
         structure,
     });
     seedAssignments = seedAssignments ?? structureSeedAssignments;
-    const { roundOffset, structureId, structureName, stage, stageSequence } = structure;
-    const { drawId, drawName, drawType } = drawDefinition ?? {};
+    const { structureId } = structure;
     exitProfiles = exitProfiles || (drawDefinition && getExitProfiles({ drawDefinition }).exitProfiles);
     const exitProfile = exitProfiles?.[structureId];
     const initialRoundOfPlay = exitProfile?.length &&
@@ -8706,16 +9022,29 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
             : undefined;
         matchUps = matchUps.map((matchUp) => {
             return addMatchUpContext({
-                scheduleVisibilityFilters,
+                tournamentParticipants: params.tournamentParticipants ?? tournamentRecord?.participants,
+                scheduleVisibilityFilters: params.scheduleVisibilityFilters,
+                afterRecoveryTimes: params.afterRecoveryTimes,
+                usePublishState: params.usePublishState,
+                participantMap: params.participantMap,
+                scheduleTiming: params.scheduleTiming,
+                publishStatus: params.publishStatus,
                 sourceDrawPositionRanges,
+                positionAssignments,
                 drawPositionsRanges,
-                roundNamingProfile,
                 initialRoundOfPlay,
+                roundNamingProfile,
+                tournamentRecord,
                 appliedPolicies,
-                usePublishState,
-                publishStatus,
+                seedAssignments,
+                contextContent,
+                contextProfile,
+                drawDefinition,
+                scoringActive,
                 isRoundRobin,
                 roundProfile,
+                structure,
+                context,
                 matchUp,
                 event,
             });
@@ -8771,306 +9100,6 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
         matchUpsMap,
         matchUps,
     };
-    function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges, drawPositionsRanges, initialRoundOfPlay, additionalContext, roundNamingProfile, tieDrawPositions, appliedPolicies, isCollectionBye, usePublishState, publishStatus, matchUpTieId, isRoundRobin, roundProfile, sideLineUps, matchUp, event, }) {
-        additionalContext = additionalContext ?? {};
-        const tieFormat = resolveTieFormat({
-            drawDefinition,
-            structure,
-            matchUp,
-            event,
-        })?.tieFormat;
-        const collectionDefinitions = tieFormat?.collectionDefinitions;
-        const collectionDefinition = matchUp.collectionId &&
-            collectionDefinitions?.find((definition) => definition.collectionId === matchUp.collectionId);
-        const matchUpFormat = matchUp.collectionId
-            ? collectionDefinition?.matchUpFormat
-            : matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
-        const matchUpType = matchUp.matchUpType ||
-            collectionDefinition?.matchUpType ||
-            structure?.matchUpType ||
-            drawDefinition?.matchUpType ||
-            (!isMatchUpEventType(TEAM$2)(event?.eventType) && event?.eventType);
-        const matchUpStatus = isCollectionBye ? BYE : matchUp.matchUpStatus;
-        const { schedule, endDate } = getMatchUpScheduleDetails({
-            scheduleVisibilityFilters,
-            afterRecoveryTimes,
-            tournamentRecord,
-            usePublishState,
-            scheduleTiming,
-            matchUpFormat,
-            publishStatus,
-            matchUpType,
-            matchUp,
-            event,
-        });
-        const drawPositions = tieDrawPositions ?? matchUp.drawPositions ?? [];
-        const { collectionPosition, collectionId, roundPosition } = matchUp;
-        const roundNumber = matchUp.roundNumber ?? additionalContext.roundNumber;
-        const collectionAssignmentDetail = collectionId
-            ? getCollectionAssignment({
-                tournamentParticipants,
-                positionAssignments,
-                collectionPosition,
-                drawDefinition,
-                participantMap,
-                drawPositions,
-                collectionId,
-                sideLineUps,
-                matchUpType,
-            })
-            : undefined;
-        const roundName = roundNamingProfile?.[roundNumber]?.roundName || additionalContext.roundName;
-        const abbreviatedRoundName = roundNamingProfile?.[roundNumber]?.abbreviatedRoundName || additionalContext.abbreviatedRoundName;
-        const feedRound = roundProfile?.[roundNumber]?.feedRound;
-        const preFeedRound = roundProfile?.[roundNumber]?.preFeedRound;
-        const roundFactor = roundProfile?.[roundNumber]?.roundFactor;
-        const drawPositionsRoundRanges = drawPositionsRanges?.[roundNumber];
-        const drawPositionsRange = roundPosition ? drawPositionsRoundRanges?.[roundPosition] : undefined;
-        const sourceDrawPositionRoundRanges = sourceDrawPositionRanges?.[roundNumber];
-        const matchUpCategory = collectionDefinition?.category
-            ? {
-                ...(context?.category || {}),
-                ...collectionDefinition.category,
-            }
-            : context?.category ?? event?.category;
-        const processCodes = (matchUp.processCodes?.length && matchUp.processCodes) ||
-            (collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes) ||
-            (structure?.processCodes?.length && structure?.processCodes) ||
-            (drawDefinition?.processCodes?.length && drawDefinition?.processCodes) ||
-            (event?.processCodes?.length && event?.processCodes) ||
-            tournamentRecord?.processCodes;
-        const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
-        const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
-        const onlyDefined = (obj) => definedAttributes(obj, undefined, true);
-        const matchUpWithContext = {
-            ...onlyDefined(context),
-            ...onlyDefined({
-                matchUpFormat: matchUp.matchUpType === TEAM$2 ? undefined : matchUpFormat,
-                tieFormat: matchUp.matchUpType !== TEAM$2 ? undefined : tieFormat,
-                gender: collectionDefinition?.gender ?? event?.gender,
-                roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0),
-                endDate: matchUp.endDate ?? endDate,
-                discipline: event?.discipline,
-                category: matchUpCategory,
-                finishingPositionRange,
-                abbreviatedRoundName,
-                drawPositionsRange,
-                competitiveProfile,
-                structureName,
-                stageSequence,
-                drawPositions,
-                matchUpStatus,
-                processCodes,
-                isRoundRobin,
-                matchUpTieId,
-                preFeedRound,
-                matchUpType,
-                roundFactor,
-                roundOffset,
-                structureId,
-                roundNumber,
-                feedRound,
-                roundName,
-                drawName,
-                drawType,
-                schedule,
-                drawId,
-                stage,
-            }),
-            ...makeDeepCopy(onlyDefined(matchUp), true, true),
-        };
-        if (matchUpFormat && matchUp.score?.scoreStringSide1) {
-            const parsedFormat = parse(matchUpFormat);
-            const { bestOf, finalSetFormat, setFormat } = parsedFormat ?? {};
-            if (finalSetFormat?.tiebreakSet || setFormat?.tiebreakSet || setFormat?.timed) {
-                matchUpWithContext.score.sets = matchUpWithContext.score.sets
-                    .sort((a, b) => a.setNumber - b.setNumber)
-                    .map((set, i) => {
-                    const setNumber = i + 1;
-                    if (setNumber === bestOf) {
-                        if (finalSetFormat?.tiebreakSet || finalSetFormat?.timed)
-                            set.tiebreakSet = true;
-                    }
-                    else if (setFormat?.tiebreakSet || setFormat?.timed) {
-                        set.tiebreakSet = true;
-                    }
-                    return set;
-                });
-            }
-        }
-        if (Array.isArray(drawPositions)) {
-            const { orderedDrawPositions, displayOrder } = getOrderedDrawPositions({
-                drawPositions,
-                roundProfile,
-                roundNumber,
-            });
-            const isFeedRound = roundProfile?.[roundNumber]?.feedRound;
-            const reversedDisplayOrder = displayOrder[0] !== orderedDrawPositions[0];
-            const sideDrawPositions = orderedDrawPositions.concat(undefined, undefined).slice(0, 2);
-            const sides = sideDrawPositions.map((drawPosition, index) => {
-                const sideNumber = index + 1;
-                const displaySideNumber = reversedDisplayOrder ? 3 - sideNumber : sideNumber;
-                const side = getSide({
-                    ...collectionAssignmentDetail,
-                    positionAssignments,
-                    displaySideNumber,
-                    seedAssignments,
-                    drawPosition,
-                    isFeedRound,
-                    sideNumber,
-                });
-                const existingSide = matchUp.sides?.find((existing) => existing.sideNumber === sideNumber);
-                const columnPosition = roundPosition ? (roundPosition - 1) * 2 + index + 1 : undefined;
-                const sourceDrawPositionRange = columnPosition ? sourceDrawPositionRoundRanges?.[columnPosition] : undefined;
-                return onlyDefined({
-                    sourceDrawPositionRange,
-                    ...existingSide,
-                    ...side,
-                });
-            });
-            Object.assign(matchUpWithContext, makeDeepCopy({ sides }, true, true));
-        }
-        if (tournamentParticipants && matchUpWithContext.sides) {
-            const participantAttributes = appliedPolicies?.[POLICY_TYPE_PARTICIPANT];
-            const getMappedParticipant = (participantId) => {
-                const participant = participantMap?.[participantId]?.participant;
-                return (participant &&
-                    attributeFilter({
-                        template: participantAttributes?.participant,
-                        source: participant,
-                    }));
-            };
-            matchUpWithContext.sides.filter(Boolean).forEach((side) => {
-                if (side.participantId) {
-                    const participant = makeDeepCopy(getMappedParticipant(side.participantId) ||
-                        (tournamentParticipants &&
-                            findParticipant({
-                                policyDefinitions: appliedPolicies,
-                                participantId: side.participantId,
-                                tournamentParticipants,
-                                internalUse: true,
-                                contextProfile,
-                            })), undefined, true);
-                    if (participant) {
-                        if (drawDefinition?.entries) {
-                            const entry = drawDefinition.entries.find((entry) => entry.participantId === side.participantId);
-                            if (entry?.entryStatus) {
-                                participant.entryStatus = entry.entryStatus;
-                            }
-                            if (entry?.entryStage) {
-                                participant.entryStage = entry.entryStage;
-                            }
-                        }
-                        Object.assign(side, { participant });
-                    }
-                }
-                if (side?.participant?.individualParticipantIds?.length && !side.participant.individualParticipants?.length) {
-                    const individualParticipants = side.participant.individualParticipantIds.map((participantId) => {
-                        return (getMappedParticipant(participantId) ||
-                            (tournamentParticipants &&
-                                findParticipant({
-                                    policyDefinitions: appliedPolicies,
-                                    tournamentParticipants,
-                                    internalUse: true,
-                                    contextProfile,
-                                    participantId,
-                                })));
-                    });
-                    Object.assign(side.participant, { individualParticipants });
-                }
-            });
-            if (!matchUpWithContext.matchUpType) {
-                const { matchUpType } = getMatchUpType({ matchUp: matchUpWithContext });
-                if (matchUpType)
-                    Object.assign(matchUpWithContext, { matchUpType });
-            }
-            const inferGender = contextProfile?.inferGender &&
-                (!matchUpWithContext.gender || matchUpWithContext.gender === MIXED) &&
-                matchUpWithContext.sides?.length === 2 &&
-                matchUpWithContext.matchUpType !== TEAM$2;
-            if (inferGender) {
-                const sideGenders = matchUpWithContext.sides.map((side) => {
-                    if (isMatchUpEventType(SINGLES)(matchUpWithContext.matchUpType))
-                        return side.participant?.person?.sex;
-                    if (side.participant?.individualParticipants?.length === 2) {
-                        const pairGenders = unique(side.participant.individualParticipants.map((participant) => participant.person?.sex)).filter(Boolean);
-                        if (pairGenders.length === 1)
-                            return pairGenders[0];
-                    }
-                });
-                if (sideGenders.filter(Boolean).length === 2 && unique(sideGenders).length === 1) {
-                    const inferredGender = sideGenders[0];
-                    matchUpWithContext.inferredGender = inferredGender;
-                }
-            }
-        }
-        if (matchUpWithContext.tieMatchUps) {
-            const isCollectionBye = matchUpWithContext.matchUpStatus === BYE;
-            const lineUps = matchUpWithContext.sides?.map(({ participant, drawPosition, sideNumber, lineUp }) => {
-                const teamParticipant = participant?.participantType === TEAM$2 && participant;
-                const teamParticipantValues = teamParticipant &&
-                    definedAttributes({
-                        participantRoleResponsibilities: teamParticipant.participantRoleResponsibilities,
-                        participantOtherName: teamParticipant.participanOthertName,
-                        participantName: teamParticipant.participantName,
-                        participantId: teamParticipant.participantId,
-                        teamId: teamParticipant.teamId,
-                    });
-                return {
-                    teamParticipant: teamParticipantValues,
-                    drawPosition,
-                    sideNumber,
-                    lineUp,
-                };
-            });
-            matchUpWithContext.tieMatchUps = matchUpWithContext.tieMatchUps.map((matchUp) => {
-                const matchUpTieId = matchUpWithContext.matchUpId;
-                const finishingPositionRange = matchUpWithContext.finishingPositionRange;
-                const additionalContext = {
-                    finishingPositionRange,
-                    abbreviatedRoundName,
-                    roundNumber,
-                    roundName,
-                };
-                return addMatchUpContext({
-                    tieDrawPositions: drawPositions,
-                    scheduleVisibilityFilters,
-                    sourceDrawPositionRanges,
-                    sideLineUps: lineUps,
-                    drawPositionsRanges,
-                    initialRoundOfPlay,
-                    roundNamingProfile,
-                    additionalContext,
-                    appliedPolicies,
-                    isCollectionBye,
-                    usePublishState,
-                    publishStatus,
-                    matchUpTieId,
-                    isRoundRobin,
-                    roundProfile,
-                    matchUp,
-                    event,
-                });
-            });
-        }
-        const hasParticipants = matchUpWithContext.sides && matchUpWithContext.sides.filter((side) => side?.participantId).length === 2;
-        const hasNoWinner = !matchUpWithContext.winningSide;
-        const readyToScore = scoringActive && hasParticipants && hasNoWinner;
-        Object.assign(matchUpWithContext, { readyToScore, hasContext: true });
-        if (hasParticipants) {
-            const { allParticipantsCheckedIn, checkedInParticipantIds } = getCheckedInParticipantIds({
-                matchUp: matchUpWithContext,
-            });
-            Object.assign(matchUpWithContext, {
-                allParticipantsCheckedIn,
-                checkedInParticipantIds,
-            });
-        }
-        if (Array.isArray(contextProfile?.exclude)) {
-            contextProfile?.exclude.forEach((attribute) => delete matchUpWithContext[attribute]);
-        }
-        return matchUpWithContext;
-    }
 }
 
 function checkMatchUpIsComplete({ matchUp }) {
@@ -12331,7 +12360,7 @@ function getParticipantEntries(params) {
                             .map((structureId) => {
                             const participation = participantAggregator.structureParticipation[structureId];
                             if (!participation)
-                                return;
+                                return undefined;
                             if (!finishingPositionRange)
                                 finishingPositionRange = participation?.finishingPositionRange;
                             if (diff(finishingPositionRange) > diff(participation?.finishingPositionRange))
@@ -17601,10 +17630,10 @@ function renameStructures({ drawDefinition, structureDetails }) {
     const detailMap = Object.assign({}, ...structureDetails
         .map((detail) => {
         if (!isObject(detail))
-            return;
+            return undefined;
         const { structureId, structureName } = detail || {};
         if (!structureId || !structureName)
-            return;
+            return undefined;
         return { [structureId]: structureName };
     })
         .filter(Boolean));
@@ -18723,9 +18752,7 @@ function generatePlayoffStructures(params) {
     const rounds = Math.ceil(Math.log(drawSize) / Math.log(2));
     const roundsToPlayOff = roundOffsetLimit
         ? Math.min(roundOffsetLimit - roundOffset, rounds)
-        : !finishingPositionLimit || finishingPositionsFrom < finishingPositionLimit
-            ? rounds
-            : 0;
+        : ((!finishingPositionLimit || finishingPositionsFrom < finishingPositionLimit) && rounds) || 0;
     if (drawSize > 2) {
         generateRange(1, roundsToPlayOff + 1).forEach((roundNumber) => generateChildStructures(roundNumber));
     }
@@ -19171,11 +19198,9 @@ function feedInLinks({ consolationStructure, roundOffset = 0, mainStructure, rou
     const roundFeedProfiles = feedPolicy?.roundFeedProfiles;
     return generateRange(1 + roundOffset, roundsCount + 1 + roundOffset)
         .map((roundNumber) => {
-        const feedProfile = roundFeedProfiles && roundFeedProfiles[roundNumber - 1]
+        const feedProfile = roundFeedProfiles?.[roundNumber - 1]
             ? roundFeedProfiles[roundNumber - 1]
-            : roundNumber % 2
-                ? TOP_DOWN
-                : BOTTOM_UP;
+            : (roundNumber % 2 && TOP_DOWN) || BOTTOM_UP;
         const targetRound = roundNumber - roundOffset <= 2 ? roundNumber - roundOffset : (roundNumber - roundOffset - 2) * 2 + 2;
         const link = {
             linkType: LOSER,
@@ -20730,7 +20755,7 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
             reversed,
         });
         report.push(result.report);
-        return result.order ? false : true;
+        return !result.order;
     });
     if (result.order)
         return { order: result.order, report };
@@ -24116,7 +24141,7 @@ function getSourceStructureIdsAndRelevantLinks({ targetRoundNumber, finishingPos
             drawDefinition,
         });
         if (finishingPosition && sourceStructure?.finishingPosition !== finishingPosition)
-            return;
+            return undefined;
         return link;
     })
         .filter(Boolean);
@@ -25732,7 +25757,7 @@ function getValidGender(params) {
         ANY === eventGender ||
         ([MALE, FEMALE].includes(eventGender) && pairGender[0] === eventGender) ||
         (MIXED === eventGender &&
-            ((pairGender.length == 1 && participant.individualParticipantIds?.length === 1) || pairGender.length === 2));
+            ((pairGender.length === 1 && participant.individualParticipantIds?.length === 1) || pairGender.length === 2));
     const personGender = participant?.person?.sex;
     const validPersonGender = !participant?.person ||
         !eventGender ||
@@ -25903,6 +25928,7 @@ function getCoercedDrawType(params) {
     const { drawTypeCoercion, enforceMinimumDrawSize } = params;
     const drawSize = ensureInt(params.drawSize);
     let drawType = (drawTypeCoercion &&
+        params.drawType !== AD_HOC &&
         (typeof drawTypeCoercion === 'boolean' || drawTypeCoercion <= 2) &&
         drawSize === 2 &&
         SINGLE_ELIMINATION) ||
@@ -29408,6 +29434,7 @@ function joinFloatingTiebreak({ score }) {
                 return lastSet;
             }
         }
+        return undefined;
     });
     const tiebreakIndices = arrayIndices('tiebreak', profile);
     if (tiebreakIndices.length) {
@@ -30022,8 +30049,8 @@ function handleNumeric(params) {
                 score = chunks.join(' ');
                 applied.push('chunkSplit');
             }
-            else if (numbers.length == 6) {
-                if (instances[1] == 2 || instances[2] === 2) {
+            else if (numbers.length === 6) {
+                if (instances[1] === 2 || instances[2] === 2) {
                     if (!Object.values(positiveInstances).includes(3)) {
                         score = chunks.join(' ');
                         applied.push('chunkSplit');
@@ -30275,7 +30302,7 @@ function removeErroneous({ score, applied }) {
         .map((part) => {
         if (/^\d+$/.test(part) && part.length === 1) {
             applied.push('removeErroneous1');
-            return;
+            return undefined;
         }
         return part;
     })
@@ -34159,7 +34186,7 @@ function getInContextCourt({ convertExtensions, ignoreDisabled, venue, court })
                 .map((availability) => {
                 const date = availability.date;
                 if (!date || disabledDates.includes(date))
-                    return;
+                    return undefined;
                 return availability;
             })
                 .filter(Boolean);
@@ -34397,7 +34424,7 @@ function getDrawData(params) {
             .sort((a, b) => structureSort(a, b, sortConfig))
             .map((structure) => {
             if (!structure)
-                return;
+                return undefined;
             const structureId = structure?.structureId;
             let seedAssignments = [];
             if (structure.stage && [MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
@@ -34515,9 +34542,7 @@ function getDrawData(params) {
         : undefined;
     return {
         structures: !usePublishState || drawInfo.drawPublished
-            ? noDeepCopy
-                ? structures
-                : makeDeepCopy(structures, false, true)
+            ? (noDeepCopy && structures) || makeDeepCopy(structures, false, true)
             : undefined,
         drawInfo: noDeepCopy ? drawInfo : makeDeepCopy(drawInfo, false, true),
         ...SUCCESS,
@@ -34829,7 +34854,7 @@ function getUpdatedSchedulingProfile({ schedulingProfile, venueIds, eventIds, dr
         const date = extractDate(dateSchedulingProfile?.scheduleDate);
         if (!date) {
             issues.push(`Invalid date: ${dateSchedulingProfile?.scheduledDate}`);
-            return;
+            return undefined;
         }
         const venues = (dateSchedulingProfile?.venues || [])
             .map((venue) => {
@@ -34837,7 +34862,7 @@ function getUpdatedSchedulingProfile({ schedulingProfile, venueIds, eventIds, dr
             const venueExists = venueIds?.includes(venueId);
             if (!venueExists) {
                 issues.push(`Missing venueId: ${venueId}`);
-                return;
+                return undefined;
             }
             const filteredRounds = rounds.filter((round) => {
                 const validEventIdAndDrawId = eventIds.includes(round.eventId) && drawIds.includes(round.drawId);
@@ -34846,7 +34871,7 @@ function getUpdatedSchedulingProfile({ schedulingProfile, venueIds, eventIds, dr
                 return validEventIdAndDrawId;
             });
             if (!filteredRounds.length)
-                return;
+                return undefined;
             return { venueId, rounds: filteredRounds };
         })
             .filter(Boolean);
@@ -34902,7 +34927,7 @@ function validateSchedulingProfile({ tournamentRecords, schedulingProfile }) {
                     info = 'Invalid segment';
                 return validRound && validSegment;
             });
-            return !validRounds ? false : true;
+            return !!validRounds;
         });
     });
     if (!isValid && !error) {
@@ -35669,11 +35694,9 @@ function getEventMatchUpFormatTiming({ tournamentRecord, matchUpFormats, categor
             .map((definition) => {
             const definitionObject = typeof definition === 'string' ? { matchUpFormat: definition } : definition;
             if (uniqueMatchUpFormats.includes(definitionObject?.matchUpFormat))
-                return;
-            if (!isValidMatchUpFormat({
-                matchUpFormat: definitionObject?.matchUpFormat,
-            }))
-                return;
+                return undefined;
+            if (!isValidMatchUpFormat({ matchUpFormat: definitionObject?.matchUpFormat }))
+                return undefined;
             uniqueMatchUpFormats.push(definitionObject.matchUpFormat);
             return definitionObject;
         })
@@ -37103,7 +37126,7 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
         .map((event) => {
         const eventDrawIds = event.drawDefinitions?.map(getDrawId);
         if (drawIds?.length && !intersection(drawIds, eventDrawIds).length)
-            return;
+            return undefined;
         const eventCopy = makeDeepCopy(event);
         if (inContext)
             Object.assign(eventCopy, { tournamentId });
@@ -44322,8 +44345,8 @@ function setMatchUpState(params) {
             AWAITING_RESULT,
         ].includes(matchUpStatus)) {
         return {
-            error: INVALID_VALUES,
             info: 'Not supported for matchUpType: TEAM',
+            error: INVALID_VALUES,
         };
     }
     const matchUpTieId = inContextMatchUp?.matchUpTieId;
@@ -44341,9 +44364,8 @@ function setMatchUpState(params) {
             winningSide,
             score,
         });
-        if (result.error) {
+        if (result.error)
             return result;
-        }
     }
     const appliedPolicies = getAppliedPolicies({
         policyTypes: [POLICY_TYPE_PROGRESSION, POLICY_TYPE_SCORING],
@@ -46289,7 +46311,7 @@ function checkRecoveryTime({ individualParticipantProfiles, matchUpNotBeforeTime
     return { enoughTime };
 }
 
-function checkDailyLimits({ individualParticipantProfiles, matchUpPotentialParticipantIds, matchUpDailyLimits = {}, matchUp, }) {
+function checkDailyLimits({ matchUpPotentialParticipantIds, individualParticipantProfiles, matchUpDailyLimits = {}, matchUp, }) {
     const { enteredIndividualParticipantIds } = getIndividualParticipantIds(matchUp);
     const { matchUpId, matchUpType } = matchUp;
     const potentialParticipantIds = ((matchUp.roundPosition && matchUpPotentialParticipantIds[matchUpId]) || []).flat();
@@ -46309,6 +46331,7 @@ function checkDailyLimits({ individualParticipantProfiles, matchUpPotentialParti
                 return participantsCount && dailyLimit && participantsCount >= dailyLimit;
             });
         }
+        return undefined;
     });
     return { participantIdsAtLimit, relevantParticipantIds };
 }
@@ -47272,7 +47295,7 @@ function scheduleProfileRounds(params) {
     const validScheduleDates = scheduleDates
         .map((scheduleDate) => {
         if (!isValidDateString(scheduleDate))
-            return;
+            return undefined;
         return extractDate(scheduleDate);
     })
         .filter(Boolean);
@@ -47714,7 +47737,7 @@ function postalCodeMocks({ count = 1, participantsCount = 32 } = {}) {
 }
 
 function genParticipantId({ idPrefix, participantType, index, uuids }) {
-    const type = participantType === INDIVIDUAL ? 'I' : 'P' ;
+    const type = isString(participantType) ? participantType[0] : 'X';
     return idPrefix ? `${idPrefix}-${type}-${index}` : uuids?.pop() || UUID();
 }
 
@@ -48234,7 +48257,7 @@ function generateParticipants(params) {
         : defaultRankingRange;
     rankingRange = rankingRange || [1, rankingUpperBound];
     rankingRange[1] += 1;
-    const individualParticipantsCount = participantsCount * (doubles ? 2 : team ? 8 : 1);
+    const individualParticipantsCount = participantsCount * ((doubles && 2) || (team && 8) || 1);
     const result = generatePersons({
         count: individualParticipantsCount,
         personExtensions,
@@ -48311,16 +48334,15 @@ function generateParticipants(params) {
     const isoMin = getMin(nationalityCodesCount);
     const isoList = isoMin
         ? shuffleArray(countryCodes).slice(0, nationalityCodesCount)
-        : nationalityCodes
-            ? countryCodes.filter((isoCountry) => nationalityCodes.includes(isoCountry.iso))
-            : countryCodes;
+        : (nationalityCodes && countryCodes.filter((isoCountry) => nationalityCodes.includes(isoCountry.iso))) ||
+            countryCodes;
     const countriesList = shuffleArray(generateRange(0, Math.ceil(individualParticipantsCount / (isoMin || 1)))
         .map(() => isoList)
         .flat(Infinity));
     const teamNames = nameMocks({ count: participantsCount }).names;
     const participants = generateRange(0, participantsCount)
         .map((i) => {
-        const sideParticipantsCount = doubles ? 2 : team ? 8 : 1;
+        const sideParticipantsCount = (doubles && 2) || (team && 8) || 1;
         const individualParticipants = generateRange(0, sideParticipantsCount).map((j) => {
             const participantIndex = i * sideParticipantsCount + j;
             return generateIndividualParticipant(participantIndex);
@@ -49661,7 +49683,7 @@ function generateEventWithDraw(params) {
         return paramsCheck;
     const { allUniqueParticipantIds = [], participantsProfile = {}, matchUpStatusProfile, completeAllMatchUps, autoEntryPositions, hydrateCollections, randomWinningSide, ratingsParameters, tournamentRecord, isMock = true, drawProfile, startDate, drawIndex, uuids, } = params;
     const drawProfileCopy = makeDeepCopy(drawProfile, false, true);
-    const { excessParticipantAlternates = true, matchUpFormat = FORMAT_STANDARD, drawType = SINGLE_ELIMINATION, tournamentAlternates = 0, alternatesCount = 0, qualifyingPositions, qualifyingProfiles, generate = true, eventExtensions, drawExtensions, completionGoal, tieFormatName, seedsCount, timeItems, drawName, category, idPrefix, publish, gender, stage, } = drawProfileCopy;
+    const { excessParticipantAlternates = true, matchUpFormat = FORMAT_STANDARD, drawType = SINGLE_ELIMINATION, tournamentAlternates = 0, alternatesCount = 0, qualifyingPositions, qualifyingProfiles, generate = true, eventExtensions, drawExtensions, completionGoal, tieFormatName, buildTeams, seedsCount, timeItems, drawName, category, idPrefix, publish, gender, stage, } = drawProfileCopy;
     const drawSize = drawProfileCopy.drawSize || (drawProfileCopy.ignoreDefaults ? undefined : 32);
     const eventId = drawProfileCopy.eventId || UUID();
     const eventType = drawProfile.eventType || drawProfile.matchUpType || SINGLES$1;
@@ -49776,11 +49798,12 @@ function generateEventWithDraw(params) {
                 fIndex += genders[FEMALE];
                 mIndex += genders[MALE];
                 rIndex += mixedCount;
+                const individualParticipantIds = buildTeams !== false ? [...fPIDs, ...mPIDs, ...rIDs] : [];
                 return {
-                    individualParticipantIds: [...fPIDs, ...mPIDs, ...rIDs],
                     participantOtherName: `TM${teamIndex + 1}`,
                     participantName: `Team ${teamIndex + 1}`,
                     participantRole: COMPETITOR,
+                    individualParticipantIds,
                     participantType: TEAM,
                     participantId: UUID(),
                 };
@@ -50079,7 +50102,7 @@ function validTimePeriod({ startTime = '', endTime = '' } = {}) {
     const [endHour, endMinute] = endTime.split(':').map(getInt);
     if (endHour < startHour)
         return false;
-    return startHour === endHour && endMinute < startMinute ? false : true;
+    return !(startHour === endHour && endMinute < startMinute);
 }
 function startTimeSort(a, b) {
     const [startHourA, startMinuteA] = a.startTime.split(':').map(getInt);
@@ -50436,11 +50459,10 @@ function processLeagueProfiles(params) {
             tournamentRecord.events = [];
         tournamentRecord.events.push(event);
         if (entries.length) {
-            const roundsCount = isNumeric(leagueProfile.roundsCount)
-                ? leagueProfile.roundsCount
-                : leagueProfile.roundsCount === DOUBLE_ROUND_ROBIN
-                    ? (drawSize - 1) * 2
-                    : drawSize - 1;
+            const roundsCount = (isNumeric(leagueProfile.roundsCount) && leagueProfile.roundsCount) ??
+                leagueProfile.roundsCount === DOUBLE_ROUND_ROBIN
+                ? (drawSize - 1) * 2
+                : drawSize - 1;
             const result = generateDrawDefinition({
                 automated: leagueProfile.automated,
                 tournamentRecord,
@@ -50678,6 +50700,8 @@ function anonymizeTournamentRecord({ keepExtensions = [], anonymizeParticipantNa
     tournamentRecord.isMock = true;
     delete tournamentRecord.parentOrganisation;
     for (const participant of tournamentRecord.participants || []) {
+        participant.extensions = filterExtensions(participant);
+        participant.onlineResources = [];
         const newParticipantId = UUID();
         idMap[participant.participantId] = newParticipantId;
         participant.participantId = newParticipantId;
@@ -50689,17 +50713,28 @@ function anonymizeTournamentRecord({ keepExtensions = [], anonymizeParticipantNa
     }
     let venueIndex = 0;
     for (const venue of tournamentRecord.venues || []) {
+        venue.venueAbbreviation = `V${venueIndex}`;
         venue.extensions = filterExtensions(venue);
         venue.venueName = `Venue #${venueIndex}`;
-        venue.venueAbbreviation = `V${venueIndex}`;
+        venue.onlineResources = [];
+        venue.addresses = [];
         const newVenueId = UUID();
         idMap[venue.venueId] = newVenueId;
         venue.isMock = true;
         venueIndex += 1;
+        let courtIndex = 0;
+        for (const court of venue.courts || []) {
+            court.courtName = `V${venueIndex}C${courtIndex}`;
+            court.extensions = filterExtensions(court);
+            court.onlineResources = [];
+            court.isMock = true;
+            courtIndex += 1;
+        }
     }
     let eventCount = 1;
     for (const event of tournamentRecord.events || []) {
         event.extensions = filterExtensions(event);
+        event.onlineResources = [];
         event.isMock = true;
         const newEventId = UUID();
         idMap[event.eventId] = newEventId;
@@ -51211,7 +51246,7 @@ function modifyPersonRequests(params) {
                     return request;
                 const modification = requests.find((updatedRequest) => updatedRequest.requestId === request.requestId);
                 if (!modification.requestType)
-                    return;
+                    return undefined;
                 return Object.assign(request, modification);
             })
                 .filter(Boolean);