tods-competition-factory 2.0.13 → 2.0.16

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.13';
+    return '2.0.16';
 }
 
 const SUCCESS = { success: true };
@@ -2197,8 +2197,9 @@ const RECOVERY_MINUTES = 'recoveryMinutes';
 const PERIOD_LENGTH = 'periodLength';
 const OBJECT = 'object';
 const ARRAY = 'array';
-const VALIDATE = 'validate';
-const INVALID = 'invalid';
+const VALIDATE = '_validate';
+const MESSAGE = '_message';
+const INVALID = '_invalid';
 const OF_TYPE = '_ofType';
 const ANY_OF = '_anyOf';
 const ONE_OF = '_oneOf';
@@ -2255,9 +2256,10 @@ function checkRequiredParameters(params, requiredParams, stack) {
         return { valid: true };
     const error = params?.[errorParam] === undefined
         ? errors[errorParam] || INVALID_VALUES
-        : (paramError.validate && paramError.invalid) || INVALID_VALUES;
+        : (paramError[VALIDATE] && paramError[INVALID]) || INVALID_VALUES;
+    const param = errorParam ?? (paramError[ONE_OF] && Object.keys(paramError[ONE_OF]).join(', '));
     return decorateResult({
-        info: { param: errorParam },
+        info: { param, message: paramError[MESSAGE] },
         result: { error },
         stack,
     });
@@ -2284,8 +2286,8 @@ function getAnyOf(params, _anyOf) {
     return overlap.reduce((attr, param) => ({ ...attr, [param]: true }), {});
 }
 function findParamError(params, requiredParams) {
-    let errorParam;
-    const paramError = requiredParams.find(({ _ofType, _oneOf, _anyOf, validate, ...attrs }) => {
+    let errorParam, paramInfo;
+    const paramError = requiredParams.find(({ _ofType, _oneOf, _anyOf, _validate, _info, ...attrs }) => {
         const oneOf = _oneOf && getOneOf(params, _oneOf);
         if (oneOf?.error)
             return oneOf.error;
@@ -2296,18 +2298,20 @@ function findParamError(params, requiredParams) {
         anyOf && Object.assign(attrs, anyOf);
         const booleanParams = Object.keys(attrs).filter((key) => typeof attrs[key] === 'boolean');
         const invalidParam = booleanParams.find((param) => {
-            const invalidValidationFunction = validate && !isFunction(validate);
-            const faliedTypeCheck = params[param] && !validate && invalidType(params, param, _ofType);
+            const invalidValidationFunction = _validate && !isFunction(_validate);
+            const faliedTypeCheck = params[param] && !_validate && invalidType(params, param, _ofType);
             const paramNotPresent = attrs[param] && !params[param];
             const invalid = invalidValidationFunction || faliedTypeCheck || paramNotPresent;
-            const hasError = invalid || (validate && params[param] && !checkValidation(params[param], validate));
-            if (hasError)
+            const hasError = invalid || (_validate && params[param] && !checkValidation(params[param], _validate));
+            if (hasError) {
                 errorParam = param;
+                paramInfo = _info;
+            }
             return hasError;
         });
         return !booleanParams.length || invalidParam;
     });
-    return { paramError, errorParam };
+    return { paramError, errorParam, paramInfo };
 }
 function invalidType(params, param, _ofType) {
     _ofType = _ofType || paramTypes[param] || 'string';
@@ -3239,11 +3243,11 @@ function getMinFinishingPositionRange(structure) {
     }, undefined);
 }
 
-function findStructure({ drawDefinition, structureId }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
+function findStructure(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [STRUCTURE_ID]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, structureId } = params;
     const { structures } = getDrawStructures({ drawDefinition });
     const allStructures = structures
         ?.map((structure) => {
@@ -5127,6 +5131,20 @@ function getCheckedInParticipantIds({ matchUp }) {
     };
 }
 
+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
@@ -5317,7 +5335,7 @@ function matchUpFormatTimes({ timingDetails, eventType }) {
     const recoveryKeys = Object.keys(recoveryTimes?.minutes || {});
     const recoveryMinutes = recoveryTimes?.minutes &&
         ((recoveryKeys?.includes(eventType) && recoveryTimes.minutes[eventType]) || recoveryTimes.minutes.default);
-    const formatChangeKey = eventType === SINGLES_EVENT ? SINGLES_DOUBLES : DOUBLES_SINGLES;
+    const formatChangeKey = isMatchUpEventType(SINGLES_EVENT)(eventType) ? SINGLES_DOUBLES : DOUBLES_SINGLES;
     const typeChangeRecoveryMinutes = recoveryTimes?.minutes &&
         ((recoveryKeys?.includes(formatChangeKey) && recoveryTimes.minutes[formatChangeKey]) || recoveryMinutes);
     return { averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes };
@@ -6601,10 +6619,9 @@ function isAdHoc({ structure }) {
     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);
-    const adHoc = !structure?.structures &&
+    return (!structure?.structures &&
         structure?.stage !== VOLUNTARY_CONSOLATION &&
-        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition));
-    return adHoc;
+        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition)));
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -6722,6 +6739,12 @@ function getMatchUpType(params) {
     return { matchUpType };
 }
 
+function includesMatchUpEventType(types, matchUpEventType) {
+    if (!Array.isArray(types) || !isString(matchUpEventType))
+        return false;
+    return intersection(types, matchUpEventTypeMap[matchUpEventType]).length;
+}
+
 function filterMatchUps(params) {
     const { matchUps, isCollectionMatchUp, excludeMatchUpStatuses, matchUpStatuses, hasWinningSide, matchUpFormats, roundPositions, matchUpFormat, collectionIds, isMatchUpTie, roundNumbers, matchUpIds, roundNames, stageSequences, scheduledDates, scheduledDate, participantIds, processContext, tournamentIds, matchUpTypes, structureIds, readyToScore, courtIds, eventIds, venueIds, drawIds, stages, filterMatchUpIds = true, filterMatchUpTypes = true, } = params;
     const targetParticipantIds = Array.isArray(participantIds) ? participantIds.filter(Boolean) : [];
@@ -6750,7 +6773,7 @@ function filterMatchUps(params) {
     const targetDrawIds = Array.isArray(drawIds) ? drawIds.filter(Boolean) : [];
     const targetStructureIds = Array.isArray(structureIds) ? structureIds.filter(Boolean) : [];
     return matchUps.filter((matchUp) => {
-        if (readyToScore && matchUp.matchUpType !== TEAM_MATCHUP && !matchUp.readyToScore)
+        if (readyToScore && !isMatchUpEventType(TEAM_MATCHUP)(matchUp) && !matchUp.readyToScore)
             return false;
         if (matchUp.winningSide && hasWinningSide && ![1, 2].includes(matchUp.winningSide))
             return false;
@@ -6801,7 +6824,8 @@ function filterMatchUps(params) {
         if (targetMatchUpIds.length && !targetMatchUpIds.includes(matchUp.matchUpId)) {
             return false;
         }
-        if (targetMatchUpTypes.length && (!matchUp.matchUpType || !targetMatchUpTypes.includes(matchUp.matchUpType))) {
+        if (targetMatchUpTypes.length &&
+            (!matchUp.matchUpType || !includesMatchUpEventType(targetMatchUpTypes, matchUp.matchUpType))) {
             return false;
         }
         if (targetMatchUpFormats.length &&
@@ -7319,7 +7343,7 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
                 matchUpWithContext.matchUpType !== TEAM$2;
             if (inferGender) {
                 const sideGenders = matchUpWithContext.sides.map((side) => {
-                    if (matchUpWithContext.matchUpType === SINGLES)
+                    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);
@@ -11389,6 +11413,11 @@ function getTournamentPublishStatus({ tournamentRecord, status = PUBLIC }) {
     })?.timeItem?.itemValue?.[status];
 }
 
+function isValidTournamentRecord(tournamentRecord) {
+    const { tournamentId } = tournamentRecord ?? {};
+    return !!tournamentId;
+}
+
 function getEventPublishStatus({ event, status = PUBLIC }) {
     const itemType = `${PUBLISH}.${STATUS$1}`;
     return getEventTimeItem({
@@ -11402,29 +11431,28 @@ function getDrawPublishStatus({ drawDetails, drawId }) {
     return details?.published;
 }
 
-function getPublishState({ tournamentRecord, drawDefinition, eventIds, eventId, drawIds, drawId, event, }) {
-    if (eventId && !event) {
+function getPublishState(params) {
+    const { tournamentRecord, drawDefinition, eventIds, eventId, drawIds, drawId, event } = params ?? {};
+    if (tournamentRecord && !isValidTournamentRecord(tournamentRecord))
+        return { error: INVALID_VALUES };
+    if (eventId && !event)
         return { error: EVENT_NOT_FOUND };
-    }
-    else if (Array.isArray(eventIds) && eventIds?.length) {
+    if (Array.isArray(eventIds) && eventIds?.length) {
         const publishState = {};
         for (const eventId of eventIds) {
             if (!isString(eventId))
                 return { error: INVALID_VALUES };
-            const event = findEvent({ tournamentRecord, eventId });
+            const event = findEvent({ tournamentRecord, eventId })?.event;
             if (!event)
                 return { error: EVENT_NOT_FOUND };
             const pubStatus = getPubStatus({ event });
-            if (pubStatus.error)
-                return pubStatus;
             publishState[eventId] = pubStatus;
         }
         return { ...SUCCESS, publishState };
     }
-    else if (event) {
+    if (event) {
         const pubStatus = getPubStatus({ event });
-        if (pubStatus.error)
-            return pubStatus;
+        let publishState = {};
         if (drawId) {
             if (!drawDefinition)
                 return { error: DRAW_DEFINITION_NOT_FOUND };
@@ -11439,47 +11467,38 @@ function getPublishState({ tournamentRecord, drawDefinition, eventIds, eventId,
             };
         }
         else if (Array.isArray(drawIds) && drawIds?.length) {
-            const publishState = {};
+            const eventDrawIds = event.drawDefinitions?.map(getDrawId) || [];
             for (const drawId of drawIds) {
                 if (!isString(drawId))
                     return { error: INVALID_VALUES };
+                if (!eventDrawIds.includes(drawId))
+                    return { error: DRAW_DEFINITION_NOT_FOUND };
                 publishState[drawId] = {
                     status: {
                         published: !!pubStatus.status.publishedDrawIds.includes(drawId),
                         drawDetail: pubStatus.status.drawDetails?.[drawId],
                     },
                 };
-                return { ...SUCCESS, publishState };
             }
         }
         else {
-            return { publishState: pubStatus };
+            publishState = pubStatus;
         }
+        return { ...SUCCESS, publishState };
     }
-    else if (!tournamentRecord) {
-        return { error: MISSING_TOURNAMENT_RECORD };
-    }
-    else {
-        const publishState = {};
-        const pubStatus = getTournamentPublishStatus({ tournamentRecord });
-        publishState.tournament = pubStatus;
-        for (const event of tournamentRecord.events ?? []) {
-            const pubStatus = getPubStatus({ event });
-            publishState[event.eventId] = pubStatus;
-            if (pubStatus.error)
-                return pubStatus;
-            for (const { drawId } of event.drawDefinitions ?? []) {
-                if (!isString(drawId))
-                    return { error: INVALID_VALUES };
-                const published = pubStatus.publishState?.publishedDrawIds?.includes(drawId);
-                if (published) {
-                    publishState[drawId] = { status: { published } };
-                }
-            }
+    const publishState = {};
+    const pubStatus = getTournamentPublishStatus({ tournamentRecord });
+    publishState.tournament = pubStatus;
+    for (const event of tournamentRecord?.events ?? []) {
+        const pubStatus = getPubStatus({ event });
+        publishState[event.eventId] = pubStatus;
+        for (const { drawId } of event.drawDefinitions ?? []) {
+            const published = pubStatus.status?.publishedDrawIds?.includes(drawId);
+            if (published)
+                publishState[drawId] = { status: { published } };
         }
-        return { ...SUCCESS, publishState };
     }
-    return { error: INVALID_VALUES };
+    return { ...SUCCESS, publishState };
 }
 function getPubStatus({ event }) {
     const eventPubStatus = getEventPublishStatus({ event });
@@ -11501,12 +11520,13 @@ function getPubStatus({ event }) {
             };
         }
     }
-    const publishedDrawIds = (drawDetails && Object.keys(drawDetails).filter((drawId) => getDrawPublishStatus({ drawDetails, drawId }))) ||
-        eventPubStatus.drawIds ||
-        [];
+    const publishedDrawIds = (drawDetails &&
+        Object.keys(drawDetails).length &&
+        Object.keys(drawDetails).filter((drawId) => getDrawPublishStatus({ drawDetails, drawId }))) ||
+        eventPubStatus.drawIds;
     return {
         status: {
-            published: publishedDrawIds.length > 0,
+            published: publishedDrawIds && publishedDrawIds.length > 0,
             publishedDrawIds,
             publishedSeeding,
             drawDetails,
@@ -12276,7 +12296,7 @@ function filterParticipants({ participantFilters = {}, tournamentRecord, partici
             .filter((event) => eventIds.includes(event.eventId))
             .map((event) => {
             const enteredParticipantIds = (event.entries || []).map((entry) => entry.participantId);
-            if (event.eventType === SINGLES$1)
+            if (isMatchUpEventType(SINGLES$1)(event.eventType))
                 return enteredParticipantIds;
             const individualParticipantIds = (tournamentRecord?.participants ?? [])
                 .filter((participant) => enteredParticipantIds.includes(participant.participantId))
@@ -12880,7 +12900,9 @@ function addEventEntries(params) {
         ?.filter((participant) => {
         if (!participantIds.includes(participant.participantId))
             return false;
-        const validSingles = event.eventType === SINGLES && participant.participantType === INDIVIDUAL && !isUngrouped(entryStatus);
+        const validSingles = isMatchUpEventType(SINGLES)(event.eventType) &&
+            participant.participantType === INDIVIDUAL &&
+            !isUngrouped(entryStatus);
         const validDoubles = event.eventType === DOUBLES && participant.participantType === PAIR;
         if (validSingles &&
             (!event.gender ||
@@ -19621,11 +19643,11 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                             checkInitializeParticipant(participantResults, tieLosingParticipantId);
                             participantResults[tieWinningParticipantId].tieMatchUpsWon += 1;
                             participantResults[tieLosingParticipantId].tieMatchUpsLost += 1;
-                            if (tieMatchUp.matchUpType === SINGLES) {
+                            if (isMatchUpEventType(SINGLES)(tieMatchUp.matchUpType)) {
                                 participantResults[tieWinningParticipantId].tieSinglesWon += 1;
                                 participantResults[tieLosingParticipantId].tieSinglesLost += 1;
                             }
-                            else if (tieMatchUp.matchUpType === DOUBLES) {
+                            else if (isMatchUpEventType(DOUBLES)(tieMatchUp.matchUpType)) {
                                 participantResults[tieWinningParticipantId].tieDoublesWon += 1;
                                 participantResults[tieLosingParticipantId].tieDoublesLost += 1;
                             }
@@ -19655,8 +19677,8 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                 perPlayer = 0;
                 for (const tieMatchUp of tieMatchUps) {
                     const { matchUpType } = tieMatchUp;
-                    const isDoubles = matchUpType === DOUBLES;
-                    const isSingles = matchUpType === SINGLES;
+                    const isDoubles = isMatchUpEventType(DOUBLES)(matchUpType);
+                    const isSingles = isMatchUpEventType(SINGLES)(matchUpType);
                     if (tieMatchUp.winningSide) {
                         if (tieMatchUp.winningSide === winningSide) {
                             if (winningParticipantId) {
@@ -20792,6 +20814,102 @@ function tieFormatGenderValidityCheck(params) {
     return { valid: true };
 }
 
+function stringify(matchUpFormatObject, preserveRedundant) {
+    if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
+        return getSetFormat(matchUpFormatObject, preserveRedundant);
+    }
+    return undefined;
+}
+function getNumber(formatstring) {
+    return !isNaN(Number(formatstring)) && Number(formatstring);
+}
+function timedSetFormat(matchUpFormatObject) {
+    let value = `T${matchUpFormatObject.minutes}`;
+    if (matchUpFormatObject.based)
+        value += matchUpFormatObject.based;
+    if (matchUpFormatObject.modifier)
+        value += `@${matchUpFormatObject.modifier}`;
+    return value;
+}
+function getSetFormat(matchUpFormatObject, preserveRedundant) {
+    const bestOfValue = getNumber(matchUpFormatObject.bestOf) || undefined;
+    const exactly = getNumber(matchUpFormatObject.exactly) || undefined;
+    const setLimit = bestOfValue || exactly;
+    if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
+        return timedSetFormat(matchUpFormatObject.setFormat);
+    }
+    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
+    const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
+    const setCode = (setCountValue && `S:${setCountValue}`) || '';
+    const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
+    const finalSetCode = (setLimit &&
+        setLimit > 1 &&
+        finalSetCountValue &&
+        setCountValue !== finalSetCountValue &&
+        `F:${finalSetCountValue}`) ||
+        '';
+    const valid = setLimitCode && setCountValue;
+    if (valid) {
+        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
+    }
+    return undefined;
+}
+function stringifySet(setObject, preserveRedundant) {
+    if (typeof setObject === 'object' && Object.keys(setObject).length) {
+        if (setObject.timed)
+            return timedSetFormat(setObject);
+        if (setObject.tiebreakSet)
+            return tiebreakFormat(setObject.tiebreakSet);
+        const setToValue = getNumber(setObject.setTo);
+        if (setToValue) {
+            const NoAD = (setObject.NoAD && NOAD) || '';
+            const setTiebreakValue = tiebreakFormat(setObject.tiebreakFormat);
+            const setTiebreakCode = (setTiebreakValue && `/${setTiebreakValue}`) || '';
+            const tiebreakAtValue = getNumber(setObject.tiebreakAt);
+            const tiebreakAtCode = (tiebreakAtValue && (tiebreakAtValue !== setToValue || preserveRedundant) && `@${tiebreakAtValue}`) || '';
+            if (setTiebreakValue !== false) {
+                return `${setToValue}${NoAD}${setTiebreakCode}${tiebreakAtCode}`;
+            }
+        }
+    }
+    return undefined;
+}
+function tiebreakFormat(tieobject) {
+    if (tieobject) {
+        if (typeof tieobject === 'object' && !tieobject.tiebreakTo) {
+            return '';
+        }
+        else if (typeof tieobject === 'object' && getNumber(tieobject.tiebreakTo)) {
+            let value = `TB${tieobject.tiebreakTo}${tieobject.NoAD ? NOAD : ''}`;
+            if (tieobject.modifier)
+                value += `@${tieobject.modifier}`;
+            return value;
+        }
+        else {
+            return false;
+        }
+    }
+    return undefined;
+}
+
+function isValidMatchUpFormat({ matchUpFormat }) {
+    if (typeof matchUpFormat !== 'string')
+        return false;
+    const parsedFormat = parse(matchUpFormat);
+    const setParts = matchUpFormat.match(/-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
+    const setsTo = setParts?.[1];
+    const tiebreakTo = setParts?.[2];
+    const tiebreakAt = setParts?.[3];
+    const finalSetParts = matchUpFormat.match(/-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
+    const finalSetTo = finalSetParts?.[1];
+    const finalSetTiebreakTo = finalSetParts?.[2];
+    const finalTiebreakAt = finalSetParts?.[3];
+    const preserveRedundant = !!((setParts && tiebreakTo && setsTo === tiebreakAt) ||
+        (finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt));
+    const stringified = stringify(parsedFormat, preserveRedundant);
+    return stringified === matchUpFormat;
+}
+
 const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
 const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
 function getCategoryAgeDetails(params) {
@@ -21038,102 +21156,6 @@ function categoryCanContain({ childCategory, withDetails, category }) {
     return result;
 }
 
-function stringify(matchUpFormatObject, preserveRedundant) {
-    if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
-        return getSetFormat(matchUpFormatObject, preserveRedundant);
-    }
-    return undefined;
-}
-function getNumber(formatstring) {
-    return !isNaN(Number(formatstring)) && Number(formatstring);
-}
-function timedSetFormat(matchUpFormatObject) {
-    let value = `T${matchUpFormatObject.minutes}`;
-    if (matchUpFormatObject.based)
-        value += matchUpFormatObject.based;
-    if (matchUpFormatObject.modifier)
-        value += `@${matchUpFormatObject.modifier}`;
-    return value;
-}
-function getSetFormat(matchUpFormatObject, preserveRedundant) {
-    const bestOfValue = getNumber(matchUpFormatObject.bestOf) || undefined;
-    const exactly = getNumber(matchUpFormatObject.exactly) || undefined;
-    const setLimit = bestOfValue || exactly;
-    if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
-        return timedSetFormat(matchUpFormatObject.setFormat);
-    }
-    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
-    const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
-    const setCode = (setCountValue && `S:${setCountValue}`) || '';
-    const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
-    const finalSetCode = (setLimit &&
-        setLimit > 1 &&
-        finalSetCountValue &&
-        setCountValue !== finalSetCountValue &&
-        `F:${finalSetCountValue}`) ||
-        '';
-    const valid = setLimitCode && setCountValue;
-    if (valid) {
-        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
-    }
-    return undefined;
-}
-function stringifySet(setObject, preserveRedundant) {
-    if (typeof setObject === 'object' && Object.keys(setObject).length) {
-        if (setObject.timed)
-            return timedSetFormat(setObject);
-        if (setObject.tiebreakSet)
-            return tiebreakFormat(setObject.tiebreakSet);
-        const setToValue = getNumber(setObject.setTo);
-        if (setToValue) {
-            const NoAD = (setObject.NoAD && NOAD) || '';
-            const setTiebreakValue = tiebreakFormat(setObject.tiebreakFormat);
-            const setTiebreakCode = (setTiebreakValue && `/${setTiebreakValue}`) || '';
-            const tiebreakAtValue = getNumber(setObject.tiebreakAt);
-            const tiebreakAtCode = (tiebreakAtValue && (tiebreakAtValue !== setToValue || preserveRedundant) && `@${tiebreakAtValue}`) || '';
-            if (setTiebreakValue !== false) {
-                return `${setToValue}${NoAD}${setTiebreakCode}${tiebreakAtCode}`;
-            }
-        }
-    }
-    return undefined;
-}
-function tiebreakFormat(tieobject) {
-    if (tieobject) {
-        if (typeof tieobject === 'object' && !tieobject.tiebreakTo) {
-            return '';
-        }
-        else if (typeof tieobject === 'object' && getNumber(tieobject.tiebreakTo)) {
-            let value = `TB${tieobject.tiebreakTo}${tieobject.NoAD ? NOAD : ''}`;
-            if (tieobject.modifier)
-                value += `@${tieobject.modifier}`;
-            return value;
-        }
-        else {
-            return false;
-        }
-    }
-    return undefined;
-}
-
-function isValidMatchUpFormat({ matchUpFormat }) {
-    if (typeof matchUpFormat !== 'string')
-        return false;
-    const parsedFormat = parse(matchUpFormat);
-    const setParts = matchUpFormat.match(/-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
-    const setsTo = setParts?.[1];
-    const tiebreakTo = setParts?.[2];
-    const tiebreakAt = setParts?.[3];
-    const finalSetParts = matchUpFormat.match(/-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
-    const finalSetTo = finalSetParts?.[1];
-    const finalSetTiebreakTo = finalSetParts?.[2];
-    const finalTiebreakAt = finalSetParts?.[3];
-    const preserveRedundant = !!((setParts && tiebreakTo && setsTo === tiebreakAt) ||
-        (finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt));
-    const stringified = stringify(parsedFormat, preserveRedundant);
-    return stringified === matchUpFormat;
-}
-
 function validateCollectionDefinition({ checkCategory = true, collectionDefinition, checkCollectionIds, checkGender = true, referenceCategory, referenceGender, event, }) {
     referenceGender = referenceGender ?? event?.gender;
     const stack = 'validateCollectionDefinition';
@@ -21149,7 +21171,7 @@ function validateCollectionDefinition({ checkCategory = true, collectionDefiniti
     if (typeof matchUpCount !== 'number') {
         errors.push(`matchUpCount is not type number: ${matchUpCount}`);
     }
-    if (matchUpType && ![SINGLES, DOUBLES].includes(matchUpType)) {
+    if (matchUpType && !includesMatchUpEventType([SINGLES, DOUBLES], matchUpType)) {
         errors.push(`matchUpType must be SINGLES or DOUBLES: ${matchUpType}`);
     }
     const valueDeclarations = [!!collectionValueProfiles?.length]
@@ -22782,14 +22804,12 @@ function assignDrawPosition({ tournamentRecord, drawDefinition, participantId, d
     return { ...SUCCESS };
 }
 
-function deleteAdHocMatchUps(params) {
-    const { tournamentRecord, matchUpIds = [], drawDefinition, event } = params;
-    if (typeof drawDefinition !== 'object')
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!Array.isArray(matchUpIds))
-        return { error: INVALID_VALUES };
+function getAdHocStructureDetails(params) {
+    let matchUpIds = params.matchUpIds ?? [];
+    const { drawDefinition } = params;
     const structureId = params.structureId ??
-        drawDefinition?.structures?.find((structure) => structure.matchUps?.some(({ matchUpId }) => matchUpIds.includes(matchUpId)))?.structureId;
+        drawDefinition?.structures?.find((structure) => structure.matchUps?.some(({ matchUpId }) => matchUpIds.includes(matchUpId)))?.structureId ??
+        drawDefinition?.structures?.[0]?.structureId;
     if (!structureId)
         return { error: STRUCTURE_NOT_FOUND };
     const structure = drawDefinition.structures?.find((structure) => structure.structureId === structureId);
@@ -22800,11 +22820,43 @@ function deleteAdHocMatchUps(params) {
     if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
         return { error: INVALID_STRUCTURE };
     }
+    const existingRoundMatchUpIds = existingMatchUps
+        .filter(({ roundNumber }) => params.roundNumbers?.includes(roundNumber))
+        .map(getMatchUpId);
+    matchUpIds = matchUpIds.filter((matchUpId) => !existingRoundMatchUpIds.includes(matchUpId));
+    if (params.roundNumbers && !matchUpIds.length)
+        matchUpIds = existingRoundMatchUpIds;
+    return { existingMatchUps, matchUpIds, structureId, structure };
+}
+
+function deleteAdHocMatchUps(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [DRAW_DEFINITION]: true },
+        {
+            [ONE_OF]: { [MATCHUP_IDS]: false, roundNumbers: false },
+            [INVALID]: INVALID_VALUES,
+            [OF_TYPE]: ARRAY,
+        },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { removeIncomplete = false, removeUnAssigned = true, removeCompleted = false, tournamentRecord, drawDefinition, event, } = params;
+    const structureResult = getAdHocStructureDetails(params);
+    if (structureResult.error)
+        return structureResult;
+    const { structure, structureId, existingMatchUps, matchUpIds } = structureResult;
     const matchUpIdsWithScoreValue = [];
-    const matchUpsToDelete = existingMatchUps?.filter(({ matchUpId, score }) => {
-        if (checkScoreHasValue({ score }))
+    const matchUpsToDelete = existingMatchUps?.filter(({ matchUpId, score, winningSide }) => {
+        if (checkScoreHasValue({ score })) {
+            if (!winningSide && !removeIncomplete)
+                return false;
+            if (winningSide && !removeCompleted)
+                return false;
             matchUpIdsWithScoreValue.push(matchUpId);
-        return matchUpIds.includes(matchUpId);
+        }
+        else if (!removeUnAssigned)
+            return false;
+        return matchUpIds?.includes(matchUpId);
     }) ?? [];
     const matchUpIdsToDelete = matchUpsToDelete.map(getMatchUpId);
     const tieMatchUpIdsToDelete = matchUpsToDelete
@@ -23429,6 +23481,39 @@ function getEligibleVoluntaryConsolationParticipants({ excludedMatchUpStatuses =
     return { eligibleParticipants, losingParticipantIds, ...SUCCESS };
 }
 
+function getAvailableMatchUpsCount(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ drawDefinition: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, roundNumber } = params;
+    const structureId = params.structureId ?? (drawDefinition.structures?.length === 1 && drawDefinition.structures?.[0]?.structureId);
+    if (typeof structureId !== 'string')
+        return { error: MISSING_STRUCTURE_ID };
+    const structure = drawDefinition.structures?.find((structure) => structure.structureId === structureId);
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    let structureHasRoundPositions;
+    const existingMatchUps = structure.matchUps ?? [];
+    const lastRoundNumber = existingMatchUps?.reduce((roundNumber, matchUp) => {
+        if (matchUp.roundPosition)
+            structureHasRoundPositions = true;
+        return (matchUp?.roundNumber || 0) > roundNumber ? matchUp.roundNumber : roundNumber;
+    }, 0);
+    if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
+        return { error: INVALID_STRUCTURE };
+    }
+    const selectedEntries = drawDefinition?.entries?.filter((entry) => {
+        const entryStatus = entry.entryStatus;
+        return STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
+    }) ?? [];
+    const roundMatchUpsCount = Math.floor(selectedEntries?.length / 2) || 1;
+    const targetRoundNumber = roundNumber ?? lastRoundNumber ?? 1;
+    const existingRoundMatchUps = structure.matchUps?.filter((matchUp) => matchUp.roundNumber === targetRoundNumber)?.length ?? 0;
+    const maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
+    const availableMatchUpsCount = maxRemaining > 0 ? maxRemaining : 0;
+    return { ...SUCCESS, availableMatchUpsCount, lastRoundNumber, roundMatchUpsCount };
+}
+
 function getDrawParticipantRepresentativeIds({ drawDefinition }) {
     const result = findExtension({
         name: 'participantRepresentatives',
@@ -24191,11 +24276,11 @@ function collectionMatchUpActions({ specifiedPolicyDefinitions, inContextDrawMat
             sideNumber: i + 1,
         }));
     const assignmentAvailable = (sideNumber &&
-        ((matchUpType === SINGLES_MATCHUP && !existingParticipantIds?.length) ||
-            (matchUpType === DOUBLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 2))) ||
+        ((isMatchUpEventType(SINGLES_MATCHUP)(matchUpType) && !existingParticipantIds?.length) ||
+            (isMatchUpEventType(DOUBLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 2))) ||
         (!sideNumber &&
-            ((matchUpType === SINGLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 2) ||
-                (matchUpType === DOUBLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 4)));
+            ((isMatchUpEventType(SINGLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 2) ||
+                (isMatchUpEventType(DOUBLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 4)));
     const availableIds = availableParticipantIds?.filter((id) => !allParticipantIds?.includes(id));
     const available = availableParticipants?.filter(({ participantId }) => availableIds.includes(participantId));
     if (assignmentAvailable && availableIds?.length) {
@@ -25114,6 +25199,7 @@ var query$a = {
     checkValidEntries: checkValidEntries,
     findDrawDefinition: publicFindDrawDefinition,
     getAssignedParticipantIds: getAssignedParticipantIds,
+    getAvailableMatchUpsCount: getAvailableMatchUpsCount,
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
@@ -25996,35 +26082,16 @@ function generateAdHocMatchUps(params) {
     if (typeof drawDefinition !== 'object')
         return { error: MISSING_DRAW_DEFINITION };
     let { participantIdPairings, matchUpsCount } = params;
-    const structureId = params.structureId ?? (drawDefinition.structures?.length === 1 && drawDefinition.structures?.[0]?.structureId);
-    if (typeof structureId !== 'string')
-        return { error: MISSING_STRUCTURE_ID };
-    const structure = drawDefinition.structures?.find((structure) => structure.structureId === structureId);
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    let structureHasRoundPositions;
-    const existingMatchUps = structure.matchUps ?? [];
-    const lastRoundNumber = existingMatchUps?.reduce((roundNumber, matchUp) => {
-        if (matchUp.roundPosition)
-            structureHasRoundPositions = true;
-        return (matchUp?.roundNumber || 0) > roundNumber ? matchUp.roundNumber : roundNumber;
-    }, 0);
-    const selectedEntries = drawDefinition?.entries?.filter((entry) => {
-        const entryStatus = entry.entryStatus;
-        return STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
-    }) ?? [];
-    const roundMatchUpsCount = Math.floor(selectedEntries?.length / 2) || 1;
+    const availableResult = getAvailableMatchUpsCount(params);
+    if (availableResult.error)
+        return decorateResult({ result: availableResult });
+    const { lastRoundNumber, availableMatchUpsCount = 0, roundMatchUpsCount = 0 } = availableResult;
     if (!matchUpsCount) {
         if (newRound) {
             matchUpsCount = roundMatchUpsCount;
         }
-        else {
-            const targetRoundNumber = roundNumber ?? lastRoundNumber ?? 1;
-            const existingRoundMatchUps = structure.matchUps?.filter((matchUp) => matchUp.roundNumber === targetRoundNumber)?.length ?? 0;
-            const maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
-            if (maxRemaining > 0)
-                matchUpsCount = maxRemaining;
-        }
+        else if (availableMatchUpsCount > 0)
+            matchUpsCount = availableMatchUpsCount;
     }
     else if (matchUpsCount > roundMatchUpsCount && params.restrictMatchUpsCount !== false) {
         return decorateResult({
@@ -26040,9 +26107,6 @@ function generateAdHocMatchUps(params) {
     if (matchUpsCount && matchUpsCount > 25) {
         return { error: INVALID_VALUES, info: 'matchUpsCount must be less than 25' };
     }
-    if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
-        return { error: INVALID_STRUCTURE };
-    }
     if (roundNumber && !params.ignoreLastRoundNumber && roundNumber - 1 > (lastRoundNumber || 0)) {
         return { error: INVALID_VALUES, info: 'roundNumber error' };
     }
@@ -26053,7 +26117,7 @@ function generateAdHocMatchUps(params) {
                 participantIds: [undefined, undefined],
             }));
     const getPrefixedId = (index) => {
-        if (!params.idPrefix && !isMock)
+        if (!params.idPrefix)
             return undefined;
         const drawId = drawDefinition.drawId;
         const idPrefix = params.idPrefix ?? 'ah';
@@ -28768,7 +28832,7 @@ function getPredictiveAccuracy(params) {
         ascending,
         scaleName,
     });
-    const marginCalc = !zoneDoubling || matchUpType === SINGLES ? zoneMargin : (zoneMargin || 0) * 2;
+    const marginCalc = !zoneDoubling || isMatchUpEventType(SINGLES)(matchUpType) ? zoneMargin : (zoneMargin || 0) * 2;
     const zoneData = zoneMargin
         ? relevantMatchUps
             .map(({ competitiveProfile, matchUpType, score, sides }) => {
@@ -30226,6 +30290,7 @@ var index$g = {
     getAllowedMatchUpFormats: getAllowedMatchUpFormats,
     getAppliedPolicies: getAppliedPolicies,
     getAssignedParticipantIds: getAssignedParticipantIds,
+    getAvailableMatchUpsCount: getAvailableMatchUpsCount,
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getCategoryAgeDetails: getCategoryAgeDetails,
     getCheckedInParticipantIds: getCheckedInParticipantIds,
@@ -35540,22 +35605,22 @@ function setMatchUpMatchUpFormat(params) {
         });
         if (result.error)
             return result;
-        if (!result.matchUp)
-            return { error: MATCHUP_NOT_FOUND };
         const matchUp = result.matchUp;
         if (matchUp?.matchUpType === TEAM$2)
             return {
-                error: INVALID_MATCHUP,
                 info: 'Cannot set matchUpFormat when { matchUpType: TEAM }',
+                error: INVALID_MATCHUP,
             };
-        matchUp.matchUpFormat = matchUpFormat;
-        modifyMatchUpNotice({
-            tournamentId: tournamentRecord?.tournamentId,
-            eventId: event?.eventId,
-            context: stack,
-            drawDefinition,
-            matchUp,
-        });
+        if (matchUp) {
+            matchUp.matchUpFormat = matchUpFormat;
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord?.tournamentId,
+                eventId: event?.eventId,
+                context: stack,
+                drawDefinition,
+                matchUp,
+            });
+        }
     }
     else if (Array.isArray(structureIds)) {
         if (event?.eventType === TEAM$2)
@@ -35564,12 +35629,8 @@ function setMatchUpMatchUpFormat(params) {
             const result = findStructure({ drawDefinition, structureId });
             if (result.error)
                 return result;
-            if (!result.structure) {
-                return { error: STRUCTURE_NOT_FOUND };
-            }
-            else {
+            if (result.structure)
                 result.structure.matchUpFormat = matchUpFormat;
-            }
         }
     }
     else if (structureId) {
@@ -35578,12 +35639,8 @@ function setMatchUpMatchUpFormat(params) {
         const result = findStructure({ drawDefinition, structureId });
         if (result.error)
             return result;
-        if (!result.structure) {
-            return { error: STRUCTURE_NOT_FOUND };
-        }
-        else {
+        if (result.structure)
             result.structure.matchUpFormat = matchUpFormat;
-        }
     }
     else if (drawDefinition) {
         drawDefinition.matchUpFormat = matchUpFormat;
@@ -36027,6 +36084,7 @@ var index$e = {
     generateQualifyingStructure: generateQualifyingStructure,
     generateVoluntaryConsolation: generateVoluntaryConsolation,
     getAssignedParticipantIds: getAssignedParticipantIds,
+    getAvailableMatchUpsCount: getAvailableMatchUpsCount,
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
@@ -38690,7 +38748,7 @@ function generateLineUps(params) {
         for (const collectionDefinition of collectionDefinitions) {
             const collectionParticipantIds = [];
             const { collectionId, matchUpCount, matchUpType, gender } = collectionDefinition;
-            const singlesMatchUp = matchUpType === SINGLES_MATCHUP;
+            const singlesMatchUp = isMatchUpEventType(SINGLES_MATCHUP)(matchUpType);
             generateRange(0, matchUpCount).forEach((i) => {
                 const typeSort = singlesMatchUp ? singlesSort : doublesSort ?? [];
                 const collectionPosition = i + 1;
@@ -39409,7 +39467,7 @@ function getTieMatchUpContext({ tournamentRecord, drawDefinition, tieMatchUpId,
     if (!inContextTieMatchUp)
         return { error: MATCHUP_NOT_FOUND };
     const { collectionPosition, drawPositions, collectionId, matchUpTieId, matchUpType } = inContextTieMatchUp;
-    if (matchUpType && ![SINGLES, DOUBLES].includes(matchUpType))
+    if (matchUpType && !includesMatchUpEventType([SINGLES, DOUBLES], matchUpType))
         return { error: INVALID_MATCHUP };
     const { positionAssignments } = getPositionAssignments$1({ structure });
     const relevantAssignments = positionAssignments?.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
@@ -39957,7 +40015,7 @@ function assignTieMatchUpParticipantId(params) {
         return { error: INVALID_PARTICIPANT, info: 'Gender mismatch' };
     }
     const { individualParticipantIds, participantType } = participantToAssign;
-    if (matchUpType === SINGLES && participantType !== INDIVIDUAL) {
+    if (isMatchUpEventType(SINGLES)(matchUpType) && participantType !== INDIVIDUAL) {
         return { error: INVALID_PARTICIPANT_TYPE };
     }
     const relevantParticipantIds = participantType === INDIVIDUAL ? [participantId] : individualParticipantIds;
@@ -40330,16 +40388,14 @@ function removeTieMatchUpParticipantId(params) {
     return { ...SUCCESS, modifiedLineUp };
 }
 
-function removeMatchUpSideParticipant({ tournamentRecord, drawDefinition, sideNumber, matchUpId, event }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
-    if (!sideNumber)
-        return { error: MISSING_VALUE };
-    if (![1, 2].includes(sideNumber))
+function removeMatchUpSideParticipant(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true, [DRAW_DEFINITION]: true, [MATCHUP_ID]: true },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, sideNumber, matchUpId, event } = params;
+    if (sideNumber && ![1, 2].includes(sideNumber))
         return { error: INVALID_VALUES, sideNumber };
     const { matchUp, structure } = findDrawMatchUp({
         drawDefinition,
@@ -40348,17 +40404,14 @@ function removeMatchUpSideParticipant({ tournamentRecord, drawDefinition, sideNu
     });
     if (!matchUp)
         return { error: MATCHUP_NOT_FOUND };
-    const isAdHoc = !structure?.structures &&
-        !(drawDefinition.drawType && drawDefinition.drawType !== AD_HOC) &&
-        !structure?.matchUps?.find(({ roundPosition }) => !!roundPosition);
-    if (!isAdHoc)
+    if (!isAdHoc({ structure }))
         return { error: INVALID_DRAW_TYPE };
     matchUp.sides?.forEach((side) => {
-        if (side.sideNumber === sideNumber)
+        if (!sideNumber || side.sideNumber === sideNumber)
             delete side.participantId;
     });
     modifyMatchUpNotice({
-        tournamentId: tournamentRecord?.tournamentId,
+        tournamentId: params.tournamentRecord?.tournamentId,
         context: 'assignSideParticipant',
         drawDefinition,
         matchUp,
@@ -42410,9 +42463,10 @@ function setMatchUpState(params) {
     }
     const structureId = inContextMatchUp?.structureId;
     const { structure } = findStructure({ drawDefinition, structureId });
+    const isTeam = isMatchUpEventType(TEAM$1)(matchUp.matchUpType);
     const assignedDrawPositions = inContextMatchUp?.drawPositions?.filter(Boolean);
     let dualWinningSideChange;
-    if (matchUp.matchUpType === TEAM$1) {
+    if (isTeam) {
         if (disableAutoCalc) {
             addExtension({
                 extension: { name: DISABLE_AUTO_CALC, value: true },
@@ -42450,7 +42504,7 @@ function setMatchUpState(params) {
             drawDefinition,
         });
     }
-    if (matchUp.matchUpType === TEAM$1 &&
+    if (isTeam &&
         matchUpStatus &&
         [
             AWAITING_RESULT,
@@ -42466,7 +42520,7 @@ function setMatchUpState(params) {
         inContextDrawMatchUps,
         drawDefinition,
     });
-    if (score && matchUp.matchUpType !== TEAM$1 && !disableScoreValidation) {
+    if (score && !isTeam && !disableScoreValidation) {
         const matchUpFormat = matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
         const result = validateScore({
             existingMatchUpStatus: matchUp.matchUpStatus,
@@ -42485,15 +42539,17 @@ function setMatchUpState(params) {
             structureId,
         }).positionAssignments
         : [];
-    const bothSideParticipants = inContextMatchUp?.sides?.map((side) => side.participantId).filter(Boolean).length === 2 ||
+    const participantsCount = inContextMatchUp?.sides?.map((side) => side.participantId).filter(Boolean).length;
+    const requiredParticipants = (participantsCount && participantsCount === 2) ||
+        (isTeam && isAdHoc({ structure }) && participantsCount && participantsCount >= 1) ||
         (assignedDrawPositions?.length === 2 &&
             positionAssignments
                 ?.filter((assignment) => assignedDrawPositions.includes(assignment.drawPosition))
                 .every((assignment) => assignment.participantId));
-    if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !bothSideParticipants) {
+    if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !requiredParticipants) {
         return decorateResult({
             info: 'present in participantRequiredMatchUpStatuses',
-            context: { matchUpStatus, bothSideParticipants },
+            context: { matchUpStatus, requiredParticipants },
             result: { error: INVALID_MATCHUP_STATUS },
         });
     }
@@ -42608,11 +42664,7 @@ function setMatchUpState(params) {
             return result;
         }
     }
-    const validWinningSideSwap = matchUp.matchUpType !== TEAM$1 &&
-        !dualWinningSideChange &&
-        winningSide &&
-        matchUp.winningSide &&
-        matchUp.winningSide !== winningSide;
+    const validWinningSideSwap = !isTeam && !dualWinningSideChange && winningSide && matchUp.winningSide && matchUp.winningSide !== winningSide;
     if (allowChangePropagation &&
         validWinningSideSwap &&
         matchUp.roundPosition) {
@@ -42780,22 +42832,23 @@ function disableTieAutoCalc({ drawDefinition, matchUpId, event }) {
 
 function setMatchUpFormat(params) {
     const stack = 'setMatchUpFormat';
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true },
+        {
+            [VALIDATE]: (value) => isValidMatchUpFormat({ matchUpFormat: value }),
+            [INVALID]: UNRECOGNIZED_MATCHUP_FORMAT,
+            matchUpFormat: true,
+        },
+    ]);
+    if (paramsCheck.error)
+        return decorateResult({ result: paramsCheck, stack });
     const { tournamentRecord, drawDefinition, scheduledDates, stageSequences, matchUpFormat, structureId, eventType, matchUpId, eventId, stages, drawId, event, force, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!matchUpFormat)
-        return { error: MISSING_MATCHUP_FORMAT };
-    if (matchUpFormat && !isValidMatchUpFormat({ matchUpFormat }))
-        return decorateResult({
-            result: { error: UNRECOGNIZED_MATCHUP_FORMAT, matchUpFormat },
-            stack,
-        });
     if (scheduledDates && !Array.isArray(scheduledDates))
         return decorateResult({
             result: { error: INVALID_VALUES, scheduledDates },
             stack,
         });
-    if (eventType && ![SINGLES$1, DOUBLES$1].includes(eventType))
+    if (eventType && !includesMatchUpEventType([SINGLES$1, DOUBLES$1], eventType))
         return decorateResult({ result: { error: INVALID_EVENT_TYPE }, stack });
     let modificationsCount = 0;
     const structureIds = params.structureIds || (structureId && [structureId].filter(Boolean)) || [];
@@ -42867,7 +42920,7 @@ function setMatchUpFormat(params) {
         }
         return modifiedStructureIds;
     };
-    for (const event of tournamentRecord.events || []) {
+    for (const event of tournamentRecord?.events || []) {
         if ((eventIds?.length && !eventIds.includes(event.eventId)) ||
             (eventType && eventType !== event.eventType) ||
             eventType === TEAM$2) {
@@ -43142,6 +43195,264 @@ function setDelegatedOutcome(params) {
     return setDelegatedOutcome$1(params);
 }
 
+function resetTieFormat(params) {
+    const stack = 'resetTieFormat';
+    const { drawDefinition, event, uuids } = params;
+    const paramCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true, [MATCHUP_ID]: true }], stack);
+    if (paramCheck.error)
+        return paramCheck;
+    const resolutions = resolveFromParameters(params, [{ [PARAM]: MATCHUP }]);
+    if (resolutions[ERROR])
+        return resolutions;
+    const tournamentId = params.tournamentRecord?.tournamentId;
+    const { matchUp, structure } = resolutions?.matchUp ?? {};
+    if (!matchUp?.tieMatchUps)
+        return decorateResult({
+            result: { error: INVALID_MATCHUP },
+            info: 'Must be a TEAM matchUp',
+            stack,
+        });
+    if (!matchUp.tieFormat)
+        return { ...SUCCESS };
+    const tieFormat = resolveTieFormat({
+        structure,
+        drawDefinition,
+        event,
+    })?.tieFormat;
+    if (!tieFormat)
+        return decorateResult({
+            result: { error: NOT_FOUND },
+            info: 'No inherited tieFormat',
+            stack,
+        });
+    const deletedMatchUpIds = [];
+    const collectionIds = [];
+    const tieMatchUps = [];
+    const newMatchUps = [];
+    for (const collectionDefinition of tieFormat.collectionDefinitions) {
+        const { matchUpCount, collectionId } = collectionDefinition;
+        collectionIds.push(collectionId);
+        const existingCollectionMatchUps = (matchUp.tieMatchUps || []).filter((matchUp) => matchUp.collectionId === collectionId);
+        if (existingCollectionMatchUps.length > matchUpCount) {
+            existingCollectionMatchUps.sort((a, b) => (a.matchUpStatus === TO_BE_PLAYED ? 1 : 0) - (b.matchUpStatus === TO_BE_PLAYED ? 1 : 0));
+            tieMatchUps.push(...existingCollectionMatchUps.slice(0, matchUpCount));
+            deletedMatchUpIds.push(...existingCollectionMatchUps.slice(3).map(getMatchUpId));
+        }
+        else {
+            tieMatchUps.push(...existingCollectionMatchUps);
+            if (existingCollectionMatchUps.length < matchUpCount) {
+                const matchUpsLimit = matchUpCount - existingCollectionMatchUps.length;
+                const matchUps = generateCollectionMatchUps({
+                    collectionDefinition,
+                    matchUpsLimit,
+                    matchUp,
+                    uuids,
+                });
+                newMatchUps.push(...matchUps);
+            }
+        }
+    }
+    for (const tieMatchUp of matchUp?.tieMatchUps || []) {
+        if (tieMatchUp.collectionId && !collectionIds.includes(tieMatchUp.collectionId))
+            deletedMatchUpIds.push(tieMatchUp.matchUpId);
+    }
+    if (newMatchUps.length) {
+        tieMatchUps.push(...newMatchUps);
+        addMatchUpsNotice({
+            eventId: event?.eventId,
+            matchUps: newMatchUps,
+            drawDefinition,
+            tournamentId,
+        });
+    }
+    if (deletedMatchUpIds.length) {
+        deleteMatchUpsNotice({
+            matchUpIds: deletedMatchUpIds,
+            eventId: event?.eventId,
+            drawDefinition,
+            tournamentId,
+        });
+    }
+    if (matchUp) {
+        matchUp.tieMatchUps = tieMatchUps;
+        matchUp.tieFormatId = undefined;
+        matchUp.tieFormat = undefined;
+        modifyMatchUpNotice({
+            structureId: structure?.structureId,
+            eventId: event?.eventId,
+            context: stack,
+            drawDefinition,
+            tournamentId,
+            matchUp,
+        });
+    }
+    return { ...SUCCESS, newMatchUps, deletedMatchUpIds };
+}
+
+function resetScorecard(params) {
+    const { tournamentRecord, drawDefinition, matchUpId, event } = params;
+    const stack = 'resetScorecard';
+    if (!drawDefinition)
+        return decorateResult({
+            result: { error: MISSING_DRAW_DEFINITION },
+            stack,
+        });
+    if (!matchUpId)
+        return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack });
+    if (!isString(matchUpId))
+        return decorateResult({
+            result: { error: INVALID_VALUES, matchUpId },
+            stack,
+        });
+    const matchUpsMap = getMatchUpsMap({ drawDefinition });
+    const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+        nextMatchUps: true,
+        inContext: true,
+        drawDefinition,
+        matchUpsMap,
+    });
+    const matchUp = matchUpsMap.drawMatchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
+    const inContextMatchUp = inContextDrawMatchUps?.find((matchUp) => matchUp.matchUpId === matchUpId);
+    if (!matchUp || !inContextDrawMatchUps)
+        return { error: MATCHUP_NOT_FOUND };
+    if (matchUp.matchUpType !== TEAM_EVENT)
+        return { error: INVALID_MATCHUP };
+    const targetData = positionTargets({
+        inContextDrawMatchUps,
+        drawDefinition,
+        matchUpId,
+    });
+    const structureId = inContextMatchUp?.structureId;
+    const { structure } = findStructure({ drawDefinition, structureId });
+    Object.assign(params, {
+        inContextDrawMatchUps,
+        inContextMatchUp,
+        matchUpsMap,
+        targetData,
+        structure,
+        matchUp,
+    });
+    const activeDownstream = isActiveDownstream(params);
+    if (activeDownstream)
+        return { error: CANNOT_CHANGE_WINNING_SIDE };
+    if (matchUp.tieMatchUps?.length) {
+        for (const tieMatchUp of matchUp.tieMatchUps) {
+            const result = setMatchUpState({
+                matchUpId: tieMatchUp.matchUpId,
+                matchUpTieId: matchUpId,
+                winningSide: undefined,
+                removeScore: true,
+                tournamentRecord,
+                drawDefinition,
+                event,
+            });
+            if (result.error)
+                return decorateResult({ result, stack });
+        }
+    }
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    })?.appliedPolicies;
+    const result = updateTieMatchUpScore({
+        event: params.event,
+        removeScore: true,
+        tournamentRecord,
+        appliedPolicies,
+        drawDefinition,
+        matchUpsMap,
+        matchUpId,
+    });
+    if (result.error)
+        return decorateResult({ result, stack });
+    if (params.tiebreakReset && !result.tieFormatRemoved) {
+        const inheritedTieFormat = resolveTieFormat({
+            drawDefinition,
+            structure,
+            event,
+        })?.tieFormat;
+        if (matchUp.tieFormat && inheritedTieFormat) {
+            const { matchUpCountDifference, descendantDifferences, ancestorDifferences, valueDifference } = compareTieFormats({
+                descendant: matchUp.tieFormat,
+                ancestor: inheritedTieFormat,
+            });
+            if (descendantDifferences.collectionIds.length === 1 &&
+                !ancestorDifferences.collectionIds.length &&
+                !ancestorDifferences.groupsCount &&
+                matchUpCountDifference === 1 &&
+                valueDifference === 1) {
+                const result = resetTieFormat({
+                    tournamentRecord,
+                    drawDefinition,
+                    matchUpId,
+                    event,
+                });
+                if (result.error)
+                    return result;
+            }
+        }
+    }
+    return { ...SUCCESS };
+}
+
+function resetAdHocMatchUps(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [DRAW_DEFINITION]: true, [EVENT]: true },
+        {
+            [ONE_OF]: { [MATCHUP_IDS]: false, roundNumbers: false },
+            [MESSAGE]: 'At least one must be provided',
+            [OF_TYPE]: ARRAY,
+        },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const structureResult = getAdHocStructureDetails(params);
+    if (structureResult.error)
+        return structureResult;
+    const { matchUpIds } = structureResult;
+    const isTeam = isMatchUpEventType(TEAM_EVENT)(params.event.eventType);
+    const { tournamentRecord, drawDefinition, event } = params;
+    for (const matchUpId of matchUpIds) {
+        if (isTeam) {
+            const result = resetScorecard({
+                tiebreakReset: true,
+                tournamentRecord,
+                drawDefinition,
+                matchUpId,
+                event,
+            });
+            if (result.error)
+                return result;
+            if (params.removeAssignments) {
+                const resetLineUpResult = resetMatchUpLineUps({
+                    inheritance: false,
+                    drawDefinition,
+                    matchUpId,
+                });
+                if (resetLineUpResult.error)
+                    return result;
+            }
+        }
+        const result = setMatchUpState({
+            winningSide: undefined,
+            removeScore: true,
+            tournamentRecord,
+            drawDefinition,
+            matchUpId,
+            event,
+        });
+        if (result.error)
+            return result;
+        if (params.removeAssignments) {
+            const removeResult = removeMatchUpSideParticipant({ ...params, matchUpId });
+            if (removeResult.error)
+                return removeResult;
+        }
+    }
+    return { ...SUCCESS };
+}
+
 function setOrderOfFinish$1({ drawDefinition, finishingOrder }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -43317,7 +43628,7 @@ function applyLineUps({ tournamentRecord, drawDefinition, matchUpId, lineUps, ev
                     collectionParticipantIds[aggregator] = [];
                 }
                 const participantsCount = collectionParticipantIds[aggregator].length;
-                if ((collectionDefinition.matchUpType === SINGLES && participantsCount) ||
+                if ((isMatchUpEventType(SINGLES)(collectionDefinition.matchUpType) && participantsCount) ||
                     (collectionDefinition.matchUpType === DOUBLES && participantsCount > 1)) {
                     return {
                         info: 'Excessive collectionPosition assignments',
@@ -43389,207 +43700,6 @@ function applyLineUps({ tournamentRecord, drawDefinition, matchUpId, lineUps, ev
     return { ...SUCCESS };
 }
 
-function resetTieFormat(params) {
-    const stack = 'resetTieFormat';
-    const { drawDefinition, event, uuids } = params;
-    const paramCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true, [MATCHUP_ID]: true }], stack);
-    if (paramCheck.error)
-        return paramCheck;
-    const resolutions = resolveFromParameters(params, [{ [PARAM]: MATCHUP }]);
-    if (resolutions[ERROR])
-        return resolutions;
-    const tournamentId = params.tournamentRecord?.tournamentId;
-    const { matchUp, structure } = resolutions?.matchUp ?? {};
-    if (!matchUp?.tieMatchUps)
-        return decorateResult({
-            result: { error: INVALID_MATCHUP },
-            info: 'Must be a TEAM matchUp',
-            stack,
-        });
-    if (!matchUp.tieFormat)
-        return { ...SUCCESS };
-    const tieFormat = resolveTieFormat({
-        structure,
-        drawDefinition,
-        event,
-    })?.tieFormat;
-    if (!tieFormat)
-        return decorateResult({
-            result: { error: NOT_FOUND },
-            info: 'No inherited tieFormat',
-            stack,
-        });
-    const deletedMatchUpIds = [];
-    const collectionIds = [];
-    const tieMatchUps = [];
-    const newMatchUps = [];
-    for (const collectionDefinition of tieFormat.collectionDefinitions) {
-        const { matchUpCount, collectionId } = collectionDefinition;
-        collectionIds.push(collectionId);
-        const existingCollectionMatchUps = (matchUp.tieMatchUps || []).filter((matchUp) => matchUp.collectionId === collectionId);
-        if (existingCollectionMatchUps.length > matchUpCount) {
-            existingCollectionMatchUps.sort((a, b) => (a.matchUpStatus === TO_BE_PLAYED ? 1 : 0) - (b.matchUpStatus === TO_BE_PLAYED ? 1 : 0));
-            tieMatchUps.push(...existingCollectionMatchUps.slice(0, matchUpCount));
-            deletedMatchUpIds.push(...existingCollectionMatchUps.slice(3).map(getMatchUpId));
-        }
-        else {
-            tieMatchUps.push(...existingCollectionMatchUps);
-            if (existingCollectionMatchUps.length < matchUpCount) {
-                const matchUpsLimit = matchUpCount - existingCollectionMatchUps.length;
-                const matchUps = generateCollectionMatchUps({
-                    collectionDefinition,
-                    matchUpsLimit,
-                    matchUp,
-                    uuids,
-                });
-                newMatchUps.push(...matchUps);
-            }
-        }
-    }
-    for (const tieMatchUp of matchUp?.tieMatchUps || []) {
-        if (tieMatchUp.collectionId && !collectionIds.includes(tieMatchUp.collectionId))
-            deletedMatchUpIds.push(tieMatchUp.matchUpId);
-    }
-    if (newMatchUps.length) {
-        tieMatchUps.push(...newMatchUps);
-        addMatchUpsNotice({
-            eventId: event?.eventId,
-            matchUps: newMatchUps,
-            drawDefinition,
-            tournamentId,
-        });
-    }
-    if (deletedMatchUpIds.length) {
-        deleteMatchUpsNotice({
-            matchUpIds: deletedMatchUpIds,
-            eventId: event?.eventId,
-            drawDefinition,
-            tournamentId,
-        });
-    }
-    if (matchUp) {
-        matchUp.tieMatchUps = tieMatchUps;
-        matchUp.tieFormatId = undefined;
-        matchUp.tieFormat = undefined;
-        modifyMatchUpNotice({
-            structureId: structure?.structureId,
-            eventId: event?.eventId,
-            context: stack,
-            drawDefinition,
-            tournamentId,
-            matchUp,
-        });
-    }
-    return { ...SUCCESS, newMatchUps, deletedMatchUpIds };
-}
-
-function resetScorecard(params) {
-    const { tournamentRecord, drawDefinition, matchUpId, event } = params;
-    const stack = 'resetScorecard';
-    if (!drawDefinition)
-        return decorateResult({
-            result: { error: MISSING_DRAW_DEFINITION },
-            stack,
-        });
-    if (!matchUpId)
-        return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack });
-    if (!isString(matchUpId))
-        return decorateResult({
-            result: { error: INVALID_VALUES, matchUpId },
-            stack,
-        });
-    const matchUpsMap = getMatchUpsMap({ drawDefinition });
-    const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
-        nextMatchUps: true,
-        inContext: true,
-        drawDefinition,
-        matchUpsMap,
-    });
-    const matchUp = matchUpsMap.drawMatchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
-    const inContextMatchUp = inContextDrawMatchUps?.find((matchUp) => matchUp.matchUpId === matchUpId);
-    if (!matchUp || !inContextDrawMatchUps)
-        return { error: MATCHUP_NOT_FOUND };
-    if (matchUp.matchUpType !== TEAM_EVENT)
-        return { error: INVALID_MATCHUP };
-    const targetData = positionTargets({
-        inContextDrawMatchUps,
-        drawDefinition,
-        matchUpId,
-    });
-    const structureId = inContextMatchUp?.structureId;
-    const { structure } = findStructure({ drawDefinition, structureId });
-    Object.assign(params, {
-        inContextDrawMatchUps,
-        inContextMatchUp,
-        matchUpsMap,
-        targetData,
-        structure,
-        matchUp,
-    });
-    const activeDownstream = isActiveDownstream(params);
-    if (activeDownstream)
-        return { error: CANNOT_CHANGE_WINNING_SIDE };
-    if (matchUp.tieMatchUps?.length) {
-        for (const tieMatchUp of matchUp.tieMatchUps) {
-            const result = setMatchUpState({
-                matchUpId: tieMatchUp.matchUpId,
-                matchUpTieId: matchUpId,
-                winningSide: undefined,
-                removeScore: true,
-                tournamentRecord,
-                drawDefinition,
-                event,
-            });
-            if (result.error)
-                return decorateResult({ result, stack });
-        }
-    }
-    const appliedPolicies = getAppliedPolicies({
-        tournamentRecord,
-        drawDefinition,
-        event,
-    })?.appliedPolicies;
-    const result = updateTieMatchUpScore({
-        event: params.event,
-        removeScore: true,
-        tournamentRecord,
-        appliedPolicies,
-        drawDefinition,
-        matchUpsMap,
-        matchUpId,
-    });
-    if (result.error)
-        return decorateResult({ result, stack });
-    if (params.tiebreakReset && !result.tieFormatRemoved) {
-        const inheritedTieFormat = resolveTieFormat({
-            drawDefinition,
-            structure,
-            event,
-        })?.tieFormat;
-        if (matchUp.tieFormat && inheritedTieFormat) {
-            const { matchUpCountDifference, descendantDifferences, ancestorDifferences, valueDifference } = compareTieFormats({
-                descendant: matchUp.tieFormat,
-                ancestor: inheritedTieFormat,
-            });
-            if (descendantDifferences.collectionIds.length === 1 &&
-                !ancestorDifferences.collectionIds.length &&
-                !ancestorDifferences.groupsCount &&
-                matchUpCountDifference === 1 &&
-                valueDifference === 1) {
-                const result = resetTieFormat({
-                    tournamentRecord,
-                    drawDefinition,
-                    matchUpId,
-                    event,
-                });
-                if (result.error)
-                    return result;
-            }
-        }
-    }
-    return { ...SUCCESS };
-}
-
 var mutate$7 = {
     __proto__: null,
     applyLineUps: applyLineUps,
@@ -43605,6 +43715,7 @@ var mutate$7 = {
     removeMatchUpSideParticipant: removeMatchUpSideParticipant,
     removeTieMatchUpParticipantId: removeTieMatchUpParticipantId,
     replaceTieMatchUpParticipantId: replaceTieMatchUpParticipantId,
+    resetAdHocMatchUps: resetAdHocMatchUps,
     resetMatchUpLineUps: resetMatchUpLineUps,
     resetScorecard: resetScorecard,
     resetTieFormat: resetTieFormat,
@@ -43668,6 +43779,7 @@ var index$9 = {
     removeMatchUpSideParticipant: removeMatchUpSideParticipant,
     removeTieMatchUpParticipantId: removeTieMatchUpParticipantId,
     replaceTieMatchUpParticipantId: replaceTieMatchUpParticipantId,
+    resetAdHocMatchUps: resetAdHocMatchUps,
     resetMatchUpLineUps: resetMatchUpLineUps,
     resetScorecard: resetScorecard,
     resetTieFormat: resetTieFormat,
@@ -44339,8 +44451,8 @@ function checkRecoveryTime({ individualParticipantProfiles, matchUpNotBeforeTime
 }
 
 function checkDailyLimits({ individualParticipantProfiles, matchUpPotentialParticipantIds, matchUpDailyLimits = {}, matchUp, }) {
-    const { matchUpId, matchUpType } = matchUp;
     const { enteredIndividualParticipantIds } = getIndividualParticipantIds(matchUp);
+    const { matchUpId, matchUpType } = matchUp;
     const potentialParticipantIds = ((matchUp.roundPosition && matchUpPotentialParticipantIds[matchUpId]) || []).flat();
     const relevantParticipantIds = unique(enteredIndividualParticipantIds.concat(...potentialParticipantIds));
     relevantParticipantIds.forEach((participantId) => {
@@ -46514,12 +46626,12 @@ function processTieFormat({ alternatesCount = 0, tieFormatName, tieFormat, drawS
         }
         if (!collectionId)
             collectionDefinition.collectionId = UUID();
-        if (matchUpType === DOUBLES) {
+        if (isMatchUpEventType(DOUBLES)(matchUpType)) {
             const doublesCount = matchUpCount;
             doublesMatchUpTotal += matchUpCount;
             maxDoublesCount = Math.max(maxDoublesCount, doublesCount);
         }
-        if (matchUpType === SINGLES) {
+        if (isMatchUpEventType(SINGLES)(matchUpType)) {
             const singlescount = matchUpCount;
             singlesMatchUpTotal += matchUpCount;
             maxSinglesCount = Math.max(maxSinglesCount, singlescount);
@@ -47470,8 +47582,8 @@ function completeDrawMatchUps(params) {
                     tournamentRecord,
                 });
                 const assignParticipants = (dualMatchUp) => {
-                    const singlesMatchUps = dualMatchUp.tieMatchUps.filter(({ matchUpType }) => matchUpType === SINGLES);
-                    const doublesMatchUps = dualMatchUp.tieMatchUps.filter(({ matchUpType }) => matchUpType === DOUBLES);
+                    const singlesMatchUps = dualMatchUp.tieMatchUps.filter(isMatchUpEventType(SINGLES));
+                    const doublesMatchUps = dualMatchUp.tieMatchUps.filter(isMatchUpEventType(DOUBLES));
                     singlesMatchUps.forEach((singlesMatchUp, i) => {
                         const tieMatchUpId = singlesMatchUp.matchUpId;
                         singlesMatchUp.sides.forEach((side) => {
@@ -47757,7 +47869,9 @@ function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchU
 function generateEventParticipants(params) {
     const { participantsProfile = {}, uniqueParticipantsCount, ratingsParameters, tournamentRecord, eventProfile, eventIndex, event, uuids, } = params;
     const { category, gender, eventType } = event;
-    const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+    const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+        eventType;
     const mainParticipantsCount = uniqueParticipantsCount[MAIN] || 0;
     const qualifyingParticipantsCount = uniqueParticipantsCount[QUALIFYING] || 0;
     const participantsCount = eventProfile.drawProfiles?.length
@@ -47873,7 +47987,9 @@ function generateEventWithFlights(params) {
         category,
         gender,
     });
-    const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+    const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+        eventType;
     const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
         ? generateEventParticipants({
             event: { eventType, category, gender },
@@ -48233,9 +48349,9 @@ function generateEventWithDraw(params) {
     }
     const isEventParticipantType = (participant) => {
         const { participantType } = participant;
-        if (eventType === SINGLES$1 && participantType === INDIVIDUAL)
+        if (isMatchUpEventType(SINGLES$1)(eventType) && participantType === INDIVIDUAL)
             return true;
-        if (eventType === DOUBLES$1 && participantType === PAIR)
+        if (isMatchUpEventType(DOUBLES$1)(eventType) && participantType === PAIR)
             return true;
         return eventType === TEAM && participantType === TEAM;
     };
@@ -48987,7 +49103,9 @@ function modifyTournamentRecord(params) {
             else {
                 const { gender, category, eventType } = event;
                 const { drawProfiles, publish } = eventProfile;
-                const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+                const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+                    (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+                    eventType;
                 if (drawProfiles) {
                     const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
                         drawProfiles,
@@ -54947,9 +55065,11 @@ function venueModify({ tournamentRecord, modifications, venueId, force }) {
         validReplacementAttributes.forEach((attribute) => Object.assign(venue, { [attribute]: modifications[attribute] }));
     const existingCourtIds = venue?.courts?.map((court) => court.courtId) ?? [];
     const courtIdsToModify = modifications.courts?.map((court) => court.courtId) || [];
-    const courtIdsToDelete = courtIdsToModify.length && existingCourtIds.filter((courtId) => !courtIdsToModify.includes(courtId));
+    const courtIdsToDelete = courtIdsToModify.length
+        ? existingCourtIds.filter((courtId) => !courtIdsToModify.includes(courtId))
+        : modifications?.courts && existingCourtIds;
     const matchUpsWithCourtId = [];
-    if (courtIdsToDelete.length) {
+    if (courtIdsToDelete?.length) {
         const courtsToDelete = venue?.courts?.filter((court) => courtIdsToDelete.includes(court.courtId));
         const scheduleDeletionsCount = courtsToDelete
             ?.map((court) => {
@@ -55372,60 +55492,6 @@ var index$1 = {
 
 const forge = {};
 
-function notifySubscribers(params) {
-    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
-    const { topics } = getTopics();
-    for (const topic of [...topics].sort(topicSort)) {
-        const notices = getNotices({ topic });
-        if (notices)
-            callListener({ topic, notices });
-    }
-    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
-        callListener({
-            notices: [{ tournamentId, directives, timeStamp }],
-            topic: MUTATIONS,
-        });
-    }
-}
-async function notifySubscribersAsync(params) {
-    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
-    const { topics } = getTopics();
-    for (const topic of [...topics].sort(topicSort)) {
-        const notices = getNotices({ topic });
-        if (notices)
-            await callListener({ topic, notices });
-    }
-    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
-        callListener({
-            notices: [{ tournamentId, directives, timeStamp }],
-            topic: MUTATIONS,
-        });
-    }
-}
-const topicValues = {
-    [UNPUBLISH_EVENT_SEEDING]: 5,
-    [UNPUBLISH_EVENT]: 5,
-    [UNPUBLISH_ORDER_OF_PLAY]: 5,
-    [MODIFY_SEED_ASSIGNMENTS]: 5,
-    [MODIFY_POSITION_ASSIGNMENTS]: 5,
-    [MODIFY_DRAW_DEFINITION]: 5,
-    [MODIFY_DRAW_ENTRIES]: 5,
-    [MODIFY_EVENT_ENTRIES]: 5,
-    [MODIFY_MATCHUP]: 1,
-    [UPDATE_INCONTEXT_MATCHUP]: 1,
-    [MODIFY_PARTICIPANTS]: 5,
-    [MODIFY_VENUE]: 5,
-    [DELETED_MATCHUP_IDS]: 4,
-    [DELETE_PARTICIPANTS]: 4,
-    [DELETE_VENUE]: 4,
-    [DELETED_DRAW_IDS]: 4,
-    [ADD_MATCHUPS]: 3,
-    [ADD_DRAW_DEFINITION]: 2,
-};
-function topicSort(a, b) {
-    return (topicValues[b] || 0) - (topicValues[a] || 0);
-}
-
 const { FACTORY } = extensionConstants;
 function updateFactoryExtension({ tournamentRecord, value }) {
     const { extension } = findExtension({
@@ -55591,6 +55657,60 @@ function invoke({ tournamentRecords, tournamentRecord, params, methodName, metho
     }
 }
 
+function notifySubscribers(params) {
+    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
+    const { topics } = getTopics();
+    for (const topic of [...topics].sort(topicSort)) {
+        const notices = getNotices({ topic });
+        if (notices)
+            callListener({ topic, notices });
+    }
+    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
+        callListener({
+            notices: [{ tournamentId, directives, timeStamp }],
+            topic: MUTATIONS,
+        });
+    }
+}
+async function notifySubscribersAsync(params) {
+    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
+    const { topics } = getTopics();
+    for (const topic of [...topics].sort(topicSort)) {
+        const notices = getNotices({ topic });
+        if (notices)
+            await callListener({ topic, notices });
+    }
+    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
+        callListener({
+            notices: [{ tournamentId, directives, timeStamp }],
+            topic: MUTATIONS,
+        });
+    }
+}
+const topicValues = {
+    [UNPUBLISH_EVENT_SEEDING]: 5,
+    [UNPUBLISH_EVENT]: 5,
+    [UNPUBLISH_ORDER_OF_PLAY]: 5,
+    [MODIFY_SEED_ASSIGNMENTS]: 5,
+    [MODIFY_POSITION_ASSIGNMENTS]: 5,
+    [MODIFY_DRAW_DEFINITION]: 5,
+    [MODIFY_DRAW_ENTRIES]: 5,
+    [MODIFY_EVENT_ENTRIES]: 5,
+    [MODIFY_MATCHUP]: 1,
+    [UPDATE_INCONTEXT_MATCHUP]: 1,
+    [MODIFY_PARTICIPANTS]: 5,
+    [MODIFY_VENUE]: 5,
+    [DELETED_MATCHUP_IDS]: 4,
+    [DELETE_PARTICIPANTS]: 4,
+    [DELETE_VENUE]: 4,
+    [DELETED_DRAW_IDS]: 4,
+    [ADD_MATCHUPS]: 3,
+    [ADD_DRAW_DEFINITION]: 2,
+};
+function topicSort(a, b) {
+    return (topicValues[b] || 0) - (topicValues[a] || 0);
+}
+
 function getState$1({ convertExtensions, removeExtensions }) {
     const tournamentRecords = getTournamentRecords();
     const tournamentId = getTournamentId();