tods-competition-factory 2.0.21 → 2.0.23

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

@@ -3,7 +3,517 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.21';
+    return '2.0.23';
+}
+
+const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
+const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
+const dateValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))([ T](0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
+const timeValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))?([ T]?(0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
+
+function getIsoDateString(schedule) {
+    let { scheduledDate } = schedule;
+    if (!scheduledDate && schedule.scheduledTime)
+        scheduledDate = extractDate(schedule.scheduledTime);
+    if (!scheduledDate)
+        return;
+    const extractedTime = extractTime(schedule.scheduledTime);
+    let isoDateString = extractDate(scheduledDate);
+    if (isoDateString && extractedTime)
+        isoDateString += `T${extractedTime}`;
+    return isoDateString;
+}
+function isDateObject(value) {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    else {
+        const datePrototype = Object.prototype.toString.call(value);
+        return datePrototype === '[object Date]';
+    }
+}
+function validTimeValue(value) {
+    const spaceSplit = typeof value === 'string' ? value?.split(' ') : [];
+    if (value && spaceSplit?.length > 1 && !['AM', 'PM'].includes(spaceSplit[1].toUpperCase()))
+        return false;
+    return !!(!value || timeValidation.test(convertTime(value, true, true)));
+}
+function isValidDateString(scheduleDate) {
+    return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
+}
+function DateHHMM(date) {
+    const dt = new Date(date);
+    const secs = dt.getSeconds() + 60 * dt.getMinutes() + 60 * 60 * dt.getHours();
+    return HHMMSS(secs, { displaySeconds: false });
+}
+function HHMMSS(s, format) {
+    const secondNumber = parseInt(s, 10);
+    const hours = Math.floor(secondNumber / 3600);
+    const minutes = Math.floor((secondNumber - hours * 3600) / 60);
+    const seconds = secondNumber - hours * 3600 - minutes * 60;
+    const displaySeconds = !format || format?.displaySeconds;
+    const timeString = displaySeconds ? hours + ':' + minutes + ':' + seconds : hours + ':' + minutes;
+    return timeString.split(':').map(zeroPad).join(':');
+}
+const getUTCdateString = (date) => {
+    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
+    const monthNumber = dateDate.getUTCMonth() + 1;
+    const utcMonth = monthNumber < 10 ? `0${monthNumber}` : `${monthNumber}`;
+    return `${dateDate.getUTCFullYear()}-${zeroPad(utcMonth)}-${zeroPad(dateDate.getUTCDate())}`;
+};
+function timeUTC(date) {
+    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
+    return Date.UTC(dateDate.getFullYear(), dateDate.getMonth(), dateDate.getDate());
+}
+function formatDate(date, separator = '-', format = 'YMD') {
+    if (!date)
+        return '';
+    if (typeof date === 'string' && date.indexOf('T') < 0)
+        date = date + 'T00:00';
+    const d = new Date(date);
+    let month = '' + (d.getMonth() + 1);
+    let day = '' + d.getDate();
+    const year = d.getFullYear();
+    if (month.length < 2)
+        month = '0' + month;
+    if (day.length < 2)
+        day = '0' + day;
+    if (format === 'DMY')
+        return [day, month, year].join(separator);
+    if (format === 'MDY')
+        return [month, day, year].join(separator);
+    if (format === 'YDM')
+        return [year, day, month].join(separator);
+    if (format === 'DYM')
+        return [day, year, month].join(separator);
+    if (format === 'MYD')
+        return [month, year, day].join(separator);
+    return [year, month, day].join(separator);
+}
+function offsetDate(date) {
+    const targetTime = date ? new Date(date) : new Date();
+    const tzDifference = targetTime.getTimezoneOffset();
+    return new Date(targetTime.getTime() - tzDifference * 60 * 1000);
+}
+function offsetTime(date) {
+    return offsetDate(date).getTime();
+}
+function isDate(dateArg) {
+    if (typeof dateArg == 'boolean')
+        return false;
+    const t = (dateArg instanceof Date && dateArg) || (!isNaN(dateArg) && new Date(dateArg)) || false;
+    return t && !isNaN(t.valueOf());
+}
+function generateDateRange(startDt, endDt) {
+    if (!isValidDateString(startDt) || !isValidDateString(endDt))
+        return [];
+    const startDateString = extractDate(startDt) + 'T00:00';
+    const endDateString = extractDate(endDt) + 'T00:00';
+    const startDate = new Date(startDateString);
+    const endDate = new Date(endDateString);
+    const process = isDate(endDate) && isDate(startDate) && isValidDateRange(startDate, endDate);
+    const between = [];
+    let iterations = 0;
+    if (process) {
+        const currentDate = startDate;
+        let dateSecs = currentDate.getTime();
+        while (dateSecs <= endDate.getTime() && iterations < 300) {
+            iterations += 1;
+            between.push(new Date(currentDate));
+            dateSecs = currentDate.setDate(currentDate.getDate() + 1);
+        }
+    }
+    return between.map((date) => formatDate(date));
+    function isValidDateRange(minDate, maxDate) {
+        return minDate <= maxDate;
+    }
+}
+const re = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function isISODateString(dateString) {
+    if (typeof dateString !== 'string')
+        return false;
+    return re.test(dateString);
+}
+function isTimeString(timeString) {
+    if (typeof timeString !== 'string')
+        return false;
+    const noZ = timeString.split('Z')[0];
+    const parts = noZ.split(':');
+    const isNumeric = parts.every((part) => !isNaN(parseInt(part)));
+    const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
+    return !invalid;
+}
+function timeStringMinutes(timeString) {
+    const validTimeString = extractTime(timeString);
+    if (!validTimeString)
+        return 0;
+    const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
+    return hours * 60 + minutes;
+}
+function dayMinutesToTimeString(totalMinutes) {
+    let hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes - hours * 60;
+    if (hours > 23)
+        hours = hours % 24;
+    return [zeroPad(hours), zeroPad(minutes)].join(':');
+}
+function tidyTime(timeString) {
+    return isTimeString(timeString) ? timeString.split(':').slice(0, 2).map(zeroPad).join(':') : undefined;
+}
+function extractTime(dateString) {
+    return isISODateString(dateString) && dateString.indexOf('T') > 0
+        ? tidyTime(dateString.split('T').reverse()[0])
+        : tidyTime(dateString);
+}
+function extractDate(dateString) {
+    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : undefined;
+}
+function dateStringDaysChange(dateString, daysChange) {
+    const date = new Date(dateString);
+    date.setDate(date.getDate() + daysChange);
+    return extractDate(date.toISOString());
+}
+function splitTime(value) {
+    value = typeof value !== 'string' ? '00:00' : value;
+    const o = {}, time = {};
+    ({ 0: o.time, 1: o.ampm } = value.split(' ') || []);
+    ({ 0: time.hours, 1: time.minutes } = o.time.split(':') || []);
+    time.ampm = o.ampm;
+    if (isNaN(time.hours) || isNaN(time.minutes) || (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
+        return {};
+    return time;
+}
+function militaryTime(value) {
+    const time = splitTime(value);
+    if (time.ampm && time.hours) {
+        if (time.ampm.toLowerCase() === 'pm' && parseInt(time.hours) < 12)
+            time.hours = ((time.hours && parseInt(time.hours)) || 0) + 12;
+        if (time.ampm.toLowerCase() === 'am' && time.hours === '12')
+            time.hours = '00';
+    }
+    const timeString = `${time.hours || '12'}:${time.minutes || '00'}`;
+    return timeString.split(':').map(zeroPad).join(':');
+}
+function regularTime(value) {
+    const time = splitTime(value);
+    if (typeof time === 'object' && !Object.keys(time).length)
+        return undefined;
+    if (time.ampm)
+        return value;
+    if (time.hours > 12) {
+        time.hours -= 12;
+        time.ampm = 'PM';
+    }
+    else if (time.hours === '12') {
+        time.ampm = 'PM';
+    }
+    else if (time.hours === '00') {
+        time.hours = '12';
+        time.ampm = 'AM';
+    }
+    else {
+        time.ampm = 'AM';
+    }
+    if (time.hours?.[0] === '0') {
+        time.hours = time.hours.slice(1);
+    }
+    return `${time.hours || '12'}:${time.minutes || '00'} ${time.ampm}`;
+}
+function convertTime(value, time24, keepDate) {
+    const hasDate = extractDate(value);
+    const timeString = extractTime(value);
+    const timeValue = hasDate ? timeString : value;
+    return !value
+        ? undefined
+        : (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue);
+}
+function timeSort(a, b) {
+    const as = splitTime(a);
+    const bs = splitTime(b);
+    if (parseInt(as.hours) < parseInt(bs.hours))
+        return -1;
+    if (parseInt(as.hours) > parseInt(bs.hours))
+        return 1;
+    if (as.hours === bs.hours) {
+        if (parseInt(as.minutes) < parseInt(bs.minutes))
+            return -1;
+        if (parseInt(as.minutes) > parseInt(bs.minutes))
+            return 1;
+    }
+    return 0;
+}
+function addDays(date, days = 7) {
+    const universalDate = extractDate(date) + 'T00:00';
+    const now = new Date(universalDate);
+    const adjustedDate = new Date(now.setDate(now.getDate() + days));
+    return formatDate(adjustedDate);
+}
+function addWeek(date) {
+    return addDays(date);
+}
+function getDateByWeek(week, year, dateFormat, sunday = false) {
+    const date = new Date(year, 0, 1 + (week - 1) * 7);
+    const startValue = sunday ? 0 : 1;
+    date.setDate(date.getDate() + (startValue - date.getDay()));
+    return formatDate(date, dateFormat);
+}
+function dateFromDay(year, day, dateFormat) {
+    const date = new Date(year, 0);
+    return formatDate(new Date(date.setDate(day)), dateFormat);
+}
+function timeToDate(timeString, date = undefined) {
+    const [hours, minutes] = (timeString || '00:00').split(':').map(zeroPad);
+    const milliseconds = offsetDate(date).setHours(hours, minutes, 0, 0);
+    return offsetDate(milliseconds);
+}
+function minutesDifference(date1, date2, absolute = true) {
+    const dt1 = new Date(date1);
+    const dt2 = new Date(date2);
+    const diff = (dt2.getTime() - dt1.getTime()) / 1000 / 60;
+    return absolute ? Math.abs(Math.round(diff)) : Math.round(diff);
+}
+function addMinutesToTimeString(timeString, minutes) {
+    const validTimeString = extractTime(timeString);
+    if (!validTimeString)
+        return '00:00';
+    const minutesToAdd = isNaN(minutes) ? 0 : minutes;
+    return extractTime(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
+}
+function addMinutes(startDate, minutes) {
+    const date = new Date(startDate);
+    return new Date(date.getTime() + minutes * 60000);
+}
+function zeroPad(number) {
+    return number.toString()[1] ? number : '0' + number;
+}
+function sameDay(date1, date2) {
+    const d1 = new Date(date1);
+    const d2 = new Date(date2);
+    return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
+}
+const dateTime = {
+    addDays,
+    addWeek,
+    addMinutesToTimeString,
+    convertTime,
+    getIsoDateString,
+    getUTCdateString,
+    DateHHMM,
+    extractDate,
+    extractTime,
+    formatDate,
+    getDateByWeek,
+    isISODateString,
+    isDate,
+    isTimeString,
+    offsetDate,
+    offsetTime,
+    sameDay,
+    timeStringMinutes,
+    timeToDate,
+    timeUTC,
+    validTimeValue,
+    validDateString,
+    timeValidation,
+    dateValidation,
+};
+
+function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
+    if (getProvider().makeDeepCopy)
+        return getProvider().makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions);
+    const deepCopy = deepCopyEnabled();
+    const { stringify, toJSON, ignore, modulate } = deepCopy || {};
+    if ((!deepCopy?.enabled && !internalUse) ||
+        typeof sourceObject !== 'object' ||
+        typeof sourceObject === 'function' ||
+        sourceObject === null ||
+        (typeof deepCopy?.threshold === 'number' && iteration >= deepCopy.threshold)) {
+        return sourceObject;
+    }
+    const targetObject = Array.isArray(sourceObject) ? [] : {};
+    const sourceObjectKeys = Object.keys(sourceObject).filter((key) => !internalUse ||
+        !ignore ||
+        (Array.isArray(ignore) && !ignore.includes(key)) ||
+        (typeof ignore === 'function' && !ignore(key)));
+    const stringifyValue = (key, value) => {
+        targetObject[key] = typeof value?.toString === 'function' ? value.toString() : JSON.stringify(value);
+    };
+    for (const key of sourceObjectKeys) {
+        const value = sourceObject[key];
+        const modulated = typeof modulate === 'function' ? modulate(value) : undefined;
+        if (modulated !== undefined) {
+            targetObject[key] = modulated;
+        }
+        else if (convertExtensions && key === 'extensions' && Array.isArray(value)) {
+            const extensionConversions = extensionsToAttributes(value);
+            Object.assign(targetObject, ...extensionConversions);
+        }
+        else if (removeExtensions && key === 'extensions') {
+            targetObject[key] = [];
+        }
+        else if (Array.isArray(stringify) && stringify.includes(key)) {
+            stringifyValue(key, value);
+        }
+        else if (Array.isArray(toJSON) && toJSON.includes(key) && typeof value?.toJSON === 'function') {
+            targetObject[key] = value.toJSON();
+        }
+        else if (value === null) {
+            targetObject[key] = undefined;
+        }
+        else if (isDateObject(value)) {
+            targetObject[key] = new Date(value).toISOString();
+        }
+        else {
+            targetObject[key] = makeDeepCopy(value, convertExtensions, internalUse, removeExtensions, iteration + 1);
+        }
+    }
+    return targetObject;
+}
+function extensionsToAttributes(extensions) {
+    return extensions
+        ?.map((extension) => {
+        const { name, value } = extension;
+        return name && value && { [`_${name}`]: value };
+    })
+        .filter(Boolean);
+}
+
+function getAccessorValue({ element, accessor }) {
+    if (typeof accessor !== 'string')
+        return { values: [] };
+    const targetElement = makeDeepCopy(element);
+    const attributes = accessor.split('.');
+    const values = [];
+    let value;
+    processKeys({ targetElement, attributes });
+    const result = { value };
+    if (values.length)
+        result.values = values;
+    return result;
+    function processKeys({ targetElement, attributes = [], significantCharacters }) {
+        for (const [index, attribute] of attributes.entries()) {
+            if (targetElement?.[attribute]) {
+                const remainingKeys = attributes.slice(index + 1);
+                if (!remainingKeys.length) {
+                    if (!value)
+                        value = targetElement[attribute];
+                    if (!values.includes(targetElement[attribute])) {
+                        values.push(targetElement[attribute]);
+                    }
+                }
+                else if (Array.isArray(targetElement[attribute])) {
+                    const values = targetElement[attribute];
+                    values.forEach((nestedTarget) => processKeys({
+                        targetElement: nestedTarget,
+                        attributes: remainingKeys,
+                    }));
+                }
+                else {
+                    targetElement = targetElement[attribute];
+                    checkValue({ targetElement, index });
+                }
+            }
+        }
+        function checkValue({ targetElement, index }) {
+            if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
+                const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
+                if (value) {
+                    if (!values.includes(extractedValue)) {
+                        values.push(extractedValue);
+                    }
+                }
+                else {
+                    value = extractedValue;
+                    values.push(extractedValue);
+                }
+            }
+        }
+    }
+}
+
+function isFunction(obj) {
+    return typeof obj === 'function';
+}
+function isString(obj) {
+    return typeof obj === 'string';
+}
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
+}
+function objShallowEqual(o1, o2) {
+    if (!isObject(o1) || !isObject(o2))
+        return false;
+    const keys1 = Object.keys(o1);
+    const keys2 = Object.keys(o2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (o1[key] !== o2[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+function createMap(objectArray, attribute) {
+    if (!Array.isArray(objectArray))
+        return {};
+    return Object.assign({}, ...(objectArray ?? [])
+        .filter(isObject)
+        .map((obj) => {
+        return (obj[attribute] && {
+            [obj[attribute]]: obj,
+        });
+    })
+        .filter(Boolean));
+}
+const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] === a[key]);
+const extractAttributes = (accessor) => (element) => !accessor || typeof element !== 'object'
+    ? undefined
+    : (Array.isArray(accessor) &&
+        accessor.map((a) => ({
+            [a]: getAccessorValue({ element, accessor: a })?.value,
+        }))) ||
+        (typeof accessor === 'object' &&
+            Object.keys(accessor).map((key) => ({
+                [key]: getAccessorValue({ element, accessor: key })?.value,
+            }))) ||
+        (typeof accessor === 'string' && getAccessorValue({ element, accessor }))?.value;
+const xa = extractAttributes;
+function undefinedToNull(obj, shallow) {
+    if (obj === undefined)
+        return null;
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    const definedKeys = Object.keys(obj);
+    const notNull = (value) => (value === undefined ? null : value);
+    return Object.assign({}, ...definedKeys.map((key) => {
+        return Array.isArray(obj[key])
+            ? {
+                [key]: shallow ? obj[key] : obj[key].map((m) => undefinedToNull(m)),
+            }
+            : { [key]: shallow ? notNull(obj[key]) : undefinedToNull(obj[key]) };
+    }));
+}
+function countKeys(o) {
+    if (Array.isArray(o)) {
+        return o.length + o.map(countKeys).reduce((a, b) => a + b, 0);
+    }
+    else if (typeof o === 'object' && o !== null) {
+        return (Object.keys(o).length +
+            Object.keys(o)
+                .map((k) => countKeys(o[k]))
+                .reduce((a, b) => a + b, 0));
+    }
+    return 0;
+}
+function generateHashCode(o) {
+    if (o === null || typeof o !== 'object')
+        return undefined;
+    const str = JSON.stringify(o);
+    const keyCount = countKeys(o);
+    const charSum = str.split('').reduce((a, b) => a + b.charCodeAt(0), 0);
+    return [str.length, keyCount, charSum].map((e) => e.toString(36)).join('');
 }
 
 const SUCCESS = { success: true };
@@ -1012,6 +1522,8 @@ function setSubscriptions$1(params) {
     return { ...SUCCESS };
 }
 function setMethods$1(params) {
+    if (typeof params !== 'object')
+        return { error: INVALID_VALUES };
     Object.keys(params).forEach((methodName) => {
         if (typeof params[methodName] !== 'function')
             return;
@@ -1024,15 +1536,13 @@ function cycleMutationStatus$1() {
     syncGlobalState.modified = false;
     return status;
 }
-function addNotice$1({ topic, payload, key }) {
-    if (typeof topic !== 'string' || typeof payload !== 'object') {
+function addNotice$1({ topic, payload, key }, isGlobalSubscription) {
+    if (typeof topic !== 'string' || typeof payload !== 'object')
         return;
-    }
     if (!syncGlobalState.disableNotifications)
         syncGlobalState.modified = true;
-    if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic]) {
+    if (syncGlobalState.disableNotifications || (!syncGlobalState.subscriptions[topic] && !isGlobalSubscription))
         return;
-    }
     if (key) {
         syncGlobalState.notices = syncGlobalState.notices.filter((notice) => !(notice.topic === topic && notice.key === key));
     }
@@ -1043,8 +1553,7 @@ function getMethods$1() {
     return syncGlobalState.methods ?? {};
 }
 function getNotices$1({ topic }) {
-    const notices = syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
-    return notices.length && notices;
+    return syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
 }
 function deleteNotices$1() {
     syncGlobalState.notices = [];
@@ -1056,11 +1565,13 @@ function getTopics$1() {
     const topics = Object.keys(syncGlobalState.subscriptions);
     return { topics };
 }
-function callListener$1({ topic, notices }) {
+function callListener$1({ topic, notices }, globalSubscriptions) {
     const method = syncGlobalState.subscriptions[topic];
-    if (method && typeof method === 'function') {
+    if (method && typeof method === 'function')
         method(notices);
-    }
+    const globalMethod = globalSubscriptions?.[topic];
+    if (globalMethod && typeof globalMethod === 'function')
+        globalMethod(notices);
 }
 function handleCaughtError$1({ engineName, methodName, params, err }) {
     let error;
@@ -1331,13 +1842,14 @@ function getMissingSequenceNumbers(arr, start = 1) {
 }
 
 const globalState = {
-    tournamentFactoryVersion: '0.0.0',
     timers: { default: { elapsedTime: 0 } },
+    globalSubscriptions: {},
     deepCopyAttributes: {
         stringify: [],
         ignore: [],
         toJSON: [],
     },
+    globalMethods: [],
     deepCopy: true,
 };
 let _globalStateProvider = syncGlobalState$1;
@@ -1491,12 +2003,30 @@ function deepCopyEnabled() {
         ...globalState.deepCopyAttributes,
     };
 }
+function setGlobalSubscriptions(params) {
+    if (!params?.subscriptions)
+        return { error: MISSING_VALUE, info: 'missing subscriptions' };
+    Object.keys(params.subscriptions).forEach((subscription) => {
+        globalState.globalSubscriptions[subscription] = params.subscriptions[subscription];
+    });
+    return { ...SUCCESS };
+}
 function setSubscriptions(params) {
     if (!params?.subscriptions)
         return { error: MISSING_VALUE, info: 'missing subscriptions' };
-    return _globalStateProvider.setSubscriptions({
-        subscriptions: params.subscriptions,
+    return _globalStateProvider.setSubscriptions({ subscriptions: params.subscriptions });
+}
+function setGlobalMethods(params) {
+    if (!params)
+        return { error: MISSING_VALUE, info: 'missing method declarations' };
+    if (typeof params !== 'object')
+        return { error: INVALID_VALUES };
+    Object.keys(params).forEach((methodName) => {
+        if (typeof params[methodName] !== 'function')
+            return;
+        globalState.globalMethods[methodName] = params[methodName];
     });
+    return { ...SUCCESS };
 }
 function setMethods(params) {
     if (!params)
@@ -1509,10 +2039,13 @@ function cycleMutationStatus() {
     return _globalStateProvider.cycleMutationStatus();
 }
 function addNotice(notice) {
-    return _globalStateProvider.addNotice(notice);
+    if (typeof notice?.topic !== 'string')
+        return;
+    const isGlobalSubscription = globalState.globalSubscriptions[notice.topic];
+    return _globalStateProvider.addNotice(notice, isGlobalSubscription);
 }
 function getMethods() {
-    return _globalStateProvider.getMethods();
+    return { ...globalState.globalMethods, ..._globalStateProvider.getMethods() };
 }
 function getNotices(params) {
     return _globalStateProvider.getNotices(params);
@@ -1527,7 +2060,7 @@ function getTopics() {
     return _globalStateProvider.getTopics();
 }
 async function callListener(payload) {
-    return _globalStateProvider.callListener(payload);
+    return _globalStateProvider.callListener(payload, globalState.globalSubscriptions);
 }
 function getTournamentId() {
     return _globalStateProvider.getTournamentId();
@@ -1578,6 +2111,29 @@ function globalLog$1(log, engine) {
         console.log(engine, log);
     }
 }
+function setStateMethods(submittedMethods, traverse, maxDepth, global) {
+    if (!isObject(submittedMethods))
+        return { error: INVALID_VALUES };
+    if (!isNumeric)
+        maxDepth = 1;
+    const collectionFilter = Array.isArray(traverse) ? traverse : [];
+    const methods = {};
+    const attrWalker = (obj, depth = 0) => {
+        Object.keys(obj).forEach((key) => {
+            if (isFunction(obj[key])) {
+                methods[key] = obj[key];
+            }
+            else if (isObject(obj[key]) &&
+                (traverse === true || collectionFilter?.includes(key)) &&
+                (maxDepth === undefined || depth < maxDepth)) {
+                attrWalker(obj[key], depth + 1);
+            }
+        });
+    };
+    attrWalker(submittedMethods);
+    global ? setGlobalMethods(methods) : setMethods(methods);
+    return { methods };
+}
 
 var globalState$1 = {
     __proto__: null,
@@ -1604,7 +2160,10 @@ var globalState$1 = {
     setDeepCopy: setDeepCopy,
     setDevContext: setDevContext,
     setGlobalLog: setGlobalLog,
+    setGlobalMethods: setGlobalMethods,
+    setGlobalSubscriptions: setGlobalSubscriptions,
     setMethods: setMethods,
+    setStateMethods: setStateMethods,
     setStateProvider: setStateProvider,
     setSubscriptions: setSubscriptions,
     setTournamentId: setTournamentId,
@@ -1653,1063 +2212,553 @@ function decorateResult({ context, result, stack, info }) {
     return result ?? { success: true };
 }
 
-const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
-const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
-const dateValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))([ T](0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
-const timeValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))?([ T]?(0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
+const TOURNAMENT_RECORDS = 'tournamentRecords';
+const POLICY_DEFINITIONS = 'policyDefinitions';
+const TOURNAMENT_RECORD = 'tournamentRecord';
+const DRAW_DEFINITION = 'drawDefinition';
+const MATCHUP_FORMAT = 'matchUpFormat';
+const PARTICIPANT_ID = 'participantId';
+const SCHEDULE_DATES = 'scheduleDates';
+const TOURNAMENT_ID = 'tournamentId';
+const SCHEDULE_DATE = 'scheduleDate';
+const STRUCTURE_ID = 'structureId';
+const PARTICIPANT = 'participant';
+const MATCHUP_IDS = 'matchUpIds';
+const POLICY_TYPE = 'policyType';
+const STRUCTURES = 'structures';
+const MATCHUP_ID = 'matchUpId';
+const IN_CONTEXT = 'inContext';
+const STRUCTURE = 'structure';
+const COURT_IDS = 'courtIds';
+const PERSON_ID = 'personId';
+const VENUE_IDS = 'venueIds';
+const MATCHUPS = 'matchUps';
+const COURT_ID = 'courtId';
+const EVENT_ID = 'eventId';
+const MATCHUP = 'matchUp';
+const DRAW_ID = 'drawId';
+const ERROR = 'error';
+const EVENT = 'event';
+const PARAM = 'param';
+const UUIDS$1 = 'uuids';
+const AVERAGE_MATCHUP_MINUTES = 'averageMatchUpMinutes';
+const RECOVERY_MINUTES = 'recoveryMinutes';
+const PERIOD_LENGTH = 'periodLength';
+const OBJECT = 'object';
+const ARRAY = 'array';
+const VALIDATE = '_validate';
+const MESSAGE = '_message';
+const INVALID = '_invalid';
+const OF_TYPE = '_ofType';
+const ANY_OF = '_anyOf';
+const ONE_OF = '_oneOf';
 
-function getIsoDateString(schedule) {
-    let { scheduledDate } = schedule;
-    if (!scheduledDate && schedule.scheduledTime)
-        scheduledDate = extractDate(schedule.scheduledTime);
-    if (!scheduledDate)
-        return;
-    const extractedTime = extractTime(schedule.scheduledTime);
-    let isoDateString = extractDate(scheduledDate);
-    if (isoDateString && extractedTime)
-        isoDateString += `T${extractedTime}`;
-    return isoDateString;
-}
-function isDateObject(value) {
-    if (typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    else {
-        const datePrototype = Object.prototype.toString.call(value);
-        return datePrototype === '[object Date]';
-    }
-}
-function validTimeValue(value) {
-    const spaceSplit = typeof value === 'string' ? value?.split(' ') : [];
-    if (value && spaceSplit?.length > 1 && !['AM', 'PM'].includes(spaceSplit[1].toUpperCase()))
-        return false;
-    return !!(!value || timeValidation.test(convertTime(value, true, true)));
+const errors = {
+    [TOURNAMENT_RECORDS]: MISSING_TOURNAMENT_RECORDS,
+    [TOURNAMENT_RECORD]: MISSING_TOURNAMENT_RECORD,
+    [POLICY_DEFINITIONS]: MISSING_POLICY_DEFINITION,
+    [DRAW_DEFINITION]: MISSING_DRAW_DEFINITION,
+    [PARTICIPANT_ID]: MISSING_PARTICIPANT_ID,
+    [MATCHUP_FORMAT]: MISSING_MATCHUP_FORMAT,
+    [TOURNAMENT_ID]: MISSING_TOURNAMENT_ID,
+    [STRUCTURE_ID]: MISSING_STRUCTURE_ID,
+    [MATCHUP_IDS]: MISSING_MATCHUP_IDS,
+    [PARTICIPANT]: MISSING_PARTICIPANT,
+    [STRUCTURES]: MISSING_STRUCTURES,
+    [MATCHUP_ID]: MISSING_MATCHUP_ID,
+    [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]: MISSING_EVENT,
+};
+const paramTypes = {
+    [TOURNAMENT_RECORDS]: OBJECT,
+    [POLICY_DEFINITIONS]: OBJECT,
+    [TOURNAMENT_RECORD]: OBJECT,
+    [DRAW_DEFINITION]: OBJECT,
+    [SCHEDULE_DATES]: ARRAY,
+    [PARTICIPANT]: OBJECT,
+    [MATCHUP_IDS]: ARRAY,
+    [STRUCTURES]: ARRAY,
+    [STRUCTURE]: OBJECT,
+    [COURT_IDS]: ARRAY,
+    [VENUE_IDS]: ARRAY,
+    [MATCHUPS]: ARRAY,
+    [MATCHUP]: OBJECT,
+    [EVENT]: OBJECT,
+    [UUIDS$1]: ARRAY,
+};
+function checkRequiredParameters(params, requiredParams, stack) {
+    if (!params && !isObject(params))
+        return { error: INVALID_VALUES };
+    if (!requiredParams?.length || params?._bypassParamCheck)
+        return { valid: true };
+    if (!Array.isArray(requiredParams))
+        return { error: INVALID_VALUES };
+    const { paramError, errorParam } = findParamError(params, requiredParams);
+    if (!paramError)
+        return { valid: true };
+    const error = params?.[errorParam] === undefined
+        ? errors[errorParam] || INVALID_VALUES
+        : (paramError[VALIDATE] && paramError[INVALID]) || INVALID_VALUES;
+    const param = errorParam ?? (paramError[ONE_OF] && Object.keys(paramError[ONE_OF]).join(', '));
+    return decorateResult({
+        info: { param, message: paramError[MESSAGE] },
+        result: { error },
+        stack,
+    });
 }
-function isValidDateString(scheduleDate) {
-    return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
+function getIntersection(params, constraint) {
+    const paramKeys = Object.keys(params);
+    const constraintKeys = Object.keys(constraint);
+    return intersection(paramKeys, constraintKeys);
 }
-function DateHHMM(date) {
-    const dt = new Date(date);
-    const secs = dt.getSeconds() + 60 * dt.getMinutes() + 60 * 60 * dt.getHours();
-    return HHMMSS(secs, { displaySeconds: false });
+function getOneOf(params, _oneOf) {
+    if (!_oneOf)
+        return;
+    const overlap = getIntersection(params, _oneOf);
+    if (overlap.length !== 1)
+        return { error: INVALID_VALUES };
+    return overlap.reduce((attr, param) => ({ ...attr, [param]: true }), {});
 }
-function HHMMSS(s, format) {
-    const secondNumber = parseInt(s, 10);
-    const hours = Math.floor(secondNumber / 3600);
-    const minutes = Math.floor((secondNumber - hours * 3600) / 60);
-    const seconds = secondNumber - hours * 3600 - minutes * 60;
-    const displaySeconds = !format || format?.displaySeconds;
-    const timeString = displaySeconds ? hours + ':' + minutes + ':' + seconds : hours + ':' + minutes;
-    return timeString.split(':').map(zeroPad).join(':');
+function getAnyOf(params, _anyOf) {
+    if (!_anyOf)
+        return;
+    const overlap = getIntersection(params, _anyOf).filter((param) => params[param]);
+    if (overlap.length < 1)
+        return { error: INVALID_VALUES };
+    return overlap.reduce((attr, param) => ({ ...attr, [param]: true }), {});
 }
-const getUTCdateString = (date) => {
-    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
-    const monthNumber = dateDate.getUTCMonth() + 1;
-    const utcMonth = monthNumber < 10 ? `0${monthNumber}` : `${monthNumber}`;
-    return `${dateDate.getUTCFullYear()}-${zeroPad(utcMonth)}-${zeroPad(dateDate.getUTCDate())}`;
-};
-function timeUTC(date) {
-    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
-    return Date.UTC(dateDate.getFullYear(), dateDate.getMonth(), dateDate.getDate());
+function findParamError(params, requiredParams) {
+    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;
+        oneOf && Object.assign(attrs, oneOf);
+        const anyOf = _anyOf && getAnyOf(params, _anyOf);
+        if (anyOf?.error)
+            return anyOf.error;
+        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 paramNotPresent = attrs[param] && !params[param];
+            const invalid = invalidValidationFunction || faliedTypeCheck || paramNotPresent;
+            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, paramInfo };
 }
-function formatDate(date, separator = '-', format = 'YMD') {
-    if (!date)
-        return '';
-    if (typeof date === 'string' && date.indexOf('T') < 0)
-        date = date + 'T00:00';
-    const d = new Date(date);
-    let month = '' + (d.getMonth() + 1);
-    let day = '' + d.getDate();
-    const year = d.getFullYear();
-    if (month.length < 2)
-        month = '0' + month;
-    if (day.length < 2)
-        day = '0' + day;
-    if (format === 'DMY')
-        return [day, month, year].join(separator);
-    if (format === 'MDY')
-        return [month, day, year].join(separator);
-    if (format === 'YDM')
-        return [year, day, month].join(separator);
-    if (format === 'DYM')
-        return [day, year, month].join(separator);
-    if (format === 'MYD')
-        return [month, year, day].join(separator);
-    return [year, month, day].join(separator);
+function invalidType(params, param, _ofType) {
+    _ofType = _ofType || paramTypes[param] || 'string';
+    if (_ofType === 'array') {
+        return !Array.isArray(params[param]);
+    }
+    return typeof params[param] !== _ofType;
 }
-function offsetDate(date) {
-    const targetTime = date ? new Date(date) : new Date();
-    const tzDifference = targetTime.getTimezoneOffset();
-    return new Date(targetTime.getTime() - tzDifference * 60 * 1000);
+function checkValidation(value, validate) {
+    if (isFunction(validate))
+        return validate(value);
+    return true;
 }
-function offsetTime(date) {
-    return offsetDate(date).getTime();
+
+const SINGLES$1 = 'SINGLES';
+const SINGLES_EVENT = 'SINGLES';
+const DOUBLES$1 = 'DOUBLES';
+const DOUBLES_EVENT = 'DOUBLES';
+const TEAM$2 = 'TEAM';
+const TEAM_EVENT = 'TEAM';
+const AGE = 'AGE';
+const RATING$2 = 'RATING';
+const BOTH = 'BOTH';
+const eventConstants = {
+    AGE,
+    BOTH,
+    DOUBLES: DOUBLES$1,
+    DOUBLES_EVENT,
+    RATING: RATING$2,
+    SINGLES: SINGLES$1,
+    SINGLES_EVENT,
+    TEAM_EVENT,
+    TEAM: TEAM$2,
+};
+
+const DYNAMIC = 'DYNAMIC';
+const RANKING$1 = 'RANKING';
+const RATING$1 = 'RATING';
+const SCALE$1 = 'SCALE';
+const SEEDING$1 = 'SEEDING';
+const scaleConstants = {
+    RANKING: RANKING$1,
+    RATING: RATING$1,
+    SCALE: SCALE$1,
+    SEEDING: SEEDING$1,
+};
+
+function getScaleValues(params) {
+    const paramCheck = checkRequiredParameters(params, [{ [PARTICIPANT]: true }]);
+    if (paramCheck.error)
+        return paramCheck;
+    const scaleItems = params.participant.timeItems?.filter(({ itemType }) => itemType?.startsWith(SCALE$1) && [RANKING$1, RATING$1, SEEDING$1].includes(itemType.split('.')[1]));
+    const scales = { ratings: {}, rankings: {}, seedings: {} };
+    if (scaleItems?.length) {
+        const latestScaleItem = (scaleType) => scaleItems
+            .filter((timeItem) => timeItem?.itemType === scaleType)
+            .sort((a, b) => new Date(a.createdAt || undefined).getTime() - new Date(b.createdAt || undefined).getTime())
+            .pop();
+        const itemTypes = unique(scaleItems.map(({ itemType }) => itemType));
+        for (const itemType of itemTypes) {
+            const scaleItem = latestScaleItem(itemType);
+            if (scaleItem) {
+                const [, type, format, scaleName, modifier] = scaleItem.itemType.split('.');
+                const namedScale = modifier ? `${scaleName}.${modifier}` : scaleName;
+                const scaleType = (type === SEEDING$1 && 'seedings') || (type === RANKING$1 && 'rankings') || 'ratings';
+                if (!scales[scaleType][format])
+                    scales[scaleType][format] = [];
+                scales[scaleType][format].push({
+                    scaleValue: scaleItem.itemValue,
+                    scaleDate: scaleItem.itemDate,
+                    scaleName: namedScale,
+                });
+            }
+        }
+    }
+    return { ...SUCCESS, ...scales };
 }
-function isDate(dateArg) {
-    if (typeof dateArg == 'boolean')
-        return false;
-    const t = (dateArg instanceof Date && dateArg) || (!isNaN(dateArg) && new Date(dateArg)) || false;
-    return t && !isNaN(t.valueOf());
+
+function attributeFilter(params) {
+    if (params === null)
+        return {};
+    const { source, template } = params || {};
+    if (!template)
+        return source;
+    const target = {};
+    attributeCopy(source, template, target);
+    return target;
+    function attributeCopy(valuesObject, templateObject, outputObject) {
+        if (!valuesObject || !templateObject)
+            return undefined;
+        const vKeys = Object.keys(valuesObject);
+        const oKeys = Object.keys(templateObject);
+        const orMap = Object.assign({}, ...oKeys
+            .filter((key) => key.indexOf('||'))
+            .map((key) => key.split('||').map((or) => ({ [or]: key })))
+            .flat());
+        const allKeys = oKeys.concat(...Object.keys(orMap));
+        const wildcard = allKeys.includes('*');
+        for (const vKey of vKeys) {
+            if (allKeys.indexOf(vKey) >= 0 || wildcard) {
+                const templateKey = orMap[vKey] || vKey;
+                const tobj = templateObject[templateKey] || wildcard;
+                const vobj = valuesObject[vKey];
+                if (typeof tobj === 'object' && typeof vobj !== 'function' && !Array.isArray(tobj)) {
+                    if (Array.isArray(vobj)) {
+                        const mappedElements = vobj
+                            .map((arrayMember) => {
+                            const target = {};
+                            const result = attributeCopy(arrayMember, tobj, target);
+                            return result !== false ? target : undefined;
+                        })
+                            .filter(Boolean);
+                        outputObject[vKey] = mappedElements;
+                    }
+                    else if (vobj) {
+                        outputObject[vKey] = {};
+                        attributeCopy(vobj, tobj, outputObject[vKey]);
+                    }
+                }
+                else {
+                    const value = valuesObject[vKey];
+                    const exclude = Array.isArray(tobj) && !tobj.includes(value);
+                    if (exclude)
+                        return false;
+                    if (templateObject[vKey] || (wildcard && templateObject[vKey] !== false)) {
+                        outputObject[vKey] = value;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
 }
-function generateDateRange(startDt, endDt) {
-    if (!isValidDateString(startDt) || !isValidDateString(endDt))
-        return [];
-    const startDateString = extractDate(startDt) + 'T00:00';
-    const endDateString = extractDate(endDt) + 'T00:00';
-    const startDate = new Date(startDateString);
-    const endDate = new Date(endDateString);
-    const process = isDate(endDate) && isDate(startDate) && isValidDateRange(startDate, endDate);
-    const between = [];
-    let iterations = 0;
-    if (process) {
-        const currentDate = startDate;
-        let dateSecs = currentDate.getTime();
-        while (dateSecs <= endDate.getTime() && iterations < 300) {
-            iterations += 1;
-            between.push(new Date(currentDate));
-            dateSecs = currentDate.setDate(currentDate.getDate() + 1);
+
+const POLICY_TYPE_VOLUNTARY_CONSOLATION = 'voluntaryConsolation';
+const POLICY_TYPE_COMPETITIVE_BANDS = 'competitiveBands';
+const POLICY_TYPE_ROUND_ROBIN_TALLY = 'roundRobinTally';
+const POLICY_TYPE_POSITION_ACTIONS = 'positionActions';
+const POLICY_TYPE_MATCHUP_ACTIONS = 'matchUpActions';
+const POLICY_TYPE_RANKING_POINTS = 'rankingPoints';
+const POLICY_TYPE_ROUND_NAMING = 'roundNaming';
+const POLICY_TYPE_PARTICIPANT = 'participant';
+const POLICY_TYPE_PROGRESSION = 'progression';
+const POLICY_TYPE_SCHEDULING = 'scheduling';
+const POLICY_TYPE_AVOIDANCE = 'avoidance';
+const POLICY_TYPE_DISPLAY = 'display';
+const POLICY_TYPE_SCORING = 'scoring';
+const POLICY_TYPE_SEEDING = 'seeding';
+const POLICY_TYPE_FEED_IN = 'feedIn';
+const POLICY_TYPE_AUDIT = 'audit';
+const POLICY_TYPE_DRAWS = 'draws';
+const policyConstants = {
+    POLICY_TYPE_VOLUNTARY_CONSOLATION,
+    POLICY_TYPE_COMPETITIVE_BANDS,
+    POLICY_TYPE_ROUND_ROBIN_TALLY,
+    POLICY_TYPE_POSITION_ACTIONS,
+    POLICY_TYPE_MATCHUP_ACTIONS,
+    POLICY_TYPE_RANKING_POINTS,
+    POLICY_TYPE_ROUND_NAMING,
+    POLICY_TYPE_PARTICIPANT,
+    POLICY_TYPE_PROGRESSION,
+    POLICY_TYPE_SCHEDULING,
+    POLICY_TYPE_AVOIDANCE,
+    POLICY_TYPE_DISPLAY,
+    POLICY_TYPE_FEED_IN,
+    POLICY_TYPE_SCORING,
+    POLICY_TYPE_SEEDING,
+    POLICY_TYPE_AUDIT,
+    POLICY_TYPE_DRAWS,
+};
+
+function findParticipant({ tournamentParticipants = [], policyDefinitions = {}, contextProfile, participantId, internalUse, personId, }) {
+    const foundParticipant = tournamentParticipants.find((candidate) => (participantId && candidate.participantId === participantId) ||
+        (personId && candidate.person && candidate.person.personId === personId));
+    const participant = makeDeepCopy(foundParticipant, false, internalUse);
+    if (participant) {
+        const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
+        if (contextProfile?.withScaleValues) {
+            const { ratings, rankings } = getScaleValues({ participant });
+            participant.rankings = rankings;
+            participant.ratings = ratings;
+        }
+        if (participantAttributes?.participant) {
+            return attributeFilter({
+                template: participantAttributes.participant,
+                source: participant,
+            });
         }
     }
-    return between.map((date) => formatDate(date));
-    function isValidDateRange(minDate, maxDate) {
-        return minDate <= maxDate;
+    return participant;
+}
+
+const ELEMENT_REQUIRED = 'element required';
+const MISSING_NAME = 'missing name';
+
+function removeExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (params.element && typeof params?.element !== 'object')
+        return { error: INVALID_VALUES };
+    if (!params?.name)
+        return { error: MISSING_VALUE, info: MISSING_NAME };
+    if (!params?.element) {
+        if (params.discover && params.tournamentRecords) {
+            for (const tournamentId of Object.keys(params.tournamentRecords)) {
+                const tournamentRecord = params.tournamentRecords[tournamentId];
+                const result = removeExtension({
+                    element: tournamentRecord,
+                    name: params.name,
+                });
+                if (result.error)
+                    return decorateResult({ result, stack: 'removeExtension' });
+            }
+            return { ...SUCCESS };
+        }
+        return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
     }
+    if (!params?.element.extensions)
+        return { ...SUCCESS, info: NOT_FOUND };
+    params.element.extensions = params.element.extensions.filter((extension) => extension?.name !== params.name);
+    return { ...SUCCESS };
 }
-const re = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
-function isISODateString(dateString) {
-    if (typeof dateString !== 'string')
+
+function isValidExtension({ requiredAttributes = ['name', 'value'], extension }) {
+    if (!extension || typeof extension !== 'object')
         return false;
-    return re.test(dateString);
-}
-function isTimeString(timeString) {
-    if (typeof timeString !== 'string')
+    if (typeof extension.name !== 'string')
         return false;
-    const noZ = timeString.split('Z')[0];
-    const parts = noZ.split(':');
-    const isNumeric = parts.every((part) => !isNaN(parseInt(part)));
-    const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
-    return !invalid;
-}
-function timeStringMinutes(timeString) {
-    const validTimeString = extractTime(timeString);
-    if (!validTimeString)
-        return 0;
-    const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
-    return hours * 60 + minutes;
-}
-function dayMinutesToTimeString(totalMinutes) {
-    let hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes - hours * 60;
-    if (hours > 23)
-        hours = hours % 24;
-    return [zeroPad(hours), zeroPad(minutes)].join(':');
-}
-function tidyTime(timeString) {
-    return isTimeString(timeString) ? timeString.split(':').slice(0, 2).map(zeroPad).join(':') : undefined;
-}
-function extractTime(dateString) {
-    return isISODateString(dateString) && dateString.indexOf('T') > 0
-        ? tidyTime(dateString.split('T').reverse()[0])
-        : tidyTime(dateString);
-}
-function extractDate(dateString) {
-    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : undefined;
-}
-function dateStringDaysChange(dateString, daysChange) {
-    const date = new Date(dateString);
-    date.setDate(date.getDate() + daysChange);
-    return extractDate(date.toISOString());
-}
-function splitTime(value) {
-    value = typeof value !== 'string' ? '00:00' : value;
-    const o = {}, time = {};
-    ({ 0: o.time, 1: o.ampm } = value.split(' ') || []);
-    ({ 0: time.hours, 1: time.minutes } = o.time.split(':') || []);
-    time.ampm = o.ampm;
-    if (isNaN(time.hours) || isNaN(time.minutes) || (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
-        return {};
-    return time;
-}
-function militaryTime(value) {
-    const time = splitTime(value);
-    if (time.ampm && time.hours) {
-        if (time.ampm.toLowerCase() === 'pm' && parseInt(time.hours) < 12)
-            time.hours = ((time.hours && parseInt(time.hours)) || 0) + 12;
-        if (time.ampm.toLowerCase() === 'am' && time.hours === '12')
-            time.hours = '00';
-    }
-    const timeString = `${time.hours || '12'}:${time.minutes || '00'}`;
-    return timeString.split(':').map(zeroPad).join(':');
+    const extensionAttributes = Object.keys(extension);
+    return (requiredAttributes.filter((attribute) => extensionAttributes.includes(attribute)).length ===
+        requiredAttributes.length);
 }
-function regularTime(value) {
-    const time = splitTime(value);
-    if (typeof time === 'object' && !Object.keys(time).length)
-        return undefined;
-    if (time.ampm)
-        return value;
-    if (time.hours > 12) {
-        time.hours -= 12;
-        time.ampm = 'PM';
-    }
-    else if (time.hours === '12') {
-        time.ampm = 'PM';
-    }
-    else if (time.hours === '00') {
-        time.hours = '12';
-        time.ampm = 'AM';
+
+function addExtension(params) {
+    if (typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    const stack = 'addExtension';
+    if (params?.element && typeof params.element !== 'object')
+        return decorateResult({ result: { error: INVALID_VALUES }, stack });
+    if (!isValidExtension({ extension: params.extension }))
+        return decorateResult({
+            result: { error: INVALID_VALUES, info: 'invalid extension' },
+            stack,
+        });
+    if (!params.element) {
+        if (params.discover && !params.tournamentId && params.tournamentRecords) {
+            for (const tournamentRecord of Object.values(params.tournamentRecords)) {
+                const result = addExtension({
+                    extension: params.extension,
+                    element: tournamentRecord,
+                });
+                if (result.error)
+                    return decorateResult({ result, stack });
+            }
+            return { ...SUCCESS };
+        }
+        else {
+            return decorateResult({ result: { error: MISSING_VALUE }, stack });
+        }
     }
-    else {
-        time.ampm = 'AM';
+    if (!params.element.extensions)
+        params.element.extensions = [];
+    const creationTime = params?.creationTime ?? true;
+    if (creationTime) {
+        const createdAt = new Date().toISOString();
+        Object.assign(params.extension, { createdAt });
     }
-    if (time.hours?.[0] === '0') {
-        time.hours = time.hours.slice(1);
+    const existingExtension = params.element.extensions.find(({ name }) => name === params.extension.name);
+    if (existingExtension) {
+        existingExtension.value = params.extension.value;
     }
-    return `${time.hours || '12'}:${time.minutes || '00'} ${time.ampm}`;
-}
-function convertTime(value, time24, keepDate) {
-    const hasDate = extractDate(value);
-    const timeString = extractTime(value);
-    const timeValue = hasDate ? timeString : value;
-    return !value
-        ? undefined
-        : (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue);
-}
-function timeSort(a, b) {
-    const as = splitTime(a);
-    const bs = splitTime(b);
-    if (parseInt(as.hours) < parseInt(bs.hours))
-        return -1;
-    if (parseInt(as.hours) > parseInt(bs.hours))
-        return 1;
-    if (as.hours === bs.hours) {
-        if (parseInt(as.minutes) < parseInt(bs.minutes))
-            return -1;
-        if (parseInt(as.minutes) > parseInt(bs.minutes))
-            return 1;
+    else if (params.extension.value) {
+        params.element.extensions.push(params.extension);
     }
-    return 0;
-}
-function addDays(date, days = 7) {
-    const universalDate = extractDate(date) + 'T00:00';
-    const now = new Date(universalDate);
-    const adjustedDate = new Date(now.setDate(now.getDate() + days));
-    return formatDate(adjustedDate);
-}
-function addWeek(date) {
-    return addDays(date);
+    return { ...SUCCESS };
 }
-function getDateByWeek(week, year, dateFormat, sunday = false) {
-    const date = new Date(year, 0, 1 + (week - 1) * 7);
-    const startValue = sunday ? 0 : 1;
-    date.setDate(date.getDate() + (startValue - date.getDay()));
-    return formatDate(date, dateFormat);
+
+function addTournamentExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    return addExtension({
+        creationTime: params.creationTime,
+        element: params.tournamentRecord,
+        extension: params.extension,
+    });
 }
-function dateFromDay(year, day, dateFormat) {
-    const date = new Date(year, 0);
-    return formatDate(new Date(date.setDate(day)), dateFormat);
+function addDrawDefinitionExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.drawDefinition)
+        return { error: DRAW_DEFINITION_NOT_FOUND };
+    return addExtension({
+        creationTime: params.creationTime,
+        element: params.drawDefinition,
+        extension: params.extension,
+    });
 }
-function timeToDate(timeString, date = undefined) {
-    const [hours, minutes] = (timeString || '00:00').split(':').map(zeroPad);
-    const milliseconds = offsetDate(date).setHours(hours, minutes, 0, 0);
-    return offsetDate(milliseconds);
+function addEventExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.event)
+        return { error: EVENT_NOT_FOUND };
+    return addExtension({
+        creationTime: params.creationTime,
+        extension: params.extension,
+        element: params.event,
+    });
 }
-function minutesDifference(date1, date2, absolute = true) {
-    const dt1 = new Date(date1);
-    const dt2 = new Date(date2);
-    const diff = (dt2.getTime() - dt1.getTime()) / 1000 / 60;
-    return absolute ? Math.abs(Math.round(diff)) : Math.round(diff);
+function addParticipantExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    const tournamentParticipants = params.tournamentRecord?.participants || [];
+    const participant = findParticipant({
+        participantId: params.participantId,
+        tournamentParticipants,
+    });
+    if (!participant)
+        return { error: PARTICIPANT_NOT_FOUND };
+    return addExtension({
+        creationTime: params.creationTime,
+        extension: params.extension,
+        element: participant,
+    });
 }
-function addMinutesToTimeString(timeString, minutes) {
-    const validTimeString = extractTime(timeString);
-    if (!validTimeString)
-        return '00:00';
-    const minutesToAdd = isNaN(minutes) ? 0 : minutes;
-    return extractTime(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
+function removeTournamentExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    return removeExtension({
+        element: params.tournamentRecord,
+        name: params.name,
+    });
 }
-function addMinutes(startDate, minutes) {
-    const date = new Date(startDate);
-    return new Date(date.getTime() + minutes * 60000);
+function removeDrawDefinitionExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.drawDefinition)
+        return { error: DRAW_DEFINITION_NOT_FOUND };
+    return removeExtension({ element: params.drawDefinition, name: params.name });
 }
-function zeroPad(number) {
-    return number.toString()[1] ? number : '0' + number;
+function removeEventExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params?.event)
+        return { error: EVENT_NOT_FOUND };
+    return removeExtension({ element: params.event, name: params.name });
 }
-function sameDay(date1, date2) {
-    const d1 = new Date(date1);
-    const d2 = new Date(date2);
-    return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
+function removeParticipantExtension(params) {
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    const tournamentParticipants = params.tournamentRecord?.participants || [];
+    const participant = findParticipant({
+        participantId: params.participantId,
+        tournamentParticipants,
+    });
+    if (!participant)
+        return { error: PARTICIPANT_NOT_FOUND };
+    return removeExtension({ element: participant, name: params.name });
 }
-const dateTime = {
-    addDays,
-    addWeek,
-    addMinutesToTimeString,
-    convertTime,
-    getIsoDateString,
-    getUTCdateString,
-    DateHHMM,
-    extractDate,
-    extractTime,
-    formatDate,
-    getDateByWeek,
-    isISODateString,
-    isDate,
-    isTimeString,
-    offsetDate,
-    offsetTime,
-    sameDay,
-    timeStringMinutes,
-    timeToDate,
-    timeUTC,
-    validTimeValue,
-    validDateString,
-    timeValidation,
-    dateValidation,
-};
 
-function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
-    if (getProvider().makeDeepCopy)
-        return getProvider().makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions);
-    const deepCopy = deepCopyEnabled();
-    const { stringify, toJSON, ignore, modulate } = deepCopy || {};
-    if ((!deepCopy?.enabled && !internalUse) ||
-        typeof sourceObject !== 'object' ||
-        typeof sourceObject === 'function' ||
-        sourceObject === null ||
-        (typeof deepCopy?.threshold === 'number' && iteration >= deepCopy.threshold)) {
-        return sourceObject;
-    }
-    const targetObject = Array.isArray(sourceObject) ? [] : {};
-    const sourceObjectKeys = Object.keys(sourceObject).filter((key) => !internalUse ||
-        !ignore ||
-        (Array.isArray(ignore) && !ignore.includes(key)) ||
-        (typeof ignore === 'function' && !ignore(key)));
-    const stringifyValue = (key, value) => {
-        targetObject[key] = typeof value?.toString === 'function' ? value.toString() : JSON.stringify(value);
-    };
-    for (const key of sourceObjectKeys) {
-        const value = sourceObject[key];
-        const modulated = typeof modulate === 'function' ? modulate(value) : undefined;
-        if (modulated !== undefined) {
-            targetObject[key] = modulated;
-        }
-        else if (convertExtensions && key === 'extensions' && Array.isArray(value)) {
-            const extensionConversions = extensionsToAttributes(value);
-            Object.assign(targetObject, ...extensionConversions);
-        }
-        else if (removeExtensions && key === 'extensions') {
-            targetObject[key] = [];
-        }
-        else if (Array.isArray(stringify) && stringify.includes(key)) {
-            stringifyValue(key, value);
-        }
-        else if (Array.isArray(toJSON) && toJSON.includes(key) && typeof value?.toJSON === 'function') {
-            targetObject[key] = value.toJSON();
-        }
-        else if (value === null) {
-            targetObject[key] = undefined;
-        }
-        else if (isDateObject(value)) {
-            targetObject[key] = new Date(value).toISOString();
-        }
-        else {
-            targetObject[key] = makeDeepCopy(value, convertExtensions, internalUse, removeExtensions, iteration + 1);
-        }
-    }
-    return targetObject;
-}
-function extensionsToAttributes(extensions) {
-    return extensions
-        ?.map((extension) => {
-        const { name, value } = extension;
-        return name && value && { [`_${name}`]: value };
-    })
-        .filter(Boolean);
+function getTournamentIds({ tournamentRecords }) {
+    const tournamentIds = isObject(tournamentRecords) ? Object.keys(tournamentRecords) : [];
+    return { tournamentIds, ...SUCCESS };
 }
 
-function getAccessorValue({ element, accessor }) {
-    if (typeof accessor !== 'string')
-        return { values: [] };
-    const targetElement = makeDeepCopy(element);
-    const attributes = accessor.split('.');
-    const values = [];
-    let value;
-    processKeys({ targetElement, attributes });
-    const result = { value };
-    if (values.length)
-        result.values = values;
-    return result;
-    function processKeys({ targetElement, attributes = [], significantCharacters }) {
-        for (const [index, attribute] of attributes.entries()) {
-            if (targetElement?.[attribute]) {
-                const remainingKeys = attributes.slice(index + 1);
-                if (!remainingKeys.length) {
-                    if (!value)
-                        value = targetElement[attribute];
-                    if (!values.includes(targetElement[attribute])) {
-                        values.push(targetElement[attribute]);
-                    }
-                }
-                else if (Array.isArray(targetElement[attribute])) {
-                    const values = targetElement[attribute];
-                    values.forEach((nestedTarget) => processKeys({
-                        targetElement: nestedTarget,
-                        attributes: remainingKeys,
-                    }));
-                }
-                else {
-                    targetElement = targetElement[attribute];
-                    checkValue({ targetElement, index });
-                }
-            }
-        }
-        function checkValue({ targetElement, index }) {
-            if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
-                const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
-                if (value) {
-                    if (!values.includes(extractedValue)) {
-                        values.push(extractedValue);
-                    }
-                }
-                else {
-                    value = extractedValue;
-                    values.push(extractedValue);
-                }
+const stack = 'extensionQueries';
+function findExtension({ discover, element, name, ...params }) {
+    if (!element || !name) {
+        if (discover && params) {
+            const attr = Object.keys(params)
+                .filter((key) => typeof discover === 'boolean' || (Array.isArray(discover) && discover.includes(key)))
+                .find((key) => {
+                if (!Array.isArray(params[key]?.extensions))
+                    return false;
+                return params[key].extensions.find((extension) => extension?.name === name);
+            });
+            let element = attr && params[attr];
+            if (!element && params.tournamentRecords) {
+                element = Object.values(params.tournamentRecords).find((tournamentRecord) => tournamentRecord.extensions?.length);
             }
+            const extension = element?.extensions?.find((extension) => extension?.name === name);
+            const info = !extension ? NOT_FOUND : undefined;
+            return { extension, info };
         }
+        return decorateResult({ result: { error: MISSING_VALUE }, stack });
     }
-}
-
-function isFunction(obj) {
-    return typeof obj === 'function';
-}
-function isString(obj) {
-    return typeof obj === 'string';
-}
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
-}
-function objShallowEqual(o1, o2) {
-    if (!isObject(o1) || !isObject(o2))
-        return false;
-    const keys1 = Object.keys(o1);
-    const keys2 = Object.keys(o2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-    for (const key of keys1) {
-        if (o1[key] !== o2[key]) {
-            return false;
-        }
-    }
-    return true;
-}
-function createMap(objectArray, attribute) {
-    if (!Array.isArray(objectArray))
-        return {};
-    return Object.assign({}, ...(objectArray ?? [])
-        .filter(isObject)
-        .map((obj) => {
-        return (obj[attribute] && {
-            [obj[attribute]]: obj,
-        });
-    })
-        .filter(Boolean));
-}
-const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] === a[key]);
-const extractAttributes = (accessor) => (element) => !accessor || typeof element !== 'object'
-    ? undefined
-    : (Array.isArray(accessor) &&
-        accessor.map((a) => ({
-            [a]: getAccessorValue({ element, accessor: a })?.value,
-        }))) ||
-        (typeof accessor === 'object' &&
-            Object.keys(accessor).map((key) => ({
-                [key]: getAccessorValue({ element, accessor: key })?.value,
-            }))) ||
-        (typeof accessor === 'string' && getAccessorValue({ element, accessor }))?.value;
-const xa = extractAttributes;
-function undefinedToNull(obj, shallow) {
-    if (obj === undefined)
-        return null;
-    if (typeof obj !== 'object' || obj === null)
-        return obj;
-    const definedKeys = Object.keys(obj);
-    const notNull = (value) => (value === undefined ? null : value);
-    return Object.assign({}, ...definedKeys.map((key) => {
-        return Array.isArray(obj[key])
-            ? {
-                [key]: shallow ? obj[key] : obj[key].map((m) => undefinedToNull(m)),
-            }
-            : { [key]: shallow ? notNull(obj[key]) : undefinedToNull(obj[key]) };
-    }));
-}
-function countKeys(o) {
-    if (Array.isArray(o)) {
-        return o.length + o.map(countKeys).reduce((a, b) => a + b, 0);
-    }
-    else if (typeof o === 'object' && o !== null) {
-        return (Object.keys(o).length +
-            Object.keys(o)
-                .map((k) => countKeys(o[k]))
-                .reduce((a, b) => a + b, 0));
-    }
-    return 0;
-}
-function generateHashCode(o) {
-    if (o === null || typeof o !== 'object')
-        return undefined;
-    const str = JSON.stringify(o);
-    const keyCount = countKeys(o);
-    const charSum = str.split('').reduce((a, b) => a + b.charCodeAt(0), 0);
-    return [str.length, keyCount, charSum].map((e) => e.toString(36)).join('');
-}
-
-const TOURNAMENT_RECORDS = 'tournamentRecords';
-const POLICY_DEFINITIONS = 'policyDefinitions';
-const TOURNAMENT_RECORD = 'tournamentRecord';
-const DRAW_DEFINITION = 'drawDefinition';
-const MATCHUP_FORMAT = 'matchUpFormat';
-const PARTICIPANT_ID = 'participantId';
-const SCHEDULE_DATES = 'scheduleDates';
-const TOURNAMENT_ID = 'tournamentId';
-const SCHEDULE_DATE = 'scheduleDate';
-const STRUCTURE_ID = 'structureId';
-const PARTICIPANT = 'participant';
-const MATCHUP_IDS = 'matchUpIds';
-const POLICY_TYPE = 'policyType';
-const STRUCTURES = 'structures';
-const MATCHUP_ID = 'matchUpId';
-const IN_CONTEXT = 'inContext';
-const STRUCTURE = 'structure';
-const COURT_IDS = 'courtIds';
-const PERSON_ID = 'personId';
-const VENUE_IDS = 'venueIds';
-const MATCHUPS = 'matchUps';
-const COURT_ID = 'courtId';
-const EVENT_ID = 'eventId';
-const MATCHUP = 'matchUp';
-const DRAW_ID = 'drawId';
-const ERROR = 'error';
-const EVENT = 'event';
-const PARAM = 'param';
-const UUIDS$1 = 'uuids';
-const AVERAGE_MATCHUP_MINUTES = 'averageMatchUpMinutes';
-const RECOVERY_MINUTES = 'recoveryMinutes';
-const PERIOD_LENGTH = 'periodLength';
-const OBJECT = 'object';
-const ARRAY = 'array';
-const VALIDATE = '_validate';
-const MESSAGE = '_message';
-const INVALID = '_invalid';
-const OF_TYPE = '_ofType';
-const ANY_OF = '_anyOf';
-const ONE_OF = '_oneOf';
-
-const errors = {
-    [TOURNAMENT_RECORDS]: MISSING_TOURNAMENT_RECORDS,
-    [TOURNAMENT_RECORD]: MISSING_TOURNAMENT_RECORD,
-    [POLICY_DEFINITIONS]: MISSING_POLICY_DEFINITION,
-    [DRAW_DEFINITION]: MISSING_DRAW_DEFINITION,
-    [PARTICIPANT_ID]: MISSING_PARTICIPANT_ID,
-    [MATCHUP_FORMAT]: MISSING_MATCHUP_FORMAT,
-    [TOURNAMENT_ID]: MISSING_TOURNAMENT_ID,
-    [STRUCTURE_ID]: MISSING_STRUCTURE_ID,
-    [MATCHUP_IDS]: MISSING_MATCHUP_IDS,
-    [PARTICIPANT]: MISSING_PARTICIPANT,
-    [STRUCTURES]: MISSING_STRUCTURES,
-    [MATCHUP_ID]: MISSING_MATCHUP_ID,
-    [STRUCTURE]: MISSING_STRUCTURE,
-    [COURT_ID]: MISSING_COURT_ID,
-    [MATCHUPS]: MISSING_MATCHUPS,
-    [MATCHUP]: MISSING_MATCHUP,
-    [COURT_IDS]: MISSING_VALUE,
-    [VENUE_IDS]: MISSING_VALUE,
-    [DRAW_ID]: MISSING_DRAW_ID,
-    [EVENT_ID]: MISSING_EVENT,
-    [EVENT]: EVENT_NOT_FOUND,
-};
-const paramTypes = {
-    [TOURNAMENT_RECORDS]: OBJECT,
-    [POLICY_DEFINITIONS]: OBJECT,
-    [TOURNAMENT_RECORD]: OBJECT,
-    [DRAW_DEFINITION]: OBJECT,
-    [SCHEDULE_DATES]: ARRAY,
-    [PARTICIPANT]: OBJECT,
-    [MATCHUP_IDS]: ARRAY,
-    [STRUCTURES]: ARRAY,
-    [STRUCTURE]: OBJECT,
-    [COURT_IDS]: ARRAY,
-    [VENUE_IDS]: ARRAY,
-    [MATCHUPS]: ARRAY,
-    [MATCHUP]: OBJECT,
-    [EVENT]: OBJECT,
-    [UUIDS$1]: ARRAY,
-};
-function checkRequiredParameters(params, requiredParams, stack) {
-    if (!params && !isObject(params))
-        return { error: INVALID_VALUES };
-    if (!requiredParams?.length || params?._bypassParamCheck)
-        return { valid: true };
-    if (!Array.isArray(requiredParams))
-        return { error: INVALID_VALUES };
-    const { paramError, errorParam } = findParamError(params, requiredParams);
-    if (!paramError)
-        return { valid: true };
-    const error = params?.[errorParam] === undefined
-        ? errors[errorParam] || INVALID_VALUES
-        : (paramError[VALIDATE] && paramError[INVALID]) || INVALID_VALUES;
-    const param = errorParam ?? (paramError[ONE_OF] && Object.keys(paramError[ONE_OF]).join(', '));
-    return decorateResult({
-        info: { param, message: paramError[MESSAGE] },
-        result: { error },
-        stack,
-    });
-}
-function getIntersection(params, constraint) {
-    const paramKeys = Object.keys(params);
-    const constraintKeys = Object.keys(constraint);
-    return intersection(paramKeys, constraintKeys);
-}
-function getOneOf(params, _oneOf) {
-    if (!_oneOf)
-        return;
-    const overlap = getIntersection(params, _oneOf);
-    if (overlap.length !== 1)
-        return { error: INVALID_VALUES };
-    return overlap.reduce((attr, param) => ({ ...attr, [param]: true }), {});
-}
-function getAnyOf(params, _anyOf) {
-    if (!_anyOf)
-        return;
-    const overlap = getIntersection(params, _anyOf).filter((param) => params[param]);
-    if (overlap.length < 1)
-        return { error: INVALID_VALUES };
-    return overlap.reduce((attr, param) => ({ ...attr, [param]: true }), {});
-}
-function findParamError(params, requiredParams) {
-    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;
-        oneOf && Object.assign(attrs, oneOf);
-        const anyOf = _anyOf && getAnyOf(params, _anyOf);
-        if (anyOf?.error)
-            return anyOf.error;
-        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 paramNotPresent = attrs[param] && !params[param];
-            const invalid = invalidValidationFunction || faliedTypeCheck || paramNotPresent;
-            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, paramInfo };
-}
-function invalidType(params, param, _ofType) {
-    _ofType = _ofType || paramTypes[param] || 'string';
-    if (_ofType === 'array') {
-        return !Array.isArray(params[param]);
-    }
-    return typeof params[param] !== _ofType;
-}
-function checkValidation(value, validate) {
-    if (isFunction(validate))
-        return validate(value);
-    return true;
-}
-
-const SINGLES$1 = 'SINGLES';
-const SINGLES_EVENT = 'SINGLES';
-const DOUBLES$1 = 'DOUBLES';
-const DOUBLES_EVENT = 'DOUBLES';
-const TEAM$2 = 'TEAM';
-const TEAM_EVENT = 'TEAM';
-const AGE = 'AGE';
-const RATING$2 = 'RATING';
-const BOTH = 'BOTH';
-const eventConstants = {
-    AGE,
-    BOTH,
-    DOUBLES: DOUBLES$1,
-    DOUBLES_EVENT,
-    RATING: RATING$2,
-    SINGLES: SINGLES$1,
-    SINGLES_EVENT,
-    TEAM_EVENT,
-    TEAM: TEAM$2,
-};
-
-const DYNAMIC = 'DYNAMIC';
-const RANKING$1 = 'RANKING';
-const RATING$1 = 'RATING';
-const SCALE$1 = 'SCALE';
-const SEEDING$1 = 'SEEDING';
-const scaleConstants = {
-    RANKING: RANKING$1,
-    RATING: RATING$1,
-    SCALE: SCALE$1,
-    SEEDING: SEEDING$1,
-};
-
-function getScaleValues(params) {
-    const paramCheck = checkRequiredParameters(params, [{ [PARTICIPANT]: true }]);
-    if (paramCheck.error)
-        return paramCheck;
-    const scaleItems = params.participant.timeItems?.filter(({ itemType }) => itemType?.startsWith(SCALE$1) && [RANKING$1, RATING$1, SEEDING$1].includes(itemType.split('.')[1]));
-    const scales = { ratings: {}, rankings: {}, seedings: {} };
-    if (scaleItems?.length) {
-        const latestScaleItem = (scaleType) => scaleItems
-            .filter((timeItem) => timeItem?.itemType === scaleType)
-            .sort((a, b) => new Date(a.createdAt || undefined).getTime() - new Date(b.createdAt || undefined).getTime())
-            .pop();
-        const itemTypes = unique(scaleItems.map(({ itemType }) => itemType));
-        for (const itemType of itemTypes) {
-            const scaleItem = latestScaleItem(itemType);
-            if (scaleItem) {
-                const [, type, format, scaleName, modifier] = scaleItem.itemType.split('.');
-                const namedScale = modifier ? `${scaleName}.${modifier}` : scaleName;
-                const scaleType = (type === SEEDING$1 && 'seedings') || (type === RANKING$1 && 'rankings') || 'ratings';
-                if (!scales[scaleType][format])
-                    scales[scaleType][format] = [];
-                scales[scaleType][format].push({
-                    scaleValue: scaleItem.itemValue,
-                    scaleDate: scaleItem.itemDate,
-                    scaleName: namedScale,
-                });
-            }
-        }
-    }
-    return { ...SUCCESS, ...scales };
-}
-
-function attributeFilter(params) {
-    if (params === null)
-        return {};
-    const { source, template } = params || {};
-    if (!template)
-        return source;
-    const target = {};
-    attributeCopy(source, template, target);
-    return target;
-    function attributeCopy(valuesObject, templateObject, outputObject) {
-        if (!valuesObject || !templateObject)
-            return undefined;
-        const vKeys = Object.keys(valuesObject);
-        const oKeys = Object.keys(templateObject);
-        const orMap = Object.assign({}, ...oKeys
-            .filter((key) => key.indexOf('||'))
-            .map((key) => key.split('||').map((or) => ({ [or]: key })))
-            .flat());
-        const allKeys = oKeys.concat(...Object.keys(orMap));
-        const wildcard = allKeys.includes('*');
-        for (const vKey of vKeys) {
-            if (allKeys.indexOf(vKey) >= 0 || wildcard) {
-                const templateKey = orMap[vKey] || vKey;
-                const tobj = templateObject[templateKey] || wildcard;
-                const vobj = valuesObject[vKey];
-                if (typeof tobj === 'object' && typeof vobj !== 'function' && !Array.isArray(tobj)) {
-                    if (Array.isArray(vobj)) {
-                        const mappedElements = vobj
-                            .map((arrayMember) => {
-                            const target = {};
-                            const result = attributeCopy(arrayMember, tobj, target);
-                            return result !== false ? target : undefined;
-                        })
-                            .filter(Boolean);
-                        outputObject[vKey] = mappedElements;
-                    }
-                    else if (vobj) {
-                        outputObject[vKey] = {};
-                        attributeCopy(vobj, tobj, outputObject[vKey]);
-                    }
-                }
-                else {
-                    const value = valuesObject[vKey];
-                    const exclude = Array.isArray(tobj) && !tobj.includes(value);
-                    if (exclude)
-                        return false;
-                    if (templateObject[vKey] || (wildcard && templateObject[vKey] !== false)) {
-                        outputObject[vKey] = value;
-                    }
-                }
-            }
-        }
-        return undefined;
-    }
-}
-
-const POLICY_TYPE_VOLUNTARY_CONSOLATION = 'voluntaryConsolation';
-const POLICY_TYPE_COMPETITIVE_BANDS = 'competitiveBands';
-const POLICY_TYPE_ROUND_ROBIN_TALLY = 'roundRobinTally';
-const POLICY_TYPE_POSITION_ACTIONS = 'positionActions';
-const POLICY_TYPE_MATCHUP_ACTIONS = 'matchUpActions';
-const POLICY_TYPE_RANKING_POINTS = 'rankingPoints';
-const POLICY_TYPE_ROUND_NAMING = 'roundNaming';
-const POLICY_TYPE_PARTICIPANT = 'participant';
-const POLICY_TYPE_PROGRESSION = 'progression';
-const POLICY_TYPE_SCHEDULING = 'scheduling';
-const POLICY_TYPE_AVOIDANCE = 'avoidance';
-const POLICY_TYPE_DISPLAY = 'display';
-const POLICY_TYPE_SCORING = 'scoring';
-const POLICY_TYPE_SEEDING = 'seeding';
-const POLICY_TYPE_FEED_IN = 'feedIn';
-const POLICY_TYPE_AUDIT = 'audit';
-const POLICY_TYPE_DRAWS = 'draws';
-const policyConstants = {
-    POLICY_TYPE_VOLUNTARY_CONSOLATION,
-    POLICY_TYPE_COMPETITIVE_BANDS,
-    POLICY_TYPE_ROUND_ROBIN_TALLY,
-    POLICY_TYPE_POSITION_ACTIONS,
-    POLICY_TYPE_MATCHUP_ACTIONS,
-    POLICY_TYPE_RANKING_POINTS,
-    POLICY_TYPE_ROUND_NAMING,
-    POLICY_TYPE_PARTICIPANT,
-    POLICY_TYPE_PROGRESSION,
-    POLICY_TYPE_SCHEDULING,
-    POLICY_TYPE_AVOIDANCE,
-    POLICY_TYPE_DISPLAY,
-    POLICY_TYPE_FEED_IN,
-    POLICY_TYPE_SCORING,
-    POLICY_TYPE_SEEDING,
-    POLICY_TYPE_AUDIT,
-    POLICY_TYPE_DRAWS,
-};
-
-function findParticipant({ tournamentParticipants = [], policyDefinitions = {}, contextProfile, participantId, internalUse, personId, }) {
-    const foundParticipant = tournamentParticipants.find((candidate) => (participantId && candidate.participantId === participantId) ||
-        (personId && candidate.person && candidate.person.personId === personId));
-    const participant = makeDeepCopy(foundParticipant, false, internalUse);
-    if (participant) {
-        const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
-        if (contextProfile?.withScaleValues) {
-            const { ratings, rankings } = getScaleValues({ participant });
-            participant.rankings = rankings;
-            participant.ratings = ratings;
-        }
-        if (participantAttributes?.participant) {
-            return attributeFilter({
-                template: participantAttributes.participant,
-                source: participant,
-            });
-        }
-    }
-    return participant;
-}
-
-const ELEMENT_REQUIRED = 'element required';
-const MISSING_NAME = 'missing name';
-
-function removeExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (params.element && typeof params?.element !== 'object')
-        return { error: INVALID_VALUES };
-    if (!params?.name)
-        return { error: MISSING_VALUE, info: MISSING_NAME };
-    if (!params?.element) {
-        if (params.discover && params.tournamentRecords) {
-            for (const tournamentId of Object.keys(params.tournamentRecords)) {
-                const tournamentRecord = params.tournamentRecords[tournamentId];
-                const result = removeExtension({
-                    element: tournamentRecord,
-                    name: params.name,
-                });
-                if (result.error)
-                    return decorateResult({ result, stack: 'removeExtension' });
-            }
-            return { ...SUCCESS };
-        }
-        return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
-    }
-    if (!params?.element.extensions)
-        return { ...SUCCESS, info: NOT_FOUND };
-    params.element.extensions = params.element.extensions.filter((extension) => extension?.name !== params.name);
-    return { ...SUCCESS };
-}
-
-function isValidExtension({ requiredAttributes = ['name', 'value'], extension }) {
-    if (!extension || typeof extension !== 'object')
-        return false;
-    if (typeof extension.name !== 'string')
-        return false;
-    const extensionAttributes = Object.keys(extension);
-    return (requiredAttributes.filter((attribute) => extensionAttributes.includes(attribute)).length ===
-        requiredAttributes.length);
-}
-
-function addExtension(params) {
-    if (typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    const stack = 'addExtension';
-    if (params?.element && typeof params.element !== 'object')
-        return decorateResult({ result: { error: INVALID_VALUES }, stack });
-    if (!isValidExtension({ extension: params.extension }))
-        return decorateResult({
-            result: { error: INVALID_VALUES, info: 'invalid extension' },
-            stack,
-        });
-    if (!params.element) {
-        if (params.discover && !params.tournamentId && params.tournamentRecords) {
-            for (const tournamentRecord of Object.values(params.tournamentRecords)) {
-                const result = addExtension({
-                    extension: params.extension,
-                    element: tournamentRecord,
-                });
-                if (result.error)
-                    return decorateResult({ result, stack });
-            }
-            return { ...SUCCESS };
-        }
-        else {
-            return decorateResult({ result: { error: MISSING_VALUE }, stack });
-        }
-    }
-    if (!params.element.extensions)
-        params.element.extensions = [];
-    const creationTime = params?.creationTime ?? true;
-    if (creationTime) {
-        const createdAt = new Date().toISOString();
-        Object.assign(params.extension, { createdAt });
-    }
-    const existingExtension = params.element.extensions.find(({ name }) => name === params.extension.name);
-    if (existingExtension) {
-        existingExtension.value = params.extension.value;
-    }
-    else if (params.extension.value) {
-        params.element.extensions.push(params.extension);
-    }
-    return { ...SUCCESS };
-}
-
-function addTournamentExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    return addExtension({
-        creationTime: params.creationTime,
-        element: params.tournamentRecord,
-        extension: params.extension,
-    });
-}
-function addDrawDefinitionExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.drawDefinition)
-        return { error: DRAW_DEFINITION_NOT_FOUND };
-    return addExtension({
-        creationTime: params.creationTime,
-        element: params.drawDefinition,
-        extension: params.extension,
-    });
-}
-function addEventExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.event)
-        return { error: EVENT_NOT_FOUND };
-    return addExtension({
-        creationTime: params.creationTime,
-        extension: params.extension,
-        element: params.event,
-    });
-}
-function addParticipantExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    const tournamentParticipants = params.tournamentRecord?.participants || [];
-    const participant = findParticipant({
-        participantId: params.participantId,
-        tournamentParticipants,
-    });
-    if (!participant)
-        return { error: PARTICIPANT_NOT_FOUND };
-    return addExtension({
-        creationTime: params.creationTime,
-        extension: params.extension,
-        element: participant,
-    });
-}
-function removeTournamentExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    return removeExtension({
-        element: params.tournamentRecord,
-        name: params.name,
-    });
-}
-function removeDrawDefinitionExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.drawDefinition)
-        return { error: DRAW_DEFINITION_NOT_FOUND };
-    return removeExtension({ element: params.drawDefinition, name: params.name });
-}
-function removeEventExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params?.event)
-        return { error: EVENT_NOT_FOUND };
-    return removeExtension({ element: params.event, name: params.name });
-}
-function removeParticipantExtension(params) {
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    const tournamentParticipants = params.tournamentRecord?.participants || [];
-    const participant = findParticipant({
-        participantId: params.participantId,
-        tournamentParticipants,
-    });
-    if (!participant)
-        return { error: PARTICIPANT_NOT_FOUND };
-    return removeExtension({ element: participant, name: params.name });
-}
-
-function getTournamentIds({ tournamentRecords }) {
-    const tournamentIds = isObject(tournamentRecords) ? Object.keys(tournamentRecords) : [];
-    return { tournamentIds, ...SUCCESS };
-}
-
-const stack = 'extensionQueries';
-function findExtension({ discover, element, name, ...params }) {
-    if (!element || !name) {
-        if (discover && params) {
-            const attr = Object.keys(params)
-                .filter((key) => typeof discover === 'boolean' || (Array.isArray(discover) && discover.includes(key)))
-                .find((key) => {
-                if (!Array.isArray(params[key]?.extensions))
-                    return false;
-                return params[key].extensions.find((extension) => extension?.name === name);
-            });
-            let element = attr && params[attr];
-            if (!element && params.tournamentRecords) {
-                element = Object.values(params.tournamentRecords).find((tournamentRecord) => tournamentRecord.extensions?.length);
-            }
-            const extension = element?.extensions?.find((extension) => extension?.name === name);
-            const info = !extension ? NOT_FOUND : undefined;
-            return { extension, info };
-        }
-        return decorateResult({ result: { error: MISSING_VALUE }, stack });
-    }
-    if (!Array.isArray(element.extensions))
-        return { info: 'no extensions' };
-    const extension = element.extensions.find((extension) => extension?.name === name);
-    const info = !extension ? NOT_FOUND : undefined;
-    return { extension, info };
+    if (!Array.isArray(element.extensions))
+        return { info: 'no extensions' };
+    const extension = element.extensions.find((extension) => extension?.name === name);
+    const info = !extension ? NOT_FOUND : undefined;
+    return { extension, info };
 }
 
 const ACTIVE_SUSPENSION = 'activeSuspension';
@@ -11466,7 +11515,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 +26836,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);
@@ -26801,371 +26850,938 @@ function getTournamentInfo(params) {
     };
 }
 
-function getCompetitionDateRange({ tournamentRecords }) {
-    if (!isObject(tournamentRecords))
-        return { error: MISSING_TOURNAMENT_RECORDS };
-    const tournamentIds = Object.keys(tournamentRecords ?? {});
-    const dateRange = tournamentIds.reduce((dateRange, tournamentId) => {
+function getCompetitionDateRange({ tournamentRecords }) {
+    if (!isObject(tournamentRecords))
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    const tournamentIds = Object.keys(tournamentRecords ?? {});
+    const dateRange = tournamentIds.reduce((dateRange, tournamentId) => {
+        const tournamentRecord = tournamentRecords[tournamentId];
+        const { tournamentInfo: { startDate, endDate }, } = getTournamentInfo({ tournamentRecord });
+        const dateOfStart = startDate && new Date(extractDate(startDate));
+        if (!dateRange.startDate || (dateOfStart && dateOfStart < dateRange.startDate)) {
+            dateRange.startDate = dateOfStart;
+        }
+        const dateOfEnd = endDate && new Date(extractDate(endDate));
+        if (!dateRange.endDate || (dateOfEnd && dateOfEnd > dateRange.endDate)) {
+            dateRange.endDate = dateOfEnd;
+        }
+        return dateRange;
+    }, { startDate: undefined, endDate: undefined });
+    const startDate = dateRange.startDate && extractDate(dateRange.startDate.toISOString());
+    const endDate = dateRange.endDate && extractDate(dateRange.endDate.toISOString());
+    if (!startDate || !endDate)
+        return { error: MISSING_DATE };
+    return { startDate, endDate };
+}
+
+function getTournamentPersons({ tournamentRecord, participantFilters }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    let tournamentParticipants = tournamentRecord.participants || [];
+    if (participantFilters)
+        tournamentParticipants = filterParticipants({
+            participants: tournamentParticipants,
+            participantFilters,
+            tournamentRecord,
+        });
+    const tournamentPersons = {};
+    const extractPerson = (participant) => {
+        if (participant.person) {
+            const { personId } = participant.person;
+            if (tournamentPersons[personId]) {
+                tournamentPersons[personId].participantIds.push(participant.participantId);
+            }
+            else {
+                tournamentPersons[personId] = {
+                    ...participant.person,
+                    participantIds: [participant.participantId],
+                };
+            }
+        }
+    };
+    tournamentParticipants.forEach((participant) => {
+        if (participant.person)
+            extractPerson(participant);
+    });
+    return { tournamentPersons: Object.values(tournamentPersons) };
+}
+
+function checkIsDual(tournamentRecord) {
+    const teamParticipants = tournamentRecord.participants?.filter(({ participantType }) => participantType === TEAM);
+    const twoTeams = teamParticipants?.length === 2;
+    const event = tournamentRecord.events?.length === 1 && tournamentRecord.events[0];
+    const drawDefinition = event?.drawDefinitions?.length === 1 && event.drawDefinitions[0];
+    const structure = drawDefinition?.structures?.length === 1 && drawDefinition.structures[0];
+    const twoDrawPositions = structure?.positionAssignments?.length === 2;
+    return !!(event.tieFormat && twoTeams && twoDrawPositions);
+}
+
+function analyzeTournament({ tournamentRecord }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const { drawsAnalysis } = analyzeDraws({ tournamentRecord });
+    const analysis = {
+        isDual: checkIsDual(tournamentRecord),
+        drawsAnalysis,
+    };
+    return { ...SUCCESS, analysis };
+}
+
+var query$9 = {
+    __proto__: null,
+    analyzeDraws: analyzeDraws,
+    analyzeTournament: analyzeTournament,
+    getAllowedDrawTypes: getAllowedDrawTypes,
+    getAllowedMatchUpFormats: getAllowedMatchUpFormats,
+    getAppliedPolicies: getAppliedPolicies,
+    getCompetitionDateRange: getCompetitionDateRange,
+    getCompetitionPenalties: getCompetitionPenalties,
+    getPolicyDefinitions: getPolicyDefinitions,
+    getTournamentInfo: getTournamentInfo,
+    getTournamentPenalties: getTournamentPenalties,
+    getTournamentPersons: getTournamentPersons,
+    getTournamentStructures: getTournamentStructures,
+    getTournamentTimeItem: getTournamentTimeItem
+};
+
+function getTieFormatDesc(tieFormat) {
+    if (!tieFormat)
+        return {};
+    const matchUpFormats = [];
+    const tieFormatName = tieFormat.tieFormatName;
+    const tieFormatDesc = tieFormat.collectionDefinitions
+        ?.map((def) => {
+        const { matchUpType, matchUpFormat, matchUpCount, category, gender } = def;
+        if (!matchUpFormats.includes(matchUpFormat))
+            matchUpFormats.push(matchUpFormat);
+        const ageCategoryCode = category?.ageCategoryCode;
+        const matchUpTypeCode = matchUpType === DOUBLES_MATCHUP ? 'D' : 'S';
+        return [matchUpCount, matchUpTypeCode, ageCategoryCode, matchUpFormat, gender].join(';');
+    })
+        .join('|');
+    return {
+        tieFormatName: (tieFormat && tieFormatName) || 'UNNAMED',
+        matchUpFormats,
+        tieFormatDesc,
+    };
+}
+
+function compareTieFormats({ considerations = {}, descendant, ancestor }) {
+    const descendantDifferences = {};
+    const ancestorDifferences = {};
+    const { matchUpFormats: descendantMatchUpFormats, tieFormatDesc: descendantDesc } = getTieFormatDesc(descendant);
+    const { matchUpFormats: ancestorMatchUpFormats, tieFormatDesc: ancestorDesc } = getTieFormatDesc(ancestor);
+    const matchUpFormatDifferences = unique((descendantMatchUpFormats ?? [])
+        .filter((format) => !(ancestorMatchUpFormats ?? []).includes(format))
+        .concat((ancestorMatchUpFormats ?? []).filter((format) => !(descendantMatchUpFormats ?? []).includes(format))));
+    const nameDifference = !!(considerations?.collectionName &&
+        descendant.collectionDefinitions.map(({ collectionName }) => collectionName).join('|') !==
+            ancestor.collectionDefinitions.map(({ collectionName }) => collectionName).join('|'));
+    const orderDifference = !!(considerations?.collectionOrder &&
+        descendant.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join('|') !==
+            ancestor.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join('|'));
+    const descendantCollectionDefinitions = Object.assign({}, ...(descendant?.collectionDefinitions || []).map((collectionDefinition) => ({
+        [collectionDefinition.collectionId]: collectionDefinition,
+    })));
+    const ancestorCollectionDefinitions = Object.assign({}, ...(ancestor?.collectionDefinitions || []).map((collectionDefinition) => ({
+        [collectionDefinition.collectionId]: collectionDefinition,
+    })));
+    descendantDifferences.collectionIds = difference(Object.keys(descendantCollectionDefinitions), Object.keys(ancestorCollectionDefinitions));
+    ancestorDifferences.collectionIds = difference(Object.keys(ancestorCollectionDefinitions), Object.keys(descendantCollectionDefinitions));
+    descendantDifferences.collectionsValue = getCollectionsValue(descendantCollectionDefinitions);
+    ancestorDifferences.collectionsValue = getCollectionsValue(ancestorCollectionDefinitions);
+    descendantDifferences.groupsCount =
+        ancestor?.collectionGroups?.length ?? (0 - (descendant?.collectionGroups?.length ?? 0) || 0);
+    ancestorDifferences.groupsCount = descendantDifferences.groupsCount ? -1 * descendantDifferences.groupsCount : 0;
+    const valueDifference = descendantDifferences.collectionsValue.totalValue - ancestorDifferences.collectionsValue.totalValue;
+    const matchUpCountDifference = descendantDifferences.collectionsValue.totalMatchUps - ancestorDifferences.collectionsValue.totalMatchUps;
+    const assignmentValuesCountDifference = ancestorDifferences.collectionsValue.assignmentValues.length !==
+        descendantDifferences.collectionsValue.assignmentValues.length;
+    const assignmentValuesDifference = ancestorDifferences.collectionsValue.assignmentValues.some((assignment, i) => {
+        const comparisonAssignment = descendantDifferences.collectionsValue.assignmentValues[i];
+        if (!comparisonAssignment)
+            return true;
+        if (assignment.valueKey !== comparisonAssignment.valueKey)
+            return true;
+        if (assignment.value !== comparisonAssignment.value)
+            return true;
+        if (Array.isArray(assignment.value)) {
+            return assignment.value.every((value, i) => comparisonAssignment.value[i] === value);
+        }
+        return false;
+    });
+    const different = nameDifference ||
+        orderDifference ||
+        ancestorDesc !== descendantDesc ||
+        assignmentValuesCountDifference ||
+        assignmentValuesDifference ||
+        valueDifference !== 0;
+    const invalidValues = [
+        ...ancestorDifferences.collectionsValue.invalidValues,
+        ...descendantDifferences.collectionsValue.invalidValues,
+    ];
+    const invalid = invalidValues.length && invalidValues;
+    return {
+        matchUpFormatDifferences,
+        matchUpCountDifference,
+        descendantDifferences,
+        ancestorDifferences,
+        orderDifference,
+        valueDifference,
+        nameDifference,
+        descendantDesc,
+        ancestorDesc,
+        ...SUCCESS,
+        different,
+        invalid,
+    };
+}
+function getCollectionsValue(definitions) {
+    const invalidValues = [];
+    const assignmentValues = [];
+    let totalMatchUps = 0;
+    const collectionIds = Object.keys(definitions).sort(stringSort);
+    const totalValue = collectionIds.reduce((total, collectionId) => {
+        const collectionDefinition = definitions[collectionId];
+        const { collectionValueProfiles, collectionValue, matchUpCount, matchUpValue, scoreValue, setValue } = collectionDefinition;
+        const valueAssignments = {
+            collectionValueProfiles,
+            collectionValue,
+            matchUpValue,
+            scoreValue,
+            setValue,
+        };
+        const valueKeys = Object.keys(valueAssignments).filter((key) => ![undefined, null].includes(valueAssignments[key]));
+        if (valueKeys.length !== 1) {
+            invalidValues.push({ collectionId });
+        }
+        const valueKey = valueKeys[0];
+        if (valueKey) {
+            const value = valueKey === 'collectionValueProfiles' ? Object.values(collectionValueProfiles) : valueAssignments[valueKey];
+            assignmentValues.push({ valueKey, value });
+        }
+        totalMatchUps += matchUpCount;
+        if (collectionValueProfiles)
+            return total + collectionValueProfiles.reduce((total, profile) => total + profile.value, 0);
+        if (matchUpCount) {
+            if (isConvertableInteger(matchUpValue))
+                return total + matchUpValue * matchUpCount;
+            if (isConvertableInteger(scoreValue))
+                return total + scoreValue * matchUpCount;
+            if (isConvertableInteger(setValue))
+                return total + setValue * matchUpCount;
+            return total + collectionValue;
+        }
+        return total;
+    }, 0);
+    return { totalValue, totalMatchUps, invalidValues, assignmentValues };
+}
+
+function publicFindMatchUp(params) {
+    Object.assign(params, { inContext: true });
+    const { matchUp, error } = findMatchUp(params);
+    return { matchUp: makeDeepCopy(matchUp, true, true), error };
+}
+function findMatchUp({ participantsProfile, afterRecoveryTimes, tournamentRecord, contextContent, contextProfile, drawDefinition, nextMatchUps, matchUpId, inContext, eventId, drawId, event, }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (typeof matchUpId !== 'string')
+        return { error: MISSING_MATCHUP_ID };
+    if (!drawDefinition || !event) {
+        const matchUps = allTournamentMatchUps({ tournamentRecord, nextMatchUps }).matchUps ?? [];
+        const inContextMatchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
+        if (!inContextMatchUp)
+            return { error: MATCHUP_NOT_FOUND };
+        ({ eventId, drawId } = inContextMatchUp);
+        ({ event, drawDefinition } = findEvent({
+            tournamentRecord,
+            eventId,
+            drawId,
+        }));
+    }
+    if (!drawDefinition)
+        return { error: DRAW_DEFINITION_NOT_FOUND };
+    if (contextProfile && !contextContent)
+        contextContent = getContextContent({ tournamentRecord, contextProfile });
+    const additionalContext = {
+        surfaceCategory: event?.surfaceCategory ?? tournamentRecord.surfaceCategory,
+        indoorOutDoor: event?.indoorOutdoor ?? tournamentRecord.indoorOutdoor,
+        endDate: event?.endDate ?? tournamentRecord.endDate,
+        tournamentId: tournamentRecord.tournamentId,
+        eventId: eventId ?? event?.eventId,
+        drawId,
+    };
+    const { participants: tournamentParticipants = [] } = hydrateParticipants({
+        participantsProfile,
+        tournamentRecord,
+        contextProfile,
+        inContext,
+    });
+    if (nextMatchUps) {
+        const matchUps = allDrawMatchUps({
+            context: inContext ? additionalContext : undefined,
+            participants: tournamentParticipants,
+            afterRecoveryTimes,
+            contextContent,
+            contextProfile,
+            drawDefinition,
+            nextMatchUps,
+            inContext,
+            event,
+        }).matchUps ?? [];
+        const inContextMatchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
+        if (!inContextMatchUp)
+            return { error: MATCHUP_NOT_FOUND };
+        const structure = drawDefinition?.structures?.find((structure) => structure.structureId === inContextMatchUp.structureId);
+        return { drawDefinition, structure, matchUp: inContextMatchUp };
+    }
+    else {
+        const { matchUp, structure } = findDrawMatchUp({
+            context: inContext ? additionalContext : undefined,
+            tournamentParticipants,
+            afterRecoveryTimes,
+            contextContent,
+            drawDefinition,
+            contextProfile,
+            matchUpId,
+            inContext,
+            event,
+        });
+        return { matchUp, structure, drawDefinition };
+    }
+}
+
+function getTieFormat$1({ tournamentRecord, drawDefinition, structureId, matchUpId, structure, eventId, drawId, event, }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!drawId && !event && !structureId && !matchUpId)
+        return decorateResult({
+            result: { error: MISSING_VALUE },
+            stack: 'getTieFormat',
+        });
+    if (eventId && !event) {
+        event = tournamentRecord.events?.find((event) => event.eventId === eventId);
+    }
+    const matchUpResult = publicFindMatchUp({
+        tournamentRecord,
+        drawDefinition,
+        matchUpId,
+        drawId,
+        event,
+    });
+    if (matchUpId && matchUpResult?.error) {
+        return matchUpResult;
+    }
+    else if (!drawDefinition && matchUpResult?.drawDefinition) {
+        drawDefinition = matchUpResult?.drawDefinition;
+    }
+    structure = structure ?? matchUpResult?.structure;
+    if (!structure && structureId && !matchUpId) {
+        if (!drawDefinition)
+            return { error: MISSING_DRAW_ID };
+        const structureResult = findStructure({ drawDefinition, structureId });
+        if (structureResult.error)
+            return structureResult;
+        structure = structureResult.structure;
+    }
+    const structureDefaultTieFormat = (structure?.tieFormat || structure?.tieFormatId) &&
+        resolveTieFormat({ structure, drawDefinition, event })?.tieFormat;
+    const drawDefaultTieFormat = (drawDefinition?.tieFormat || drawDefinition?.tieFormatId) &&
+        resolveTieFormat({
+            drawDefinition,
+            event,
+        })?.tieFormat;
+    const eventDefaultTieFormat = resolveTieFormat({ event })?.tieFormat;
+    const tieFormat = resolveTieFormat({
+        matchUp: matchUpResult?.matchUp,
+        drawDefinition,
+        structure,
+        event,
+    })?.tieFormat;
+    return {
+        ...SUCCESS,
+        matchUp: matchUpResult?.matchUp,
+        structureDefaultTieFormat: copyTieFormat(structureDefaultTieFormat),
+        eventDefaultTieFormat: copyTieFormat(eventDefaultTieFormat),
+        drawDefaultTieFormat: copyTieFormat(drawDefaultTieFormat),
+        tieFormat: copyTieFormat(tieFormat),
+        structure,
+    };
+}
+
+var query$8 = {
+    __proto__: null,
+    compareTieFormats: compareTieFormats,
+    getTieFormat: getTieFormat$1,
+    tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
+    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];
-        const { tournamentInfo: { startDate, endDate }, } = getTournamentInfo({ tournamentRecord });
-        const dateOfStart = startDate && new Date(extractDate(startDate));
-        if (!dateRange.startDate || (dateOfStart && dateOfStart < dateRange.startDate)) {
-            dateRange.startDate = dateOfStart;
-        }
-        const dateOfEnd = endDate && new Date(extractDate(endDate));
-        if (!dateRange.endDate || (dateOfEnd && dateOfEnd > dateRange.endDate)) {
-            dateRange.endDate = dateOfEnd;
+        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 dateRange;
-    }, { startDate: undefined, endDate: undefined });
-    const startDate = dateRange.startDate && extractDate(dateRange.startDate.toISOString());
-    const endDate = dateRange.endDate && extractDate(dateRange.endDate.toISOString());
-    if (!startDate || !endDate)
-        return { error: MISSING_DATE };
-    return { startDate, endDate };
+    });
+    return { courts, venues, ...SUCCESS };
 }
-
-function getTournamentPersons({ tournamentRecord, participantFilters }) {
+function getTournamentVenuesAndCourts({ convertExtensions, tournamentRecord, ignoreDisabled, dates, }) {
     if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    let tournamentParticipants = tournamentRecord.participants || [];
-    if (participantFilters)
-        tournamentParticipants = filterParticipants({
-            participants: tournamentParticipants,
-            participantFilters,
+        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,
         });
-    const tournamentPersons = {};
-    const extractPerson = (participant) => {
-        if (participant.person) {
-            const { personId } = participant.person;
-            if (tournamentPersons[personId]) {
-                tournamentPersons[personId].participantIds.push(participant.participantId);
-            }
-            else {
-                tournamentPersons[personId] = {
-                    ...participant.person,
-                    participantIds: [participant.participantId],
-                };
+        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);
             }
-        }
-    };
-    tournamentParticipants.forEach((participant) => {
-        if (participant.person)
-            extractPerson(participant);
-    });
-    return { tournamentPersons: Object.values(tournamentPersons) };
-}
-
-function checkIsDual(tournamentRecord) {
-    const teamParticipants = tournamentRecord.participants?.filter(({ participantType }) => participantType === TEAM);
-    const twoTeams = teamParticipants?.length === 2;
-    const event = tournamentRecord.events?.length === 1 && tournamentRecord.events[0];
-    const drawDefinition = event?.drawDefinitions?.length === 1 && event.drawDefinitions[0];
-    const structure = drawDefinition?.structures?.length === 1 && drawDefinition.structures[0];
-    const twoDrawPositions = structure?.positionAssignments?.length === 2;
-    return !!(event.tieFormat && twoTeams && twoDrawPositions);
+        });
+        return accumulator;
+    }, { venues: [], venueIds: [] });
 }
 
-function analyzeTournament({ tournamentRecord }) {
+function getAllEventData({ tournamentRecord, policyDefinitions }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    const { drawsAnalysis } = analyzeDraws({ tournamentRecord });
-    const analysis = {
-        isDual: checkIsDual(tournamentRecord),
-        drawsAnalysis,
-    };
-    return { ...SUCCESS, analysis };
+    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$9 = {
-    __proto__: null,
-    analyzeDraws: analyzeDraws,
-    analyzeTournament: analyzeTournament,
-    getAllowedDrawTypes: getAllowedDrawTypes,
-    getAllowedMatchUpFormats: getAllowedMatchUpFormats,
-    getAppliedPolicies: getAppliedPolicies,
-    getCompetitionDateRange: getCompetitionDateRange,
-    getCompetitionPenalties: getCompetitionPenalties,
-    getPolicyDefinitions: getPolicyDefinitions,
-    getTournamentInfo: getTournamentInfo,
-    getTournamentPenalties: getTournamentPenalties,
-    getTournamentPersons: getTournamentPersons,
-    getTournamentStructures: getTournamentStructures,
-    getTournamentTimeItem: getTournamentTimeItem
-};
-
-function getTieFormatDesc(tieFormat) {
-    if (!tieFormat)
-        return {};
-    const matchUpFormats = [];
-    const tieFormatName = tieFormat.tieFormatName;
-    const tieFormatDesc = tieFormat.collectionDefinitions
-        ?.map((def) => {
-        const { matchUpType, matchUpFormat, matchUpCount, category, gender } = def;
-        if (!matchUpFormats.includes(matchUpFormat))
-            matchUpFormats.push(matchUpFormat);
-        const ageCategoryCode = category?.ageCategoryCode;
-        const matchUpTypeCode = matchUpType === DOUBLES_MATCHUP ? 'D' : 'S';
-        return [matchUpCount, matchUpTypeCode, ageCategoryCode, matchUpFormat, gender].join(';');
-    })
-        .join('|');
-    return {
-        tieFormatName: (tieFormat && tieFormatName) || 'UNNAMED',
-        matchUpFormats,
-        tieFormatDesc,
-    };
+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 compareTieFormats({ considerations = {}, descendant, ancestor }) {
-    const descendantDifferences = {};
-    const ancestorDifferences = {};
-    const { matchUpFormats: descendantMatchUpFormats, tieFormatDesc: descendantDesc } = getTieFormatDesc(descendant);
-    const { matchUpFormats: ancestorMatchUpFormats, tieFormatDesc: ancestorDesc } = getTieFormatDesc(ancestor);
-    const matchUpFormatDifferences = unique((descendantMatchUpFormats ?? [])
-        .filter((format) => !(ancestorMatchUpFormats ?? []).includes(format))
-        .concat((ancestorMatchUpFormats ?? []).filter((format) => !(descendantMatchUpFormats ?? []).includes(format))));
-    const nameDifference = !!(considerations?.collectionName &&
-        descendant.collectionDefinitions.map(({ collectionName }) => collectionName).join('|') !==
-            ancestor.collectionDefinitions.map(({ collectionName }) => collectionName).join('|'));
-    const orderDifference = !!(considerations?.collectionOrder &&
-        descendant.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join('|') !==
-            ancestor.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join('|'));
-    const descendantCollectionDefinitions = Object.assign({}, ...(descendant?.collectionDefinitions || []).map((collectionDefinition) => ({
-        [collectionDefinition.collectionId]: collectionDefinition,
-    })));
-    const ancestorCollectionDefinitions = Object.assign({}, ...(ancestor?.collectionDefinitions || []).map((collectionDefinition) => ({
-        [collectionDefinition.collectionId]: collectionDefinition,
-    })));
-    descendantDifferences.collectionIds = difference(Object.keys(descendantCollectionDefinitions), Object.keys(ancestorCollectionDefinitions));
-    ancestorDifferences.collectionIds = difference(Object.keys(ancestorCollectionDefinitions), Object.keys(descendantCollectionDefinitions));
-    descendantDifferences.collectionsValue = getCollectionsValue(descendantCollectionDefinitions);
-    ancestorDifferences.collectionsValue = getCollectionsValue(ancestorCollectionDefinitions);
-    descendantDifferences.groupsCount =
-        ancestor?.collectionGroups?.length ?? (0 - (descendant?.collectionGroups?.length ?? 0) || 0);
-    ancestorDifferences.groupsCount = descendantDifferences.groupsCount ? -1 * descendantDifferences.groupsCount : 0;
-    const valueDifference = descendantDifferences.collectionsValue.totalValue - ancestorDifferences.collectionsValue.totalValue;
-    const matchUpCountDifference = descendantDifferences.collectionsValue.totalMatchUps - ancestorDifferences.collectionsValue.totalMatchUps;
-    const assignmentValuesCountDifference = ancestorDifferences.collectionsValue.assignmentValues.length !==
-        descendantDifferences.collectionsValue.assignmentValues.length;
-    const assignmentValuesDifference = ancestorDifferences.collectionsValue.assignmentValues.some((assignment, i) => {
-        const comparisonAssignment = descendantDifferences.collectionsValue.assignmentValues[i];
-        if (!comparisonAssignment)
-            return true;
-        if (assignment.valueKey !== comparisonAssignment.valueKey)
-            return true;
-        if (assignment.value !== comparisonAssignment.value)
-            return true;
-        if (Array.isArray(assignment.value)) {
-            return assignment.value.every((value, i) => comparisonAssignment.value[i] === value);
-        }
-        return false;
+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,
     });
-    const different = nameDifference ||
-        orderDifference ||
-        ancestorDesc !== descendantDesc ||
-        assignmentValuesCountDifference ||
-        assignmentValuesDifference ||
-        valueDifference !== 0;
-    const invalidValues = [
-        ...ancestorDifferences.collectionsValue.invalidValues,
-        ...descendantDifferences.collectionsValue.invalidValues,
-    ];
-    const invalid = invalidValues.length && invalidValues;
+    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 {
-        matchUpFormatDifferences,
-        matchUpCountDifference,
-        descendantDifferences,
-        ancestorDifferences,
-        orderDifference,
-        valueDifference,
-        nameDifference,
-        descendantDesc,
-        ancestorDesc,
-        ...SUCCESS,
-        different,
-        invalid,
+        structures: !usePublishState || drawInfo.drawPublished
+            ? noDeepCopy
+                ? structures
+                : makeDeepCopy(structures, false, true)
+            : undefined,
+        drawInfo: noDeepCopy ? drawInfo : makeDeepCopy(drawInfo, false, true),
+        ...SUCCESS,
     };
 }
-function getCollectionsValue(definitions) {
-    const invalidValues = [];
-    const assignmentValues = [];
-    let totalMatchUps = 0;
-    const collectionIds = Object.keys(definitions).sort(stringSort);
-    const totalValue = collectionIds.reduce((total, collectionId) => {
-        const collectionDefinition = definitions[collectionId];
-        const { collectionValueProfiles, collectionValue, matchUpCount, matchUpValue, scoreValue, setValue } = collectionDefinition;
-        const valueAssignments = {
-            collectionValueProfiles,
-            collectionValue,
-            matchUpValue,
-            scoreValue,
-            setValue,
-        };
-        const valueKeys = Object.keys(valueAssignments).filter((key) => ![undefined, null].includes(valueAssignments[key]));
-        if (valueKeys.length !== 1) {
-            invalidValues.push({ collectionId });
-        }
-        const valueKey = valueKeys[0];
-        if (valueKey) {
-            const value = valueKey === 'collectionValueProfiles' ? Object.values(collectionValueProfiles) : valueAssignments[valueKey];
-            assignmentValues.push({ valueKey, value });
-        }
-        totalMatchUps += matchUpCount;
-        if (collectionValueProfiles)
-            return total + collectionValueProfiles.reduce((total, profile) => total + profile.value, 0);
-        if (matchUpCount) {
-            if (isConvertableInteger(matchUpValue))
-                return total + matchUpValue * matchUpCount;
-            if (isConvertableInteger(scoreValue))
-                return total + scoreValue * matchUpCount;
-            if (isConvertableInteger(setValue))
-                return total + setValue * matchUpCount;
-            return total + collectionValue;
-        }
-        return total;
-    }, 0);
-    return { totalValue, totalMatchUps, invalidValues, assignmentValues };
-}
 
-function publicFindMatchUp(params) {
-    Object.assign(params, { inContext: true });
-    const { matchUp, error } = findMatchUp(params);
-    return { matchUp: makeDeepCopy(matchUp, true, true), error };
-}
-function findMatchUp({ participantsProfile, afterRecoveryTimes, tournamentRecord, contextContent, contextProfile, drawDefinition, nextMatchUps, matchUpId, inContext, eventId, drawId, event, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (typeof matchUpId !== 'string')
-        return { error: MISSING_MATCHUP_ID };
-    if (!drawDefinition || !event) {
-        const matchUps = allTournamentMatchUps({ tournamentRecord, nextMatchUps }).matchUps ?? [];
-        const inContextMatchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
-        if (!inContextMatchUp)
-            return { error: MATCHUP_NOT_FOUND };
-        ({ eventId, drawId } = inContextMatchUp);
-        ({ event, drawDefinition } = findEvent({
-            tournamentRecord,
-            eventId,
-            drawId,
-        }));
-    }
-    if (!drawDefinition)
-        return { error: DRAW_DEFINITION_NOT_FOUND };
-    if (contextProfile && !contextContent)
-        contextContent = getContextContent({ tournamentRecord, contextProfile });
-    const additionalContext = {
-        surfaceCategory: event?.surfaceCategory ?? tournamentRecord.surfaceCategory,
-        indoorOutDoor: event?.indoorOutdoor ?? tournamentRecord.indoorOutdoor,
-        endDate: event?.endDate ?? tournamentRecord.endDate,
-        tournamentId: tournamentRecord.tournamentId,
-        eventId: eventId ?? event?.eventId,
-        drawId,
-    };
-    const { participants: tournamentParticipants = [] } = hydrateParticipants({
-        participantsProfile,
+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,
-        contextProfile,
-        inContext,
     });
-    if (nextMatchUps) {
-        const matchUps = allDrawMatchUps({
-            context: inContext ? additionalContext : undefined,
-            participants: tournamentParticipants,
-            afterRecoveryTimes,
-            contextContent,
-            contextProfile,
-            drawDefinition,
-            nextMatchUps,
-            inContext,
-            event,
-        }).matchUps ?? [];
-        const inContextMatchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
-        if (!inContextMatchUp)
-            return { error: MATCHUP_NOT_FOUND };
-        const structure = drawDefinition?.structures?.find((structure) => structure.structureId === inContextMatchUp.structureId);
-        return { drawDefinition, structure, matchUp: inContextMatchUp };
-    }
-    else {
-        const { matchUp, structure } = findDrawMatchUp({
-            context: inContext ? additionalContext : undefined,
+    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,
-            afterRecoveryTimes,
-            contextContent,
+            noDeepCopy: true,
+            policyDefinitions,
+            tournamentRecord,
+            usePublishState,
             drawDefinition,
-            contextProfile,
-            matchUpId,
-            inContext,
+            publishStatus,
+            sortConfig,
             event,
-        });
-        return { matchUp, structure, drawDefinition };
-    }
-}
-
-function getTieFormat$1({ tournamentRecord, drawDefinition, structureId, matchUpId, structure, eventId, drawId, event, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!drawId && !event && !structureId && !matchUpId)
-        return decorateResult({
-            result: { error: MISSING_VALUE },
-            stack: 'getTieFormat',
-        });
-    if (eventId && !event) {
-        event = tournamentRecord.events?.find((event) => event.eventId === eventId);
-    }
-    const matchUpResult = publicFindMatchUp({
+        })))
+            .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,
-        drawDefinition,
-        matchUpId,
-        drawId,
-        event,
-    });
-    if (matchUpId && matchUpResult?.error) {
-        return matchUpResult;
-    }
-    else if (!drawDefinition && matchUpResult?.drawDefinition) {
-        drawDefinition = matchUpResult?.drawDefinition;
-    }
-    structure = structure ?? matchUpResult?.structure;
-    if (!structure && structureId && !matchUpId) {
-        if (!drawDefinition)
-            return { error: MISSING_DRAW_ID };
-        const structureResult = findStructure({ drawDefinition, structureId });
-        if (structureResult.error)
-            return structureResult;
-        structure = structureResult.structure;
-    }
-    const structureDefaultTieFormat = (structure?.tieFormat || structure?.tieFormatId) &&
-        resolveTieFormat({ structure, drawDefinition, event })?.tieFormat;
-    const drawDefaultTieFormat = (drawDefinition?.tieFormat || drawDefinition?.tieFormatId) &&
-        resolveTieFormat({
-            drawDefinition,
-            event,
-        })?.tieFormat;
-    const eventDefaultTieFormat = resolveTieFormat({ event })?.tieFormat;
-    const tieFormat = resolveTieFormat({
-        matchUp: matchUpResult?.matchUp,
-        drawDefinition,
-        structure,
-        event,
-    })?.tieFormat;
-    return {
-        ...SUCCESS,
-        matchUp: matchUpResult?.matchUp,
-        structureDefaultTieFormat: copyTieFormat(structureDefaultTieFormat),
-        eventDefaultTieFormat: copyTieFormat(eventDefaultTieFormat),
-        drawDefaultTieFormat: copyTieFormat(drawDefaultTieFormat),
-        tieFormat: copyTieFormat(tieFormat),
-        structure,
+        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$8 = {
+var query$7 = {
     __proto__: null,
-    compareTieFormats: compareTieFormats,
-    getTieFormat: getTieFormat$1,
-    tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
-    validateCollectionDefinition: validateCollectionDefinition
+    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, }) {
@@ -27486,164 +28102,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 +28430,7 @@ function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentReco
     return { profileRounds, segmentedRounds };
 }
 
-var query$7 = {
+var query$6 = {
     __proto__: null,
     getPersonRequests: getPersonRequests,
     getProfileRounds: getProfileRounds,
@@ -28014,7 +28472,7 @@ function getMaxEntryPosition(params) {
         .map(({ entryPosition }) => ensureInt(entryPosition || 0)), 0);
 }
 
-var query$6 = {
+var query$5 = {
     __proto__: null,
     getEntriesAndSeedsCount: getEntriesAndSeedsCount,
     getMaxEntryPosition: getMaxEntryPosition
@@ -29930,7 +30388,7 @@ function drawMatchUps({ participants: tournamentParticipants, tournamentAppliedP
     return { ...drawMatchUpsResult, groupInfo };
 }
 
-var query$5 = {
+var query$4 = {
     __proto__: null,
     allCompetitionMatchUps: allCompetitionMatchUps,
     allDrawMatchUps: allDrawMatchUps,
@@ -29993,7 +30451,7 @@ function getCourts({ tournamentRecord, venueId, venueIds }) {
     return { courts };
 }
 
-var query$4 = {
+var query$3 = {
     __proto__: null,
     getCompetitionVenues: getCompetitionVenues,
     getCourts: getCourts,
@@ -30001,42 +30459,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 +30723,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 +30761,7 @@ var index$g = {
     findDrawDefinition: publicFindDrawDefinition,
     findExtension: findExtension,
     getAllDrawMatchUps: getAllDrawMatchUps,
+    getAllEventData: getAllEventData,
     getAllStructureMatchUps: getAllStructureMatchUps,
     getAllowedDrawTypes: getAllowedDrawTypes,
     getAllowedMatchUpFormats: getAllowedMatchUpFormats,
@@ -30354,15 +30776,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 +30824,7 @@ var index$g = {
     getPositionsPlayedOff: getPositionsPlayedOff,
     getPredictiveAccuracy: getPredictiveAccuracy,
     getProfileRounds: getProfileRounds,
+    getPublishState: getPublishState,
     getRoundMatchUps: getRoundMatchUps,
     getRounds: getRounds,
     getScaleValues: getScaleValues,
@@ -30418,6 +30845,7 @@ var index$g = {
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
     getValidGroupSizes: getValidGroupSizes,
+    getVenueData: getVenueData,
     getVenuesAndCourts: getVenuesAndCourts,
     isAdHoc: isAdHoc,
     isCompletedStructure: isCompletedStructure,
@@ -33792,7 +34220,7 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '' }) {
     }
 }
 
-var query$2 = {
+var query$1 = {
     __proto__: null,
     analyzeSet: analyzeSet,
     checkScoreHasValue: checkScoreHasValue,
@@ -33827,7 +34255,7 @@ var scoreGovernor = {
     mutate: mutate$b,
     parseMatchUpFormat: parse,
     parseScoreString: parseScoreString,
-    query: query$2,
+    query: query$1,
     redo: redo,
     reverseScore: reverseScore,
     setServingSide: setServingSide,
@@ -35858,7 +36286,7 @@ var mutate$a = {
     removePolicy: removePolicy
 };
 
-var query$1 = {
+var query = {
     __proto__: null,
     findPolicy: findPolicy,
     getAppliedPolicies: getAppliedPolicies,
@@ -35872,7 +36300,7 @@ var index$f = {
     getAppliedPolicies: getAppliedPolicies,
     getPolicyDefinitions: getPolicyDefinitions,
     mutate: mutate$a,
-    query: query$1,
+    query: query,
     removePolicy: removePolicy
 };
 
@@ -36861,7 +37289,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 +37312,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 +38860,6 @@ var index$c = {
     addFlight: addFlight,
     assignSeedPositions: assignSeedPositions,
     attachFlightProfile: attachFlightProfile,
-    bulkUpdatePublishedEventIds: bulkUpdatePublishedEventIds,
     categoryCanContain: categoryCanContain,
     deleteDrawDefinitions: deleteDrawDefinitions,
     deleteEvents: deleteEvents,
@@ -38749,7 +38877,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 +44076,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 +45665,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 +50830,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 +50844,7 @@ var index$7 = {
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
-    query: query,
+    query: query$7,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
@@ -52663,7 +52742,7 @@ var index$5 = {
     proAutoSchedule: proAutoSchedule,
     proConflicts: proConflicts,
     publicFindCourt: publicFindCourt,
-    query: query$7,
+    query: query$6,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,
@@ -54490,13 +54569,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 +54588,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 +54614,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 +55427,7 @@ var index$2 = {
     modifyVenue: modifyVenue,
     mutate: mutate,
     publicFindVenue: publicFindVenue,
-    query: query$4
+    query: query$3
 };
 
 var governors = {
@@ -55820,7 +55914,7 @@ function notifySubscribers(params) {
     const { topics } = getTopics();
     for (const topic of [...topics].sort(topicSort)) {
         const notices = getNotices({ topic });
-        if (notices)
+        if (notices?.length)
             callListener({ topic, notices });
     }
     if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
@@ -56005,25 +56099,11 @@ async function asyncEngineInvoke(engine, args) {
     return result;
 }
 
-function importMethods(engine, engineInvoke, submittedMethods, traverse, maxDepth) {
-    if (!isObject(submittedMethods))
-        return { error: INVALID_VALUES };
-    const collectionFilter = Array.isArray(traverse) ? traverse : [];
-    const methods = {};
-    const attrWalker = (obj, depth = 0) => {
-        Object.keys(obj).forEach((key) => {
-            if (isFunction(obj[key])) {
-                methods[key] = obj[key];
-            }
-            else if (isObject(obj[key]) &&
-                (traverse === true || collectionFilter?.includes(key)) &&
-                (maxDepth === undefined || depth < maxDepth)) {
-                attrWalker(obj[key], depth + 1);
-            }
-        });
-    };
-    attrWalker(submittedMethods);
-    setMethods(methods);
+function methodImporter(engine, engineInvoke, submittedMethods, traverse, maxDepth, global) {
+    const setResult = setStateMethods(submittedMethods, traverse, maxDepth, global);
+    if (setResult.error)
+        return setResult;
+    const methods = setResult.methods ?? [];
     const methodNames = Object.keys(methods).filter((key) => isFunction(methods[key]));
     methodNames.forEach((methodName) => {
         engine[methodName] = (params) => {
@@ -56065,7 +56145,7 @@ function processResult(engine, result) {
 }
 
 function engineStart(engine, engineInvoke) {
-    engine.importMethods = (methods, collections, depth) => importMethods(engine, engineInvoke, methods, collections, depth);
+    engine.importMethods = (methods, collections, depth, global) => methodImporter(engine, engineInvoke, methods, collections, depth, global);
     engine.getTournament = (params) => getTournament(params);
     engine.getState = (params) => getState$1({
         convertExtensions: params?.convertExtensions,