tods-competition-factory 2.0.0-alpha.1 → 2.0.0-beta.1

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.0-alpha.1';
+    return '2.0.0-beta.1';
 }
 
 /******************************************************************************
@@ -2103,141 +2103,6 @@ var eventConstants = {
     TEAM: TEAM$2,
 };
 
-function getScaleValues(_a) {
-    var e_1, _b;
-    var _c;
-    var participant = _a.participant;
-    var scaleItems = (_c = participant.timeItems) === null || _c === void 0 ? void 0 : _c.filter(function (_a) {
-        var itemType = _a.itemType;
-        return (itemType === null || itemType === void 0 ? void 0 : itemType.startsWith(SCALE$1)) &&
-            [RANKING$1, RATING$2, SEEDING$1].includes(itemType.split('.')[1]);
-    });
-    var scales = { ratings: {}, rankings: {}, seedings: {} };
-    if (scaleItems === null || scaleItems === void 0 ? void 0 : scaleItems.length) {
-        var latestScaleItem = function (scaleType) {
-            return scaleItems
-                .filter(function (timeItem) { return (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) === scaleType; })
-                .sort(function (a, b) {
-                return new Date(a.createdAt || undefined).getTime() -
-                    new Date(b.createdAt || undefined).getTime();
-            })
-                .pop();
-        };
-        var itemTypes = unique(scaleItems.map(function (_a) {
-            var itemType = _a.itemType;
-            return itemType;
-        }));
-        try {
-            for (var itemTypes_1 = __values(itemTypes), itemTypes_1_1 = itemTypes_1.next(); !itemTypes_1_1.done; itemTypes_1_1 = itemTypes_1.next()) {
-                var itemType = itemTypes_1_1.value;
-                var scaleItem = latestScaleItem(itemType);
-                if (scaleItem) {
-                    var _d = __read(scaleItem.itemType.split('.'), 5), type = _d[1], format = _d[2], scaleName = _d[3], modifier = _d[4];
-                    var namedScale = modifier ? "".concat(scaleName, ".").concat(modifier) : scaleName;
-                    var 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,
-                    });
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (itemTypes_1_1 && !itemTypes_1_1.done && (_b = itemTypes_1.return)) _b.call(itemTypes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    }
-    return __assign(__assign({}, SUCCESS), scales);
-}
-
-// NOTE: type really does need to be any!
-function attributeFilter(params) {
-    if (params === null)
-        return {};
-    var _a = params || {}, source = _a.source, template = _a.template;
-    if (!template)
-        return source;
-    var target = {};
-    attributeCopy(source, template, target);
-    return target;
-    function attributeCopy(valuesObject, templateObject, outputObject) {
-        var e_1, _a;
-        if (!valuesObject || !templateObject)
-            return undefined;
-        var vKeys = Object.keys(valuesObject);
-        var oKeys = Object.keys(templateObject);
-        // the orMap allows spcification of { 'a||b': boolean } so that filter templates can apply to multiple attributes
-        var orMap = Object.assign.apply(Object, __spreadArray([{}], __read(oKeys
-            .filter(function (key) { return key.indexOf('||'); })
-            .map(function (key) { return key.split('||').map(function (or) {
-            var _a;
-            return (_a = {}, _a[or] = key, _a);
-        }); })
-            .flat()), false));
-        var allKeys = oKeys.concat.apply(oKeys, __spreadArray([], __read(Object.keys(orMap)), false));
-        var wildcard = allKeys.includes('*');
-        var _loop_1 = function (vKey) {
-            if (allKeys.indexOf(vKey) >= 0 || wildcard) {
-                var templateKey = orMap[vKey] || vKey;
-                var tobj_1 = templateObject[templateKey] || wildcard;
-                var vobj = valuesObject[vKey];
-                if (typeof tobj_1 === 'object' &&
-                    typeof vobj !== 'function' &&
-                    !Array.isArray(tobj_1)) {
-                    if (Array.isArray(vobj)) {
-                        var mappedElements = vobj
-                            .map(function (arrayMember) {
-                            var target = {};
-                            var result = attributeCopy(arrayMember, tobj_1, target);
-                            return result !== false ? target : undefined;
-                        })
-                            .filter(Boolean);
-                        outputObject[vKey] = mappedElements;
-                    }
-                    else if (vobj) {
-                        outputObject[vKey] = {};
-                        attributeCopy(vobj, tobj_1, outputObject[vKey]);
-                    }
-                }
-                else {
-                    var value = valuesObject[vKey];
-                    var exclude = Array.isArray(tobj_1) && !tobj_1.includes(value);
-                    if (exclude)
-                        return { value: false };
-                    if (templateObject[vKey] ||
-                        (wildcard && templateObject[vKey] !== false)) {
-                        outputObject[vKey] = value;
-                    }
-                }
-            }
-        };
-        try {
-            for (var vKeys_1 = __values(vKeys), vKeys_1_1 = vKeys_1.next(); !vKeys_1_1.done; vKeys_1_1 = vKeys_1.next()) {
-                var vKey = vKeys_1_1.value;
-                var state_1 = _loop_1(vKey);
-                if (typeof state_1 === "object")
-                    return state_1.value;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (vKeys_1_1 && !vKeys_1_1.done && (_a = vKeys_1.return)) _a.call(vKeys_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return undefined;
-    }
-}
-
 var validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
 var validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
 var 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?$/;
@@ -2669,238 +2534,6 @@ function extensionsToAttributes(extensions) {
     }).filter(Boolean);
 }
 
-var POLICY_TYPE_VOLUNTARY_CONSOLATION = 'voluntaryConsolation';
-var POLICY_TYPE_COMPETITIVE_BANDS = 'competitiveBands';
-var POLICY_TYPE_ROUND_ROBIN_TALLY = 'roundRobinTally';
-var POLICY_TYPE_POSITION_ACTIONS = 'positionActions';
-var POLICY_TYPE_MATCHUP_ACTIONS = 'matchUpActions';
-var POLICY_TYPE_RANKING_POINTS = 'rankingPoints';
-var POLICY_TYPE_ROUND_NAMING = 'roundNaming';
-var POLICY_TYPE_PARTICIPANT = 'participant';
-var POLICY_TYPE_PROGRESSION = 'progression';
-var POLICY_TYPE_SCHEDULING = 'scheduling';
-var POLICY_TYPE_AVOIDANCE = 'avoidance';
-var POLICY_TYPE_DISPLAY = 'display'; // storage for client type displays, e.g. { public: {}, admin: {} }
-var POLICY_TYPE_SCORING = 'scoring';
-var POLICY_TYPE_SEEDING = 'seeding';
-var POLICY_TYPE_FEED_IN = 'feedIn';
-var POLICY_TYPE_AUDIT = 'audit';
-var POLICY_TYPE_DRAWS = 'draws';
-var policyConstants = {
-    POLICY_TYPE_VOLUNTARY_CONSOLATION: POLICY_TYPE_VOLUNTARY_CONSOLATION,
-    POLICY_TYPE_COMPETITIVE_BANDS: POLICY_TYPE_COMPETITIVE_BANDS,
-    POLICY_TYPE_ROUND_ROBIN_TALLY: POLICY_TYPE_ROUND_ROBIN_TALLY,
-    POLICY_TYPE_POSITION_ACTIONS: POLICY_TYPE_POSITION_ACTIONS,
-    POLICY_TYPE_MATCHUP_ACTIONS: POLICY_TYPE_MATCHUP_ACTIONS,
-    POLICY_TYPE_RANKING_POINTS: POLICY_TYPE_RANKING_POINTS,
-    POLICY_TYPE_ROUND_NAMING: POLICY_TYPE_ROUND_NAMING,
-    POLICY_TYPE_PARTICIPANT: POLICY_TYPE_PARTICIPANT,
-    POLICY_TYPE_PROGRESSION: POLICY_TYPE_PROGRESSION,
-    POLICY_TYPE_SCHEDULING: POLICY_TYPE_SCHEDULING,
-    POLICY_TYPE_AVOIDANCE: POLICY_TYPE_AVOIDANCE,
-    POLICY_TYPE_DISPLAY: POLICY_TYPE_DISPLAY,
-    POLICY_TYPE_FEED_IN: POLICY_TYPE_FEED_IN,
-    POLICY_TYPE_SCORING: POLICY_TYPE_SCORING,
-    POLICY_TYPE_SEEDING: POLICY_TYPE_SEEDING,
-    POLICY_TYPE_AUDIT: POLICY_TYPE_AUDIT,
-    POLICY_TYPE_DRAWS: POLICY_TYPE_DRAWS,
-};
-
-function findParticipant(_a) {
-    var _b = _a.tournamentParticipants, tournamentParticipants = _b === void 0 ? [] : _b, _c = _a.policyDefinitions, policyDefinitions = _c === void 0 ? {} : _c, contextProfile = _a.contextProfile, participantId = _a.participantId, internalUse = _a.internalUse, personId = _a.personId;
-    var foundParticipant = tournamentParticipants.find(function (candidate) {
-        return (participantId && candidate.participantId === participantId) ||
-            (personId && candidate.person && candidate.person.personId === personId);
-    });
-    var participant = makeDeepCopy(foundParticipant, false, internalUse);
-    if (participant) {
-        var participantAttributes = policyDefinitions === null || policyDefinitions === void 0 ? void 0 : policyDefinitions[POLICY_TYPE_PARTICIPANT];
-        if (contextProfile === null || contextProfile === void 0 ? void 0 : contextProfile.withScaleValues) {
-            var _d = getScaleValues({ participant: participant }), ratings = _d.ratings, rankings = _d.rankings;
-            participant.rankings = rankings;
-            participant.ratings = ratings;
-        }
-        if (participantAttributes === null || participantAttributes === void 0 ? void 0 : participantAttributes.participant) {
-            return attributeFilter({
-                template: participantAttributes.participant,
-                source: participant,
-            });
-        }
-    }
-    return participant;
-}
-
-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) {
-    var _a;
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    var tournamentParticipants = ((_a = params.tournamentRecord) === null || _a === void 0 ? void 0 : _a.participants) || [];
-    var participant = findParticipant({
-        participantId: params.participantId,
-        tournamentParticipants: 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 === null || params === void 0 ? void 0 : params.event))
-        return { error: EVENT_NOT_FOUND };
-    return removeExtension({ element: params.event, name: params.name });
-}
-function removeParticipantExtension(params) {
-    var _a;
-    if (!params || typeof params !== 'object')
-        return { error: MISSING_VALUE };
-    if (!params.participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    var tournamentParticipants = ((_a = params.tournamentRecord) === null || _a === void 0 ? void 0 : _a.participants) || [];
-    var participant = findParticipant({
-        participantId: params.participantId,
-        tournamentParticipants: tournamentParticipants,
-    });
-    if (!participant)
-        return { error: PARTICIPANT_NOT_FOUND };
-    return removeExtension({ element: participant, name: params.name });
-}
-
-var ACTIVE_SUSPENSION = 'activeSuspension';
-var APPLIED_POLICIES = 'appliedPolicies';
-var AUDIT_POSITION_ACTIONS = 'positionActions';
-var CONTEXT = 'context';
-var DELEGATED_OUTCOME = 'delegatedOutcome';
-var DISABLED = 'disabled';
-var DISABLE_LINKS = 'disableLinks';
-var DISABLE_AUTO_CALC = 'disableAutoCalc';
-var DRAW_DELETIONS = 'drawDeletions';
-var DRAW_PROFILE = 'drawProfile';
-var ENTRY_PROFILE = 'entryProfile';
-var EVENT_PROFILE = 'eventProfile';
-var EVENT_WITHDRAWAL_REQUESTS = 'eventWithdrawalRequests';
-var FACTORY$1 = 'factory';
-var FLIGHT_PROFILE = 'flightProfile';
-var GROUPING_ATTRIBUTE = 'groupingAttribute';
-var LINEUPS = 'lineUps';
-var LINKED_TOURNAMENTS = 'linkedTournamentsIds';
-var MATCHUP_HISTORY = 'matchUpHistory';
-var PARTICIPANT_REPRESENTATIVES = 'participantRepresentatives';
-var PERSON_REQUESTS = 'personRequests';
-var RANKING_POINTS = 'rankingPoints';
-var ROUND_TARGET = 'roundTarget';
-var SCHEDULE_LIMITS = 'scheduleLimits';
-var SCHEDULE_TIMING = 'scheduleTiming';
-var SCHEDULING_PROFILE = 'schedulingProfile';
-var STATUS_DETAIL = 'statusDetail';
-var SUB_ORDER = 'subOrder';
-var TALLY = 'tally';
-var TIE_FORMAT_MODIFICATIONS = 'tieFormatModification';
-var extensionConstants = {
-    ACTIVE_SUSPENSION: ACTIVE_SUSPENSION,
-    APPLIED_POLICIES: APPLIED_POLICIES,
-    AUDIT_POSITION_ACTIONS: AUDIT_POSITION_ACTIONS,
-    CONTEXT: CONTEXT, // used to capture, e.g. context in which a venue was added
-    DELEGATED_OUTCOME: DELEGATED_OUTCOME,
-    DISABLED: DISABLED,
-    DISABLE_LINKS: DISABLE_LINKS,
-    DISABLE_AUTO_CALC: DISABLE_AUTO_CALC,
-    DRAW_DELETIONS: DRAW_DELETIONS,
-    DRAW_PROFILE: DRAW_PROFILE,
-    ENTRY_PROFILE: ENTRY_PROFILE, // used for drawGeneration; not relevant for anonymized tournaments
-    EVENT_PROFILE: EVENT_PROFILE,
-    EVENT_WITHDRAWAL_REQUESTS: EVENT_WITHDRAWAL_REQUESTS,
-    FLIGHT_PROFILE: FLIGHT_PROFILE,
-    GROUPING_ATTRIBUTE: GROUPING_ATTRIBUTE, // for generating teams; not relevant for anonymized tournaments
-    LINEUPS: LINEUPS,
-    LINKED_TOURNAMENTS: LINKED_TOURNAMENTS,
-    MATCHUP_HISTORY: MATCHUP_HISTORY,
-    PARTICIPANT_REPRESENTATIVES: PARTICIPANT_REPRESENTATIVES,
-    PERSON_REQUESTS: PERSON_REQUESTS,
-    RANKING_POINTS: RANKING_POINTS, // for attaching points awarded to tournamentRecord
-    ROUND_TARGET: ROUND_TARGET,
-    SCHEDULE_LIMITS: SCHEDULE_LIMITS,
-    SCHEDULE_TIMING: SCHEDULE_TIMING,
-    SCHEDULING_PROFILE: SCHEDULING_PROFILE,
-    STATUS_DETAIL: STATUS_DETAIL, // attached to event.entries
-    SUB_ORDER: SUB_ORDER,
-    TALLY: TALLY,
-    TIE_FORMAT_MODIFICATIONS: TIE_FORMAT_MODIFICATIONS, // for auditing, not important when anonymized
-    FACTORY: FACTORY$1,
-};
-var internalExtensions = [
-    DELEGATED_OUTCOME,
-    DISABLED,
-    DISABLE_LINKS,
-    FLIGHT_PROFILE,
-    LINEUPS,
-    MATCHUP_HISTORY,
-    PARTICIPANT_REPRESENTATIVES,
-    PERSON_REQUESTS,
-    ROUND_TARGET,
-    SCHEDULE_LIMITS,
-    SCHEDULE_TIMING,
-    SCHEDULING_PROFILE,
-    SUB_ORDER,
-    TALLY,
-];
-
 function getAccessorValue(_a) {
     var element = _a.element, accessor = _a.accessor;
     if (typeof accessor !== 'string')
@@ -3091,94 +2724,625 @@ function generateHashCode(o) {
     return [str.length, keyCount, charSum].map(function (e) { return e.toString(36); }).join('');
 }
 
-function getTournamentIds(_a) {
-    var tournamentRecords = _a.tournamentRecords;
-    var tournamentIds = isObject(tournamentRecords)
-        ? Object.keys(tournamentRecords)
-        : [];
-    return __assign({ tournamentIds: tournamentIds }, SUCCESS);
-}
+var TOURNAMENT_RECORDS = 'tournamentRecords';
+var POLICY_DEFINITIONS = 'policyDefinitions';
+var TOURNAMENT_RECORD = 'tournamentRecord';
+var DRAW_DEFINITION = 'drawDefinition';
+var MATCHUP_FORMAT = 'matchUpFormat';
+var PARTICIPANT_ID = 'participantId';
+var SCHEDULE_DATES = 'scheduleDates';
+var TOURNAMENT_ID = 'tournamentId';
+var SCHEDULE_DATE = 'scheduleDate';
+var STRUCTURE_ID = 'structureId';
+var PARTICIPANT = 'participant';
+var MATCHUP_IDS = 'matchUpIds';
+var POLICY_TYPE = 'policyType';
+var STRUCTURES = 'structures';
+var MATCHUP_ID = 'matchUpId';
+var IN_CONTEXT = 'inContext';
+var STRUCTURE = 'structure';
+var COURT_IDS = 'courtIds';
+var PERSON_ID = 'personId';
+var VENUE_IDS = 'venueIds';
+var MATCHUPS = 'matchUps';
+var COURT_ID = 'courtId';
+var EVENT_ID = 'eventId';
+var MATCHUP = 'matchUp';
+var DRAW_ID = 'drawId';
+var ERROR = 'error';
+var EVENT = 'event';
+var PARAM = 'param';
+var AVERAGE_MATCHUP_MINUTES = 'averageMatchUpMinutes';
+var RECOVERY_MINUTES = 'recoveryMinutes';
+var PERIOD_LENGTH = 'periodLength';
+var OBJECT = 'object';
+var ARRAY = 'array';
+var VALIDATE = 'validate';
+var INVALID = 'invalid';
+var OF_TYPE = '_ofType';
+var ANY_OF = '_anyOf';
+var ONE_OF = '_oneOf';
 
-/**
- * Links all tournaments which are currently loaded into competitionEngine state
- */
-function linkTournaments(_a) {
-    var tournamentRecords = _a.tournamentRecords;
-    if (typeof tournamentRecords !== 'object' ||
-        !Object.keys(tournamentRecords).length)
-        return { error: MISSING_TOURNAMENT_RECORDS };
-    var result = getTournamentIds({ tournamentRecords: tournamentRecords });
-    var tournamentIds = result.tournamentIds;
-    if ((tournamentIds === null || tournamentIds === void 0 ? void 0 : tournamentIds.length) > 1) {
-        var extension = {
-            name: LINKED_TOURNAMENTS,
-            value: { tournamentIds: tournamentIds },
-        };
-        return addExtension({
-            tournamentRecords: tournamentRecords,
-            discover: true,
-            extension: extension,
-        });
-    }
-    return __assign({}, SUCCESS);
-}
-function unlinkTournaments(_a) {
-    var tournamentRecords = _a.tournamentRecords;
-    if (typeof tournamentRecords !== 'object' ||
-        !Object.keys(tournamentRecords).length)
-        return { error: MISSING_TOURNAMENT_RECORDS };
-    var result = removeExtension({
-        name: LINKED_TOURNAMENTS,
-        tournamentRecords: tournamentRecords,
-        discover: true,
+var _a$k, _b$8;
+var errors = (_a$k = {},
+    _a$k[TOURNAMENT_RECORDS] = MISSING_TOURNAMENT_RECORDS,
+    _a$k[TOURNAMENT_RECORD] = MISSING_TOURNAMENT_RECORD,
+    _a$k[POLICY_DEFINITIONS] = MISSING_POLICY_DEFINITION,
+    _a$k[DRAW_DEFINITION] = MISSING_DRAW_DEFINITION,
+    _a$k[PARTICIPANT_ID] = MISSING_PARTICIPANT_ID,
+    _a$k[TOURNAMENT_ID] = MISSING_TOURNAMENT_ID,
+    _a$k[STRUCTURE_ID] = MISSING_STRUCTURE_ID,
+    _a$k[MATCHUP_IDS] = MISSING_MATCHUP_IDS,
+    _a$k[PARTICIPANT] = MISSING_PARTICIPANT,
+    _a$k[STRUCTURES] = MISSING_STRUCTURES,
+    _a$k[MATCHUP_ID] = MISSING_MATCHUP_ID,
+    _a$k[STRUCTURE] = MISSING_STRUCTURE,
+    _a$k[COURT_ID] = MISSING_COURT_ID,
+    _a$k[MATCHUPS] = MISSING_MATCHUPS,
+    _a$k[MATCHUP] = MISSING_MATCHUP,
+    _a$k[COURT_IDS] = MISSING_VALUE,
+    _a$k[VENUE_IDS] = MISSING_VALUE,
+    _a$k[DRAW_ID] = MISSING_DRAW_ID,
+    _a$k[EVENT_ID] = MISSING_EVENT,
+    _a$k[EVENT] = EVENT_NOT_FOUND,
+    _a$k);
+var paramTypes = (_b$8 = {},
+    _b$8[TOURNAMENT_RECORDS] = OBJECT,
+    _b$8[POLICY_DEFINITIONS] = OBJECT,
+    _b$8[TOURNAMENT_RECORD] = OBJECT,
+    _b$8[DRAW_DEFINITION] = OBJECT,
+    _b$8[SCHEDULE_DATES] = ARRAY,
+    _b$8[PARTICIPANT] = OBJECT,
+    _b$8[MATCHUP_IDS] = ARRAY,
+    _b$8[STRUCTURES] = ARRAY,
+    _b$8[STRUCTURE] = OBJECT,
+    _b$8[COURT_IDS] = ARRAY,
+    _b$8[VENUE_IDS] = ARRAY,
+    _b$8[MATCHUPS] = ARRAY,
+    _b$8[MATCHUP] = OBJECT,
+    _b$8[EVENT] = OBJECT,
+    _b$8);
+function checkRequiredParameters(params, requiredParams, stack) {
+    if (!params && !isObject(params))
+        return { error: INVALID_VALUES };
+    if (!(requiredParams === null || requiredParams === void 0 ? void 0 : requiredParams.length) || (params === null || params === void 0 ? void 0 : params._bypassParamCheck))
+        return { valid: true };
+    if (!Array.isArray(requiredParams))
+        return { error: INVALID_VALUES };
+    var _a = findParamError(params, requiredParams), paramError = _a.paramError, errorParam = _a.errorParam;
+    if (!paramError)
+        return { valid: true };
+    var error = params[errorParam] === undefined
+        ? errors[errorParam] || INVALID_VALUES
+        : (paramError.validate && paramError.invalid) || INVALID_VALUES;
+    return decorateResult({
+        info: { param: errorParam },
+        result: { error: error },
+        stack: stack,
     });
-    // TODO: check the integrity of the venues attached to each tournment...
-    // get all competitionScheduleMatchUps and ensure that each tournamentRecord has all venues for scheduled matchUps
-    return decorateResult({ result: result, stack: 'unlinkTournaments' });
 }
-function unlinkTournament(_a) {
-    var tournamentRecords = _a.tournamentRecords, tournamentId = _a.tournamentId;
-    if (typeof tournamentRecords !== 'object')
+function getIntersection(params, constraint) {
+    var paramKeys = Object.keys(params);
+    var constraintKeys = Object.keys(constraint);
+    return intersection(paramKeys, constraintKeys);
+}
+function getOneOf(params, _oneOf) {
+    if (!_oneOf)
+        return;
+    var overlap = getIntersection(params, _oneOf);
+    if (overlap.length !== 1)
         return { error: INVALID_VALUES };
-    if (!tournamentId)
-        return { error: MISSING_TOURNAMENT_ID };
-    var result = getTournamentIds({ tournamentRecords: tournamentRecords });
-    var tournamentIds = result.tournamentIds;
-    if (!tournamentIds.includes(tournamentId))
-        return { error: MISSING_TOURNAMENT_ID };
-    // not using bulk update function here to handle scenario where
-    // tournamentRecords loaded into state are not all linked
-    var unlinkError;
-    tournamentIds.every(function (currentTournamentId) {
+    return overlap.reduce(function (attr, param) {
         var _a;
-        var tournamentRecord = tournamentRecords[currentTournamentId];
-        var extension = findExtension({
-            element: tournamentRecord,
-            name: LINKED_TOURNAMENTS,
-        }).extension;
-        // if there is no extension return { ...SUCCESS } because no links exist
-        if (!extension)
-            return true;
-        var linkedTournamentIds = ((_a = extension === null || extension === void 0 ? void 0 : extension.value) === null || _a === void 0 ? void 0 : _a.tournamentIds) || [];
-        // if there are no tournamentIds
-        if (!(linkedTournamentIds === null || linkedTournamentIds === void 0 ? void 0 : linkedTournamentIds.length) ||
-            (linkedTournamentIds.length === 1 &&
-                linkedTournamentIds.includes(tournamentId)) ||
-            currentTournamentId === tournamentId) {
-            var result_1 = removeTournamentExtension({
-                name: LINKED_TOURNAMENTS,
-                tournamentRecord: tournamentRecord,
-            });
-            if (result_1.error)
-                unlinkError = result_1.error;
-            return result_1.success;
-        }
-        var tournamentIds = linkedTournamentIds.filter(function (linkedTournamentId) { return linkedTournamentId !== tournamentId; });
-        extension.value = { tournamentIds: tournamentIds };
-        var result = addTournamentExtension({ tournamentRecord: tournamentRecord, extension: extension });
-        if (result.error)
-            unlinkError = result.error;
-        return result.success;
+        return (__assign(__assign({}, attr), (_a = {}, _a[param] = true, _a)));
+    }, {});
+}
+function getAnyOf(params, _anyOf) {
+    if (!_anyOf)
+        return;
+    var overlap = getIntersection(params, _anyOf).filter(function (param) { return params[param]; });
+    if (overlap.length < 1)
+        return { error: INVALID_VALUES };
+    return overlap.reduce(function (attr, param) {
+        var _a;
+        return (__assign(__assign({}, attr), (_a = {}, _a[param] = true, _a)));
+    }, {});
+}
+function findParamError(params, requiredParams) {
+    var errorParam;
+    var paramError = requiredParams.find(function (_a) {
+        var _ofType = _a._ofType, _oneOf = _a._oneOf, _anyOf = _a._anyOf, validate = _a.validate, attrs = __rest(_a, ["_ofType", "_oneOf", "_anyOf", "validate"]);
+        var oneOf = _oneOf && getOneOf(params, _oneOf);
+        if (oneOf === null || oneOf === void 0 ? void 0 : oneOf.error)
+            return oneOf.error;
+        oneOf && Object.assign(attrs, oneOf);
+        var anyOf = _anyOf && getAnyOf(params, _anyOf);
+        if (anyOf === null || anyOf === void 0 ? void 0 : anyOf.error)
+            return anyOf.error;
+        anyOf && Object.assign(attrs, anyOf);
+        var booleanParams = Object.keys(attrs).filter(function (key) { return typeof attrs[key] === 'boolean'; });
+        var invalidParam = booleanParams.find(function (param) {
+            var invalid = !isFunction(validate) &&
+                (params[param] === undefined || invalidType(params, param, _ofType));
+            var hasError = invalid || (validate && !checkValidation(params[param], validate));
+            if (hasError)
+                errorParam = param;
+            return hasError;
+        });
+        return !booleanParams.length || invalidParam;
+    });
+    return { paramError: paramError, errorParam: errorParam };
+}
+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;
+}
+
+function getScaleValues(params) {
+    var e_1, _a;
+    var _b;
+    var paramCheck = checkRequiredParameters(params, [{ participant: true }]);
+    if (paramCheck.error)
+        return paramCheck;
+    var scaleItems = (_b = params.participant.timeItems) === null || _b === void 0 ? void 0 : _b.filter(function (_a) {
+        var itemType = _a.itemType;
+        return (itemType === null || itemType === void 0 ? void 0 : itemType.startsWith(SCALE$1)) &&
+            [RANKING$1, RATING$2, SEEDING$1].includes(itemType.split('.')[1]);
+    });
+    var scales = { ratings: {}, rankings: {}, seedings: {} };
+    if (scaleItems === null || scaleItems === void 0 ? void 0 : scaleItems.length) {
+        var latestScaleItem = function (scaleType) {
+            return scaleItems
+                .filter(function (timeItem) { return (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) === scaleType; })
+                .sort(function (a, b) {
+                return new Date(a.createdAt || undefined).getTime() -
+                    new Date(b.createdAt || undefined).getTime();
+            })
+                .pop();
+        };
+        var itemTypes = unique(scaleItems.map(function (_a) {
+            var itemType = _a.itemType;
+            return itemType;
+        }));
+        try {
+            for (var itemTypes_1 = __values(itemTypes), itemTypes_1_1 = itemTypes_1.next(); !itemTypes_1_1.done; itemTypes_1_1 = itemTypes_1.next()) {
+                var itemType = itemTypes_1_1.value;
+                var scaleItem = latestScaleItem(itemType);
+                if (scaleItem) {
+                    var _c = __read(scaleItem.itemType.split('.'), 5), type = _c[1], format = _c[2], scaleName = _c[3], modifier = _c[4];
+                    var namedScale = modifier ? "".concat(scaleName, ".").concat(modifier) : scaleName;
+                    var 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,
+                    });
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (itemTypes_1_1 && !itemTypes_1_1.done && (_a = itemTypes_1.return)) _a.call(itemTypes_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return __assign(__assign({}, SUCCESS), scales);
+}
+
+// NOTE: type really does need to be any!
+function attributeFilter(params) {
+    if (params === null)
+        return {};
+    var _a = params || {}, source = _a.source, template = _a.template;
+    if (!template)
+        return source;
+    var target = {};
+    attributeCopy(source, template, target);
+    return target;
+    function attributeCopy(valuesObject, templateObject, outputObject) {
+        var e_1, _a;
+        if (!valuesObject || !templateObject)
+            return undefined;
+        var vKeys = Object.keys(valuesObject);
+        var oKeys = Object.keys(templateObject);
+        // the orMap allows spcification of { 'a||b': boolean } so that filter templates can apply to multiple attributes
+        var orMap = Object.assign.apply(Object, __spreadArray([{}], __read(oKeys
+            .filter(function (key) { return key.indexOf('||'); })
+            .map(function (key) { return key.split('||').map(function (or) {
+            var _a;
+            return (_a = {}, _a[or] = key, _a);
+        }); })
+            .flat()), false));
+        var allKeys = oKeys.concat.apply(oKeys, __spreadArray([], __read(Object.keys(orMap)), false));
+        var wildcard = allKeys.includes('*');
+        var _loop_1 = function (vKey) {
+            if (allKeys.indexOf(vKey) >= 0 || wildcard) {
+                var templateKey = orMap[vKey] || vKey;
+                var tobj_1 = templateObject[templateKey] || wildcard;
+                var vobj = valuesObject[vKey];
+                if (typeof tobj_1 === 'object' &&
+                    typeof vobj !== 'function' &&
+                    !Array.isArray(tobj_1)) {
+                    if (Array.isArray(vobj)) {
+                        var mappedElements = vobj
+                            .map(function (arrayMember) {
+                            var target = {};
+                            var result = attributeCopy(arrayMember, tobj_1, target);
+                            return result !== false ? target : undefined;
+                        })
+                            .filter(Boolean);
+                        outputObject[vKey] = mappedElements;
+                    }
+                    else if (vobj) {
+                        outputObject[vKey] = {};
+                        attributeCopy(vobj, tobj_1, outputObject[vKey]);
+                    }
+                }
+                else {
+                    var value = valuesObject[vKey];
+                    var exclude = Array.isArray(tobj_1) && !tobj_1.includes(value);
+                    if (exclude)
+                        return { value: false };
+                    if (templateObject[vKey] ||
+                        (wildcard && templateObject[vKey] !== false)) {
+                        outputObject[vKey] = value;
+                    }
+                }
+            }
+        };
+        try {
+            for (var vKeys_1 = __values(vKeys), vKeys_1_1 = vKeys_1.next(); !vKeys_1_1.done; vKeys_1_1 = vKeys_1.next()) {
+                var vKey = vKeys_1_1.value;
+                var state_1 = _loop_1(vKey);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (vKeys_1_1 && !vKeys_1_1.done && (_a = vKeys_1.return)) _a.call(vKeys_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return undefined;
+    }
+}
+
+var POLICY_TYPE_VOLUNTARY_CONSOLATION = 'voluntaryConsolation';
+var POLICY_TYPE_COMPETITIVE_BANDS = 'competitiveBands';
+var POLICY_TYPE_ROUND_ROBIN_TALLY = 'roundRobinTally';
+var POLICY_TYPE_POSITION_ACTIONS = 'positionActions';
+var POLICY_TYPE_MATCHUP_ACTIONS = 'matchUpActions';
+var POLICY_TYPE_RANKING_POINTS = 'rankingPoints';
+var POLICY_TYPE_ROUND_NAMING = 'roundNaming';
+var POLICY_TYPE_PARTICIPANT = 'participant';
+var POLICY_TYPE_PROGRESSION = 'progression';
+var POLICY_TYPE_SCHEDULING = 'scheduling';
+var POLICY_TYPE_AVOIDANCE = 'avoidance';
+var POLICY_TYPE_DISPLAY = 'display'; // storage for client type displays, e.g. { public: {}, admin: {} }
+var POLICY_TYPE_SCORING = 'scoring';
+var POLICY_TYPE_SEEDING = 'seeding';
+var POLICY_TYPE_FEED_IN = 'feedIn';
+var POLICY_TYPE_AUDIT = 'audit';
+var POLICY_TYPE_DRAWS = 'draws';
+var policyConstants = {
+    POLICY_TYPE_VOLUNTARY_CONSOLATION: POLICY_TYPE_VOLUNTARY_CONSOLATION,
+    POLICY_TYPE_COMPETITIVE_BANDS: POLICY_TYPE_COMPETITIVE_BANDS,
+    POLICY_TYPE_ROUND_ROBIN_TALLY: POLICY_TYPE_ROUND_ROBIN_TALLY,
+    POLICY_TYPE_POSITION_ACTIONS: POLICY_TYPE_POSITION_ACTIONS,
+    POLICY_TYPE_MATCHUP_ACTIONS: POLICY_TYPE_MATCHUP_ACTIONS,
+    POLICY_TYPE_RANKING_POINTS: POLICY_TYPE_RANKING_POINTS,
+    POLICY_TYPE_ROUND_NAMING: POLICY_TYPE_ROUND_NAMING,
+    POLICY_TYPE_PARTICIPANT: POLICY_TYPE_PARTICIPANT,
+    POLICY_TYPE_PROGRESSION: POLICY_TYPE_PROGRESSION,
+    POLICY_TYPE_SCHEDULING: POLICY_TYPE_SCHEDULING,
+    POLICY_TYPE_AVOIDANCE: POLICY_TYPE_AVOIDANCE,
+    POLICY_TYPE_DISPLAY: POLICY_TYPE_DISPLAY,
+    POLICY_TYPE_FEED_IN: POLICY_TYPE_FEED_IN,
+    POLICY_TYPE_SCORING: POLICY_TYPE_SCORING,
+    POLICY_TYPE_SEEDING: POLICY_TYPE_SEEDING,
+    POLICY_TYPE_AUDIT: POLICY_TYPE_AUDIT,
+    POLICY_TYPE_DRAWS: POLICY_TYPE_DRAWS,
+};
+
+function findParticipant(_a) {
+    var _b = _a.tournamentParticipants, tournamentParticipants = _b === void 0 ? [] : _b, _c = _a.policyDefinitions, policyDefinitions = _c === void 0 ? {} : _c, contextProfile = _a.contextProfile, participantId = _a.participantId, internalUse = _a.internalUse, personId = _a.personId;
+    var foundParticipant = tournamentParticipants.find(function (candidate) {
+        return (participantId && candidate.participantId === participantId) ||
+            (personId && candidate.person && candidate.person.personId === personId);
+    });
+    var participant = makeDeepCopy(foundParticipant, false, internalUse);
+    if (participant) {
+        var participantAttributes = policyDefinitions === null || policyDefinitions === void 0 ? void 0 : policyDefinitions[POLICY_TYPE_PARTICIPANT];
+        if (contextProfile === null || contextProfile === void 0 ? void 0 : contextProfile.withScaleValues) {
+            var _d = getScaleValues({ participant: participant }), ratings = _d.ratings, rankings = _d.rankings;
+            participant.rankings = rankings;
+            participant.ratings = ratings;
+        }
+        if (participantAttributes === null || participantAttributes === void 0 ? void 0 : participantAttributes.participant) {
+            return attributeFilter({
+                template: participantAttributes.participant,
+                source: participant,
+            });
+        }
+    }
+    return participant;
+}
+
+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) {
+    var _a;
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    var tournamentParticipants = ((_a = params.tournamentRecord) === null || _a === void 0 ? void 0 : _a.participants) || [];
+    var participant = findParticipant({
+        participantId: params.participantId,
+        tournamentParticipants: 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 === null || params === void 0 ? void 0 : params.event))
+        return { error: EVENT_NOT_FOUND };
+    return removeExtension({ element: params.event, name: params.name });
+}
+function removeParticipantExtension(params) {
+    var _a;
+    if (!params || typeof params !== 'object')
+        return { error: MISSING_VALUE };
+    if (!params.participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    var tournamentParticipants = ((_a = params.tournamentRecord) === null || _a === void 0 ? void 0 : _a.participants) || [];
+    var participant = findParticipant({
+        participantId: params.participantId,
+        tournamentParticipants: tournamentParticipants,
+    });
+    if (!participant)
+        return { error: PARTICIPANT_NOT_FOUND };
+    return removeExtension({ element: participant, name: params.name });
+}
+
+var ACTIVE_SUSPENSION = 'activeSuspension';
+var APPLIED_POLICIES = 'appliedPolicies';
+var AUDIT_POSITION_ACTIONS = 'positionActions';
+var CONTEXT = 'context';
+var DELEGATED_OUTCOME = 'delegatedOutcome';
+var DISABLED = 'disabled';
+var DISABLE_LINKS = 'disableLinks';
+var DISABLE_AUTO_CALC = 'disableAutoCalc';
+var DRAW_DELETIONS = 'drawDeletions';
+var DRAW_PROFILE = 'drawProfile';
+var ENTRY_PROFILE = 'entryProfile';
+var EVENT_PROFILE = 'eventProfile';
+var EVENT_WITHDRAWAL_REQUESTS = 'eventWithdrawalRequests';
+var FACTORY$1 = 'factory';
+var FLIGHT_PROFILE = 'flightProfile';
+var GROUPING_ATTRIBUTE = 'groupingAttribute';
+var LINEUPS = 'lineUps';
+var LINKED_TOURNAMENTS = 'linkedTournamentsIds';
+var MATCHUP_HISTORY = 'matchUpHistory';
+var PARTICIPANT_REPRESENTATIVES = 'participantRepresentatives';
+var PERSON_REQUESTS = 'personRequests';
+var RANKING_POINTS = 'rankingPoints';
+var ROUND_TARGET = 'roundTarget';
+var SCHEDULE_LIMITS = 'scheduleLimits';
+var SCHEDULE_TIMING = 'scheduleTiming';
+var SCHEDULING_PROFILE = 'schedulingProfile';
+var STATUS_DETAIL = 'statusDetail';
+var SUB_ORDER = 'subOrder';
+var TALLY = 'tally';
+var TIE_FORMAT_MODIFICATIONS = 'tieFormatModification';
+var extensionConstants = {
+    ACTIVE_SUSPENSION: ACTIVE_SUSPENSION,
+    APPLIED_POLICIES: APPLIED_POLICIES,
+    AUDIT_POSITION_ACTIONS: AUDIT_POSITION_ACTIONS,
+    CONTEXT: CONTEXT, // used to capture, e.g. context in which a venue was added
+    DELEGATED_OUTCOME: DELEGATED_OUTCOME,
+    DISABLED: DISABLED,
+    DISABLE_LINKS: DISABLE_LINKS,
+    DISABLE_AUTO_CALC: DISABLE_AUTO_CALC,
+    DRAW_DELETIONS: DRAW_DELETIONS,
+    DRAW_PROFILE: DRAW_PROFILE,
+    ENTRY_PROFILE: ENTRY_PROFILE, // used for drawGeneration; not relevant for anonymized tournaments
+    EVENT_PROFILE: EVENT_PROFILE,
+    EVENT_WITHDRAWAL_REQUESTS: EVENT_WITHDRAWAL_REQUESTS,
+    FLIGHT_PROFILE: FLIGHT_PROFILE,
+    GROUPING_ATTRIBUTE: GROUPING_ATTRIBUTE, // for generating teams; not relevant for anonymized tournaments
+    LINEUPS: LINEUPS,
+    LINKED_TOURNAMENTS: LINKED_TOURNAMENTS,
+    MATCHUP_HISTORY: MATCHUP_HISTORY,
+    PARTICIPANT_REPRESENTATIVES: PARTICIPANT_REPRESENTATIVES,
+    PERSON_REQUESTS: PERSON_REQUESTS,
+    RANKING_POINTS: RANKING_POINTS, // for attaching points awarded to tournamentRecord
+    ROUND_TARGET: ROUND_TARGET,
+    SCHEDULE_LIMITS: SCHEDULE_LIMITS,
+    SCHEDULE_TIMING: SCHEDULE_TIMING,
+    SCHEDULING_PROFILE: SCHEDULING_PROFILE,
+    STATUS_DETAIL: STATUS_DETAIL, // attached to event.entries
+    SUB_ORDER: SUB_ORDER,
+    TALLY: TALLY,
+    TIE_FORMAT_MODIFICATIONS: TIE_FORMAT_MODIFICATIONS, // for auditing, not important when anonymized
+    FACTORY: FACTORY$1,
+};
+var internalExtensions = [
+    DELEGATED_OUTCOME,
+    DISABLED,
+    DISABLE_LINKS,
+    FLIGHT_PROFILE,
+    LINEUPS,
+    MATCHUP_HISTORY,
+    PARTICIPANT_REPRESENTATIVES,
+    PERSON_REQUESTS,
+    ROUND_TARGET,
+    SCHEDULE_LIMITS,
+    SCHEDULE_TIMING,
+    SCHEDULING_PROFILE,
+    SUB_ORDER,
+    TALLY,
+];
+
+function getTournamentIds(_a) {
+    var tournamentRecords = _a.tournamentRecords;
+    var tournamentIds = isObject(tournamentRecords)
+        ? Object.keys(tournamentRecords)
+        : [];
+    return __assign({ tournamentIds: tournamentIds }, SUCCESS);
+}
+
+/**
+ * Links all tournaments which are currently loaded into competitionEngine state
+ */
+function linkTournaments(_a) {
+    var tournamentRecords = _a.tournamentRecords;
+    if (typeof tournamentRecords !== 'object' ||
+        !Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    var result = getTournamentIds({ tournamentRecords: tournamentRecords });
+    var tournamentIds = result.tournamentIds;
+    if ((tournamentIds === null || tournamentIds === void 0 ? void 0 : tournamentIds.length) > 1) {
+        var extension = {
+            name: LINKED_TOURNAMENTS,
+            value: { tournamentIds: tournamentIds },
+        };
+        return addExtension({
+            tournamentRecords: tournamentRecords,
+            discover: true,
+            extension: extension,
+        });
+    }
+    return __assign({}, SUCCESS);
+}
+function unlinkTournaments(_a) {
+    var tournamentRecords = _a.tournamentRecords;
+    if (typeof tournamentRecords !== 'object' ||
+        !Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    var result = removeExtension({
+        name: LINKED_TOURNAMENTS,
+        tournamentRecords: tournamentRecords,
+        discover: true,
+    });
+    // TODO: check the integrity of the venues attached to each tournment...
+    // get all competitionScheduleMatchUps and ensure that each tournamentRecord has all venues for scheduled matchUps
+    return decorateResult({ result: result, stack: 'unlinkTournaments' });
+}
+function unlinkTournament(_a) {
+    var tournamentRecords = _a.tournamentRecords, tournamentId = _a.tournamentId;
+    if (typeof tournamentRecords !== 'object')
+        return { error: INVALID_VALUES };
+    if (!tournamentId)
+        return { error: MISSING_TOURNAMENT_ID };
+    var result = getTournamentIds({ tournamentRecords: tournamentRecords });
+    var tournamentIds = result.tournamentIds;
+    if (!tournamentIds.includes(tournamentId))
+        return { error: MISSING_TOURNAMENT_ID };
+    // not using bulk update function here to handle scenario where
+    // tournamentRecords loaded into state are not all linked
+    var unlinkError;
+    tournamentIds.every(function (currentTournamentId) {
+        var _a;
+        var tournamentRecord = tournamentRecords[currentTournamentId];
+        var extension = findExtension({
+            element: tournamentRecord,
+            name: LINKED_TOURNAMENTS,
+        }).extension;
+        // if there is no extension return { ...SUCCESS } because no links exist
+        if (!extension)
+            return true;
+        var linkedTournamentIds = ((_a = extension === null || extension === void 0 ? void 0 : extension.value) === null || _a === void 0 ? void 0 : _a.tournamentIds) || [];
+        // if there are no tournamentIds
+        if (!(linkedTournamentIds === null || linkedTournamentIds === void 0 ? void 0 : linkedTournamentIds.length) ||
+            (linkedTournamentIds.length === 1 &&
+                linkedTournamentIds.includes(tournamentId)) ||
+            currentTournamentId === tournamentId) {
+            var result_1 = removeTournamentExtension({
+                name: LINKED_TOURNAMENTS,
+                tournamentRecord: tournamentRecord,
+            });
+            if (result_1.error)
+                unlinkError = result_1.error;
+            return result_1.success;
+        }
+        var tournamentIds = linkedTournamentIds.filter(function (linkedTournamentId) { return linkedTournamentId !== tournamentId; });
+        extension.value = { tournamentIds: tournamentIds };
+        var result = addTournamentExtension({ tournamentRecord: tournamentRecord, extension: extension });
+        if (result.error)
+            unlinkError = result.error;
+        return result.success;
     });
     return unlinkError ? { error: unlinkError } : __assign({}, SUCCESS);
 }
@@ -3350,7 +3514,7 @@ var matchUpStatusConstants = {
     WALKOVER: WALKOVER$2,
 };
 
-var _a$k, _b$8, _c$1;
+var _a$j, _b$7, _c$1;
 // stage types
 var MAIN = 'MAIN';
 var QUALIFYING = 'QUALIFYING';
@@ -3364,22 +3528,22 @@ var validStages = [
     PLAY_OFF,
     VOLUNTARY_CONSOLATION,
 ];
-var stageOrder$1 = (_a$k = {},
-    _a$k[QUALIFYING] = 1,
-    _a$k[MAIN] = 2,
-    _a$k[PLAY_OFF] = 3,
-    _a$k[CONSOLATION] = 3,
-    _a$k[VOLUNTARY_CONSOLATION] = 4,
-    _a$k);
+var stageOrder$1 = (_a$j = {},
+    _a$j[QUALIFYING] = 1,
+    _a$j[MAIN] = 2,
+    _a$j[PLAY_OFF] = 3,
+    _a$j[CONSOLATION] = 3,
+    _a$j[VOLUNTARY_CONSOLATION] = 4,
+    _a$j);
 var FINISHING_POSITIONS = 'finishingPositions';
 var AGGREGATE_EVENT_STRUCTURES = 'aggregateEventStructures';
-var finishOrder = (_b$8 = {},
-    _b$8[MAIN] = 1,
-    _b$8[PLAY_OFF] = 2,
-    _b$8[CONSOLATION] = 3,
-    _b$8[QUALIFYING] = 4,
-    _b$8[VOLUNTARY_CONSOLATION] = 5,
-    _b$8);
+var finishOrder = (_b$7 = {},
+    _b$7[MAIN] = 1,
+    _b$7[PLAY_OFF] = 2,
+    _b$7[CONSOLATION] = 3,
+    _b$7[QUALIFYING] = 4,
+    _b$7[VOLUNTARY_CONSOLATION] = 5,
+    _b$7);
 // for aggregateOrder { stage: MAIN, stageSequence: 1 } is always first
 var aggregateOrder = (_c$1 = {},
     _c$1[PLAY_OFF] = 1,
@@ -5157,16 +5321,16 @@ var ROUTINE = 'ROUTINE';
 var DECISIVE = 'DECISIVE';
 var WIN_RATIO = 'winRatio';
 
-var _a$j, _b$7;
-var POLICY_COMPETITIVE_BANDS_DEFAULT = (_a$j = {},
-    _a$j[POLICY_TYPE_COMPETITIVE_BANDS] = {
+var _a$i, _b$6;
+var POLICY_COMPETITIVE_BANDS_DEFAULT = (_a$i = {},
+    _a$i[POLICY_TYPE_COMPETITIVE_BANDS] = {
         policyName: 'Competitive Bands Default',
-        profileBands: (_b$7 = {},
-            _b$7[DECISIVE] = 20,
-            _b$7[ROUTINE] = 50,
-            _b$7),
+        profileBands: (_b$6 = {},
+            _b$6[DECISIVE] = 20,
+            _b$6[ROUTINE] = 50,
+            _b$6),
     },
-    _a$j);
+    _a$i);
 
 function getContextContent(_a) {
     var _b, _c;
@@ -7844,9 +8008,9 @@ function isAdHoc(_a) {
         !hasDrawPosition);
 }
 
-var _a$i, _b$6;
-var POLICY_ROUND_NAMING_DEFAULT = (_a$i = {},
-    _a$i[POLICY_TYPE_ROUND_NAMING] = {
+var _a$h, _b$5;
+var POLICY_ROUND_NAMING_DEFAULT = (_a$h = {},
+    _a$h[POLICY_TYPE_ROUND_NAMING] = {
         policyName: 'Round Naming Default',
         namingConventions: {
             round: 'Round',
@@ -7871,14 +8035,14 @@ var POLICY_ROUND_NAMING_DEFAULT = (_a$i = {},
             preFeedRound: 'Q',
             preQualifying: 'P',
         },
-        stageConstants: (_b$6 = {},
-            _b$6[MAIN] = '',
-            _b$6[PLAY_OFF] = 'P',
-            _b$6[QUALIFYING] = 'Q',
-            _b$6[CONSOLATION] = 'C',
-            _b$6),
+        stageConstants: (_b$5 = {},
+            _b$5[MAIN] = '',
+            _b$5[PLAY_OFF] = 'P',
+            _b$5[QUALIFYING] = 'Q',
+            _b$5[CONSOLATION] = 'C',
+            _b$5),
     },
-    _a$i);
+    _a$h);
 
 function getRoundContextProfile(_a) {
     var _b, _c, _d, _e, _f, _g;
@@ -7976,165 +8140,6 @@ function getRoundContextProfile(_a) {
     return { roundNamingProfile: roundNamingProfile, roundProfile: roundProfile, roundMatchUps: roundMatchUps };
 }
 
-var TOURNAMENT_RECORDS = 'tournamentRecords';
-var POLICY_DEFINITIONS = 'policyDefinitions';
-var TOURNAMENT_RECORD = 'tournamentRecord';
-var DRAW_DEFINITION = 'drawDefinition';
-var MATCHUP_FORMAT = 'matchUpFormat';
-var PARTICIPANT_ID = 'participantId';
-var SCHEDULE_DATES = 'scheduleDates';
-var TOURNAMENT_ID = 'tournamentId';
-var SCHEDULE_DATE = 'scheduleDate';
-var STRUCTURE_ID = 'structureId';
-var MATCHUP_IDS = 'matchUpIds';
-var POLICY_TYPE = 'policyType';
-var STRUCTURES = 'structures';
-var MATCHUP_ID = 'matchUpId';
-var IN_CONTEXT = 'inContext';
-var STRUCTURE = 'structure';
-var COURT_IDS = 'courtIds';
-var PERSON_ID = 'personId';
-var VENUE_IDS = 'venueIds';
-var MATCHUPS = 'matchUps';
-var COURT_ID = 'courtId';
-var EVENT_ID = 'eventId';
-var MATCHUP = 'matchUp';
-var DRAW_ID = 'drawId';
-var ERROR = 'error';
-var EVENT = 'event';
-var PARAM = 'param';
-var AVERAGE_MATCHUP_MINUTES = 'averageMatchUpMinutes';
-var RECOVERY_MINUTES = 'recoveryMinutes';
-var PERIOD_LENGTH = 'periodLength';
-var OBJECT = 'object';
-var ARRAY = 'array';
-var VALIDATE = 'validate';
-var INVALID = 'invalid';
-var OF_TYPE = '_ofType';
-var ANY_OF = '_anyOf';
-var ONE_OF = '_oneOf';
-
-var _a$h, _b$5;
-var errors = (_a$h = {},
-    _a$h[TOURNAMENT_RECORDS] = MISSING_TOURNAMENT_RECORDS,
-    _a$h[TOURNAMENT_RECORD] = MISSING_TOURNAMENT_RECORD,
-    _a$h[POLICY_DEFINITIONS] = MISSING_POLICY_DEFINITION,
-    _a$h[DRAW_DEFINITION] = MISSING_DRAW_DEFINITION,
-    _a$h[PARTICIPANT_ID] = MISSING_PARTICIPANT_ID,
-    _a$h[TOURNAMENT_ID] = MISSING_TOURNAMENT_ID,
-    _a$h[STRUCTURE_ID] = MISSING_STRUCTURE_ID,
-    _a$h[MATCHUP_IDS] = MISSING_MATCHUP_IDS,
-    _a$h[STRUCTURES] = MISSING_STRUCTURES,
-    _a$h[MATCHUP_ID] = MISSING_MATCHUP_ID,
-    _a$h[STRUCTURE] = MISSING_STRUCTURE,
-    _a$h[COURT_ID] = MISSING_COURT_ID,
-    _a$h[MATCHUPS] = MISSING_MATCHUPS,
-    _a$h[MATCHUP] = MISSING_MATCHUP,
-    _a$h[COURT_IDS] = MISSING_VALUE,
-    _a$h[VENUE_IDS] = MISSING_VALUE,
-    _a$h[DRAW_ID] = MISSING_DRAW_ID,
-    _a$h[EVENT_ID] = MISSING_EVENT,
-    _a$h[EVENT] = EVENT_NOT_FOUND,
-    _a$h);
-var paramTypes = (_b$5 = {},
-    _b$5[TOURNAMENT_RECORDS] = OBJECT,
-    _b$5[POLICY_DEFINITIONS] = OBJECT,
-    _b$5[TOURNAMENT_RECORD] = OBJECT,
-    _b$5[DRAW_DEFINITION] = OBJECT,
-    _b$5[SCHEDULE_DATES] = ARRAY,
-    _b$5[MATCHUP_IDS] = ARRAY,
-    _b$5[STRUCTURES] = ARRAY,
-    _b$5[STRUCTURE] = OBJECT,
-    _b$5[COURT_IDS] = ARRAY,
-    _b$5[VENUE_IDS] = ARRAY,
-    _b$5[MATCHUPS] = ARRAY,
-    _b$5[MATCHUP] = OBJECT,
-    _b$5[EVENT] = OBJECT,
-    _b$5);
-function checkRequiredParameters(params, requiredParams, stack) {
-    if (!params && !isObject(params))
-        return { error: INVALID_VALUES };
-    if (!(requiredParams === null || requiredParams === void 0 ? void 0 : requiredParams.length) || (params === null || params === void 0 ? void 0 : params._bypassParamCheck))
-        return { valid: true };
-    if (!Array.isArray(requiredParams))
-        return { error: INVALID_VALUES };
-    var _a = findParamError(params, requiredParams), paramError = _a.paramError, errorParam = _a.errorParam;
-    if (!paramError)
-        return { valid: true };
-    var error = params[errorParam] === undefined
-        ? errors[errorParam] || INVALID_VALUES
-        : (paramError.validate && paramError.invalid) || INVALID_VALUES;
-    return decorateResult({
-        info: { param: errorParam },
-        result: { error: error },
-        stack: stack,
-    });
-}
-function getIntersection(params, constraint) {
-    var paramKeys = Object.keys(params);
-    var constraintKeys = Object.keys(constraint);
-    return intersection(paramKeys, constraintKeys);
-}
-function getOneOf(params, _oneOf) {
-    if (!_oneOf)
-        return;
-    var overlap = getIntersection(params, _oneOf);
-    if (overlap.length !== 1)
-        return { error: INVALID_VALUES };
-    return overlap.reduce(function (attr, param) {
-        var _a;
-        return (__assign(__assign({}, attr), (_a = {}, _a[param] = true, _a)));
-    }, {});
-}
-function getAnyOf(params, _anyOf) {
-    if (!_anyOf)
-        return;
-    var overlap = getIntersection(params, _anyOf).filter(function (param) { return params[param]; });
-    if (overlap.length < 1)
-        return { error: INVALID_VALUES };
-    return overlap.reduce(function (attr, param) {
-        var _a;
-        return (__assign(__assign({}, attr), (_a = {}, _a[param] = true, _a)));
-    }, {});
-}
-function findParamError(params, requiredParams) {
-    var errorParam;
-    var paramError = requiredParams.find(function (_a) {
-        var _ofType = _a._ofType, _oneOf = _a._oneOf, _anyOf = _a._anyOf, validate = _a.validate, attrs = __rest(_a, ["_ofType", "_oneOf", "_anyOf", "validate"]);
-        var oneOf = _oneOf && getOneOf(params, _oneOf);
-        if (oneOf === null || oneOf === void 0 ? void 0 : oneOf.error)
-            return oneOf.error;
-        oneOf && Object.assign(attrs, oneOf);
-        var anyOf = _anyOf && getAnyOf(params, _anyOf);
-        if (anyOf === null || anyOf === void 0 ? void 0 : anyOf.error)
-            return anyOf.error;
-        anyOf && Object.assign(attrs, anyOf);
-        var booleanParams = Object.keys(attrs).filter(function (key) { return typeof attrs[key] === 'boolean'; });
-        var invalidParam = booleanParams.find(function (param) {
-            var invalid = !isFunction(validate) &&
-                (params[param] === undefined || invalidType(params, param, _ofType));
-            var hasError = invalid || (validate && !checkValidation(params[param], validate));
-            if (hasError)
-                errorParam = param;
-            return hasError;
-        });
-        return !booleanParams.length || invalidParam;
-    });
-    return { paramError: paramError, errorParam: errorParam };
-}
-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;
-}
-
 // derive matchUpType from participants when not defined on matchUp
 function getMatchUpType(params) {
     var _a;
@@ -19925,7 +19930,7 @@ function qualifierDrawPositionAssignment(params) {
 }
 
 function getTieMatchUpContext(_a) {
-    var _b;
+    var _b, _c, _d, _e;
     var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, tieMatchUpId = _a.tieMatchUpId, event = _a.event;
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -19942,14 +19947,14 @@ function getTieMatchUpContext(_a) {
     }).matchUp;
     if (!tieMatchUp)
         return { error: MATCHUP_NOT_FOUND };
-    var _c = findDrawMatchUp({
+    var _f = findDrawMatchUp({
         tournamentParticipants: tournamentRecord.participants,
         matchUpId: tieMatchUpId,
         inContext: true,
         drawDefinition: drawDefinition,
         matchUpsMap: matchUpsMap,
         event: event,
-    }), inContextTieMatchUp = _c.matchUp, structure = _c.structure;
+    }), inContextTieMatchUp = _f.matchUp, structure = _f.structure;
     if (!inContextTieMatchUp)
         return { error: MATCHUP_NOT_FOUND };
     var collectionPosition = inContextTieMatchUp.collectionPosition, drawPositions = inContextTieMatchUp.drawPositions, collectionId = inContextTieMatchUp.collectionId, matchUpTieId = inContextTieMatchUp.matchUpTieId, matchUpType = inContextTieMatchUp.matchUpType;
@@ -19957,7 +19962,14 @@ function getTieMatchUpContext(_a) {
         return { error: INVALID_MATCHUP };
     var positionAssignments = getPositionAssignments$1({ structure: structure }).positionAssignments;
     var relevantAssignments = positionAssignments === null || positionAssignments === void 0 ? void 0 : positionAssignments.filter(function (assignment) { return drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.includes(assignment.drawPosition); });
-    var participantIds = relevantAssignments === null || relevantAssignments === void 0 ? void 0 : relevantAssignments.map(extractAttributes('participantId'));
+    var dualMatchUp = findDrawMatchUp({
+        matchUpId: matchUpTieId,
+        drawDefinition: drawDefinition,
+        matchUpsMap: matchUpsMap,
+    }).matchUp;
+    var sideParticipantIds = (_c = (_b = dualMatchUp === null || dualMatchUp === void 0 ? void 0 : dualMatchUp.sides) === null || _b === void 0 ? void 0 : _b.map(extractAttributes('participantId'))) !== null && _c !== void 0 ? _c : [];
+    var assignedParticipantIds = (_d = relevantAssignments === null || relevantAssignments === void 0 ? void 0 : relevantAssignments.map(extractAttributes('participantId'))) !== null && _d !== void 0 ? _d : [];
+    var participantIds = __spreadArray(__spreadArray([], __read(sideParticipantIds), false), __read(assignedParticipantIds), false);
     var teamParticipants = getParticipants({
         tournamentRecord: tournamentRecord,
         participantFilters: {
@@ -19965,23 +19977,18 @@ function getTieMatchUpContext(_a) {
             participantIds: participantIds,
         },
     }).participants;
-    var dualMatchUp = findDrawMatchUp({
-        matchUpId: matchUpTieId,
-        drawDefinition: drawDefinition,
-        matchUpsMap: matchUpsMap,
-    }).matchUp;
     var inContextDualMatchUp = findDrawMatchUp({
         matchUpId: matchUpTieId,
         inContext: true,
         drawDefinition: drawDefinition,
         matchUpsMap: matchUpsMap,
     }).matchUp;
-    var tieFormat = (_b = resolveTieFormat({
+    var tieFormat = (_e = resolveTieFormat({
         matchUp: dualMatchUp,
         drawDefinition: drawDefinition,
         structure: structure,
         event: event,
-    })) === null || _b === void 0 ? void 0 : _b.tieFormat;
+    })) === null || _e === void 0 ? void 0 : _e.tieFormat;
     return __assign({ inContextDualMatchUp: inContextDualMatchUp, inContextTieMatchUp: inContextTieMatchUp, relevantAssignments: relevantAssignments, collectionPosition: collectionPosition, teamParticipants: teamParticipants, collectionId: collectionId, matchUpType: matchUpType, dualMatchUp: dualMatchUp, tieMatchUp: tieMatchUp, tieFormat: tieFormat, structure: structure }, SUCCESS);
 }
 
@@ -20814,9 +20821,8 @@ function assignTieMatchUpParticipantId(params) {
             var individualParticipantIds = _a.individualParticipantIds;
             return overlap(relevantParticipantIds, individualParticipantIds);
         }));
-    if (!participantTeam) {
+    if (!participantTeam)
         return { error: TEAM_NOT_FOUND };
-    }
     if (!teamParticipantId)
         teamParticipantId = participantTeam.participantId;
     if (!teamParticipantId)
@@ -21424,9 +21430,9 @@ function calculateWinCriteria(_a) {
         finally { if (e_3) throw e_3.error; }
     }
     if (aggregateValueImperative || !valueTotal)
-        return { aggregateValue: true };
+        return __assign({ aggregateValue: true }, SUCCESS);
     var valueGoal = Math.floor(valueTotal / 2) + 1;
-    return { valueGoal: valueGoal };
+    return __assign({ valueGoal: valueGoal }, SUCCESS);
 }
 
 function getTieFormat$1(_a) {
@@ -21586,7 +21592,8 @@ function tiebreakFormat(tieobject) {
     return undefined;
 }
 
-function isValidMatchUpFormat(matchUpFormat) {
+function isValidMatchUpFormat(_a) {
+    var matchUpFormat = _a.matchUpFormat;
     if (typeof matchUpFormat !== 'string')
         return false;
     var parsedFormat = parse(matchUpFormat);
@@ -21968,7 +21975,8 @@ function validateCollectionDefinition(_a) {
     if (collectionGroupNumber && typeof collectionGroupNumber !== 'number') {
         errors.push("collectionGroupNumber is not type number: ".concat(collectionValue));
     }
-    if (matchUpFormat && !matchUpFormatCode.isValidMatchUpFormat(matchUpFormat)) {
+    if (matchUpFormat &&
+        !matchUpFormatCode.isValidMatchUpFormat({ matchUpFormat: matchUpFormat })) {
         errors.push("Invalid matchUpFormat: ".concat(matchUpFormat));
     }
     if (checkGender) {
@@ -22653,7 +22661,7 @@ function modifyCollectionDefinition(_a) {
     // value assignment, only one is allowed to have a value
     collectionValueProfiles = _a.collectionValueProfiles, collectionValue = _a.collectionValue, matchUpValue = _a.matchUpValue, scoreValue = _a.scoreValue, setValue = _a.setValue;
     var stack = 'modifyCollectionDefinition';
-    if (matchUpFormat && !isValidMatchUpFormat(matchUpFormat)) {
+    if (matchUpFormat && !isValidMatchUpFormat({ matchUpFormat: matchUpFormat })) {
         return decorateResult({
             result: { error: INVALID_VALUES },
             context: { matchUpFormat: matchUpFormat },
@@ -26950,7 +26958,7 @@ function tallyParticipantResults(_a) {
     var completedTieMatchUps = matchUps.every(function (_a) {
         var matchUpType = _a.matchUpType, tieMatchUps = _a.tieMatchUps;
         return matchUpType === TEAM$1 &&
-            tieMatchUps.every(function (matchUp) { return checkMatchUpIsComplete({ matchUp: matchUp }); });
+            (tieMatchUps === null || tieMatchUps === void 0 ? void 0 : tieMatchUps.every(function (matchUp) { return checkMatchUpIsComplete({ matchUp: matchUp }); }));
     });
     var tallyPolicy = policyDefinitions === null || policyDefinitions === void 0 ? void 0 : policyDefinitions[POLICY_TYPE_ROUND_ROBIN_TALLY];
     var consideredMatchUps = matchUps.filter(function (matchUp) {
@@ -32909,7 +32917,7 @@ function setMatchUpMatchUpFormat(params) {
         return { error: MISSING_DRAW_DEFINITION };
     if (!matchUpFormat)
         return { error: MISSING_MATCHUP_FORMAT };
-    if (!isValidMatchUpFormat(matchUpFormat))
+    if (!isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
     var stack = 'setMatchUpFormat';
     if (matchUpId) {
@@ -32992,7 +33000,7 @@ function setMatchUpFormat(params) {
         return { error: MISSING_TOURNAMENT_RECORD };
     if (!matchUpFormat)
         return { error: MISSING_MATCHUP_FORMAT };
-    if (matchUpFormat && !isValidMatchUpFormat(matchUpFormat))
+    if (matchUpFormat && !isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return decorateResult({
             result: { error: UNRECOGNIZED_MATCHUP_FORMAT, matchUpFormat: matchUpFormat },
             stack: stack,
@@ -36328,49 +36336,6 @@ function removeAdHocRound(_a) {
     return __assign({ deletedMatchUpsCount: deletedMatchUpIds.length, roundRemoved: roundRemoved }, SUCCESS);
 }
 
-function addAdHocMatchUps(_a) {
-    var _b;
-    var _c, _d, _e, _f, _g, _h, _j;
-    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, structureId = _a.structureId, matchUps = _a.matchUps;
-    if (typeof drawDefinition !== 'object')
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId && ((_c = drawDefinition.structures) === null || _c === void 0 ? void 0 : _c.length) === 1)
-        structureId = (_e = (_d = drawDefinition.structures) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.structureId;
-    if (typeof structureId !== 'string')
-        return { error: MISSING_STRUCTURE_ID };
-    if (!validMatchUps(matchUps))
-        return { error: INVALID_VALUES, info: mustBeAnArray('matchUps') };
-    var structure = (_f = drawDefinition.structures) === null || _f === void 0 ? void 0 : _f.find(function (structure) { return structure.structureId === structureId; });
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    var existingMatchUps = structure === null || structure === void 0 ? void 0 : structure.matchUps;
-    var structureHasRoundPositions = existingMatchUps.find(function (matchUp) { return !!matchUp.roundPosition; });
-    if (structure.structures ||
-        structureHasRoundPositions ||
-        structure.finishingPosition === ROUND_OUTCOME) {
-        return { error: INVALID_STRUCTURE };
-    }
-    var existingMatchUpIds = (_j = (_h = (_g = allTournamentMatchUps({
-        tournamentRecord: tournamentRecord,
-        inContext: false,
-    })) === null || _g === void 0 ? void 0 : _g.matchUps) === null || _h === void 0 ? void 0 : _h.map(getMatchUpId)) !== null && _j !== void 0 ? _j : [];
-    var newMatchUpIds = matchUps.map(getMatchUpId);
-    if (overlap(existingMatchUpIds, newMatchUpIds)) {
-        return {
-            error: EXISTING_MATCHUP_ID,
-            info: 'One or more matchUpIds already present in tournamentRecord',
-        };
-    }
-    (_b = structure.matchUps).push.apply(_b, __spreadArray([], __read(matchUps), false));
-    addMatchUpsNotice({
-        tournamentId: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.tournamentId,
-        drawDefinition: drawDefinition,
-        matchUps: matchUps,
-    });
-    modifyDrawNotice({ drawDefinition: drawDefinition, structureIds: [structureId] });
-    return __assign({}, SUCCESS);
-}
-
 function aggregateTieFormats(_a) {
     var e_1, _b;
     var _c, _d, _e, _f, _g;
@@ -37264,822 +37229,241 @@ function modifyEventEntries(_a) {
     return __assign({}, SUCCESS);
 }
 
-function attachFlightProfile(_a) {
-    var _b;
-    var deleteExisting = _a.deleteExisting, event = _a.event, flightProfile = _a.flightProfile;
-    var stack = 'attachFlightProfile';
-    if (!flightProfile)
-        return decorateResult({ result: { error: MISSING_VALUE }, stack: stack });
-    if (!event)
-        return decorateResult({ result: { error: MISSING_EVENT }, stack: stack });
-    var existingFlightProfile = getFlightProfile({ event: event }).flightProfile;
-    if (existingFlightProfile && !deleteExisting)
-        return decorateResult({ result: { error: EXISTING_PROFILE }, stack: stack });
-    if ((_b = event.drawDefinitions) === null || _b === void 0 ? void 0 : _b.length)
-        return decorateResult({
-            result: { error: EXISTING_DRAW_DEFINITIONS },
-            stack: stack,
+function generateAdHocMatchUps(_a) {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    var participantIdPairings = _a.participantIdPairings, _q = _a.matchUpIds, matchUpIds = _q === void 0 ? [] : _q, drawDefinition = _a.drawDefinition, matchUpsCount = _a.matchUpsCount, roundNumber = _a.roundNumber, structureId = _a.structureId, newRound = _a.newRound, isMock = _a.isMock, event = _a.event;
+    if (typeof drawDefinition !== 'object')
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId && ((_b = drawDefinition.structures) === null || _b === void 0 ? void 0 : _b.length) === 1)
+        structureId = (_d = (_c = drawDefinition.structures) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.structureId;
+    if (typeof structureId !== 'string')
+        return { error: MISSING_STRUCTURE_ID };
+    // if drawDefinition and structureId are provided it is possible to infer roundNumber
+    var structure = (_e = drawDefinition.structures) === null || _e === void 0 ? void 0 : _e.find(function (structure) { return structure.structureId === structureId; });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    var structureHasRoundPositions;
+    var existingMatchUps = (_f = structure.matchUps) !== null && _f !== void 0 ? _f : [];
+    var lastRoundNumber = existingMatchUps === null || existingMatchUps === void 0 ? void 0 : existingMatchUps.reduce(function (roundNumber, matchUp) {
+        if (matchUp.roundPosition)
+            structureHasRoundPositions = true;
+        return ((matchUp === null || matchUp === void 0 ? void 0 : matchUp.roundNumber) || 0) > roundNumber
+            ? matchUp.roundNumber
+            : roundNumber;
+    }, 0);
+    if (!matchUpsCount) {
+        var selectedEntries = (_h = (_g = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries) === null || _g === void 0 ? void 0 : _g.filter(function (entry) {
+            var entryStatus = entry.entryStatus;
+            return STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
+        })) !== null && _h !== void 0 ? _h : [];
+        var roundMatchUpsCount = Math.floor((selectedEntries === null || selectedEntries === void 0 ? void 0 : selectedEntries.length) / 2) || 1;
+        if (newRound) {
+            matchUpsCount = roundMatchUpsCount;
+        }
+        else {
+            var targetRoundNumber_1 = (_j = roundNumber !== null && roundNumber !== void 0 ? roundNumber : lastRoundNumber) !== null && _j !== void 0 ? _j : 1;
+            var existingRoundMatchUps = (_m = (_l = (_k = structure.matchUps) === null || _k === void 0 ? void 0 : _k.filter(function (matchUp) { return matchUp.roundNumber === targetRoundNumber_1; })) === null || _l === void 0 ? void 0 : _l.length) !== null && _m !== void 0 ? _m : 0;
+            var maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
+            if (maxRemaining > 0)
+                matchUpsCount = maxRemaining;
+        }
+    }
+    if ((participantIdPairings && !Array.isArray(participantIdPairings)) ||
+        (matchUpsCount && !isConvertableInteger(matchUpsCount)) ||
+        (matchUpIds && !Array.isArray(matchUpIds)) ||
+        (!participantIdPairings && !matchUpsCount)) {
+        return { error: INVALID_VALUES, info: 'matchUpsCount or pairings error' };
+    }
+    // structure must not be a container of other structures
+    // structure must not contain matchUps with roundPosition
+    // structure must not determine finishingPosition by ROUND_OUTCOME
+    if (structure.structures ||
+        structureHasRoundPositions ||
+        structure.finishingPosition === ROUND_OUTCOME) {
+        return { error: INVALID_STRUCTURE };
+    }
+    if (roundNumber && roundNumber - 1 > (lastRoundNumber || 0))
+        return { error: INVALID_VALUES, info: 'roundNumber error' };
+    var nextRoundNumber = roundNumber !== null && roundNumber !== void 0 ? roundNumber : ((newRound && (lastRoundNumber !== null && lastRoundNumber !== void 0 ? lastRoundNumber : 0) + 1) || lastRoundNumber || 1);
+    participantIdPairings =
+        participantIdPairings !== null && participantIdPairings !== void 0 ? participantIdPairings : generateRange(0, matchUpsCount).map(function () { return ({
+            participantIds: [undefined, undefined],
+        }); });
+    var matchUps = participantIdPairings === null || participantIdPairings === void 0 ? void 0 : participantIdPairings.map(function (pairing) {
+        var _a, _b;
+        var idStack = (_a = pairing === null || pairing === void 0 ? void 0 : pairing.participantIds) !== null && _a !== void 0 ? _a : [undefined, undefined];
+        // ensure there are always 2 sides in generated matchUps
+        idStack.push.apply(idStack, [undefined, undefined]);
+        var participantIds = idStack.slice(0, 2);
+        var sides = participantIds.map(function (participantId, i) {
+            return definedAttributes({
+                sideNumber: i + 1,
+                participantId: participantId,
+            });
         });
-    var extension = {
-        name: FLIGHT_PROFILE,
-        value: flightProfile,
-    };
-    addEventExtension({ event: event, extension: extension });
-    return __assign({ flightProfile: makeDeepCopy(flightProfile, false, true) }, SUCCESS);
-}
-
-/**
- *
- * @param {object} tournamentRecord - passed automatically if tournamentEngine.setState()
- * @param {string[]} participantIds
- * @param {string} scaleAttributes - { scaleType, scaleName, eventType }
- * @returns {boolean} { success: true } or { error }
- */
-function removeParticipantsScaleItems(_a) {
-    var _b;
-    var tournamentRecord = _a.tournamentRecord, scaleAttributes = _a.scaleAttributes, participantIds = _a.participantIds;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!participantIds)
-        return { error: MISSING_PARTICIPANT_IDS };
-    if (!scaleAttributes)
-        return { error: MISSING_VALUE, info: 'scaleAttributes required' };
-    var scaleType = scaleAttributes.scaleType, eventType = scaleAttributes.eventType, scaleName = scaleAttributes.scaleName;
-    var itemType = [SCALE, scaleType, eventType, scaleName].join('.');
-    (_b = tournamentRecord.participants) === null || _b === void 0 ? void 0 : _b.forEach(function (participant) {
-        if (participantIds.includes(participant.participantId) &&
-            participant.timeItems) {
-            participant.timeItems = participant.timeItems.filter(function (timeItem) {
-                return timeItem && (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) !== itemType;
+        return {
+            matchUpId: (_b = matchUpIds.pop()) !== null && _b !== void 0 ? _b : UUID(),
+            roundNumber: nextRoundNumber,
+            matchUpStatus: TO_BE_PLAYED,
+            sides: sides,
+        };
+    });
+    if (matchUps === null || matchUps === void 0 ? void 0 : matchUps.length) {
+        var tieFormat_1 = (_o = resolveTieFormat({ drawDefinition: drawDefinition, event: event })) === null || _o === void 0 ? void 0 : _o.tieFormat;
+        if (tieFormat_1) {
+            matchUps.forEach(function (matchUp) {
+                var tieMatchUps = generateTieMatchUps({ tieFormat: tieFormat_1, isMock: isMock }).tieMatchUps;
+                Object.assign(matchUp, { tieMatchUps: tieMatchUps, matchUpType: TEAM$1 });
             });
         }
-    });
-    return __assign({}, SUCCESS);
+    }
+    return __assign({ matchUpsCount: (_p = matchUps === null || matchUps === void 0 ? void 0 : matchUps.length) !== null && _p !== void 0 ? _p : 0, matchUps: matchUps }, SUCCESS);
 }
 
-/**
- *
- * @param {object} tournamentRecord - passed automatically if tournamentEngine.setState()
- * @param {string} eventId - resolves to event
- * @param {string} drawId - OPTIONAL - resolves drawDefinition - scopes participants to clear to drawDefinition.entries or flightProfile.flight.drawEntries
- * @param {string} scaleAttributes - { scaleType, scaleName, eventType }
- * @param {string} stage - OPTIONAL - filter event or draw entries by stage
- * @returns {boolean} { success: true } or { error }
- */
-function removeScaleValues(_a) {
-    var _b;
-    var tournamentRecord = _a.tournamentRecord, scaleAttributes = _a.scaleAttributes, drawDefinition = _a.drawDefinition, entryStatuses = _a.entryStatuses, drawId = _a.drawId, event = _a.event, stage = _a.stage;
-    if (!event)
-        return { error: MISSING_EVENT };
-    if (entryStatuses && !Array.isArray(entryStatuses))
-        return decorateResult({
-            result: { error: INVALID_VALUES },
-            info: mustBeAnArray('entryStatus'),
-            stack: 'removeScaleValues',
+function generateCandidate(_a) {
+    var _b = _a.maxIterations, maxIterations = _b === void 0 ? 4000 : _b, // cap the processing intensity of the candidate generator
+    valueSortedPairings = _a.valueSortedPairings, // pairings sorted by value from low to high
+    pairingValues = _a.pairingValues, valueObjects = _a.valueObjects, deltaObjects = _a.deltaObjects;
+    var pairingValueMap = Object.assign.apply(Object, __spreadArray([{}], __read(valueSortedPairings.map(function (rm) {
+        var _a;
+        return (_a = {}, _a[rm.pairing] = rm.value, _a);
+    })), false));
+    var actors = Object.keys(pairingValues);
+    var proposedCandidates = [];
+    // generate an initial candidate value with no stipulated pairings
+    var initialProposal = roundCandidate({
+        actorsCount: actors.length,
+        valueSortedPairings: valueSortedPairings,
+        pairingValueMap: pairingValueMap,
+        deltaObjects: deltaObjects,
+        valueObjects: valueObjects,
+    });
+    var candidateHashes = [candidateHash(initialProposal)];
+    proposedCandidates.push(initialProposal);
+    var lowCandidateValue = initialProposal.value;
+    var deltaCandidate = initialProposal;
+    // iterations is the number of loops over valueSortedPairings
+    var candidatesCount = 0;
+    var iterations = 0;
+    var opponentCount = actors.length;
+    var calculatedIterations;
+    // calculate the number of opponents to consider for each participantId
+    do {
+        opponentCount -= 1;
+        calculatedIterations = actors.length * pairingValues[actors[0]].length;
+    } while (calculatedIterations > maxIterations && opponentCount > 5);
+    // keep track of proposed pairings
+    var stipulatedPairs = [];
+    // for each actor generate a roundCandidate using opponentCount of pairing values
+    actors.forEach(function (actor) {
+        var participantIdPairings = pairingValues[actor];
+        // opponentCount limits the number of opponents to consider
+        participantIdPairings.slice(0, opponentCount).forEach(function (pairing) {
+            iterations += 1;
+            var stipulatedPair = pairingHash(actor, pairing.opponent);
+            if (!stipulatedPairs.includes(stipulatedPair)) {
+                var proposed = roundCandidate({
+                    // each roundCandidate starts with stipulated pairings
+                    stipulated: [[actor, pairing.opponent]],
+                    actorsCount: actors.length,
+                    valueSortedPairings: valueSortedPairings,
+                    pairingValueMap: pairingValueMap,
+                    deltaObjects: deltaObjects,
+                    valueObjects: valueObjects,
+                });
+                // ensure no duplicate candidates are considered
+                if (!candidateHashes.includes(candidateHash(proposed))) {
+                    candidateHashes.push(candidateHash(proposed));
+                    proposedCandidates.push(proposed);
+                    var maxDelta = proposed.maxDelta, value = proposed.value;
+                    if (maxDelta < deltaCandidate.maxDelta)
+                        deltaCandidate = proposed;
+                    if (value < lowCandidateValue ||
+                        (value === lowCandidateValue && Math.round(Math.random())) // randomize if equivalent values
+                    ) {
+                        lowCandidateValue = value;
+                    }
+                    stipulatedPairs.push(stipulatedPair);
+                    candidatesCount += 1;
+                }
+            }
         });
-    var entries = event.entries;
-    if (drawId) {
-        var flightProfile = getFlightProfile({ event: event }).flightProfile;
-        var flight = (_b = flightProfile === null || flightProfile === void 0 ? void 0 : flightProfile.flights) === null || _b === void 0 ? void 0 : _b.find(function (flight) { return flight.drawId === drawId; });
-        if (flight) {
-            entries = flight.drawEntries;
-        }
-        else {
-            entries = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries;
-        }
-    }
-    var stageEntries = (entries || []).filter(function (entry) {
-        return (!stage || !entry.entryStage || entry.entryStage === stage) &&
-            (!entryStatuses || entryStatuses.includes(entry.entryStatus));
+        proposedCandidates = proposedCandidates.filter(function (proposed) { return Math.abs(proposed.value - lowCandidateValue) < 5; });
     });
-    var participantIds = stageEntries.map(getParticipantId);
-    return removeParticipantsScaleItems({
-        tournamentRecord: tournamentRecord,
-        scaleAttributes: scaleAttributes,
-        participantIds: participantIds,
+    proposedCandidates.sort(function (a, b) { return a.maxDiff - b.maxDiff; });
+    var candidate = randomPop(proposedCandidates);
+    return {
+        candidatesCount: candidatesCount,
+        deltaCandidate: deltaCandidate,
+        maxIterations: maxIterations,
+        iterations: iterations,
+        candidate: candidate,
+    };
+}
+function candidateHash(candidate) {
+    return candidate.participantIdPairings
+        .map(function (_a) {
+        var participantIds = _a.participantIds;
+        return participantIds.sort().join('|');
+    })
+        .sort()
+        .join('/');
+}
+function roundCandidate(_a) {
+    var valueSortedPairings = _a.valueSortedPairings, _b = _a.stipulated, stipulated = _b === void 0 ? [] : _b, pairingValueMap = _a.pairingValueMap, deltaObjects = _a.deltaObjects, valueObjects = _a.valueObjects, actorsCount = _a.actorsCount;
+    // roundPlayers starts with the stipulated pairing
+    var roundPlayers = [].concat.apply([], __spreadArray([], __read(stipulated), false));
+    // aggregates the pairings generated for a roundCandidate
+    var participantIdPairings = [];
+    // candidateValue is the sum of all participantIdPairings in a roundCandidate
+    // the winning candidate has the LOWEST total value
+    var candidateValue = 0;
+    // candidateValue is initialized with any stipulated pairings
+    stipulated.filter(Boolean).forEach(function (participantIds) {
+        var _a = __read(participantIds, 2), p1 = _a[0], p2 = _a[1];
+        var pairing = pairingHash(p1, p2);
+        var value = pairingValueMap[pairing];
+        participantIdPairings.push({ participantIds: participantIds, value: value });
+        candidateValue += pairingValueMap[pairing];
+    });
+    // valueSortedPairings is an array sorted from lowest value to highest value
+    // introduce random shuffling of chunks of valueSortedPairings
+    var consideredPairings = chunkArray(valueSortedPairings, actorsCount)
+        .map(function (pairings) {
+        return shuffleArray(pairings).map(function (pairing) { return (__assign(__assign({}, pairing), { value: pairing.value + Math.random() * Math.round(Math.random()) })); });
+    })
+        .flat();
+    // go through the valueSortedPairings (of all possible unique pairings)
+    consideredPairings.forEach(function (rankedPairing) {
+        var participantIds = rankedPairing.pairing.split('|');
+        var opponentExists = participantIds.reduce(function (p, c) { return roundPlayers.includes(c) || p; }, false);
+        if (!opponentExists) {
+            roundPlayers.push.apply(roundPlayers, __spreadArray([], __read(participantIds), false));
+            var value = rankedPairing.value;
+            candidateValue += value;
+            participantIdPairings.push({ participantIds: participantIds, value: value });
+        }
     });
-}
-
-function applyLineUps(_a) {
-    var e_1, _b, e_2, _c, e_3, _d, e_4, _e;
-    var _f, _g, _h, _j;
-    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, matchUpId = _a.matchUpId, lineUps = _a.lineUps, event = _a.event;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!drawDefinition)
-        return { error: DRAW_DEFINITION_NOT_FOUND };
-    if (typeof matchUpId !== 'string')
-        return { error: INVALID_MATCHUP };
-    if (!Array.isArray(lineUps))
-        return { error: INVALID_VALUES, lineUps: lineUps };
-    var stack = 'applyLineUps';
-    var tournamentParticipants = tournamentRecord.participants || [];
-    var result = findDrawMatchUp({
-        tournamentParticipants: tournamentParticipants,
-        inContext: true,
-        drawDefinition: drawDefinition,
-        matchUpId: matchUpId,
-    });
-    if (result.error)
-        return result;
-    if (!result.matchUp)
-        return { error: MATCHUP_NOT_FOUND };
-    var inContextMatchUp = result.matchUp, structure = result.structure;
-    var drawPositions = inContextMatchUp.drawPositions, matchUpType = inContextMatchUp.matchUpType;
-    if (matchUpType !== TEAM$1)
-        return { error: INVALID_MATCHUP };
-    if (!(drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.length))
-        return { error: MISSING_DRAW_POSITIONS };
-    var tieFormat = (_f = resolveTieFormat({
-        matchUp: inContextMatchUp,
-        drawDefinition: drawDefinition,
-        structure: structure,
-        event: event,
-    })) === null || _f === void 0 ? void 0 : _f.tieFormat;
-    // verify integrity of lineUps...
-    // 1. all participantIds must be valid individualParticipantIds
-    // 2. there should be at most one participantId for a given collectionPosition in singles
-    // 3. there should be at most two participantIds for a given collectionPosition in doubles
-    var sideAssignments = {};
-    try {
-        for (var lineUps_1 = __values(lineUps), lineUps_1_1 = lineUps_1.next(); !lineUps_1_1.done; lineUps_1_1 = lineUps_1.next()) {
-            var lineUp = lineUps_1_1.value;
-            if (!Array.isArray(lineUp))
-                return { error: INVALID_VALUES, lineUp: lineUp };
-            // maintain mapping of collectionId|collectionPosition to the participantIds assigned
-            var collectionParticipantIds = {};
-            var sideNumbers = [];
-            var _loop_1 = function (lineUpAssignment) {
-                var e_5, _m;
-                if (typeof lineUpAssignment !== 'object')
-                    return { value: { error: INVALID_VALUES, lineUpAssignment: lineUpAssignment } };
-                var participantId = lineUpAssignment.participantId, _o = lineUpAssignment.collectionAssignments, collectionAssignments = _o === void 0 ? [] : _o;
-                if (!Array.isArray(collectionAssignments))
-                    return { value: { error: INVALID_VALUES, collectionAssignments: collectionAssignments } };
-                var participant = tournamentParticipants.find(function (participant) { return participant.participantId === participantId; });
-                if (!participant)
-                    return { value: { error: PARTICIPANT_NOT_FOUND } };
-                if (participant.participantType !== INDIVIDUAL)
-                    return { value: { error: INVALID_PARTICIPANT_TYPE } };
-                var sideNumber_1 = (_h = (_g = inContextMatchUp.sides) === null || _g === void 0 ? void 0 : _g.find(function (side) { var _a, _b; return (_b = (_a = side.participant) === null || _a === void 0 ? void 0 : _a.individualParticipantIds) === null || _b === void 0 ? void 0 : _b.includes(participantId); })) === null || _h === void 0 ? void 0 : _h.sideNumber;
-                if (sideNumber_1)
-                    sideNumbers.push(sideNumber_1);
-                var _loop_3 = function (collectionAssignment) {
-                    if (typeof collectionAssignment !== 'object')
-                        return { value: { error: INVALID_VALUES, collectionAssignment: collectionAssignment } };
-                    var collectionId = collectionAssignment.collectionId, collectionPosition = collectionAssignment.collectionPosition;
-                    var collectionDefinition = (_j = tieFormat === null || tieFormat === void 0 ? void 0 : tieFormat.collectionDefinitions) === null || _j === void 0 ? void 0 : _j.find(function (collectionDefinition) {
-                        return collectionDefinition.collectionId === collectionId;
-                    });
-                    // all collectionIds in the lineUp must be present in the tieFormat collectionDefinitions
-                    if (!collectionDefinition)
-                        return { value: { error: INVALID_VALUES, collectionId: collectionId } };
-                    var aggregator = "".concat(collectionId, "-").concat(collectionPosition);
-                    if (!collectionParticipantIds[aggregator]) {
-                        collectionParticipantIds[aggregator] = [];
-                    }
-                    var participantsCount = collectionParticipantIds[aggregator].length;
-                    if ((collectionDefinition.matchUpType === SINGLES && participantsCount) ||
-                        (collectionDefinition.matchUpType === DOUBLES &&
-                            participantsCount > 1)) {
-                        return { value: {
-                                info: 'Excessive collectionPosition assignments',
-                                error: INVALID_VALUES,
-                            } };
-                    }
-                    collectionParticipantIds[aggregator].push(participantId);
-                };
-                try {
-                    for (var collectionAssignments_1 = (e_5 = void 0, __values(collectionAssignments)), collectionAssignments_1_1 = collectionAssignments_1.next(); !collectionAssignments_1_1.done; collectionAssignments_1_1 = collectionAssignments_1.next()) {
-                        var collectionAssignment = collectionAssignments_1_1.value;
-                        var state_2 = _loop_3(collectionAssignment);
-                        if (typeof state_2 === "object")
-                            return state_2;
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (collectionAssignments_1_1 && !collectionAssignments_1_1.done && (_m = collectionAssignments_1.return)) _m.call(collectionAssignments_1);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-            };
-            try {
-                for (var lineUp_1 = (e_2 = void 0, __values(lineUp)), lineUp_1_1 = lineUp_1.next(); !lineUp_1_1.done; lineUp_1_1 = lineUp_1.next()) {
-                    var lineUpAssignment = lineUp_1_1.value;
-                    var state_1 = _loop_1(lineUpAssignment);
-                    if (typeof state_1 === "object")
-                        return state_1.value;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (lineUp_1_1 && !lineUp_1_1.done && (_c = lineUp_1.return)) _c.call(lineUp_1);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            // ensure that doubles pair participants exist, otherwise create
-            var collectionParticipantIdPairs = Object.values(collectionParticipantIds);
-            try {
-                for (var collectionParticipantIdPairs_1 = (e_3 = void 0, __values(collectionParticipantIdPairs)), collectionParticipantIdPairs_1_1 = collectionParticipantIdPairs_1.next(); !collectionParticipantIdPairs_1_1.done; collectionParticipantIdPairs_1_1 = collectionParticipantIdPairs_1.next()) {
-                    var participantIds = collectionParticipantIdPairs_1_1.value;
-                    if (participantIds.length === 2) {
-                        var pairedParticipant = getPairedParticipant({
-                            tournamentParticipants: tournamentParticipants,
-                            participantIds: participantIds,
-                        }).participant;
-                        if (!pairedParticipant) {
-                            // create pair participant
-                            var newPairParticipant = {
-                                participantType: PAIR,
-                                participantRole: COMPETITOR,
-                                individualParticipantIds: participantIds,
-                            };
-                            var result_1 = addParticipant({
-                                participant: newPairParticipant,
-                                pairOverride: true,
-                                tournamentRecord: tournamentRecord,
-                            });
-                            if (result_1.error)
-                                return result_1;
-                        }
-                    }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (collectionParticipantIdPairs_1_1 && !collectionParticipantIdPairs_1_1.done && (_d = collectionParticipantIdPairs_1.return)) _d.call(collectionParticipantIdPairs_1);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            // determine sideNumber based on instances of participants appearing in team participants assigned to sides
-            // allows for some team members to be "borrowed"
-            var instances = instanceCount(sideNumbers);
-            var sideNumber = ((instances[1] || 0) > (instances[2] || 0) && 1) ||
-                ((instances[2] || 0) > (instances[1] || 0) && 2) ||
-                undefined;
-            // if side not previously assigned, map sideNumber to lineUp
-            var sideAssignmentKeys = Object.keys(sideAssignments).map(function (key) {
-                return parseInt(key);
-            });
-            if (sideNumber && !sideAssignmentKeys.includes(sideNumber)) {
-                sideAssignments[sideNumber] = lineUp;
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (lineUps_1_1 && !lineUps_1_1.done && (_b = lineUps_1.return)) _b.call(lineUps_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    if (!Object.keys(sideAssignments).length)
-        return { error: VALUE_UNCHANGED };
-    result = findDrawMatchUp({ drawDefinition: drawDefinition, matchUpId: matchUpId });
-    if (result.error)
-        return result;
-    if (!result.matchUp)
-        return { error: MATCHUP_NOT_FOUND };
-    var matchUp = result.matchUp;
-    if (!matchUp.sides)
-        matchUp.sides = [];
-    var _loop_2 = function (sideNumber) {
-        var side = matchUp.sides.find(function (side) { return side.sideNumber === sideNumber; });
-        var assignment = sideAssignments[sideNumber];
-        if (!assignment) {
-            return "continue";
-        }
-        else if (!side) {
-            matchUp.sides.push({ lineUp: assignment, sideNumber: sideNumber });
-        }
-        else {
-            side.lineUp = assignment;
-        }
-    };
-    try {
-        for (var _k = __values([1, 2]), _l = _k.next(); !_l.done; _l = _k.next()) {
-            var sideNumber = _l.value;
-            _loop_2(sideNumber);
-        }
-    }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-    finally {
-        try {
-            if (_l && !_l.done && (_e = _k.return)) _e.call(_k);
-        }
-        finally { if (e_4) throw e_4.error; }
-    }
-    modifyMatchUpNotice({
-        tournamentId: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.tournamentId,
-        context: stack,
-        drawDefinition: drawDefinition,
-        matchUp: matchUp,
-    });
-    return __assign({}, SUCCESS);
-}
-
-function resetTieFormat(params) {
-    var _a, _b, e_1, _c, e_2, _d;
-    var _e, _f, _g;
-    var stack = 'resetTieFormat';
-    var drawDefinition = params.drawDefinition, event = params.event, uuids = params.uuids;
-    var paramCheck = checkRequiredParameters(params, [(_a = {}, _a[TOURNAMENT_RECORD] = true, _a[MATCHUP_ID] = true, _a)], stack);
-    if (paramCheck.error)
-        return paramCheck;
-    var resolutions = resolveFromParameters(params, [(_b = {}, _b[PARAM] = MATCHUP, _b)]);
-    if (resolutions[ERROR])
-        return resolutions;
-    var tournamentId = (_e = params.tournamentRecord) === null || _e === void 0 ? void 0 : _e.tournamentId;
-    var _h = (_f = resolutions === null || resolutions === void 0 ? void 0 : resolutions.matchUp) !== null && _f !== void 0 ? _f : {}, matchUp = _h.matchUp, structure = _h.structure;
-    if (!(matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps))
-        return decorateResult({
-            result: { error: INVALID_MATCHUP },
-            info: 'Must be a TEAM matchUp',
-            stack: stack,
-        });
-    // if there is no tieFormat there is nothing to do
-    if (!matchUp.tieFormat)
-        return __assign({}, SUCCESS);
-    var tieFormat = (_g = resolveTieFormat({
-        structure: structure,
-        drawDefinition: drawDefinition,
-        event: event,
-    })) === null || _g === void 0 ? void 0 : _g.tieFormat;
-    if (!tieFormat)
-        return decorateResult({
-            result: { error: NOT_FOUND },
-            info: 'No inherited tieFormat',
-            stack: stack,
-        });
-    var deletedMatchUpIds = [];
-    var collectionIds = [];
-    var tieMatchUps = [];
-    var newMatchUps = [];
-    var _loop_1 = function (collectionDefinition) {
-        // delete any matchUp.tieMatchUps that are not found in the ancestor tieFormat collectionDefinitions
-        var matchUpCount = collectionDefinition.matchUpCount, collectionId = collectionDefinition.collectionId;
-        collectionIds.push(collectionId);
-        var existingCollectionMatchUps = (matchUp.tieMatchUps || []).filter(function (matchUp) { return matchUp.collectionId === collectionId; });
-        if (existingCollectionMatchUps.length > matchUpCount) {
-            // sort by matchUpStatus to prioritize active or completed matchUpsA
-            existingCollectionMatchUps.sort(function (a, b) {
-                return (a.matchUpStatus === TO_BE_PLAYED ? 1 : 0) -
-                    (b.matchUpStatus === TO_BE_PLAYED ? 1 : 0);
-            });
-            tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(existingCollectionMatchUps.slice(0, matchUpCount)), false));
-            deletedMatchUpIds.push.apply(deletedMatchUpIds, __spreadArray([], __read(existingCollectionMatchUps.slice(3).map(getMatchUpId)), false));
-        }
-        else {
-            tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(existingCollectionMatchUps), false));
-            if (existingCollectionMatchUps.length < matchUpCount) {
-                var matchUpsLimit = matchUpCount - existingCollectionMatchUps.length;
-                var matchUps = generateCollectionMatchUps({
-                    collectionDefinition: collectionDefinition,
-                    matchUpsLimit: matchUpsLimit,
-                    uuids: uuids,
-                });
-                newMatchUps.push.apply(newMatchUps, __spreadArray([], __read(matchUps), false));
-            }
-        }
-    };
-    try {
-        for (var _j = __values(tieFormat.collectionDefinitions), _k = _j.next(); !_k.done; _k = _j.next()) {
-            var collectionDefinition = _k.value;
-            _loop_1(collectionDefinition);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    try {
-        for (var _l = __values((matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps) || []), _m = _l.next(); !_m.done; _m = _l.next()) {
-            var tieMatchUp = _m.value;
-            if (tieMatchUp.collectionId &&
-                !collectionIds.includes(tieMatchUp.collectionId))
-                deletedMatchUpIds.push(tieMatchUp.matchUpId);
-        }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
-        }
-        finally { if (e_2) throw e_2.error; }
-    }
-    if (newMatchUps.length) {
-        tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(newMatchUps), false));
-        addMatchUpsNotice({
-            eventId: event === null || event === void 0 ? void 0 : event.eventId,
-            matchUps: newMatchUps,
-            drawDefinition: drawDefinition,
-            tournamentId: tournamentId,
-        });
-    }
-    if (deletedMatchUpIds.length) {
-        deleteMatchUpsNotice({
-            matchUpIds: deletedMatchUpIds,
-            eventId: event === null || event === void 0 ? void 0 : event.eventId,
-            drawDefinition: drawDefinition,
-            tournamentId: tournamentId,
-        });
-    }
-    if (matchUp) {
-        matchUp.tieMatchUps = tieMatchUps;
-        matchUp.tieFormatId = undefined;
-        matchUp.tieFormat = undefined;
-        modifyMatchUpNotice({
-            structureId: structure === null || structure === void 0 ? void 0 : structure.structureId,
-            eventId: event === null || event === void 0 ? void 0 : event.eventId,
-            context: stack,
-            drawDefinition: drawDefinition,
-            tournamentId: tournamentId,
-            matchUp: matchUp,
-        });
-    }
-    return __assign(__assign({}, SUCCESS), { newMatchUps: newMatchUps, deletedMatchUpIds: deletedMatchUpIds });
-}
-
-function resetScorecard(params) {
-    var e_1, _a;
-    var _b, _c;
-    var tournamentRecord = params.tournamentRecord, drawDefinition = params.drawDefinition, matchUpId = params.matchUpId, event = params.event;
-    var stack = 'resetScorecard';
-    // Check for missing parameters ---------------------------------------------
-    if (!drawDefinition)
-        return decorateResult({
-            result: { error: MISSING_DRAW_DEFINITION },
-            stack: stack,
-        });
-    if (!matchUpId)
-        return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack: stack });
-    if (!isString(matchUpId))
-        return decorateResult({
-            result: { error: INVALID_VALUES, matchUpId: matchUpId },
-            stack: stack,
-        });
-    // Get map of all drawMatchUps and inContextDrawMatchUPs ---------------------
-    var matchUpsMap = getMatchUpsMap({ drawDefinition: drawDefinition });
-    var inContextDrawMatchUps = getAllDrawMatchUps({
-        nextMatchUps: true,
-        inContext: true,
-        drawDefinition: drawDefinition,
-        matchUpsMap: matchUpsMap,
-    }).matchUps;
-    // Find target matchUp ------------------------------------------------------
-    var matchUp = matchUpsMap.drawMatchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
-    var inContextMatchUp = inContextDrawMatchUps === null || inContextDrawMatchUps === void 0 ? void 0 : inContextDrawMatchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
-    if (!matchUp || !inContextDrawMatchUps)
-        return { error: MATCHUP_NOT_FOUND };
-    // only accept matchUpType: TEAM
-    if (matchUp.matchUpType !== TEAM_EVENT)
-        return { error: INVALID_MATCHUP };
-    // Get winner/loser position targets ----------------------------------------
-    var targetData = positionTargets({
-        inContextDrawMatchUps: inContextDrawMatchUps,
-        drawDefinition: drawDefinition,
-        matchUpId: matchUpId,
-    });
-    var structureId = inContextMatchUp === null || inContextMatchUp === void 0 ? void 0 : inContextMatchUp.structureId;
-    var structure = findStructure({ drawDefinition: drawDefinition, structureId: structureId }).structure;
-    Object.assign(params, {
-        inContextDrawMatchUps: inContextDrawMatchUps,
-        inContextMatchUp: inContextMatchUp,
-        matchUpsMap: matchUpsMap,
-        targetData: targetData,
-        structure: structure,
-        matchUp: matchUp,
-    });
-    // with propagating winningSide changes, activeDownstream only applies to eventType: TEAM
-    var activeDownstream = isActiveDownstream(params);
-    if (activeDownstream)
-        return { error: CANNOT_CHANGE_WINNING_SIDE };
-    if ((_b = matchUp.tieMatchUps) === null || _b === void 0 ? void 0 : _b.length) {
-        try {
-            for (var _d = __values(matchUp.tieMatchUps), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var tieMatchUp = _e.value;
-                var result_1 = setMatchUpState({
-                    matchUpId: tieMatchUp.matchUpId,
-                    matchUpTieId: matchUpId,
-                    winningSide: undefined,
-                    removeScore: true,
-                    tournamentRecord: tournamentRecord,
-                    drawDefinition: drawDefinition,
-                    event: event,
-                });
-                if (result_1.error)
-                    return decorateResult({ result: result_1, stack: stack });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    }
-    var result = updateTieMatchUpScore({
-        event: params.event,
-        removeScore: true,
-        tournamentRecord: tournamentRecord,
-        drawDefinition: drawDefinition,
-        matchUpsMap: matchUpsMap,
-        matchUpId: matchUpId,
-    });
-    if (result.error)
-        return decorateResult({ result: result, stack: stack });
-    if (params.tiebreakReset && !result.tieFormatRemoved) {
-        // check for scenarios where an added "Tiebreaker" collectionDefinition/matchUp has been added
-        var inheritedTieFormat = (_c = resolveTieFormat({
-            drawDefinition: drawDefinition,
-            structure: structure,
-            event: event,
-        })) === null || _c === void 0 ? void 0 : _c.tieFormat;
-        if (matchUp.tieFormat && inheritedTieFormat) {
-            var _f = compareTieFormats({
-                descendant: matchUp.tieFormat,
-                ancestor: inheritedTieFormat,
-            }), matchUpCountDifference = _f.matchUpCountDifference, descendantDifferences = _f.descendantDifferences, ancestorDifferences = _f.ancestorDifferences, valueDifference = _f.valueDifference;
-            if (descendantDifferences.collectionIds.length === 1 &&
-                !ancestorDifferences.collectionIds.length &&
-                !ancestorDifferences.groupsCount &&
-                matchUpCountDifference === 1 &&
-                valueDifference === 1) {
-                var result_2 = resetTieFormat({
-                    tournamentRecord: tournamentRecord,
-                    drawDefinition: drawDefinition,
-                    matchUpId: matchUpId,
-                    event: event,
-                });
-                if (result_2.error)
-                    return result_2;
-            }
-        }
-    }
-    return __assign({}, SUCCESS);
-}
-
-function removeSeeding(_a) {
-    var _b, _c;
-    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, entryStatuses = _a.entryStatuses, scaleName = _a.scaleName, drawId = _a.drawId, event = _a.event, stage = _a.stage;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!event)
-        return { error: MISSING_EVENT };
-    scaleName =
-        scaleName ||
-            ((_b = event.category) === null || _b === void 0 ? void 0 : _b.categoryName) ||
-            ((_c = event.category) === null || _c === void 0 ? void 0 : _c.ageCategoryCode);
-    var scaleAttributes = {
-        eventType: event.eventType,
-        scaleType: SEEDING$1,
-        scaleName: scaleName,
-    };
-    return removeScaleValues({
-        tournamentRecord: tournamentRecord,
-        scaleAttributes: scaleAttributes,
-        drawDefinition: drawDefinition,
-        entryStatuses: entryStatuses,
-        drawId: drawId,
-        event: event,
-        stage: stage,
-    });
-}
-
-function generateAdHocMatchUps(_a) {
-    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-    var participantIdPairings = _a.participantIdPairings, _p = _a.matchUpIds, matchUpIds = _p === void 0 ? [] : _p, drawDefinition = _a.drawDefinition, matchUpsCount = _a.matchUpsCount, roundNumber = _a.roundNumber, structureId = _a.structureId, newRound = _a.newRound;
-    if (typeof drawDefinition !== 'object')
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId && ((_b = drawDefinition.structures) === null || _b === void 0 ? void 0 : _b.length) === 1)
-        structureId = (_d = (_c = drawDefinition.structures) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.structureId;
-    if (typeof structureId !== 'string')
-        return { error: MISSING_STRUCTURE_ID };
-    // if drawDefinition and structureId are provided it is possible to infer roundNumber
-    var structure = (_e = drawDefinition.structures) === null || _e === void 0 ? void 0 : _e.find(function (structure) { return structure.structureId === structureId; });
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    var structureHasRoundPositions;
-    var existingMatchUps = (_f = structure.matchUps) !== null && _f !== void 0 ? _f : [];
-    var lastRoundNumber = existingMatchUps === null || existingMatchUps === void 0 ? void 0 : existingMatchUps.reduce(function (roundNumber, matchUp) {
-        if (matchUp.roundPosition)
-            structureHasRoundPositions = true;
-        return ((matchUp === null || matchUp === void 0 ? void 0 : matchUp.roundNumber) || 0) > roundNumber
-            ? matchUp.roundNumber
-            : roundNumber;
-    }, 0);
-    if (!matchUpsCount) {
-        var selectedEntries = (_h = (_g = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries) === null || _g === void 0 ? void 0 : _g.filter(function (entry) {
-            var entryStatus = entry.entryStatus;
-            return STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
-        })) !== null && _h !== void 0 ? _h : [];
-        var roundMatchUpsCount = Math.floor((selectedEntries === null || selectedEntries === void 0 ? void 0 : selectedEntries.length) / 2) || 1;
-        if (newRound) {
-            matchUpsCount = roundMatchUpsCount;
-        }
-        else {
-            var targetRoundNumber_1 = (_j = roundNumber !== null && roundNumber !== void 0 ? roundNumber : lastRoundNumber) !== null && _j !== void 0 ? _j : 1;
-            var existingRoundMatchUps = (_m = (_l = (_k = structure.matchUps) === null || _k === void 0 ? void 0 : _k.filter(function (matchUp) { return matchUp.roundNumber === targetRoundNumber_1; })) === null || _l === void 0 ? void 0 : _l.length) !== null && _m !== void 0 ? _m : 0;
-            var maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
-            if (maxRemaining > 0)
-                matchUpsCount = maxRemaining;
-        }
-    }
-    if ((participantIdPairings && !Array.isArray(participantIdPairings)) ||
-        (matchUpsCount && !isConvertableInteger(matchUpsCount)) ||
-        (matchUpIds && !Array.isArray(matchUpIds)) ||
-        (!participantIdPairings && !matchUpsCount)) {
-        return { error: INVALID_VALUES, info: 'matchUpsCount or pairings error' };
-    }
-    // structure must not be a container of other structures
-    // structure must not contain matchUps with roundPosition
-    // structure must not determine finishingPosition by ROUND_OUTCOME
-    if (structure.structures ||
-        structureHasRoundPositions ||
-        structure.finishingPosition === ROUND_OUTCOME) {
-        return { error: INVALID_STRUCTURE };
-    }
-    if (roundNumber && roundNumber - 1 > (lastRoundNumber || 0))
-        return { error: INVALID_VALUES, info: 'roundNumber error' };
-    var nextRoundNumber = roundNumber !== null && roundNumber !== void 0 ? roundNumber : ((newRound && (lastRoundNumber !== null && lastRoundNumber !== void 0 ? lastRoundNumber : 0) + 1) || lastRoundNumber || 1);
-    participantIdPairings =
-        participantIdPairings !== null && participantIdPairings !== void 0 ? participantIdPairings : generateRange(0, matchUpsCount).map(function () { return ({
-            participantIds: [undefined, undefined],
-        }); });
-    var matchUps = participantIdPairings === null || participantIdPairings === void 0 ? void 0 : participantIdPairings.map(function (pairing) {
-        var _a, _b;
-        var idStack = (_a = pairing === null || pairing === void 0 ? void 0 : pairing.participantIds) !== null && _a !== void 0 ? _a : [undefined, undefined];
-        // ensure there are always 2 sides in generated matchUps
-        idStack.push.apply(idStack, [undefined, undefined]);
-        var participantIds = idStack.slice(0, 2);
-        var sides = participantIds.map(function (participantId, i) {
-            return definedAttributes({
-                sideNumber: i + 1,
-                participantId: participantId,
-            });
-        });
-        return {
-            matchUpId: (_b = matchUpIds.pop()) !== null && _b !== void 0 ? _b : UUID(),
-            roundNumber: nextRoundNumber,
-            matchUpStatus: TO_BE_PLAYED,
-            sides: sides,
-        };
-    });
-    return __assign({ matchUpsCount: (_o = matchUps === null || matchUps === void 0 ? void 0 : matchUps.length) !== null && _o !== void 0 ? _o : 0, matchUps: matchUps }, SUCCESS);
-}
-
-function generateCandidate(_a) {
-    var _b = _a.maxIterations, maxIterations = _b === void 0 ? 4000 : _b, // cap the processing intensity of the candidate generator
-    valueSortedPairings = _a.valueSortedPairings, // pairings sorted by value from low to high
-    pairingValues = _a.pairingValues, valueObjects = _a.valueObjects, deltaObjects = _a.deltaObjects;
-    var pairingValueMap = Object.assign.apply(Object, __spreadArray([{}], __read(valueSortedPairings.map(function (rm) {
-        var _a;
-        return (_a = {}, _a[rm.pairing] = rm.value, _a);
-    })), false));
-    var actors = Object.keys(pairingValues);
-    var proposedCandidates = [];
-    // generate an initial candidate value with no stipulated pairings
-    var initialProposal = roundCandidate({
-        actorsCount: actors.length,
-        valueSortedPairings: valueSortedPairings,
-        pairingValueMap: pairingValueMap,
-        deltaObjects: deltaObjects,
-        valueObjects: valueObjects,
-    });
-    var candidateHashes = [candidateHash(initialProposal)];
-    proposedCandidates.push(initialProposal);
-    var lowCandidateValue = initialProposal.value;
-    var deltaCandidate = initialProposal;
-    // iterations is the number of loops over valueSortedPairings
-    var candidatesCount = 0;
-    var iterations = 0;
-    var opponentCount = actors.length;
-    var calculatedIterations;
-    // calculate the number of opponents to consider for each participantId
-    do {
-        opponentCount -= 1;
-        calculatedIterations = actors.length * pairingValues[actors[0]].length;
-    } while (calculatedIterations > maxIterations && opponentCount > 5);
-    // keep track of proposed pairings
-    var stipulatedPairs = [];
-    // for each actor generate a roundCandidate using opponentCount of pairing values
-    actors.forEach(function (actor) {
-        var participantIdPairings = pairingValues[actor];
-        // opponentCount limits the number of opponents to consider
-        participantIdPairings.slice(0, opponentCount).forEach(function (pairing) {
-            iterations += 1;
-            var stipulatedPair = pairingHash(actor, pairing.opponent);
-            if (!stipulatedPairs.includes(stipulatedPair)) {
-                var proposed = roundCandidate({
-                    // each roundCandidate starts with stipulated pairings
-                    stipulated: [[actor, pairing.opponent]],
-                    actorsCount: actors.length,
-                    valueSortedPairings: valueSortedPairings,
-                    pairingValueMap: pairingValueMap,
-                    deltaObjects: deltaObjects,
-                    valueObjects: valueObjects,
-                });
-                // ensure no duplicate candidates are considered
-                if (!candidateHashes.includes(candidateHash(proposed))) {
-                    candidateHashes.push(candidateHash(proposed));
-                    proposedCandidates.push(proposed);
-                    var maxDelta = proposed.maxDelta, value = proposed.value;
-                    if (maxDelta < deltaCandidate.maxDelta)
-                        deltaCandidate = proposed;
-                    if (value < lowCandidateValue ||
-                        (value === lowCandidateValue && Math.round(Math.random())) // randomize if equivalent values
-                    ) {
-                        lowCandidateValue = value;
-                    }
-                    stipulatedPairs.push(stipulatedPair);
-                    candidatesCount += 1;
-                }
-            }
-        });
-        proposedCandidates = proposedCandidates.filter(function (proposed) { return Math.abs(proposed.value - lowCandidateValue) < 5; });
-    });
-    proposedCandidates.sort(function (a, b) { return a.maxDiff - b.maxDiff; });
-    var candidate = randomPop(proposedCandidates);
-    return {
-        candidatesCount: candidatesCount,
-        deltaCandidate: deltaCandidate,
-        maxIterations: maxIterations,
-        iterations: iterations,
-        candidate: candidate,
-    };
-}
-function candidateHash(candidate) {
-    return candidate.participantIdPairings
-        .map(function (_a) {
-        var participantIds = _a.participantIds;
-        return participantIds.sort().join('|');
-    })
-        .sort()
-        .join('/');
-}
-function roundCandidate(_a) {
-    var valueSortedPairings = _a.valueSortedPairings, _b = _a.stipulated, stipulated = _b === void 0 ? [] : _b, pairingValueMap = _a.pairingValueMap, deltaObjects = _a.deltaObjects, valueObjects = _a.valueObjects, actorsCount = _a.actorsCount;
-    // roundPlayers starts with the stipulated pairing
-    var roundPlayers = [].concat.apply([], __spreadArray([], __read(stipulated), false));
-    // aggregates the pairings generated for a roundCandidate
-    var participantIdPairings = [];
-    // candidateValue is the sum of all participantIdPairings in a roundCandidate
-    // the winning candidate has the LOWEST total value
-    var candidateValue = 0;
-    // candidateValue is initialized with any stipulated pairings
-    stipulated.filter(Boolean).forEach(function (participantIds) {
-        var _a = __read(participantIds, 2), p1 = _a[0], p2 = _a[1];
-        var pairing = pairingHash(p1, p2);
-        var value = pairingValueMap[pairing];
-        participantIdPairings.push({ participantIds: participantIds, value: value });
-        candidateValue += pairingValueMap[pairing];
-    });
-    // valueSortedPairings is an array sorted from lowest value to highest value
-    // introduce random shuffling of chunks of valueSortedPairings
-    var consideredPairings = chunkArray(valueSortedPairings, actorsCount)
-        .map(function (pairings) {
-        return shuffleArray(pairings).map(function (pairing) { return (__assign(__assign({}, pairing), { value: pairing.value + Math.random() * Math.round(Math.random()) })); });
-    })
-        .flat();
-    // go through the valueSortedPairings (of all possible unique pairings)
-    consideredPairings.forEach(function (rankedPairing) {
-        var participantIds = rankedPairing.pairing.split('|');
-        var opponentExists = participantIds.reduce(function (p, c) { return roundPlayers.includes(c) || p; }, false);
-        if (!opponentExists) {
-            roundPlayers.push.apply(roundPlayers, __spreadArray([], __read(participantIds), false));
-            var value = rankedPairing.value;
-            candidateValue += value;
-            participantIdPairings.push({ participantIds: participantIds, value: value });
-        }
-    });
-    // sort the candidate's proposed pairings by value
-    participantIdPairings.sort(function (a, b) { return a.value - b.value; });
-    // determine the greatest delta in the candidate's pairings
-    var maxDelta = participantIdPairings.reduce(function (p, c) {
-        var _a = __read(c.participantIds, 2), p1 = _a[0], p2 = _a[1];
-        var hash = pairingHash(p1, p2);
-        var delta = deltaObjects[hash];
-        return delta > p ? delta : p;
-    }, 0);
-    // determine the greatest delta in the candidate's pairings
-    var maxDiff = participantIdPairings.reduce(function (p, c) {
-        var _a = __read(c.participantIds, 2), p1 = _a[0], p2 = _a[1];
-        var hash = pairingHash(p1, p2);
-        var diff = valueObjects[hash];
-        return diff > p ? diff : p;
-    }, 0);
-    return { value: candidateValue, participantIdPairings: participantIdPairings, maxDelta: maxDelta, maxDiff: maxDiff };
-}
-function pairingHash(id1, id2) {
-    return [id1, id2].sort(stringSort).join('|');
+    // sort the candidate's proposed pairings by value
+    participantIdPairings.sort(function (a, b) { return a.value - b.value; });
+    // determine the greatest delta in the candidate's pairings
+    var maxDelta = participantIdPairings.reduce(function (p, c) {
+        var _a = __read(c.participantIds, 2), p1 = _a[0], p2 = _a[1];
+        var hash = pairingHash(p1, p2);
+        var delta = deltaObjects[hash];
+        return delta > p ? delta : p;
+    }, 0);
+    // determine the greatest delta in the candidate's pairings
+    var maxDiff = participantIdPairings.reduce(function (p, c) {
+        var _a = __read(c.participantIds, 2), p1 = _a[0], p2 = _a[1];
+        var hash = pairingHash(p1, p2);
+        var diff = valueObjects[hash];
+        return diff > p ? diff : p;
+    }, 0);
+    return { value: candidateValue, participantIdPairings: participantIdPairings, maxDelta: maxDelta, maxDiff: maxDiff };
+}
+function pairingHash(id1, id2) {
+    return [id1, id2].sort(stringSort).join('|');
 }
 
 function getPairingsData(_a) {
@@ -38292,7 +37676,7 @@ var MAX_ITERATIONS = 4000;
 function generateDrawMaticRound(_a) {
     var e_1, _b, e_2, _c, e_3, _d;
     var _e, _f;
-    var _g = _a.encounterValue, encounterValue = _g === void 0 ? ENCOUNTER_VALUE : _g, _h = _a.sameTeamValue, sameTeamValue = _h === void 0 ? SAME_TEAM_VALUE : _h, _j = _a.maxIterations, maxIterations = _j === void 0 ? MAX_ITERATIONS : _j, _k = _a.generateMatchUps, generateMatchUps = _k === void 0 ? true : _k, tournamentParticipants = _a.tournamentParticipants, participantIds = _a.participantIds, drawDefinition = _a.drawDefinition, adHocRatings = _a.adHocRatings, structureId = _a.structureId, _l = _a.salted, salted = _l === void 0 ? 0.5 : _l, matchUpIds = _a.matchUpIds, eventType = _a.eventType, structure = _a.structure, scaleName = _a.scaleName;
+    var _g = _a.encounterValue, encounterValue = _g === void 0 ? ENCOUNTER_VALUE : _g, _h = _a.sameTeamValue, sameTeamValue = _h === void 0 ? SAME_TEAM_VALUE : _h, _j = _a.maxIterations, maxIterations = _j === void 0 ? MAX_ITERATIONS : _j, _k = _a.generateMatchUps, generateMatchUps = _k === void 0 ? true : _k, tournamentParticipants = _a.tournamentParticipants, participantIds = _a.participantIds, drawDefinition = _a.drawDefinition, adHocRatings = _a.adHocRatings, structureId = _a.structureId, _l = _a.salted, salted = _l === void 0 ? 0.5 : _l, matchUpIds = _a.matchUpIds, eventType = _a.eventType, structure = _a.structure, scaleName = _a.scaleName, isMock = _a.isMock, event = _a.event;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure && !structureId)
@@ -38400,6 +37784,8 @@ function generateDrawMaticRound(_a) {
             newRound: true,
             drawDefinition: drawDefinition,
             matchUpIds: matchUpIds,
+            isMock: isMock,
+            event: event,
         });
         if (result.error)
             return result;
@@ -38409,11 +37795,11 @@ function generateDrawMaticRound(_a) {
     return __assign(__assign({}, SUCCESS), { participantIdPairings: participantIdPairings, candidatesCount: candidatesCount, iterations: iterations, matchUps: matchUps, maxDelta: maxDelta, maxDiff: maxDiff });
 }
 
-function drawMatic$1(_a) {
+function drawMatic(_a) {
     var e_1, _b;
     var _c, _d, _e, _f, _g;
-    var tournamentParticipants = _a.tournamentParticipants, restrictEntryStatus = _a.restrictEntryStatus, _h = _a.adHocRatings, adHocRatings = _h === void 0 ? {} : _h, generateMatchUps = _a.generateMatchUps, tournamentRecord = _a.tournamentRecord, participantIds = _a.participantIds, encounterValue = _a.encounterValue, sameTeamValue = _a.sameTeamValue, drawDefinition = _a.drawDefinition, scaleAccessor = _a.scaleAccessor, maxIterations = _a.maxIterations, structureId = _a.structureId, matchUpIds = _a.matchUpIds, scaleName = _a.scaleName, // custom rating name to seed dynamic ratings
-    eventType = _a.eventType, salted = _a.salted, event = _a.event;
+    var restrictEntryStatus = _a.restrictEntryStatus, _h = _a.adHocRatings, adHocRatings = _h === void 0 ? {} : _h, generateMatchUps = _a.generateMatchUps, tournamentRecord = _a.tournamentRecord, participantIds = _a.participantIds, encounterValue = _a.encounterValue, sameTeamValue = _a.sameTeamValue, drawDefinition = _a.drawDefinition, scaleAccessor = _a.scaleAccessor, maxIterations = _a.maxIterations, structureId = _a.structureId, matchUpIds = _a.matchUpIds, scaleName = _a.scaleName, // custom rating name to seed dynamic ratings
+    eventType = _a.eventType, isMock = _a.isMock, salted = _a.salted, event = _a.event;
     if (typeof drawDefinition !== 'object' ||
         (drawDefinition.drawType && drawDefinition.drawType !== AD_HOC)) {
         return { error: INVALID_DRAW_DEFINITION };
@@ -38441,102 +37827,729 @@ function drawMatic$1(_a) {
     else {
         participantIds = enteredParticipantIds;
     }
-    // if no structureId is specified find the latest AD_HOC stage which has matchUps
-    if (!structureId) {
-        var targetStructure = (_e = (_d = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) === null || _d === void 0 ? void 0 : _d.filter(function (structure) { return structure.stageSequence === 1; })) === null || _e === void 0 ? void 0 : _e.reduce(function (targetStructure, structure) {
-            var orderNumber = structure.stage && stageOrder$1[structure.stage];
-            var structureIsAdHoc = isAdHoc({ drawDefinition: drawDefinition, structure: structure });
-            return structureIsAdHoc &&
-                orderNumber > (stageOrder$1[targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.stage] || 1)
-                ? structure
-                : targetStructure;
-        }, undefined);
-        structureId = targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.structureId;
+    // if no structureId is specified find the latest AD_HOC stage which has matchUps
+    if (!structureId) {
+        var targetStructure = (_e = (_d = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) === null || _d === void 0 ? void 0 : _d.filter(function (structure) { return structure.stageSequence === 1; })) === null || _e === void 0 ? void 0 : _e.reduce(function (targetStructure, structure) {
+            var orderNumber = structure.stage && stageOrder$1[structure.stage];
+            var structureIsAdHoc = isAdHoc({ drawDefinition: drawDefinition, structure: structure });
+            return structureIsAdHoc &&
+                orderNumber > (stageOrder$1[targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.stage] || 1)
+                ? structure
+                : targetStructure;
+        }, undefined);
+        structureId = targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.structureId;
+    }
+    var structure = (_f = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) === null || _f === void 0 ? void 0 : _f.find(function (structure) { return structure.structureId === structureId; });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    // an AD_HOC structure is one that has no child structures and in which no matchUps have roundPosition
+    var structureIsAdHoc = isAdHoc({ drawDefinition: drawDefinition, structure: structure });
+    if (!structureIsAdHoc)
+        return { error: INVALID_DRAW_DEFINITION };
+    var tournamentParticipants = (_g = tournamentRecord.participants) !== null && _g !== void 0 ? _g : [];
+    var _loop_1 = function (participantId) {
+        var participant = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.find(function (participant) { return participant.participantId === participantId; });
+        // first see if there is already a dynamic value
+        var scaleValue = getScaleValue({
+            scaleName: "".concat(scaleName, ".").concat(DYNAMIC),
+            scaleAccessor: scaleAccessor,
+            participant: participant,
+            eventType: eventType,
+        });
+        // if no dynamic value found and a seeding scaleValue is provided...
+        if (!scaleValue && scaleName) {
+            scaleValue = getScaleValue({
+                scaleAccessor: scaleAccessor,
+                participant: participant,
+                scaleName: scaleName,
+                eventType: eventType,
+            });
+        }
+        if (scaleValue && !adHocRatings[participantId])
+            adHocRatings[participantId] = scaleValue;
+    };
+    try {
+        for (var _j = __values(participantIds !== null && participantIds !== void 0 ? participantIds : []), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var participantId = _k.value;
+            _loop_1(participantId);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // TODO: update dynamic ratings based on matchUps present from last played round
+    // use scaleEngine.generateDynamicRatings(); see dynamicCalculations.test.ts
+    return generateDrawMaticRound({
+        tournamentParticipants: tournamentParticipants,
+        generateMatchUps: generateMatchUps,
+        participantIds: participantIds,
+        encounterValue: encounterValue,
+        sameTeamValue: sameTeamValue,
+        drawDefinition: drawDefinition,
+        maxIterations: maxIterations,
+        adHocRatings: adHocRatings,
+        matchUpIds: matchUpIds,
+        structure: structure,
+        eventType: eventType,
+        salted: salted,
+        isMock: isMock,
+        event: event,
+    });
+}
+function getScaleValue(_a) {
+    var _b;
+    var _c = _a.scaleType, scaleType = _c === void 0 ? RATING$2 : _c, scaleAccessor = _a.scaleAccessor, participant = _a.participant, scaleName = _a.scaleName, eventType = _a.eventType;
+    var scaleAttributes = {
+        eventType: eventType !== null && eventType !== void 0 ? eventType : SINGLES_EVENT,
+        scaleType: scaleType,
+        scaleName: scaleName,
+    };
+    var result = participant &&
+        participantScaleItem({
+            scaleAttributes: scaleAttributes,
+            participant: participant,
+        });
+    var scaleValue = (_b = result === null || result === void 0 ? void 0 : result.scaleItem) === null || _b === void 0 ? void 0 : _b.scaleValue;
+    return scaleAccessor && isObject(scaleValue)
+        ? scaleValue[scaleAccessor]
+        : scaleValue;
+}
+
+function addAdHocMatchUps(_a) {
+    var _b;
+    var _c, _d, _e, _f, _g, _h, _j;
+    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, structureId = _a.structureId, matchUps = _a.matchUps;
+    if (typeof drawDefinition !== 'object')
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId && ((_c = drawDefinition.structures) === null || _c === void 0 ? void 0 : _c.length) === 1)
+        structureId = (_e = (_d = drawDefinition.structures) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.structureId;
+    if (typeof structureId !== 'string')
+        return { error: MISSING_STRUCTURE_ID };
+    if (!validMatchUps(matchUps))
+        return { error: INVALID_VALUES, info: mustBeAnArray('matchUps') };
+    var structure = (_f = drawDefinition.structures) === null || _f === void 0 ? void 0 : _f.find(function (structure) { return structure.structureId === structureId; });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    var existingMatchUps = structure === null || structure === void 0 ? void 0 : structure.matchUps;
+    var structureHasRoundPositions = existingMatchUps.find(function (matchUp) { return !!matchUp.roundPosition; });
+    if (structure.structures ||
+        structureHasRoundPositions ||
+        structure.finishingPosition === ROUND_OUTCOME) {
+        return { error: INVALID_STRUCTURE };
+    }
+    var existingMatchUpIds = (_j = (_h = (_g = allTournamentMatchUps({
+        tournamentRecord: tournamentRecord,
+        inContext: false,
+    })) === null || _g === void 0 ? void 0 : _g.matchUps) === null || _h === void 0 ? void 0 : _h.map(getMatchUpId)) !== null && _j !== void 0 ? _j : [];
+    var newMatchUpIds = matchUps.map(getMatchUpId);
+    if (overlap(existingMatchUpIds, newMatchUpIds)) {
+        return {
+            error: EXISTING_MATCHUP_ID,
+            info: 'One or more matchUpIds already present in tournamentRecord',
+        };
+    }
+    (_b = structure.matchUps).push.apply(_b, __spreadArray([], __read(matchUps), false));
+    addMatchUpsNotice({
+        tournamentId: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.tournamentId,
+        drawDefinition: drawDefinition,
+        matchUps: matchUps,
+    });
+    modifyDrawNotice({ drawDefinition: drawDefinition, structureIds: [structureId] });
+    return __assign({}, SUCCESS);
+}
+
+function attachFlightProfile(_a) {
+    var _b;
+    var deleteExisting = _a.deleteExisting, event = _a.event, flightProfile = _a.flightProfile;
+    var stack = 'attachFlightProfile';
+    if (!flightProfile)
+        return decorateResult({ result: { error: MISSING_VALUE }, stack: stack });
+    if (!event)
+        return decorateResult({ result: { error: MISSING_EVENT }, stack: stack });
+    var existingFlightProfile = getFlightProfile({ event: event }).flightProfile;
+    if (existingFlightProfile && !deleteExisting)
+        return decorateResult({ result: { error: EXISTING_PROFILE }, stack: stack });
+    if ((_b = event.drawDefinitions) === null || _b === void 0 ? void 0 : _b.length)
+        return decorateResult({
+            result: { error: EXISTING_DRAW_DEFINITIONS },
+            stack: stack,
+        });
+    var extension = {
+        name: FLIGHT_PROFILE,
+        value: flightProfile,
+    };
+    addEventExtension({ event: event, extension: extension });
+    return __assign({ flightProfile: makeDeepCopy(flightProfile, false, true) }, SUCCESS);
+}
+
+/**
+ *
+ * @param {object} tournamentRecord - passed automatically if tournamentEngine.setState()
+ * @param {string[]} participantIds
+ * @param {string} scaleAttributes - { scaleType, scaleName, eventType }
+ * @returns {boolean} { success: true } or { error }
+ */
+function removeParticipantsScaleItems(_a) {
+    var _b;
+    var tournamentRecord = _a.tournamentRecord, scaleAttributes = _a.scaleAttributes, participantIds = _a.participantIds;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!participantIds)
+        return { error: MISSING_PARTICIPANT_IDS };
+    if (!scaleAttributes)
+        return { error: MISSING_VALUE, info: 'scaleAttributes required' };
+    var scaleType = scaleAttributes.scaleType, eventType = scaleAttributes.eventType, scaleName = scaleAttributes.scaleName;
+    var itemType = [SCALE, scaleType, eventType, scaleName].join('.');
+    (_b = tournamentRecord.participants) === null || _b === void 0 ? void 0 : _b.forEach(function (participant) {
+        if (participantIds.includes(participant.participantId) &&
+            participant.timeItems) {
+            participant.timeItems = participant.timeItems.filter(function (timeItem) {
+                return timeItem && (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) !== itemType;
+            });
+        }
+    });
+    return __assign({}, SUCCESS);
+}
+
+/**
+ *
+ * @param {object} tournamentRecord - passed automatically if tournamentEngine.setState()
+ * @param {string} eventId - resolves to event
+ * @param {string} drawId - OPTIONAL - resolves drawDefinition - scopes participants to clear to drawDefinition.entries or flightProfile.flight.drawEntries
+ * @param {string} scaleAttributes - { scaleType, scaleName, eventType }
+ * @param {string} stage - OPTIONAL - filter event or draw entries by stage
+ * @returns {boolean} { success: true } or { error }
+ */
+function removeScaleValues(_a) {
+    var _b;
+    var tournamentRecord = _a.tournamentRecord, scaleAttributes = _a.scaleAttributes, drawDefinition = _a.drawDefinition, entryStatuses = _a.entryStatuses, drawId = _a.drawId, event = _a.event, stage = _a.stage;
+    if (!event)
+        return { error: MISSING_EVENT };
+    if (entryStatuses && !Array.isArray(entryStatuses))
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: mustBeAnArray('entryStatus'),
+            stack: 'removeScaleValues',
+        });
+    var entries = event.entries;
+    if (drawId) {
+        var flightProfile = getFlightProfile({ event: event }).flightProfile;
+        var flight = (_b = flightProfile === null || flightProfile === void 0 ? void 0 : flightProfile.flights) === null || _b === void 0 ? void 0 : _b.find(function (flight) { return flight.drawId === drawId; });
+        if (flight) {
+            entries = flight.drawEntries;
+        }
+        else {
+            entries = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries;
+        }
+    }
+    var stageEntries = (entries || []).filter(function (entry) {
+        return (!stage || !entry.entryStage || entry.entryStage === stage) &&
+            (!entryStatuses || entryStatuses.includes(entry.entryStatus));
+    });
+    var participantIds = stageEntries.map(getParticipantId);
+    return removeParticipantsScaleItems({
+        tournamentRecord: tournamentRecord,
+        scaleAttributes: scaleAttributes,
+        participantIds: participantIds,
+    });
+}
+
+function applyLineUps(_a) {
+    var e_1, _b, e_2, _c, e_3, _d, e_4, _e;
+    var _f, _g, _h, _j;
+    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, matchUpId = _a.matchUpId, lineUps = _a.lineUps, event = _a.event;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!drawDefinition)
+        return { error: DRAW_DEFINITION_NOT_FOUND };
+    if (typeof matchUpId !== 'string')
+        return { error: INVALID_MATCHUP };
+    if (!Array.isArray(lineUps))
+        return { error: INVALID_VALUES, lineUps: lineUps };
+    var stack = 'applyLineUps';
+    var tournamentParticipants = tournamentRecord.participants || [];
+    var result = findDrawMatchUp({
+        tournamentParticipants: tournamentParticipants,
+        inContext: true,
+        drawDefinition: drawDefinition,
+        matchUpId: matchUpId,
+    });
+    if (result.error)
+        return result;
+    if (!result.matchUp)
+        return { error: MATCHUP_NOT_FOUND };
+    var inContextMatchUp = result.matchUp, structure = result.structure;
+    var drawPositions = inContextMatchUp.drawPositions, matchUpType = inContextMatchUp.matchUpType;
+    if (matchUpType !== TEAM$1)
+        return { error: INVALID_MATCHUP };
+    if (!(drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.length))
+        return { error: MISSING_DRAW_POSITIONS };
+    var tieFormat = (_f = resolveTieFormat({
+        matchUp: inContextMatchUp,
+        drawDefinition: drawDefinition,
+        structure: structure,
+        event: event,
+    })) === null || _f === void 0 ? void 0 : _f.tieFormat;
+    // verify integrity of lineUps...
+    // 1. all participantIds must be valid individualParticipantIds
+    // 2. there should be at most one participantId for a given collectionPosition in singles
+    // 3. there should be at most two participantIds for a given collectionPosition in doubles
+    var sideAssignments = {};
+    try {
+        for (var lineUps_1 = __values(lineUps), lineUps_1_1 = lineUps_1.next(); !lineUps_1_1.done; lineUps_1_1 = lineUps_1.next()) {
+            var lineUp = lineUps_1_1.value;
+            if (!Array.isArray(lineUp))
+                return { error: INVALID_VALUES, lineUp: lineUp };
+            // maintain mapping of collectionId|collectionPosition to the participantIds assigned
+            var collectionParticipantIds = {};
+            var sideNumbers = [];
+            var _loop_1 = function (lineUpAssignment) {
+                var e_5, _m;
+                if (typeof lineUpAssignment !== 'object')
+                    return { value: { error: INVALID_VALUES, lineUpAssignment: lineUpAssignment } };
+                var participantId = lineUpAssignment.participantId, _o = lineUpAssignment.collectionAssignments, collectionAssignments = _o === void 0 ? [] : _o;
+                if (!Array.isArray(collectionAssignments))
+                    return { value: { error: INVALID_VALUES, collectionAssignments: collectionAssignments } };
+                var participant = tournamentParticipants.find(function (participant) { return participant.participantId === participantId; });
+                if (!participant)
+                    return { value: { error: PARTICIPANT_NOT_FOUND } };
+                if (participant.participantType !== INDIVIDUAL)
+                    return { value: { error: INVALID_PARTICIPANT_TYPE } };
+                var sideNumber_1 = (_h = (_g = inContextMatchUp.sides) === null || _g === void 0 ? void 0 : _g.find(function (side) { var _a, _b; return (_b = (_a = side.participant) === null || _a === void 0 ? void 0 : _a.individualParticipantIds) === null || _b === void 0 ? void 0 : _b.includes(participantId); })) === null || _h === void 0 ? void 0 : _h.sideNumber;
+                if (sideNumber_1)
+                    sideNumbers.push(sideNumber_1);
+                var _loop_3 = function (collectionAssignment) {
+                    if (typeof collectionAssignment !== 'object')
+                        return { value: { error: INVALID_VALUES, collectionAssignment: collectionAssignment } };
+                    var collectionId = collectionAssignment.collectionId, collectionPosition = collectionAssignment.collectionPosition;
+                    var collectionDefinition = (_j = tieFormat === null || tieFormat === void 0 ? void 0 : tieFormat.collectionDefinitions) === null || _j === void 0 ? void 0 : _j.find(function (collectionDefinition) {
+                        return collectionDefinition.collectionId === collectionId;
+                    });
+                    // all collectionIds in the lineUp must be present in the tieFormat collectionDefinitions
+                    if (!collectionDefinition)
+                        return { value: { error: INVALID_VALUES, collectionId: collectionId } };
+                    var aggregator = "".concat(collectionId, "-").concat(collectionPosition);
+                    if (!collectionParticipantIds[aggregator]) {
+                        collectionParticipantIds[aggregator] = [];
+                    }
+                    var participantsCount = collectionParticipantIds[aggregator].length;
+                    if ((collectionDefinition.matchUpType === SINGLES && participantsCount) ||
+                        (collectionDefinition.matchUpType === DOUBLES &&
+                            participantsCount > 1)) {
+                        return { value: {
+                                info: 'Excessive collectionPosition assignments',
+                                error: INVALID_VALUES,
+                            } };
+                    }
+                    collectionParticipantIds[aggregator].push(participantId);
+                };
+                try {
+                    for (var collectionAssignments_1 = (e_5 = void 0, __values(collectionAssignments)), collectionAssignments_1_1 = collectionAssignments_1.next(); !collectionAssignments_1_1.done; collectionAssignments_1_1 = collectionAssignments_1.next()) {
+                        var collectionAssignment = collectionAssignments_1_1.value;
+                        var state_2 = _loop_3(collectionAssignment);
+                        if (typeof state_2 === "object")
+                            return state_2;
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (collectionAssignments_1_1 && !collectionAssignments_1_1.done && (_m = collectionAssignments_1.return)) _m.call(collectionAssignments_1);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            };
+            try {
+                for (var lineUp_1 = (e_2 = void 0, __values(lineUp)), lineUp_1_1 = lineUp_1.next(); !lineUp_1_1.done; lineUp_1_1 = lineUp_1.next()) {
+                    var lineUpAssignment = lineUp_1_1.value;
+                    var state_1 = _loop_1(lineUpAssignment);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (lineUp_1_1 && !lineUp_1_1.done && (_c = lineUp_1.return)) _c.call(lineUp_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            // ensure that doubles pair participants exist, otherwise create
+            var collectionParticipantIdPairs = Object.values(collectionParticipantIds);
+            try {
+                for (var collectionParticipantIdPairs_1 = (e_3 = void 0, __values(collectionParticipantIdPairs)), collectionParticipantIdPairs_1_1 = collectionParticipantIdPairs_1.next(); !collectionParticipantIdPairs_1_1.done; collectionParticipantIdPairs_1_1 = collectionParticipantIdPairs_1.next()) {
+                    var participantIds = collectionParticipantIdPairs_1_1.value;
+                    if (participantIds.length === 2) {
+                        var pairedParticipant = getPairedParticipant({
+                            tournamentParticipants: tournamentParticipants,
+                            participantIds: participantIds,
+                        }).participant;
+                        if (!pairedParticipant) {
+                            // create pair participant
+                            var newPairParticipant = {
+                                participantType: PAIR,
+                                participantRole: COMPETITOR,
+                                individualParticipantIds: participantIds,
+                            };
+                            var result_1 = addParticipant({
+                                participant: newPairParticipant,
+                                pairOverride: true,
+                                tournamentRecord: tournamentRecord,
+                            });
+                            if (result_1.error)
+                                return result_1;
+                        }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (collectionParticipantIdPairs_1_1 && !collectionParticipantIdPairs_1_1.done && (_d = collectionParticipantIdPairs_1.return)) _d.call(collectionParticipantIdPairs_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            // determine sideNumber based on instances of participants appearing in team participants assigned to sides
+            // allows for some team members to be "borrowed"
+            var instances = instanceCount(sideNumbers);
+            var sideNumber = ((instances[1] || 0) > (instances[2] || 0) && 1) ||
+                ((instances[2] || 0) > (instances[1] || 0) && 2) ||
+                undefined;
+            // if side not previously assigned, map sideNumber to lineUp
+            var sideAssignmentKeys = Object.keys(sideAssignments).map(function (key) {
+                return parseInt(key);
+            });
+            if (sideNumber && !sideAssignmentKeys.includes(sideNumber)) {
+                sideAssignments[sideNumber] = lineUp;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (lineUps_1_1 && !lineUps_1_1.done && (_b = lineUps_1.return)) _b.call(lineUps_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (!Object.keys(sideAssignments).length)
+        return { error: VALUE_UNCHANGED };
+    result = findDrawMatchUp({ drawDefinition: drawDefinition, matchUpId: matchUpId });
+    if (result.error)
+        return result;
+    if (!result.matchUp)
+        return { error: MATCHUP_NOT_FOUND };
+    var matchUp = result.matchUp;
+    if (!matchUp.sides)
+        matchUp.sides = [];
+    var _loop_2 = function (sideNumber) {
+        var side = matchUp.sides.find(function (side) { return side.sideNumber === sideNumber; });
+        var assignment = sideAssignments[sideNumber];
+        if (!assignment) {
+            return "continue";
+        }
+        else if (!side) {
+            matchUp.sides.push({ lineUp: assignment, sideNumber: sideNumber });
+        }
+        else {
+            side.lineUp = assignment;
+        }
+    };
+    try {
+        for (var _k = __values([1, 2]), _l = _k.next(); !_l.done; _l = _k.next()) {
+            var sideNumber = _l.value;
+            _loop_2(sideNumber);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_e = _k.return)) _e.call(_k);
+        }
+        finally { if (e_4) throw e_4.error; }
     }
-    var structure = (_f = drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) === null || _f === void 0 ? void 0 : _f.find(function (structure) { return structure.structureId === structureId; });
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    // an AD_HOC structure is one that has no child structures and in which no matchUps have roundPosition
-    var structureIsAdHoc = isAdHoc({ drawDefinition: drawDefinition, structure: structure });
-    if (!structureIsAdHoc)
-        return { error: INVALID_DRAW_DEFINITION };
-    tournamentParticipants =
-        (_g = tournamentParticipants !== null && tournamentParticipants !== void 0 ? tournamentParticipants : tournamentRecord.participants) !== null && _g !== void 0 ? _g : [];
-    var _loop_1 = function (participantId) {
-        var participant = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.find(function (participant) { return participant.participantId === participantId; });
-        // first see if there is already a dynamic value
-        var scaleValue = getScaleValue({
-            scaleName: "".concat(scaleName, ".").concat(DYNAMIC),
-            scaleAccessor: scaleAccessor,
-            participant: participant,
-            eventType: eventType,
+    modifyMatchUpNotice({
+        tournamentId: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.tournamentId,
+        context: stack,
+        drawDefinition: drawDefinition,
+        matchUp: matchUp,
+    });
+    return __assign({}, SUCCESS);
+}
+
+function resetTieFormat(params) {
+    var _a, _b, e_1, _c, e_2, _d;
+    var _e, _f, _g;
+    var stack = 'resetTieFormat';
+    var drawDefinition = params.drawDefinition, event = params.event, uuids = params.uuids;
+    var paramCheck = checkRequiredParameters(params, [(_a = {}, _a[TOURNAMENT_RECORD] = true, _a[MATCHUP_ID] = true, _a)], stack);
+    if (paramCheck.error)
+        return paramCheck;
+    var resolutions = resolveFromParameters(params, [(_b = {}, _b[PARAM] = MATCHUP, _b)]);
+    if (resolutions[ERROR])
+        return resolutions;
+    var tournamentId = (_e = params.tournamentRecord) === null || _e === void 0 ? void 0 : _e.tournamentId;
+    var _h = (_f = resolutions === null || resolutions === void 0 ? void 0 : resolutions.matchUp) !== null && _f !== void 0 ? _f : {}, matchUp = _h.matchUp, structure = _h.structure;
+    if (!(matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps))
+        return decorateResult({
+            result: { error: INVALID_MATCHUP },
+            info: 'Must be a TEAM matchUp',
+            stack: stack,
         });
-        // if no dynamic value found and a seeding scaleValue is provided...
-        if (!scaleValue && scaleName) {
-            scaleValue = getScaleValue({
-                scaleAccessor: scaleAccessor,
-                participant: participant,
-                scaleName: scaleName,
-                eventType: eventType,
+    // if there is no tieFormat there is nothing to do
+    if (!matchUp.tieFormat)
+        return __assign({}, SUCCESS);
+    var tieFormat = (_g = resolveTieFormat({
+        structure: structure,
+        drawDefinition: drawDefinition,
+        event: event,
+    })) === null || _g === void 0 ? void 0 : _g.tieFormat;
+    if (!tieFormat)
+        return decorateResult({
+            result: { error: NOT_FOUND },
+            info: 'No inherited tieFormat',
+            stack: stack,
+        });
+    var deletedMatchUpIds = [];
+    var collectionIds = [];
+    var tieMatchUps = [];
+    var newMatchUps = [];
+    var _loop_1 = function (collectionDefinition) {
+        // delete any matchUp.tieMatchUps that are not found in the ancestor tieFormat collectionDefinitions
+        var matchUpCount = collectionDefinition.matchUpCount, collectionId = collectionDefinition.collectionId;
+        collectionIds.push(collectionId);
+        var existingCollectionMatchUps = (matchUp.tieMatchUps || []).filter(function (matchUp) { return matchUp.collectionId === collectionId; });
+        if (existingCollectionMatchUps.length > matchUpCount) {
+            // sort by matchUpStatus to prioritize active or completed matchUpsA
+            existingCollectionMatchUps.sort(function (a, b) {
+                return (a.matchUpStatus === TO_BE_PLAYED ? 1 : 0) -
+                    (b.matchUpStatus === TO_BE_PLAYED ? 1 : 0);
             });
+            tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(existingCollectionMatchUps.slice(0, matchUpCount)), false));
+            deletedMatchUpIds.push.apply(deletedMatchUpIds, __spreadArray([], __read(existingCollectionMatchUps.slice(3).map(getMatchUpId)), false));
+        }
+        else {
+            tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(existingCollectionMatchUps), false));
+            if (existingCollectionMatchUps.length < matchUpCount) {
+                var matchUpsLimit = matchUpCount - existingCollectionMatchUps.length;
+                var matchUps = generateCollectionMatchUps({
+                    collectionDefinition: collectionDefinition,
+                    matchUpsLimit: matchUpsLimit,
+                    uuids: uuids,
+                });
+                newMatchUps.push.apply(newMatchUps, __spreadArray([], __read(matchUps), false));
+            }
         }
-        if (scaleValue && !adHocRatings[participantId])
-            adHocRatings[participantId] = scaleValue;
     };
     try {
-        for (var _j = __values(participantIds !== null && participantIds !== void 0 ? participantIds : []), _k = _j.next(); !_k.done; _k = _j.next()) {
-            var participantId = _k.value;
-            _loop_1(participantId);
+        for (var _j = __values(tieFormat.collectionDefinitions), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var collectionDefinition = _k.value;
+            _loop_1(collectionDefinition);
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
         }
         finally { if (e_1) throw e_1.error; }
     }
-    // TODO: update dynamic ratings based on matchUps present from last played round
-    // use scaleEngine.generateDynamicRatings(); see dynamicCalculations.test.ts
-    return generateDrawMaticRound({
-        tournamentParticipants: tournamentParticipants,
-        generateMatchUps: generateMatchUps,
-        participantIds: participantIds,
-        encounterValue: encounterValue,
-        sameTeamValue: sameTeamValue,
+    try {
+        for (var _l = __values((matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps) || []), _m = _l.next(); !_m.done; _m = _l.next()) {
+            var tieMatchUp = _m.value;
+            if (tieMatchUp.collectionId &&
+                !collectionIds.includes(tieMatchUp.collectionId))
+                deletedMatchUpIds.push(tieMatchUp.matchUpId);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (newMatchUps.length) {
+        tieMatchUps.push.apply(tieMatchUps, __spreadArray([], __read(newMatchUps), false));
+        addMatchUpsNotice({
+            eventId: event === null || event === void 0 ? void 0 : event.eventId,
+            matchUps: newMatchUps,
+            drawDefinition: drawDefinition,
+            tournamentId: tournamentId,
+        });
+    }
+    if (deletedMatchUpIds.length) {
+        deleteMatchUpsNotice({
+            matchUpIds: deletedMatchUpIds,
+            eventId: event === null || event === void 0 ? void 0 : event.eventId,
+            drawDefinition: drawDefinition,
+            tournamentId: tournamentId,
+        });
+    }
+    if (matchUp) {
+        matchUp.tieMatchUps = tieMatchUps;
+        matchUp.tieFormatId = undefined;
+        matchUp.tieFormat = undefined;
+        modifyMatchUpNotice({
+            structureId: structure === null || structure === void 0 ? void 0 : structure.structureId,
+            eventId: event === null || event === void 0 ? void 0 : event.eventId,
+            context: stack,
+            drawDefinition: drawDefinition,
+            tournamentId: tournamentId,
+            matchUp: matchUp,
+        });
+    }
+    return __assign(__assign({}, SUCCESS), { newMatchUps: newMatchUps, deletedMatchUpIds: deletedMatchUpIds });
+}
+
+function resetScorecard(params) {
+    var e_1, _a;
+    var _b, _c;
+    var tournamentRecord = params.tournamentRecord, drawDefinition = params.drawDefinition, matchUpId = params.matchUpId, event = params.event;
+    var stack = 'resetScorecard';
+    // Check for missing parameters ---------------------------------------------
+    if (!drawDefinition)
+        return decorateResult({
+            result: { error: MISSING_DRAW_DEFINITION },
+            stack: stack,
+        });
+    if (!matchUpId)
+        return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack: stack });
+    if (!isString(matchUpId))
+        return decorateResult({
+            result: { error: INVALID_VALUES, matchUpId: matchUpId },
+            stack: stack,
+        });
+    // Get map of all drawMatchUps and inContextDrawMatchUPs ---------------------
+    var matchUpsMap = getMatchUpsMap({ drawDefinition: drawDefinition });
+    var inContextDrawMatchUps = getAllDrawMatchUps({
+        nextMatchUps: true,
+        inContext: true,
         drawDefinition: drawDefinition,
-        maxIterations: maxIterations,
-        adHocRatings: adHocRatings,
-        matchUpIds: matchUpIds,
+        matchUpsMap: matchUpsMap,
+    }).matchUps;
+    // Find target matchUp ------------------------------------------------------
+    var matchUp = matchUpsMap.drawMatchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
+    var inContextMatchUp = inContextDrawMatchUps === null || inContextDrawMatchUps === void 0 ? void 0 : inContextDrawMatchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
+    if (!matchUp || !inContextDrawMatchUps)
+        return { error: MATCHUP_NOT_FOUND };
+    // only accept matchUpType: TEAM
+    if (matchUp.matchUpType !== TEAM_EVENT)
+        return { error: INVALID_MATCHUP };
+    // Get winner/loser position targets ----------------------------------------
+    var targetData = positionTargets({
+        inContextDrawMatchUps: inContextDrawMatchUps,
+        drawDefinition: drawDefinition,
+        matchUpId: matchUpId,
+    });
+    var structureId = inContextMatchUp === null || inContextMatchUp === void 0 ? void 0 : inContextMatchUp.structureId;
+    var structure = findStructure({ drawDefinition: drawDefinition, structureId: structureId }).structure;
+    Object.assign(params, {
+        inContextDrawMatchUps: inContextDrawMatchUps,
+        inContextMatchUp: inContextMatchUp,
+        matchUpsMap: matchUpsMap,
+        targetData: targetData,
         structure: structure,
-        eventType: eventType,
-        salted: salted,
+        matchUp: matchUp,
+    });
+    // with propagating winningSide changes, activeDownstream only applies to eventType: TEAM
+    var activeDownstream = isActiveDownstream(params);
+    if (activeDownstream)
+        return { error: CANNOT_CHANGE_WINNING_SIDE };
+    if ((_b = matchUp.tieMatchUps) === null || _b === void 0 ? void 0 : _b.length) {
+        try {
+            for (var _d = __values(matchUp.tieMatchUps), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var tieMatchUp = _e.value;
+                var result_1 = setMatchUpState({
+                    matchUpId: tieMatchUp.matchUpId,
+                    matchUpTieId: matchUpId,
+                    winningSide: undefined,
+                    removeScore: true,
+                    tournamentRecord: tournamentRecord,
+                    drawDefinition: drawDefinition,
+                    event: event,
+                });
+                if (result_1.error)
+                    return decorateResult({ result: result_1, stack: stack });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    var result = updateTieMatchUpScore({
+        event: params.event,
+        removeScore: true,
+        tournamentRecord: tournamentRecord,
+        drawDefinition: drawDefinition,
+        matchUpsMap: matchUpsMap,
+        matchUpId: matchUpId,
     });
+    if (result.error)
+        return decorateResult({ result: result, stack: stack });
+    if (params.tiebreakReset && !result.tieFormatRemoved) {
+        // check for scenarios where an added "Tiebreaker" collectionDefinition/matchUp has been added
+        var inheritedTieFormat = (_c = resolveTieFormat({
+            drawDefinition: drawDefinition,
+            structure: structure,
+            event: event,
+        })) === null || _c === void 0 ? void 0 : _c.tieFormat;
+        if (matchUp.tieFormat && inheritedTieFormat) {
+            var _f = compareTieFormats({
+                descendant: matchUp.tieFormat,
+                ancestor: inheritedTieFormat,
+            }), matchUpCountDifference = _f.matchUpCountDifference, descendantDifferences = _f.descendantDifferences, ancestorDifferences = _f.ancestorDifferences, valueDifference = _f.valueDifference;
+            if (descendantDifferences.collectionIds.length === 1 &&
+                !ancestorDifferences.collectionIds.length &&
+                !ancestorDifferences.groupsCount &&
+                matchUpCountDifference === 1 &&
+                valueDifference === 1) {
+                var result_2 = resetTieFormat({
+                    tournamentRecord: tournamentRecord,
+                    drawDefinition: drawDefinition,
+                    matchUpId: matchUpId,
+                    event: event,
+                });
+                if (result_2.error)
+                    return result_2;
+            }
+        }
+    }
+    return __assign({}, SUCCESS);
 }
-function getScaleValue(_a) {
-    var _b;
-    var _c = _a.scaleType, scaleType = _c === void 0 ? RATING$2 : _c, scaleAccessor = _a.scaleAccessor, participant = _a.participant, scaleName = _a.scaleName, eventType = _a.eventType;
+
+function removeSeeding(_a) {
+    var _b, _c;
+    var tournamentRecord = _a.tournamentRecord, drawDefinition = _a.drawDefinition, entryStatuses = _a.entryStatuses, scaleName = _a.scaleName, drawId = _a.drawId, event = _a.event, stage = _a.stage;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!event)
+        return { error: MISSING_EVENT };
+    scaleName =
+        scaleName ||
+            ((_b = event.category) === null || _b === void 0 ? void 0 : _b.categoryName) ||
+            ((_c = event.category) === null || _c === void 0 ? void 0 : _c.ageCategoryCode);
     var scaleAttributes = {
-        eventType: eventType !== null && eventType !== void 0 ? eventType : SINGLES_EVENT,
-        scaleType: scaleType,
+        eventType: event.eventType,
+        scaleType: SEEDING$1,
         scaleName: scaleName,
     };
-    var result = participant &&
-        participantScaleItem({
-            scaleAttributes: scaleAttributes,
-            participant: participant,
-        });
-    var scaleValue = (_b = result === null || result === void 0 ? void 0 : result.scaleItem) === null || _b === void 0 ? void 0 : _b.scaleValue;
-    return scaleAccessor && isObject(scaleValue)
-        ? scaleValue[scaleAccessor]
-        : scaleValue;
-}
-
-function drawMatic(params) {
-    var _a;
-    var tournamentParticipants = (_a = params.tournamentRecord) === null || _a === void 0 ? void 0 : _a.participants;
-    Object.assign(params, { tournamentParticipants: tournamentParticipants });
-    return drawMatic$1(params);
+    return removeScaleValues({
+        tournamentRecord: tournamentRecord,
+        scaleAttributes: scaleAttributes,
+        drawDefinition: drawDefinition,
+        entryStatuses: entryStatuses,
+        drawId: drawId,
+        event: event,
+        stage: stage,
+    });
 }
 
 function setSubOrder(_a) {
@@ -42596,7 +42609,7 @@ function generateDrawDefinition(params) {
                 var _a, _b, _c;
                 if (params.automated) {
                     var _d = (_a = params.drawMatic) !== null && _a !== void 0 ? _a : {}, restrictEntryStatus = _d.restrictEntryStatus, generateMatchUps = _d.generateMatchUps, structureId_1 = _d.structureId, matchUpIds = _d.matchUpIds, scaleName = _d.scaleName;
-                    var matchUps = drawMatic$1({
+                    var matchUps = drawMatic({
                         eventType: (_c = (_b = params.drawMatic) === null || _b === void 0 ? void 0 : _b.eventType) !== null && _c !== void 0 ? _c : matchUpType,
                         generateMatchUps: generateMatchUps !== null && generateMatchUps !== void 0 ? generateMatchUps : true,
                         restrictEntryStatus: restrictEntryStatus,
@@ -42605,7 +42618,8 @@ function generateDrawDefinition(params) {
                         drawDefinition: drawDefinition,
                         structureId: structureId_1,
                         matchUpIds: matchUpIds,
-                        scaleName: scaleName,
+                        scaleName: scaleName, // custom rating name to seed dynamic ratings
+                        event: event,
                     }).matchUps;
                     addAdHocMatchUps({
                         tournamentRecord: tournamentRecord,
@@ -42619,6 +42633,7 @@ function generateDrawDefinition(params) {
                         newRound: true,
                         drawDefinition: drawDefinition,
                         matchUpsCount: matchUpsCount_1,
+                        event: event,
                     }).matchUps;
                     addAdHocMatchUps({
                         tournamentRecord: tournamentRecord,
@@ -45203,7 +45218,7 @@ function checkRequestConflicts(_a) {
 
 function findMatchUpFormatTiming(_a) {
     var _b = _a.defaultRecoveryMinutes, defaultRecoveryMinutes = _b === void 0 ? 0 : _b, defaultAverageMinutes = _a.defaultAverageMinutes, tournamentRecords = _a.tournamentRecords, matchUpFormat = _a.matchUpFormat, categoryName = _a.categoryName, categoryType = _a.categoryType, tournamentId = _a.tournamentId, eventType = _a.eventType, eventId = _a.eventId;
-    if (!isValidMatchUpFormat(matchUpFormat))
+    if (!isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
     var tournamentIds = Object.keys(tournamentRecords).filter(function (currentTournamentId) {
         return !tournamentId || currentTournamentId === tournamentId;
@@ -49074,7 +49089,7 @@ function generateOutcome(params) {
     var _d = params.matchUpStatusProfile, matchUpStatusProfile = _d === void 0 ? defaultStatusProfile : _d, // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
     _e = params.matchUpFormat, // { matchUpStatusProfile: {} } will always return only { matchUpStatus: COMPLETED }
     matchUpFormat = _e === void 0 ? FORMAT_STANDARD : _e, _f = params.pointsPerMinute, pointsPerMinute = _f === void 0 ? 1 : _f, _g = params.sideWeight, sideWeight = _g === void 0 ? 4 : _g;
-    if (!isValidMatchUpFormat(matchUpFormat))
+    if (!isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return { error: INVALID_MATCHUP_FORMAT };
     if (typeof matchUpStatusProfile !== 'object')
         return { error: INVALID_VALUES };
@@ -52549,7 +52564,6 @@ var publishingGovernor = {
     getDrawData: getDrawData,
     getEventData: getEventData,
     getPublishState: getPublishState,
-    getTournamentInfo: getTournamentInfo,
     getVenueData: getVenueData,
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
@@ -53094,7 +53108,9 @@ function getEventMatchUpFormatTiming(_a) {
                 : definition;
             if (uniqueMatchUpFormats_1.includes(definitionObject === null || definitionObject === void 0 ? void 0 : definitionObject.matchUpFormat))
                 return;
-            if (!isValidMatchUpFormat(definitionObject === null || definitionObject === void 0 ? void 0 : definitionObject.matchUpFormat))
+            if (!isValidMatchUpFormat({
+                matchUpFormat: definitionObject === null || definitionObject === void 0 ? void 0 : definitionObject.matchUpFormat,
+            }))
                 return;
             uniqueMatchUpFormats_1.push(definitionObject.matchUpFormat);
             return definitionObject;
@@ -53125,8 +53141,8 @@ function getModifiedMatchUpFormatTiming(params) {
     var paramCheck = checkRequiredParameters(params, [
         (_a = {}, _a[TOURNAMENT_RECORD] = true, _a),
         (_b = {},
+            _b[VALIDATE] = function (matchUpFormat) { return isValidMatchUpFormat({ matchUpFormat: matchUpFormat }); },
             _b[INVALID] = UNRECOGNIZED_MATCHUP_FORMAT,
-            _b[VALIDATE] = isValidMatchUpFormat,
             _b[MATCHUP_FORMAT] = true,
             _b),
     ]);
@@ -54126,6 +54142,53 @@ function getParticipantMembership(_a) {
     }, {});
 }
 
+/**
+ *
+ * @param {object[]} outcomes - array of outcomes to be applied to matchUps, relevent attributes: { eventId: string; drawId: string; }
+ *
+ */
+function bulkUpdatePublishedEventIds(_a) {
+    var _b;
+    var tournamentRecord = _a.tournamentRecord, outcomes = _a.outcomes;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!(outcomes === null || outcomes === void 0 ? void 0 : outcomes.length))
+        return { error: MISSING_VALUE, info: 'Missing outcomes' };
+    var eventIdsMap = outcomes.reduce(function (eventIdsMap, outcome) {
+        var drawId = outcome.drawId, eventId = outcome.eventId;
+        if (eventId && drawId) {
+            if (!eventIdsMap[eventId]) {
+                eventIdsMap[eventId] = [drawId];
+            }
+            else if (!eventIdsMap[eventId].includes(drawId)) {
+                eventIdsMap[eventId].push(drawId);
+            }
+        }
+        return eventIdsMap;
+    }, {});
+    var relevantEventsIds = Object.keys(eventIdsMap);
+    var relevantEvents = (_b = tournamentRecord.events) === null || _b === void 0 ? void 0 : _b.filter(function (event) {
+        return relevantEventsIds.includes(event.eventId);
+    });
+    var publishedEventIds = relevantEvents
+        .filter(function (event) {
+        var pubStatus = getEventPublishStatus({ event: event });
+        var _a = pubStatus !== null && pubStatus !== void 0 ? pubStatus : {}, drawDetails = _a.drawDetails, drawIds = _a.drawIds;
+        var eventId = event.eventId;
+        var publishedDrawIds = eventIdsMap[eventId].filter(function (drawId) {
+            var keyedDrawIds = drawDetails
+                ? Object.keys(pubStatus.drawDetails).filter(function (drawId) {
+                    return getDrawPublishStatus({ drawId: drawId, drawDetails: drawDetails });
+                })
+                : [];
+            return (drawIds === null || drawIds === void 0 ? void 0 : drawIds.includes(drawId)) || keyedDrawIds.includes(drawId);
+        });
+        return publishedDrawIds.length;
+    })
+        .map(function (event) { return event.eventId; });
+    return { publishedEventIds: publishedEventIds, eventIdPublishedDrawIdsMap: eventIdsMap };
+}
+
 function getSourceStructureIdsAndRelevantLinks(_a) {
     var targetRoundNumber = _a.targetRoundNumber, finishingPosition = _a.finishingPosition, drawDefinition = _a.drawDefinition, structureId = _a.structureId, // structure for which source and target links are to be found
     linkType = _a.linkType;
@@ -56371,6 +56434,15 @@ function getParticipantSignInStatus(_a) {
     return timeItem && timeItem.itemValue === SIGNED_IN && SIGNED_IN;
 }
 
+function getMatchUpContextIds(_a) {
+    var matchUps = _a.matchUps, matchUpId = _a.matchUpId;
+    if (!validMatchUps(matchUps))
+        return { error: INVALID_VALUES };
+    var matchUp = matchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
+    var _b = matchUp || {}, drawId = _b.drawId, eventId = _b.eventId, structureId = _b.structureId, tournamentId = _b.tournamentId;
+    return { matchUpId: matchUpId, drawId: drawId, eventId: eventId, structureId: structureId, tournamentId: tournamentId };
+}
+
 function getMaxEntryPosition(params) {
     var _a = params.entries, entries = _a === void 0 ? [] : _a, entryStatus = params.entryStatus, stage = params.stage;
     return Math.max.apply(Math, __spreadArray(__spreadArray([], __read(entries
@@ -56463,53 +56535,6 @@ function getMatchUpFormat(params) {
     };
 }
 
-/**
- *
- * @param {object[]} outcomes - array of outcomes to be applied to matchUps, relevent attributes: { eventId: string; drawId: string; }
- *
- */
-function bulkUpdatePublishedEventIds(_a) {
-    var _b;
-    var tournamentRecord = _a.tournamentRecord, outcomes = _a.outcomes;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!(outcomes === null || outcomes === void 0 ? void 0 : outcomes.length))
-        return { error: MISSING_VALUE, info: 'Missing outcomes' };
-    var eventIdsMap = outcomes.reduce(function (eventIdsMap, outcome) {
-        var drawId = outcome.drawId, eventId = outcome.eventId;
-        if (eventId && drawId) {
-            if (!eventIdsMap[eventId]) {
-                eventIdsMap[eventId] = [drawId];
-            }
-            else if (!eventIdsMap[eventId].includes(drawId)) {
-                eventIdsMap[eventId].push(drawId);
-            }
-        }
-        return eventIdsMap;
-    }, {});
-    var relevantEventsIds = Object.keys(eventIdsMap);
-    var relevantEvents = (_b = tournamentRecord.events) === null || _b === void 0 ? void 0 : _b.filter(function (event) {
-        return relevantEventsIds.includes(event.eventId);
-    });
-    var publishedEventIds = relevantEvents
-        .filter(function (event) {
-        var pubStatus = getEventPublishStatus({ event: event });
-        var _a = pubStatus !== null && pubStatus !== void 0 ? pubStatus : {}, drawDetails = _a.drawDetails, drawIds = _a.drawIds;
-        var eventId = event.eventId;
-        var publishedDrawIds = eventIdsMap[eventId].filter(function (drawId) {
-            var keyedDrawIds = drawDetails
-                ? Object.keys(pubStatus.drawDetails).filter(function (drawId) {
-                    return getDrawPublishStatus({ drawId: drawId, drawDetails: drawDetails });
-                })
-                : [];
-            return (drawIds === null || drawIds === void 0 ? void 0 : drawIds.includes(drawId)) || keyedDrawIds.includes(drawId);
-        });
-        return publishedDrawIds.length;
-    })
-        .map(function (event) { return event.eventId; });
-    return { publishedEventIds: publishedEventIds, eventIdPublishedDrawIdsMap: eventIdsMap };
-}
-
 function publicFindParticipant(params) {
     var _a, e_1, _b;
     var tournamentRecord = params.tournamentRecord, policyDefinitions = params.policyDefinitions, contextProfile = params.contextProfile, participantId = params.participantId, personId = params.personId;
@@ -57656,6 +57681,7 @@ var queryGovernor = {
     getTeamLineUp: getTeamLineUp,
     getTieFormat: getTieFormat,
     getTournamentIds: getTournamentIds,
+    getTournamentInfo: getTournamentInfo,
     getTournamentPenalties: getTournamentPenalties,
     getTournamentPersons: getTournamentPersons,
     getTournamentStructures: getTournamentStructures,
@@ -57674,6 +57700,20 @@ var queryGovernor = {
     validateLineUp: validateLineUp,
     validMatchUp: validMatchUp,
     validMatchUps: validMatchUps,
+    allPlayoffPositionsFilled: allPlayoffPositionsFilled,
+    getCategoryAgeDetails: getCategoryAgeDetails,
+    calculateWinCriteria: calculateWinCriteria,
+    compareTieFormats: compareTieFormats,
+    getMatchUpContextIds: getMatchUpContextIds,
+    getScaleValues: getScaleValues,
+    getSeedingThresholds: getSeedingThresholds,
+    getTimeItem: getTimeItem,
+    getValidGroupSizes: getValidGroupSizes,
+    isAdHoc: isAdHoc,
+    isCompletedStructure: isCompletedStructure,
+    roundRobinGroups: roundRobinGroups,
+    tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
+    validateCategory: validateCategory,
 };
 
 function getDetailsWTN(_a) {
@@ -59044,7 +59084,7 @@ function modifyEventMatchUpFormatTiming(params) {
     var tournamentRecord = params.tournamentRecord, recoveryMinutes = params.recoveryMinutes, averageMinutes = params.averageMinutes, matchUpFormat = params.matchUpFormat, categoryType = params.categoryType, eventId = params.eventId, event = params.event;
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
-    if (!isValidMatchUpFormat(matchUpFormat))
+    if (!isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return { error: INVALID_VALUES };
     if (!event)
         return { error: MISSING_EVENT };
@@ -63585,7 +63625,7 @@ function calculateHistoryScore(params) {
     var matchUpFormat = matchUp.matchUpFormat;
     if (!matchUpFormat)
         return { error: MISSING_MATCHUP_FORMAT };
-    if (!isValidMatchUpFormat(matchUpFormat))
+    if (!isValidMatchUpFormat({ matchUpFormat: matchUpFormat }))
         return { error: INVALID_MATCHUP_FORMAT };
     var parsedFormat = parse(matchUpFormat);
     var bestOf = parsedFormat.bestOf, finalSetFormat = parsedFormat.finalSetFormat, setFormat = parsedFormat.setFormat;
@@ -64309,15 +64349,6 @@ function visualizeScheduledMatchUps(_a) {
         printGlobalLog();
 }
 
-function getMatchUpContextIds(_a) {
-    var matchUps = _a.matchUps, matchUpId = _a.matchUpId;
-    if (!validMatchUps(matchUps))
-        return { error: INVALID_VALUES };
-    var matchUp = matchUps.find(function (matchUp) { return matchUp.matchUpId === matchUpId; });
-    var _b = matchUp || {}, drawId = _b.drawId, eventId = _b.eventId, structureId = _b.structureId, tournamentId = _b.tournamentId;
-    return { matchUpId: matchUpId, drawId: drawId, eventId: eventId, structureId: structureId, tournamentId: tournamentId };
-}
-
 function dehydrateMatchUps(_a) {
     var tournamentRecord = _a.tournamentRecord;
     if (!tournamentRecord)
@@ -64640,38 +64671,29 @@ function flattenJSON(obj, keyJoiner, path) {
 }
 
 var utilitiesGovernor = {
+    visualizeScheduledMatchUps: visualizeScheduledMatchUps,
+    dehydrateMatchUps: dehydrateMatchUps,
+    structureSort: structureSort,
     allNumeric: allNumeric$1,
-    allPlayoffPositionsFilled: allPlayoffPositionsFilled,
     attributeFilter: attributeFilter,
-    calculateWinCriteria: calculateWinCriteria,
     chunkArray: chunkArray,
     chunkByNth: chunkByNth,
     chunkSizeProfile: chunkSizeProfile,
-    compareTieFormats: compareTieFormats,
     constantToString: constantToString,
     countValues: countValues,
     createMap: createMap,
     dateRange: dateRange,
     dateTime: dateTime,
     definedAttributes: definedAttributes,
-    dehydrateMatchUps: dehydrateMatchUps,
     extractAttributes: extractAttributes,
     flattenJSON: flattenJSON,
     generateHashCode: generateHashCode,
     generateRange: generateRange,
     generateTimeCode: generateTimeCode,
-    getCategoryAgeDetails: getCategoryAgeDetails,
-    getMatchUpContextIds: getMatchUpContextIds,
-    getScaleValues: getScaleValues,
-    getSeedingThresholds: getSeedingThresholds,
-    getTimeItem: getTimeItem,
-    getValidGroupSizes: getValidGroupSizes,
     groupValues: groupValues,
     hasAttributeValues: hasAttributeValues,
     instanceCount: instanceCount,
     intersection: intersection,
-    isAdHoc: isAdHoc,
-    isCompletedStructure: isCompletedStructure,
     isConvertableInteger: isConvertableInteger,
     isNumeric: isNumeric,
     isOdd: isOdd,
@@ -64688,17 +64710,12 @@ var utilitiesGovernor = {
     overlap: overlap,
     randomMember: randomMember,
     randomPop: randomPop,
-    roundRobinGroups: roundRobinGroups,
     shuffleArray: shuffleArray,
-    structureSort: structureSort,
     subSort: subSort,
-    tieFormatGenderValidityCheck: tieFormatGenderValidityCheck,
     undefinedToNull: undefinedToNull,
     unique: unique,
     UUID: UUID,
     UUIDS: UUIDS,
-    validateCategory: validateCategory,
-    visualizeScheduledMatchUps: visualizeScheduledMatchUps,
 };
 var utilities = utilitiesGovernor;
 
@@ -66043,7 +66060,7 @@ function asyncExecutionQueue(engine, directives, rollbackOnError) {
         var e_1, _a;
         return __generator(this, function (_b) {
             if (!Array.isArray(directives))
-                return [2 /*return*/, { error: INVALID_VALUES }];
+                return [2 /*return*/, { error: INVALID_VALUES, message: 'directives must be an array' }];
             methods = getMethods();
             start = Date.now();
             snapshot = rollbackOnError && makeDeepCopy(getTournamentRecords(), false, true);
@@ -66052,7 +66069,7 @@ function asyncExecutionQueue(engine, directives, rollbackOnError) {
                 for (directives_1 = __values(directives), directives_1_1 = directives_1.next(); !directives_1_1.done; directives_1_1 = directives_1.next()) {
                     directive = directives_1_1.value;
                     if (typeof directive !== 'object')
-                        return [2 /*return*/, { error: INVALID_VALUES }];
+                        return [2 /*return*/, { error: INVALID_VALUES, message: 'directive must be an object' }];
                     methodName = directive.method, params = directive.params;
                     if (!methods[methodName])
                         return [2 /*return*/, logMethodNotFound({ methodName: methodName, start: start, params: params })];
@@ -66090,15 +66107,18 @@ function asyncEngineInvoke(engine, args) {
             switch (_d.label) {
                 case 0:
                     if (!isObject(args))
-                        return [2 /*return*/, { error: INVALID_VALUES }];
+                        return [2 /*return*/, { error: INVALID_VALUES, message: 'args must be an object' }];
                     methodsCount = Object.values(args).filter(isFunction).length;
                     if (methodsCount > 1)
-                        return [2 /*return*/, { error: INVALID_VALUES }];
+                        return [2 /*return*/, {
+                                message: 'there must be only one arg with typeof function',
+                                error: INVALID_VALUES,
+                            }];
                     methodName = methodsCount
                         ? Object.keys(args).find(function (key) { return isFunction(args[key]); })
                         : isString(args.method) && args.method;
                     if (!methodName)
-                        return [2 /*return*/, { error: INVALID_VALUES }];
+                        return [2 /*return*/, { error: METHOD_NOT_FOUND }];
                     _b = args, _c = methodName, passedMethod = _b[_c], remainingArgs = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
                     params = (args === null || args === void 0 ? void 0 : args.params) || __assign({}, remainingArgs);
                     snapshot = params.rollbackOnError && makeDeepCopy(getTournamentRecords(), false, true);
@@ -66253,15 +66273,18 @@ function asyncEngine(test) {
 
 function askInvoke(engine, args) {
     if (!isObject(args))
-        return { error: INVALID_VALUES };
+        return { error: INVALID_VALUES, message: 'args must be an object' };
     var methodsCount = Object.values(args).filter(isFunction).length;
     if (methodsCount > 1)
-        return { error: INVALID_VALUES };
+        return {
+            message: 'there must be only one arg with typeof function',
+            error: INVALID_VALUES,
+        };
     var methodName = methodsCount
         ? Object.keys(args).find(function (key) { return isFunction(args[key]); })
         : isString(args.method) && args.method;
     if (!methodName)
-        return { error: INVALID_VALUES };
+        return { error: METHOD_NOT_FOUND };
     var _a = args, _b = methodName, passedMethod = _a[_b], remainingArgs = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
     var params = (args === null || args === void 0 ? void 0 : args.params) || __assign({}, remainingArgs);
     var method = passedMethod || engine[methodName] || getMethods$1()[methodName];
@@ -66281,7 +66304,7 @@ var askEngine = (function () {
 function executionQueue(engine, directives, rollbackOnError) {
     var e_1, _a;
     if (!Array.isArray(directives))
-        return { error: INVALID_VALUES };
+        return { error: INVALID_VALUES, message: 'directives must be an array' };
     var methods = getMethods();
     var start = Date.now();
     var snapshot = rollbackOnError && makeDeepCopy(getTournamentRecords(), false, true);
@@ -66290,7 +66313,7 @@ function executionQueue(engine, directives, rollbackOnError) {
         for (var directives_1 = __values(directives), directives_1_1 = directives_1.next(); !directives_1_1.done; directives_1_1 = directives_1.next()) {
             var directive = directives_1_1.value;
             if (typeof directive !== 'object')
-                return { error: INVALID_VALUES };
+                return { error: INVALID_VALUES, message: 'directive must be an object' };
             var methodName = directive.method, params = directive.params;
             if (!methods[methodName])
                 return logMethodNotFound({ methodName: methodName, start: start, params: params });
@@ -66321,15 +66344,18 @@ function executionQueue(engine, directives, rollbackOnError) {
 function engineInvoke(engine, args) {
     var _a;
     if (!isObject(args))
-        return { error: INVALID_VALUES };
+        return { error: INVALID_VALUES, message: 'args must be an object' };
     var methodsCount = Object.values(args).filter(isFunction).length;
     if (methodsCount > 1)
-        return { error: INVALID_VALUES };
+        return {
+            message: 'there must be only one arg with typeof function',
+            error: INVALID_VALUES,
+        };
     var methodName = methodsCount
         ? Object.keys(args).find(function (key) { return isFunction(args[key]); })
         : isString(args.method) && args.method;
     if (!methodName)
-        return { error: INVALID_VALUES };
+        return { error: METHOD_NOT_FOUND };
     var _b = args, _c = methodName, passedMethod = _b[_c], remainingArgs = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
     var params = (args === null || args === void 0 ? void 0 : args.params) || __assign({}, remainingArgs);
     var snapshot = params.rollbackOnError && makeDeepCopy(getTournamentRecords(), false, true);
@@ -67686,7 +67712,6 @@ exports.positionActionConstants = positionActionConstants;
 exports.resultConstants = resultConstants;
 exports.scaleConstants = scaleConstants;
 exports.scaleEngine = scaleEngine;
-exports.scoreGovernor = scoreGovernor;
 exports.surfaceConstants = surfaceConstants;
 exports.syncEngine = engine;
 exports.timeItemConstants = timeItemConstants;