tods-competition-factory 2.0.21 → 2.0.22

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.21';
+    return '2.0.22';
 }
 
 const SUCCESS = { success: true };
@@ -2220,12 +2220,12 @@ const errors = {
     [STRUCTURE]: MISSING_STRUCTURE,
     [COURT_ID]: MISSING_COURT_ID,
     [MATCHUPS]: MISSING_MATCHUPS,
+    [EVENT_ID]: EVENT_NOT_FOUND,
     [MATCHUP]: MISSING_MATCHUP,
     [COURT_IDS]: MISSING_VALUE,
     [VENUE_IDS]: MISSING_VALUE,
     [DRAW_ID]: MISSING_DRAW_ID,
-    [EVENT_ID]: MISSING_EVENT,
-    [EVENT]: EVENT_NOT_FOUND,
+    [EVENT]: MISSING_EVENT,
 };
 const paramTypes = {
     [TOURNAMENT_RECORDS]: OBJECT,
@@ -11466,7 +11466,7 @@ function getPublishState(params) {
             };
         }
         else if (Array.isArray(drawIds) && drawIds?.length) {
-            const eventDrawIds = event.drawDefinitions?.map(getDrawId) || [];
+            const eventDrawIds = event.drawDefinitions?.map(getDrawId) ?? [];
             for (const drawId of drawIds) {
                 if (!isString(drawId))
                     return { error: INVALID_VALUES };
@@ -26787,8 +26787,8 @@ function getTournamentInfo(params) {
     const publishState = getPublishState({ tournamentRecord })?.publishState;
     const publishedEventIds = publishState?.tournament?.status?.publishedEventIds || [];
     const eventInfo = [];
-    for (const event of tournamentRecord.events || []) {
-        if (publishedEventIds.includes(event.eventId)) {
+    for (const event of tournamentRecord.events ?? []) {
+        if (!params?.usePublishState || publishedEventIds.includes(event.eventId)) {
             const info = extractEventInfo({ event }).eventInfo;
             if (info)
                 eventInfo.push(info);
@@ -27168,6 +27168,573 @@ var query$8 = {
     validateCollectionDefinition: validateCollectionDefinition
 };
 
+function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!outcomes?.length)
+        return { error: MISSING_VALUE, info: 'Missing outcomes' };
+    const eventIdsMap = outcomes.reduce((eventIdsMap, outcome) => {
+        const { drawId, eventId } = outcome;
+        if (eventId && drawId) {
+            if (!eventIdsMap[eventId]) {
+                eventIdsMap[eventId] = [drawId];
+            }
+            else if (!eventIdsMap[eventId].includes(drawId)) {
+                eventIdsMap[eventId].push(drawId);
+            }
+        }
+        return eventIdsMap;
+    }, {});
+    const relevantEventsIds = Object.keys(eventIdsMap);
+    const relevantEvents = tournamentRecord.events?.filter((event) => relevantEventsIds.includes(event.eventId));
+    const publishedEventIds = relevantEvents
+        .filter((event) => {
+        const pubStatus = getEventPublishStatus({ event });
+        const { drawDetails, drawIds } = pubStatus ?? {};
+        const { eventId } = event;
+        const publishedDrawIds = eventIdsMap[eventId].filter((drawId) => {
+            const keyedDrawIds = drawDetails
+                ? Object.keys(pubStatus.drawDetails).filter((drawId) => getDrawPublishStatus({ drawId, drawDetails }))
+                : [];
+            return drawIds?.includes(drawId) || keyedDrawIds.includes(drawId);
+        });
+        return publishedDrawIds.length;
+    })
+        .map((event) => event.eventId);
+    return { publishedEventIds, eventIdPublishedDrawIdsMap: eventIdsMap };
+}
+
+function getDisabledStatus({ dates = [], extension }) {
+    if (!extension)
+        return false;
+    if (typeof extension.value === 'boolean' && extension.value)
+        return true;
+    if (!dates.length)
+        return false;
+    const disabledDates = isObject(extension.value) ? extension.value?.dates : undefined;
+    if (Array.isArray(disabledDates)) {
+        if (!disabledDates?.length)
+            return false;
+        const datesToConsider = disabledDates.filter((date) => !dates.length || dates.includes(date));
+        return !!datesToConsider.length;
+    }
+    return undefined;
+}
+
+function getInContextCourt({ convertExtensions, ignoreDisabled, venue, court }) {
+    const inContextCourt = {
+        ...makeDeepCopy(court, convertExtensions, true),
+        venueId: venue.venueId,
+    };
+    const { extension } = findExtension({
+        name: DISABLED,
+        element: court,
+    });
+    if (ignoreDisabled && extension) {
+        const disabledDates = isObject(extension.value) ? extension.value?.dates : undefined;
+        const dateAvailability = extension?.value === true
+            ? []
+            : inContextCourt.dateAvailability
+                .map((availability) => {
+                const date = availability.date;
+                if (!date || disabledDates.includes(date))
+                    return;
+                return availability;
+            })
+                .filter(Boolean);
+        inContextCourt.dateAvailability = dateAvailability;
+    }
+    return { inContextCourt };
+}
+
+function getVenuesAndCourts(params) {
+    const { convertExtensions, ignoreDisabled, venueIds = [], dates, } = params;
+    const tournamentRecords = params.tournamentRecords ||
+        (params.tournamentRecord && {
+            [params.tournamentRecord.tournamentId]: params.tournamentRecord,
+        }) ||
+        {};
+    const uniqueVenueIds = [];
+    const uniqueCourtIds = [];
+    const courts = [];
+    const venues = [];
+    const tournamentIds = Object.keys(tournamentRecords).filter((id) => !params.tournamentId || id === params.tournamentId);
+    tournamentIds.forEach((tournamentId) => {
+        const tournamentRecord = tournamentRecords[tournamentId];
+        for (const venue of tournamentRecord.venues ?? []) {
+            if (venueIds.length && !venueIds.includes(venue.venueId))
+                continue;
+            if (ignoreDisabled) {
+                const { extension } = findExtension({
+                    name: DISABLED,
+                    element: venue,
+                });
+                if (extension?.value)
+                    continue;
+            }
+            if (!uniqueVenueIds.includes(venue.venueId)) {
+                venues.push(makeDeepCopy(venue, convertExtensions, true));
+                uniqueVenueIds.push(venue.venueId);
+            }
+            for (const court of venue.courts ?? []) {
+                if (!uniqueCourtIds.includes(court.courtId)) {
+                    if (ignoreDisabled) {
+                        const { extension } = findExtension({
+                            name: DISABLED,
+                            element: court,
+                        });
+                        const isDisabled = getDisabledStatus({ extension, dates });
+                        if (isDisabled)
+                            continue;
+                    }
+                    const { inContextCourt } = getInContextCourt({
+                        convertExtensions,
+                        ignoreDisabled,
+                        venue,
+                        court,
+                    });
+                    courts.push(inContextCourt);
+                    uniqueCourtIds.push(court.courtId);
+                }
+            }
+        }
+    });
+    return { courts, venues, ...SUCCESS };
+}
+function getTournamentVenuesAndCourts({ convertExtensions, tournamentRecord, ignoreDisabled, dates, }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    const venues = makeDeepCopy(tournamentRecord.venues ?? [], convertExtensions)
+        .filter((venue) => {
+        if (!ignoreDisabled)
+            return venue;
+        const { extension } = findExtension({
+            name: DISABLED,
+            element: venue,
+        });
+        return !extension?.value && venue;
+    })
+        .filter(Boolean);
+    const courts = venues.reduce((courts, venue) => {
+        const additionalCourts = (venue?.courts || [])
+            .filter((court) => {
+            if (!ignoreDisabled && !dates?.length)
+                return court;
+            const { extension } = findExtension({
+                name: DISABLED,
+                element: court,
+            });
+            return getDisabledStatus({ extension, dates });
+        })
+            .filter(Boolean)
+            .map((court) => {
+            const { inContextCourt } = getInContextCourt({
+                convertExtensions,
+                ignoreDisabled,
+                venue,
+                court,
+            });
+            return inContextCourt;
+        });
+        return additionalCourts.length ? courts.concat(additionalCourts) : courts;
+    }, []);
+    return { venues, courts };
+}
+function getCompetitionVenues({ tournamentRecords, requireCourts, dates }) {
+    if (typeof tournamentRecords !== 'object' || !Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    const tournamentIds = Object.keys(tournamentRecords);
+    return tournamentIds.reduce((accumulator, tournamentId) => {
+        const tournamentRecord = tournamentRecords[tournamentId];
+        const { venues } = getTournamentVenuesAndCourts({
+            tournamentRecord,
+            dates,
+        });
+        venues?.forEach((venue) => {
+            const { venueId, courts } = venue;
+            const includeVenue = !requireCourts || courts?.length;
+            if (includeVenue && !accumulator.venueIds.includes(venueId)) {
+                accumulator.venues.push(venue);
+                accumulator.venueIds.push(venueId);
+            }
+        });
+        return accumulator;
+    }, { venues: [], venueIds: [] });
+}
+
+function getAllEventData({ tournamentRecord, policyDefinitions }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const events = tournamentRecord.events || [];
+    const tournamentParticipants = tournamentRecord?.participants || [];
+    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
+    const { venues: venuesData } = getVenuesAndCourts({
+        tournamentRecord,
+    });
+    const eventsData = events.map((event) => {
+        const { eventId } = event;
+        const eventInfo = extractEventInfo({ event }).eventInfo;
+        const scheduleTiming = getScheduleTiming({
+            tournamentRecord,
+            event,
+        }).scheduleTiming;
+        const drawsData = (event.drawDefinitions || []).map((drawDefinition) => {
+            const drawInfo = (({ drawId, drawName, matchUpFormat, updatedAt }) => ({
+                matchUpFormat,
+                updatedAt,
+                drawName,
+                drawId,
+            }))(drawDefinition);
+            const { abandonedMatchUps, completedMatchUps, upcomingMatchUps, pendingMatchUps } = getDrawMatchUps({
+                requireParticipants: true,
+                tournamentParticipants,
+                context: { eventId },
+                policyDefinitions,
+                tournamentRecord,
+                inContext: true,
+                scheduleTiming,
+                drawDefinition,
+                event,
+            });
+            return {
+                drawInfo,
+                matchUps: {
+                    abandonedMatchUps,
+                    completedMatchUps,
+                    upcomingMatchUps,
+                    pendingMatchUps,
+                },
+            };
+        });
+        const publish = getEventPublishStatus({ event });
+        Object.assign(eventInfo, {
+            drawsData,
+            publish,
+        });
+        return eventInfo;
+    });
+    const allEventData = { tournamentInfo, venuesData, eventsData };
+    return { allEventData };
+}
+
+function getDrawIsPublished({ publishStatus, drawId }) {
+    if (publishStatus?.drawDetails) {
+        return publishStatus.drawDetails?.[drawId]?.publishingDetail?.published;
+    }
+    else if (publishStatus?.drawIds) {
+        return publishStatus.drawIds.includes(drawId);
+    }
+    return true;
+}
+
+function getDrawData(params) {
+    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
+    if (!drawDefinition)
+        return { error: MISSING_DRAW_DEFINITION };
+    const drawInfo = (({ matchUpFormat, updatedAt, drawType, drawName, drawId }) => ({
+        matchUpFormat,
+        updatedAt,
+        drawName,
+        drawType,
+        drawId,
+    }))(drawDefinition);
+    let mainStageSeedAssignments, qualificationStageSeedAssignments;
+    const { allStructuresLinked, sourceStructureIds, hasDrawFeedProfile, structureGroups } = getStructureGroups({
+        drawDefinition,
+    });
+    if (!allStructuresLinked)
+        return { error: UNLINKED_STRUCTURES };
+    const publishStatus = params?.publishStatus ?? getEventPublishStatus({ event, status });
+    const eventPublished = params.eventPublished ?? !!getPublishState({ event }).publishState?.status?.published;
+    let drawActive = false;
+    let participantPlacements = false;
+    const groupedStructures = structureGroups.map((structureIds) => {
+        const completedStructures = {};
+        const structures = structureIds
+            .map((structureId) => {
+            const { structure } = findStructure({ drawDefinition, structureId });
+            const { seedAssignments } = getStructureSeedAssignments({
+                drawDefinition,
+                structure,
+            });
+            if (structure?.stage === MAIN && structure.stageSequence === 1) {
+                mainStageSeedAssignments = seedAssignments;
+            }
+            if (structure?.stage === QUALIFYING && structure.stageSequence === 1) {
+                qualificationStageSeedAssignments = seedAssignments;
+            }
+            return structure;
+        })
+            .sort((a, b) => structureSort(a, b, sortConfig))
+            .map((structure) => {
+            if (!structure)
+                return;
+            const structureId = structure?.structureId;
+            let seedAssignments = [];
+            if (structure.stage && [MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
+                seedAssignments = mainStageSeedAssignments;
+            }
+            if (structure?.stage === QUALIFYING) {
+                seedAssignments = qualificationStageSeedAssignments;
+            }
+            const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
+                seedAssignments: !structure?.seedAssignments?.length ? seedAssignments : undefined,
+                context: { drawId: drawInfo.drawId, ...context },
+                tournamentParticipants,
+                policyDefinitions,
+                tournamentRecord,
+                usePublishState,
+                publishStatus,
+                drawDefinition,
+                inContext,
+                structure,
+                event,
+            });
+            const { positionAssignments } = getPositionAssignments$1({
+                structure,
+            });
+            let participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
+                const { drawPosition, participantId } = assignment;
+                const { extension } = findExtension({
+                    element: assignment,
+                    name: TALLY,
+                });
+                participantPlacements = true;
+                return {
+                    participantResult: extension?.value,
+                    participantId,
+                    drawPosition,
+                };
+            });
+            if (!participantResults?.length && matchUps.length && params.allParticipantResults) {
+                const { subOrderMap } = createSubOrderMap({ positionAssignments });
+                const result = tallyParticipantResults({
+                    matchUpFormat: structure.matchUpFormat,
+                    policyDefinitions,
+                    subOrderMap,
+                    matchUps,
+                });
+                participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
+                    const { drawPosition, participantId } = assignment;
+                    participantPlacements = true;
+                    return {
+                        participantResult: participantId && result.participantResults[participantId],
+                        participantId,
+                        drawPosition,
+                    };
+                });
+            }
+            const structureInfo = structure
+                ? (({ stageSequence, structureName, structureType, matchUpFormat, stage }) => ({
+                    stageSequence,
+                    structureName,
+                    structureType,
+                    matchUpFormat,
+                    stage,
+                }))(structure)
+                : {};
+            structureInfo.sourceStructureIds = sourceStructureIds[structureId];
+            structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
+            structureInfo.positionAssignments = positionAssignments;
+            structureInfo.structureActive = matchUps.reduce((active, matchUp) => {
+                const activeMatchUpStatus = [
+                    COMPLETED$1,
+                    CANCELLED$1,
+                    DEFAULTED,
+                    RETIRED$1,
+                    WALKOVER$2,
+                    IN_PROGRESS$1,
+                    DOUBLE_DEFAULT,
+                    DOUBLE_WALKOVER,
+                ].includes(matchUp.matchUpStatus);
+                return active || activeMatchUpStatus || !!matchUp.winningSide || !!matchUp.score?.scoreStringSide1;
+            }, false);
+            const structureCompleted = matchUps.reduce((completed, matchUp) => {
+                return completed && [BYE, COMPLETED$1, RETIRED$1, WALKOVER$2, DEFAULTED, ABANDONED$1].includes(matchUp.matchUpStatus);
+            }, !!matchUps.length);
+            structureInfo.structureCompleted = structureCompleted;
+            completedStructures[structureId] = structureCompleted;
+            if (structureInfo.structureActive)
+                drawActive = true;
+            return {
+                ...structureInfo,
+                participantResults,
+                seedAssignments,
+                roundMatchUps,
+                roundProfile,
+                structureId,
+            };
+        });
+        structures.forEach((structure) => {
+            if (!includePositionAssignments)
+                delete structure.positionAssignments;
+            structure.sourceStructuresComplete = structure.sourceStructureIds?.every((id) => completedStructures[id]);
+        });
+        return structures;
+    });
+    const structures = groupedStructures.flat();
+    drawInfo.drawActive = drawActive;
+    drawInfo.participantPlacements = participantPlacements;
+    drawInfo.drawGenerated = structures?.reduce((generated, structure) => {
+        return generated || !!structure?.roundMatchUps;
+    }, false);
+    drawInfo.drawCompleted = structures?.reduce((completed, structure) => completed && structure.structureCompleted, true);
+    drawInfo.drawPublished = usePublishState
+        ? eventPublished && getDrawIsPublished({ publishStatus, drawId: drawInfo.drawId })
+        : undefined;
+    return {
+        structures: !usePublishState || drawInfo.drawPublished
+            ? noDeepCopy
+                ? structures
+                : makeDeepCopy(structures, false, true)
+            : undefined,
+        drawInfo: noDeepCopy ? drawInfo : makeDeepCopy(drawInfo, false, true),
+        ...SUCCESS,
+    };
+}
+
+function getEventData(params) {
+    const { includePositionAssignments, participantsProfile, policyDefinitions, usePublishState, status = PUBLIC, sortConfig, } = params;
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true },
+        { [ANY_OF]: { event: false, eventId: false } },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const tournamentRecord = makeDeepCopy(params.tournamentRecord, false, true);
+    const foundEvent = !params.event ? findEvent({ tournamentRecord, eventId: params.eventId }).event : undefined;
+    const event = params.event
+        ? makeDeepCopy(params.event, false, true)
+        : (foundEvent && makeDeepCopy(foundEvent, false, true)) || undefined;
+    if (!event)
+        return { error: EVENT_NOT_FOUND };
+    const { eventId } = event;
+    const { tournamentId, endDate } = tournamentRecord;
+    const publishStatus = getEventPublishStatus({ event, status });
+    const publishState = getPublishState({ event }).publishState ?? {};
+    const eventPublished = !!publishState?.status?.published;
+    const { participants: tournamentParticipants } = getParticipants({
+        withGroupings: true,
+        withEvents: false,
+        withDraws: false,
+        policyDefinitions,
+        ...participantsProfile,
+        tournamentRecord,
+    });
+    const stageFilter = ({ stage, drawId }) => {
+        if (!usePublishState)
+            return true;
+        const stageDetails = publishStatus?.drawDetails?.[drawId]?.stageDetails;
+        if (!stageDetails || !Object.keys(stageDetails).length)
+            return true;
+        return stageDetails[stage]?.published;
+    };
+    const structureFilter = ({ structureId, drawId }) => {
+        if (!usePublishState)
+            return true;
+        const structureDetails = publishStatus?.drawDetails?.[drawId]?.structureDetails;
+        if (!structureDetails || !Object.keys(structureDetails).length)
+            return true;
+        return structureDetails[structureId]?.published;
+    };
+    const drawFilter = ({ drawId }) => (!usePublishState ? true : getDrawIsPublished({ publishStatus, drawId }));
+    const roundLimitMapper = ({ drawId, structure }) => {
+        if (!usePublishState)
+            return structure;
+        const roundLimit = publishStatus?.drawDetails?.[drawId]?.structureDetails?.[structure.structureId]?.roundLimit;
+        if (isConvertableInteger(roundLimit)) {
+            const roundNumbers = generateRange(1, roundLimit + 1);
+            const roundMatchUps = {};
+            const roundProfile = {};
+            for (const roundNumber of roundNumbers) {
+                if (structure.roundMatchUps[roundNumber]) {
+                    roundMatchUps[roundNumber] = structure.roundMatchUps[roundNumber];
+                    roundProfile[roundNumber] = structure.roundProfile[roundNumber];
+                }
+            }
+            structure.roundMatchUps = roundMatchUps;
+            structure.roundProfile = roundProfile;
+        }
+        return structure;
+    };
+    const drawDefinitions = event.drawDefinitions || [];
+    const drawsData = !usePublishState || eventPublished
+        ? drawDefinitions
+            .filter(drawFilter)
+            .map((drawDefinition) => (({ drawInfo, structures }) => ({
+            ...drawInfo,
+            structures,
+        }))(getDrawData({
+            allParticipantResults: params.allParticipantResults,
+            context: { eventId, tournamentId, endDate },
+            includePositionAssignments,
+            tournamentParticipants,
+            noDeepCopy: true,
+            policyDefinitions,
+            tournamentRecord,
+            usePublishState,
+            drawDefinition,
+            publishStatus,
+            sortConfig,
+            event,
+        })))
+            .map(({ structures, ...drawData }) => {
+            const filteredStructures = structures
+                ?.filter(({ stage, structureId }) => structureFilter({ structureId, drawId: drawData.drawId }) &&
+                stageFilter({ stage, drawId: drawData.drawId }))
+                .map((structure) => roundLimitMapper({ drawId: drawData.drawId, structure }));
+            return {
+                ...drawData,
+                structures: filteredStructures,
+            };
+        })
+            .filter((drawData) => drawData.structures?.length)
+        : undefined;
+    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
+    const venues = tournamentRecord.venues || [];
+    const venuesData = venues.map((venue) => (({ venueData }) => ({
+        ...venueData,
+    }))(getVenueData({
+        tournamentRecord,
+        venueId: venue.venueId,
+    })));
+    const eventInfo = (({ eventId, eventName, eventType, eventLevel, surfaceCategory, matchUpFormat, category, gender, startDate, endDate, ballType, discipline, }) => ({
+        eventId,
+        eventName,
+        eventType,
+        eventLevel,
+        surfaceCategory,
+        matchUpFormat,
+        category,
+        gender,
+        startDate,
+        endDate,
+        ballType,
+        discipline,
+    }))(event);
+    const eventData = {
+        tournamentInfo,
+        venuesData,
+        eventInfo,
+        drawsData,
+    };
+    eventData.eventInfo.publishState = publishState;
+    eventData.eventInfo.published = publishState?.status?.published;
+    return { ...SUCCESS, eventData, participants: tournamentParticipants };
+}
+
+var query$7 = {
+    __proto__: null,
+    bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
+    getAllEventData: getAllEventData,
+    getCourtInfo: getCourtInfo,
+    getDrawData: getDrawData,
+    getEventData: getEventData,
+    getEventPublishStatus: getEventPublishStatus,
+    getPublishState: getPublishState,
+    getVenueData: getVenueData
+};
+
 function findMatchUpFormatTiming({ defaultRecoveryMinutes = 0, defaultAverageMinutes, tournamentRecords, matchUpFormat, categoryName, categoryType, tournamentId, eventType, eventId, }) {
     if (!isValidMatchUpFormat({ matchUpFormat }))
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
@@ -27486,164 +28053,6 @@ function getAllRelevantSchedulingIds(params) {
     };
 }
 
-function getDisabledStatus({ dates = [], extension }) {
-    if (!extension)
-        return false;
-    if (typeof extension.value === 'boolean' && extension.value)
-        return true;
-    if (!dates.length)
-        return false;
-    const disabledDates = isObject(extension.value) ? extension.value?.dates : undefined;
-    if (Array.isArray(disabledDates)) {
-        if (!disabledDates?.length)
-            return false;
-        const datesToConsider = disabledDates.filter((date) => !dates.length || dates.includes(date));
-        return !!datesToConsider.length;
-    }
-    return undefined;
-}
-
-function getInContextCourt({ convertExtensions, ignoreDisabled, venue, court }) {
-    const inContextCourt = {
-        ...makeDeepCopy(court, convertExtensions, true),
-        venueId: venue.venueId,
-    };
-    const { extension } = findExtension({
-        name: DISABLED,
-        element: court,
-    });
-    if (ignoreDisabled && extension) {
-        const disabledDates = isObject(extension.value) ? extension.value?.dates : undefined;
-        const dateAvailability = extension?.value === true
-            ? []
-            : inContextCourt.dateAvailability
-                .map((availability) => {
-                const date = availability.date;
-                if (!date || disabledDates.includes(date))
-                    return;
-                return availability;
-            })
-                .filter(Boolean);
-        inContextCourt.dateAvailability = dateAvailability;
-    }
-    return { inContextCourt };
-}
-
-function getVenuesAndCourts(params) {
-    const { convertExtensions, ignoreDisabled, venueIds = [], dates, } = params;
-    const tournamentRecords = params.tournamentRecords ||
-        (params.tournamentRecord && {
-            [params.tournamentRecord.tournamentId]: params.tournamentRecord,
-        }) ||
-        {};
-    const uniqueVenueIds = [];
-    const uniqueCourtIds = [];
-    const courts = [];
-    const venues = [];
-    const tournamentIds = Object.keys(tournamentRecords).filter((id) => !params.tournamentId || id === params.tournamentId);
-    tournamentIds.forEach((tournamentId) => {
-        const tournamentRecord = tournamentRecords[tournamentId];
-        for (const venue of tournamentRecord.venues ?? []) {
-            if (venueIds.length && !venueIds.includes(venue.venueId))
-                continue;
-            if (ignoreDisabled) {
-                const { extension } = findExtension({
-                    name: DISABLED,
-                    element: venue,
-                });
-                if (extension?.value)
-                    continue;
-            }
-            if (!uniqueVenueIds.includes(venue.venueId)) {
-                venues.push(makeDeepCopy(venue, convertExtensions, true));
-                uniqueVenueIds.push(venue.venueId);
-            }
-            for (const court of venue.courts ?? []) {
-                if (!uniqueCourtIds.includes(court.courtId)) {
-                    if (ignoreDisabled) {
-                        const { extension } = findExtension({
-                            name: DISABLED,
-                            element: court,
-                        });
-                        const isDisabled = getDisabledStatus({ extension, dates });
-                        if (isDisabled)
-                            continue;
-                    }
-                    const { inContextCourt } = getInContextCourt({
-                        convertExtensions,
-                        ignoreDisabled,
-                        venue,
-                        court,
-                    });
-                    courts.push(inContextCourt);
-                    uniqueCourtIds.push(court.courtId);
-                }
-            }
-        }
-    });
-    return { courts, venues, ...SUCCESS };
-}
-function getTournamentVenuesAndCourts({ convertExtensions, tournamentRecord, ignoreDisabled, dates, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORDS };
-    const venues = makeDeepCopy(tournamentRecord.venues ?? [], convertExtensions)
-        .filter((venue) => {
-        if (!ignoreDisabled)
-            return venue;
-        const { extension } = findExtension({
-            name: DISABLED,
-            element: venue,
-        });
-        return !extension?.value && venue;
-    })
-        .filter(Boolean);
-    const courts = venues.reduce((courts, venue) => {
-        const additionalCourts = (venue?.courts || [])
-            .filter((court) => {
-            if (!ignoreDisabled && !dates?.length)
-                return court;
-            const { extension } = findExtension({
-                name: DISABLED,
-                element: court,
-            });
-            return getDisabledStatus({ extension, dates });
-        })
-            .filter(Boolean)
-            .map((court) => {
-            const { inContextCourt } = getInContextCourt({
-                convertExtensions,
-                ignoreDisabled,
-                venue,
-                court,
-            });
-            return inContextCourt;
-        });
-        return additionalCourts.length ? courts.concat(additionalCourts) : courts;
-    }, []);
-    return { venues, courts };
-}
-function getCompetitionVenues({ tournamentRecords, requireCourts, dates }) {
-    if (typeof tournamentRecords !== 'object' || !Object.keys(tournamentRecords).length)
-        return { error: MISSING_TOURNAMENT_RECORDS };
-    const tournamentIds = Object.keys(tournamentRecords);
-    return tournamentIds.reduce((accumulator, tournamentId) => {
-        const tournamentRecord = tournamentRecords[tournamentId];
-        const { venues } = getTournamentVenuesAndCourts({
-            tournamentRecord,
-            dates,
-        });
-        venues?.forEach((venue) => {
-            const { venueId, courts } = venue;
-            const includeVenue = !requireCourts || courts?.length;
-            if (includeVenue && !accumulator.venueIds.includes(venueId)) {
-                accumulator.venues.push(venue);
-                accumulator.venueIds.push(venueId);
-            }
-        });
-        return accumulator;
-    }, { venues: [], venueIds: [] });
-}
-
 function getSchedulingProfile({ tournamentRecords, tournamentRecord }) {
     if (typeof tournamentRecords !== 'object' || !Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
@@ -27972,7 +28381,7 @@ function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentReco
     return { profileRounds, segmentedRounds };
 }
 
-var query$7 = {
+var query$6 = {
     __proto__: null,
     getPersonRequests: getPersonRequests,
     getProfileRounds: getProfileRounds,
@@ -28014,7 +28423,7 @@ function getMaxEntryPosition(params) {
         .map(({ entryPosition }) => ensureInt(entryPosition || 0)), 0);
 }
 
-var query$6 = {
+var query$5 = {
     __proto__: null,
     getEntriesAndSeedsCount: getEntriesAndSeedsCount,
     getMaxEntryPosition: getMaxEntryPosition
@@ -29930,7 +30339,7 @@ function drawMatchUps({ participants: tournamentParticipants, tournamentAppliedP
     return { ...drawMatchUpsResult, groupInfo };
 }
 
-var query$5 = {
+var query$4 = {
     __proto__: null,
     allCompetitionMatchUps: allCompetitionMatchUps,
     allDrawMatchUps: allDrawMatchUps,
@@ -29993,7 +30402,7 @@ function getCourts({ tournamentRecord, venueId, venueIds }) {
     return { courts };
 }
 
-var query$4 = {
+var query$3 = {
     __proto__: null,
     getCompetitionVenues: getCompetitionVenues,
     getCourts: getCourts,
@@ -30001,42 +30410,6 @@ var query$4 = {
     publicFindVenue: publicFindVenue
 };
 
-function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!outcomes?.length)
-        return { error: MISSING_VALUE, info: 'Missing outcomes' };
-    const eventIdsMap = outcomes.reduce((eventIdsMap, outcome) => {
-        const { drawId, eventId } = outcome;
-        if (eventId && drawId) {
-            if (!eventIdsMap[eventId]) {
-                eventIdsMap[eventId] = [drawId];
-            }
-            else if (!eventIdsMap[eventId].includes(drawId)) {
-                eventIdsMap[eventId].push(drawId);
-            }
-        }
-        return eventIdsMap;
-    }, {});
-    const relevantEventsIds = Object.keys(eventIdsMap);
-    const relevantEvents = tournamentRecord.events?.filter((event) => relevantEventsIds.includes(event.eventId));
-    const publishedEventIds = relevantEvents
-        .filter((event) => {
-        const pubStatus = getEventPublishStatus({ event });
-        const { drawDetails, drawIds } = pubStatus ?? {};
-        const { eventId } = event;
-        const publishedDrawIds = eventIdsMap[eventId].filter((drawId) => {
-            const keyedDrawIds = drawDetails
-                ? Object.keys(pubStatus.drawDetails).filter((drawId) => getDrawPublishStatus({ drawId, drawDetails }))
-                : [];
-            return drawIds?.includes(drawId) || keyedDrawIds.includes(drawId);
-        });
-        return publishedDrawIds.length;
-    })
-        .map((event) => event.eventId);
-    return { publishedEventIds, eventIdPublishedDrawIdsMap: eventIdsMap };
-}
-
 function getEventProperties({ tournamentRecord, event }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -30301,9 +30674,8 @@ function getEvent({ tournamentRecord, drawDefinition, context, event }) {
     });
 }
 
-var query$3 = {
+var query$2 = {
     __proto__: null,
-    bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
     categoryCanContain: categoryCanContain,
     getCategoryAgeDetails: getCategoryAgeDetails,
     getEvent: getEvent,
@@ -30340,6 +30712,7 @@ var index$g = {
     findDrawDefinition: publicFindDrawDefinition,
     findExtension: findExtension,
     getAllDrawMatchUps: getAllDrawMatchUps,
+    getAllEventData: getAllEventData,
     getAllStructureMatchUps: getAllStructureMatchUps,
     getAllowedDrawTypes: getAllowedDrawTypes,
     getAllowedMatchUpFormats: getAllowedMatchUpFormats,
@@ -30354,15 +30727,19 @@ var index$g = {
     getCompetitionParticipants: getCompetitionParticipants,
     getCompetitionPenalties: getCompetitionPenalties,
     getCompetitionVenues: getCompetitionVenues,
+    getCourtInfo: getCourtInfo,
     getCourts: getCourts,
+    getDrawData: getDrawData,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getEntriesAndSeedsCount: getEntriesAndSeedsCount,
     getEvent: getEvent,
+    getEventData: getEventData,
     getEventMatchUpFormatTiming: getEventMatchUpFormatTiming,
     getEventProperties: getEventProperties,
+    getEventPublishStatus: getEventPublishStatus,
     getEventStructures: getEventStructures,
     getEventTimeItem: getEventTimeItem,
     getEvents: getEvents,
@@ -30398,6 +30775,7 @@ var index$g = {
     getPositionsPlayedOff: getPositionsPlayedOff,
     getPredictiveAccuracy: getPredictiveAccuracy,
     getProfileRounds: getProfileRounds,
+    getPublishState: getPublishState,
     getRoundMatchUps: getRoundMatchUps,
     getRounds: getRounds,
     getScaleValues: getScaleValues,
@@ -30418,6 +30796,7 @@ var index$g = {
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
     getValidGroupSizes: getValidGroupSizes,
+    getVenueData: getVenueData,
     getVenuesAndCourts: getVenuesAndCourts,
     isAdHoc: isAdHoc,
     isCompletedStructure: isCompletedStructure,
@@ -33792,7 +34171,7 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '' }) {
     }
 }
 
-var query$2 = {
+var query$1 = {
     __proto__: null,
     analyzeSet: analyzeSet,
     checkScoreHasValue: checkScoreHasValue,
@@ -33827,7 +34206,7 @@ var scoreGovernor = {
     mutate: mutate$b,
     parseMatchUpFormat: parse,
     parseScoreString: parseScoreString,
-    query: query$2,
+    query: query$1,
     redo: redo,
     reverseScore: reverseScore,
     setServingSide: setServingSide,
@@ -35858,7 +36237,7 @@ var mutate$a = {
     removePolicy: removePolicy
 };
 
-var query$1 = {
+var query = {
     __proto__: null,
     findPolicy: findPolicy,
     getAppliedPolicies: getAppliedPolicies,
@@ -35872,7 +36251,7 @@ var index$f = {
     getAppliedPolicies: getAppliedPolicies,
     getPolicyDefinitions: getPolicyDefinitions,
     mutate: mutate$a,
-    query: query$1,
+    query: query,
     removePolicy: removePolicy
 };
 
@@ -36861,7 +37240,7 @@ var index$d = {
     mutate: mutate$9,
     promoteAlternate: promoteAlternate,
     promoteAlternates: promoteAlternates,
-    query: query$6,
+    query: query$5,
     removeDrawEntries: removeDrawEntries,
     removeEventEntries: removeEventEntries,
     setEntryPosition: setEntryPosition,
@@ -36884,305 +37263,6 @@ function modifyEventPublishStatus({ removePriorValues = true, status = PUBLIC, s
     });
 }
 
-function getDrawIsPublished({ publishStatus, drawId }) {
-    if (publishStatus?.drawDetails) {
-        return publishStatus.drawDetails?.[drawId]?.publishingDetail?.published;
-    }
-    else if (publishStatus?.drawIds) {
-        return publishStatus.drawIds.includes(drawId);
-    }
-    return true;
-}
-
-function getDrawData(params) {
-    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    const drawInfo = (({ matchUpFormat, updatedAt, drawType, drawName, drawId }) => ({
-        matchUpFormat,
-        updatedAt,
-        drawName,
-        drawType,
-        drawId,
-    }))(drawDefinition);
-    let mainStageSeedAssignments, qualificationStageSeedAssignments;
-    const { allStructuresLinked, sourceStructureIds, hasDrawFeedProfile, structureGroups } = getStructureGroups({
-        drawDefinition,
-    });
-    if (!allStructuresLinked)
-        return { error: UNLINKED_STRUCTURES };
-    const publishStatus = params?.publishStatus ?? getEventPublishStatus({ event, status });
-    const eventPublished = params.eventPublished ?? !!getPublishState({ event }).publishState?.status?.published;
-    let drawActive = false;
-    let participantPlacements = false;
-    const groupedStructures = structureGroups.map((structureIds) => {
-        const completedStructures = {};
-        const structures = structureIds
-            .map((structureId) => {
-            const { structure } = findStructure({ drawDefinition, structureId });
-            const { seedAssignments } = getStructureSeedAssignments({
-                drawDefinition,
-                structure,
-            });
-            if (structure?.stage === MAIN && structure.stageSequence === 1) {
-                mainStageSeedAssignments = seedAssignments;
-            }
-            if (structure?.stage === QUALIFYING && structure.stageSequence === 1) {
-                qualificationStageSeedAssignments = seedAssignments;
-            }
-            return structure;
-        })
-            .sort((a, b) => structureSort(a, b, sortConfig))
-            .map((structure) => {
-            if (!structure)
-                return;
-            const structureId = structure?.structureId;
-            let seedAssignments = [];
-            if (structure.stage && [MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
-                seedAssignments = mainStageSeedAssignments;
-            }
-            if (structure?.stage === QUALIFYING) {
-                seedAssignments = qualificationStageSeedAssignments;
-            }
-            const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
-                seedAssignments: !structure?.seedAssignments?.length ? seedAssignments : undefined,
-                context: { drawId: drawInfo.drawId, ...context },
-                tournamentParticipants,
-                policyDefinitions,
-                tournamentRecord,
-                usePublishState,
-                publishStatus,
-                drawDefinition,
-                inContext,
-                structure,
-                event,
-            });
-            const { positionAssignments } = getPositionAssignments$1({
-                structure,
-            });
-            let participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
-                const { drawPosition, participantId } = assignment;
-                const { extension } = findExtension({
-                    element: assignment,
-                    name: TALLY,
-                });
-                participantPlacements = true;
-                return {
-                    participantResult: extension?.value,
-                    participantId,
-                    drawPosition,
-                };
-            });
-            if (!participantResults?.length && matchUps.length && params.allParticipantResults) {
-                const { subOrderMap } = createSubOrderMap({ positionAssignments });
-                const result = tallyParticipantResults({
-                    matchUpFormat: structure.matchUpFormat,
-                    policyDefinitions,
-                    subOrderMap,
-                    matchUps,
-                });
-                participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
-                    const { drawPosition, participantId } = assignment;
-                    participantPlacements = true;
-                    return {
-                        participantResult: participantId && result.participantResults[participantId],
-                        participantId,
-                        drawPosition,
-                    };
-                });
-            }
-            const structureInfo = structure
-                ? (({ stageSequence, structureName, structureType, matchUpFormat, stage }) => ({
-                    stageSequence,
-                    structureName,
-                    structureType,
-                    matchUpFormat,
-                    stage,
-                }))(structure)
-                : {};
-            structureInfo.sourceStructureIds = sourceStructureIds[structureId];
-            structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
-            structureInfo.positionAssignments = positionAssignments;
-            structureInfo.structureActive = matchUps.reduce((active, matchUp) => {
-                const activeMatchUpStatus = [
-                    COMPLETED$1,
-                    CANCELLED$1,
-                    DEFAULTED,
-                    RETIRED$1,
-                    WALKOVER$2,
-                    IN_PROGRESS$1,
-                    DOUBLE_DEFAULT,
-                    DOUBLE_WALKOVER,
-                ].includes(matchUp.matchUpStatus);
-                return active || activeMatchUpStatus || !!matchUp.winningSide || !!matchUp.score?.scoreStringSide1;
-            }, false);
-            const structureCompleted = matchUps.reduce((completed, matchUp) => {
-                return completed && [BYE, COMPLETED$1, RETIRED$1, WALKOVER$2, DEFAULTED, ABANDONED$1].includes(matchUp.matchUpStatus);
-            }, !!matchUps.length);
-            structureInfo.structureCompleted = structureCompleted;
-            completedStructures[structureId] = structureCompleted;
-            if (structureInfo.structureActive)
-                drawActive = true;
-            return {
-                ...structureInfo,
-                participantResults,
-                seedAssignments,
-                roundMatchUps,
-                roundProfile,
-                structureId,
-            };
-        });
-        structures.forEach((structure) => {
-            if (!includePositionAssignments)
-                delete structure.positionAssignments;
-            structure.sourceStructuresComplete = structure.sourceStructureIds?.every((id) => completedStructures[id]);
-        });
-        return structures;
-    });
-    const structures = groupedStructures.flat();
-    drawInfo.drawActive = drawActive;
-    drawInfo.participantPlacements = participantPlacements;
-    drawInfo.drawGenerated = structures?.reduce((generated, structure) => {
-        return generated || !!structure?.roundMatchUps;
-    }, false);
-    drawInfo.drawCompleted = structures?.reduce((completed, structure) => completed && structure.structureCompleted, true);
-    drawInfo.drawPublished = usePublishState
-        ? eventPublished && getDrawIsPublished({ publishStatus, drawId: drawInfo.drawId })
-        : undefined;
-    return {
-        structures: !usePublishState || drawInfo.drawPublished
-            ? noDeepCopy
-                ? structures
-                : makeDeepCopy(structures, false, true)
-            : undefined,
-        drawInfo: noDeepCopy ? drawInfo : makeDeepCopy(drawInfo, false, true),
-        ...SUCCESS,
-    };
-}
-
-function getEventData(params) {
-    const { includePositionAssignments, tournamentRecord: t, participantsProfile, policyDefinitions, usePublishState, status = PUBLIC, sortConfig, event: e, } = params;
-    const tournamentRecord = makeDeepCopy(t, false, true);
-    const event = makeDeepCopy(e, false, true);
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!event)
-        return { error: MISSING_EVENT };
-    const { eventId } = event;
-    const { tournamentId, endDate } = tournamentRecord;
-    const publishStatus = getEventPublishStatus({ event, status });
-    const publishState = getPublishState({ event }).publishState ?? {};
-    const eventPublished = !!publishState?.status?.published;
-    const { participants: tournamentParticipants } = getParticipants({
-        withGroupings: true,
-        withEvents: false,
-        withDraws: false,
-        policyDefinitions,
-        ...participantsProfile,
-        tournamentRecord,
-    });
-    const stageFilter = ({ stage, drawId }) => {
-        if (!usePublishState)
-            return true;
-        const stageDetails = publishStatus?.drawDetails?.[drawId]?.stageDetails;
-        if (!stageDetails || !Object.keys(stageDetails).length)
-            return true;
-        return stageDetails[stage]?.published;
-    };
-    const structureFilter = ({ structureId, drawId }) => {
-        if (!usePublishState)
-            return true;
-        const structureDetails = publishStatus?.drawDetails?.[drawId]?.structureDetails;
-        if (!structureDetails || !Object.keys(structureDetails).length)
-            return true;
-        return structureDetails[structureId]?.published;
-    };
-    const drawFilter = ({ drawId }) => (!usePublishState ? true : getDrawIsPublished({ publishStatus, drawId }));
-    const roundLimitMapper = ({ drawId, structure }) => {
-        if (!usePublishState)
-            return structure;
-        const roundLimit = publishStatus?.drawDetails?.[drawId]?.structureDetails?.[structure.structureId]?.roundLimit;
-        if (isConvertableInteger(roundLimit)) {
-            const roundNumbers = generateRange(1, roundLimit + 1);
-            const roundMatchUps = {};
-            const roundProfile = {};
-            for (const roundNumber of roundNumbers) {
-                if (structure.roundMatchUps[roundNumber]) {
-                    roundMatchUps[roundNumber] = structure.roundMatchUps[roundNumber];
-                    roundProfile[roundNumber] = structure.roundProfile[roundNumber];
-                }
-            }
-            structure.roundMatchUps = roundMatchUps;
-            structure.roundProfile = roundProfile;
-        }
-        return structure;
-    };
-    const drawDefinitions = event.drawDefinitions || [];
-    const drawsData = !usePublishState || eventPublished
-        ? drawDefinitions
-            .filter(drawFilter)
-            .map((drawDefinition) => (({ drawInfo, structures }) => ({
-            ...drawInfo,
-            structures,
-        }))(getDrawData({
-            allParticipantResults: params.allParticipantResults,
-            context: { eventId, tournamentId, endDate },
-            includePositionAssignments,
-            tournamentParticipants,
-            noDeepCopy: true,
-            policyDefinitions,
-            tournamentRecord,
-            usePublishState,
-            drawDefinition,
-            publishStatus,
-            sortConfig,
-            event,
-        })))
-            .map(({ structures, ...drawData }) => {
-            const filteredStructures = structures
-                ?.filter(({ stage, structureId }) => structureFilter({ structureId, drawId: drawData.drawId }) &&
-                stageFilter({ stage, drawId: drawData.drawId }))
-                .map((structure) => roundLimitMapper({ drawId: drawData.drawId, structure }));
-            return {
-                ...drawData,
-                structures: filteredStructures,
-            };
-        })
-            .filter((drawData) => drawData.structures?.length)
-        : undefined;
-    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
-    const venues = tournamentRecord.venues || [];
-    const venuesData = venues.map((venue) => (({ venueData }) => ({
-        ...venueData,
-    }))(getVenueData({
-        tournamentRecord,
-        venueId: venue.venueId,
-    })));
-    const eventInfo = (({ eventId, eventName, eventType, eventLevel, surfaceCategory, matchUpFormat, category, gender, startDate, endDate, ballType, discipline, }) => ({
-        eventId,
-        eventName,
-        eventType,
-        eventLevel,
-        surfaceCategory,
-        matchUpFormat,
-        category,
-        gender,
-        startDate,
-        endDate,
-        ballType,
-        discipline,
-    }))(event);
-    const eventData = {
-        tournamentInfo,
-        venuesData,
-        eventInfo,
-        drawsData,
-    };
-    eventData.eventInfo.publishState = publishState;
-    eventData.eventInfo.published = publishState?.status?.published;
-    return { ...SUCCESS, eventData, participants: tournamentParticipants };
-}
-
 function publishEvent(params) {
     const { includePositionAssignments, removePriorValues, tournamentRecord, status = PUBLIC, event, drawIdsToRemove, drawIdsToAdd, } = params;
     if (!tournamentRecord)
@@ -38731,7 +38811,6 @@ var index$c = {
     addFlight: addFlight,
     assignSeedPositions: assignSeedPositions,
     attachFlightProfile: attachFlightProfile,
-    bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
     categoryCanContain: categoryCanContain,
     deleteDrawDefinitions: deleteDrawDefinitions,
     deleteEvents: deleteEvents,
@@ -38749,7 +38828,7 @@ var index$c = {
     modifyEventMatchUpFormatTiming: modifyEventMatchUpFormatTiming,
     modifyPairAssignment: modifyPairAssignment,
     mutate: mutate$8,
-    query: query$3,
+    query: query$2,
     refreshEventDrawOrder: refreshEventDrawOrder,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeScaleValues: removeScaleValues,
@@ -43948,7 +44027,7 @@ var index$9 = {
     matchUpActions: matchUpActions,
     mutate: mutate$7,
     participantScheduledMatchUps: participantScheduledMatchUps,
-    query: query$5,
+    query: query$4,
     removeDelegatedOutcome: removeDelegatedOutcome,
     removeMatchUpSideParticipant: removeMatchUpSideParticipant,
     removeTieMatchUpParticipantId: removeTieMatchUpParticipantId,
@@ -45537,22 +45616,40 @@ function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime'
         matchUpFilters: { scheduledDates },
         tournamentRecord,
     }).matchUps ?? [];
-    const relevantMatchUpIds = inContextMatchUps
-        .filter((matchUp) => matchUp.matchUpStatus &&
-        !ignoreMatchUpStatuses.includes(matchUp.matchUpStatus) &&
-        hasSchedule({ schedule: matchUp.schedule, scheduleAttributes }) &&
-        (!venueIds?.length || venueIds.includes(matchUp.schedule.venueId)))
-        .map(getMatchUpId);
-    const matchUps = allTournamentMatchUps({
-        tournamentRecord,
-        inContext: false,
-    }).matchUps ?? [];
+    const drawMatchUpIds = {};
+    inContextMatchUps.forEach(({ matchUpStatus, schedule, drawId, matchUpId }) => {
+        if ((!matchUpStatus || !ignoreMatchUpStatuses.includes(matchUpStatus)) &&
+            hasSchedule({ schedule, scheduleAttributes }) &&
+            (!venueIds?.length || venueIds.includes(schedule.venueId))) {
+            if (!drawMatchUpIds[drawId])
+                drawMatchUpIds[drawId] = [];
+            drawMatchUpIds[drawId].push(matchUpId);
+        }
+    });
+    const tournamentId = tournamentRecord.tournamentId;
     let clearedScheduleCount = 0;
-    for (const matchUp of matchUps) {
-        if (relevantMatchUpIds.includes(matchUp.matchUpId)) {
-            matchUp.timeItems = (matchUp.timeItems ?? []).filter((timeItem) => timeItem?.itemType &&
-                ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType));
-            clearedScheduleCount += 1;
+    for (const drawId in drawMatchUpIds) {
+        const { event, drawDefinition } = findEvent({ tournamentRecord, drawId });
+        const drawMatchUps = allDrawMatchUps({ drawDefinition, matchUpFilters: { matchUpIds: drawMatchUpIds[drawId] } }).matchUps ?? [];
+        for (const matchUp of drawMatchUps) {
+            let modified = false;
+            matchUp.timeItems = (matchUp.timeItems ?? []).filter((timeItem) => {
+                const preserve = timeItem?.itemType &&
+                    ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType);
+                if (!preserve)
+                    modified = true;
+                return preserve;
+            });
+            if (modified) {
+                modifyMatchUpNotice({
+                    context: 'clear schedules',
+                    eventId: event?.eventId,
+                    drawDefinition,
+                    tournamentId,
+                    matchUp,
+                });
+                clearedScheduleCount += 1;
+            }
         }
     }
     return { ...SUCCESS, clearedScheduleCount };
@@ -50684,73 +50781,6 @@ var mutate$4 = {
     unPublishOrderOfPlay: unPublishOrderOfPlay
 };
 
-function getAllEventData({ tournamentRecord, policyDefinitions }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    const events = tournamentRecord.events || [];
-    const tournamentParticipants = tournamentRecord?.participants || [];
-    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
-    const { venues: venuesData } = getVenuesAndCourts({
-        tournamentRecord,
-    });
-    const eventsData = events.map((event) => {
-        const { eventId } = event;
-        const eventInfo = extractEventInfo({ event }).eventInfo;
-        const scheduleTiming = getScheduleTiming({
-            tournamentRecord,
-            event,
-        }).scheduleTiming;
-        const drawsData = (event.drawDefinitions || []).map((drawDefinition) => {
-            const drawInfo = (({ drawId, drawName, matchUpFormat, updatedAt }) => ({
-                matchUpFormat,
-                updatedAt,
-                drawName,
-                drawId,
-            }))(drawDefinition);
-            const { abandonedMatchUps, completedMatchUps, upcomingMatchUps, pendingMatchUps } = getDrawMatchUps({
-                requireParticipants: true,
-                tournamentParticipants,
-                context: { eventId },
-                policyDefinitions,
-                tournamentRecord,
-                inContext: true,
-                scheduleTiming,
-                drawDefinition,
-                event,
-            });
-            return {
-                drawInfo,
-                matchUps: {
-                    abandonedMatchUps,
-                    completedMatchUps,
-                    upcomingMatchUps,
-                    pendingMatchUps,
-                },
-            };
-        });
-        const publish = getEventPublishStatus({ event });
-        Object.assign(eventInfo, {
-            drawsData,
-            publish,
-        });
-        return eventInfo;
-    });
-    const allEventData = { tournamentInfo, venuesData, eventsData };
-    return { allEventData };
-}
-
-var query = {
-    __proto__: null,
-    bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
-    getAllEventData: getAllEventData,
-    getCourtInfo: getCourtInfo,
-    getDrawData: getDrawData,
-    getEventData: getEventData,
-    getEventPublishStatus: getEventPublishStatus,
-    getPublishState: getPublishState,
-    getVenueData: getVenueData
-};
-
 var index$7 = {
     __proto__: null,
     bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
@@ -50765,7 +50795,7 @@ var index$7 = {
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
-    query: query,
+    query: query$7,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
@@ -52663,7 +52693,7 @@ var index$5 = {
     proAutoSchedule: proAutoSchedule,
     proConflicts: proConflicts,
     publicFindCourt: publicFindCourt,
-    query: query$7,
+    query: query$6,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,
@@ -54490,13 +54520,18 @@ function updateCourtAvailability({ tournamentRecord }) {
     return { ...SUCCESS };
 }
 
-function setTournamentDates({ tournamentRecord, startDate, endDate }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if ((startDate && !dateValidation.test(startDate)) || (endDate && !dateValidation.test(endDate)))
-        return { error: INVALID_DATE };
-    if (!startDate && !endDate)
-        return { error: MISSING_DATE };
+function setTournamentDates(params) {
+    const { tournamentRecord, startDate, endDate } = params;
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true },
+        {
+            [ANY_OF]: { startDate: false, endDate: false },
+            [INVALID]: INVALID_DATE,
+            [VALIDATE]: (value) => dateValidation.test(value),
+        },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
     if (endDate && startDate && new Date(endDate) < new Date(startDate))
         return { error: INVALID_VALUES };
     let checkScheduling;
@@ -54504,10 +54539,20 @@ function setTournamentDates({ tournamentRecord, startDate, endDate }) {
         (endDate && tournamentRecord.endDate && new Date(endDate) < new Date(tournamentRecord.endDate))) {
         checkScheduling = true;
     }
+    const initialDateRange = generateDateRange(tournamentRecord.startDate, tournamentRecord.endDate);
     if (startDate)
         tournamentRecord.startDate = startDate;
     if (endDate)
         tournamentRecord.endDate = endDate;
+    const resultingDateRange = generateDateRange(tournamentRecord.startDate, tournamentRecord.endDate);
+    const datesRemoved = initialDateRange.filter((date) => !resultingDateRange.includes(date));
+    const datesAdded = resultingDateRange.filter((date) => !initialDateRange.includes(date));
+    for (const event of tournamentRecord.events ?? []) {
+        if (startDate && event.startDate && new Date(startDate) > new Date(event.startDate))
+            event.startDate = startDate;
+        if (endDate && event.endDate && new Date(endDate) < new Date(event.endDate))
+            event.endDate = endDate;
+    }
     if (startDate && tournamentRecord.endDate && new Date(startDate) > new Date(tournamentRecord.endDate)) {
         tournamentRecord.endDate = startDate;
     }
@@ -54520,7 +54565,7 @@ function setTournamentDates({ tournamentRecord, startDate, endDate }) {
         topic: MODIFY_TOURNAMENT_DETAIL,
         payload: { startDate, endDate },
     });
-    return { ...SUCCESS, unscheduledMatchUpIds };
+    return { ...SUCCESS, unscheduledMatchUpIds, datesAdded, datesRemoved };
 }
 function setTournamentStartDate({ tournamentRecord, startDate }) {
     return setTournamentDates({ tournamentRecord, startDate });
@@ -55333,7 +55378,7 @@ var index$2 = {
     modifyVenue: modifyVenue,
     mutate: mutate,
     publicFindVenue: publicFindVenue,
-    query: query$4
+    query: query$3
 };
 
 var governors = {