tods-competition-factory 0.63.2 → 0.65.0

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

@@ -16322,7 +16322,7 @@ function updateTieMatchUpScore({
   });
   if (result.error) return result;
   const matchUp = result.matchUp;
-  const tieFormat = matchUp.tieFormat || (structure === null || structure === void 0 ? void 0 : structure.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
+  const tieFormat = matchUp.tieFormat || (structure === null || structure === void 0 ? void 0 : structure.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat) || undefined;
   const {
     winningSide,
     set,
@@ -18057,9 +18057,9 @@ function getAvailableAdHocParticipantIds({
     drawPosition,
     participantId
   }) => roundDrawPositions.includes(drawPosition) && participantId).map(getParticipantId);
-  const enteredParticipantIds = drawDefinition.entries.filter(({
+  const enteredParticipantIds = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries.filter(({
     entryStatus
-  }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId); // AdHoc available participants are those entered in the draw who are not assigned to the target round
+  }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId)) || []; // AdHoc available participants are those entered in the draw who are not assigned to the target round
 
   const availableParticipantIds = enteredParticipantIds.filter(participantId => !roundAssignedParticipantIds.includes(participantId));
   return availableParticipantIds;
@@ -19900,7 +19900,7 @@ function setMatchUpStatus$2(params) {
       matchUpsMap,
       event
     });
-    const tieFormat = dualMatchUp.tieFormat || drawDefinition.tieFormat;
+    const tieFormat = (dualMatchUp === null || dualMatchUp === void 0 ? void 0 : dualMatchUp.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat) || undefined;
     const {
       projectedWinningSide
     } = getProjectedDualWinningSide({
@@ -27550,9 +27550,6 @@ function bulkRescheduleMatchUps({
   matchUpIds,
   dryRun
 }) {
-  if (!tournamentRecords) return {
-    error: MISSING_TOURNAMENT_RECORDS
-  };
   if (!matchUpIds || !Array.isArray(matchUpIds)) return {
     error: MISSING_MATCHUP_IDS
   };
@@ -28043,7 +28040,7 @@ const scheduleGovernor$1 = {
 };
 
 function factoryVersion() {
-  return '0.63.2';
+  return '0.65.0';
 }
 
 function attachPolicies$2({
@@ -32760,7 +32757,7 @@ function addPlayoffStructures$1(params) {
   }) => addedMatchUpIds.includes(matchUpId));
 
   if (addedMatchUps.length) {
-    const tieFormat = drawDefinition.tieFormat || (event === null || event === void 0 ? void 0 : event.tieFormat);
+    const tieFormat = drawDefinition.tieFormat || (event === null || event === void 0 ? void 0 : event.tieFormat) || undefined;
 
     if (tieFormat) {
       addedMatchUps.forEach(matchUp => {
@@ -33882,17 +33879,17 @@ function generateDrawType(params = {}) {
     tieFormat,
     matchUpType
   } = params;
-  tieFormat = tieFormat || drawDefinition.tieFormat;
+  tieFormat = tieFormat || drawDefinition.tieFormat || undefined;
   matchUpType = matchUpType || drawDefinition.matchUpType || SINGLES$1;
   const drawSize = getStageDrawPositionsCount({
     stage,
     drawDefinition
   });
-  Object.assign(params, {
+  Object.assign(params, definedAttributes({
     drawSize,
     matchUpType,
     tieFormat
-  });
+  }));
   const validDoubleEliminationSize = isPowerOf2(drawSize * 2 / 3); // check that drawSize is a valid value
 
   const invalidDrawSize = drawSize < 2 || !staggeredEntry && ![FEED_IN$1, AD_HOC].includes(drawType) && (drawType === ROUND_ROBIN && drawSize < 3 || drawType === DOUBLE_ELIMINATION && !validDoubleEliminationSize || ![ROUND_ROBIN, DOUBLE_ELIMINATION, ROUND_ROBIN_WITH_PLAYOFF].includes(drawType) && !isPowerOf2(drawSize));
@@ -34636,7 +34633,7 @@ function getAssignedParticipantIds({
 function refreshEntryPositions({
   entries = []
 } = {}) {
-  const stagedEntries = entries.reduce((stages, entry) => {
+  const stagedEntries = entries.filter(Boolean).reduce((stages, entry) => {
     const {
       entryStage,
       entryStatus
@@ -34848,6 +34845,8 @@ function modifyEntriesStatus({
         return true;
       });
       (_event$drawDefinition4 = event.drawDefinitions) === null || _event$drawDefinition4 === void 0 ? void 0 : _event$drawDefinition4.every(drawDefinition => {
+        var _drawDefinition$entri2;
+
         const result = updateEntryStatus(drawDefinition.entries);
 
         if (result.error) {
@@ -34855,7 +34854,7 @@ function modifyEntriesStatus({
           return false;
         }
 
-        drawDefinition.entries = drawDefinition.entries.filter(({
+        drawDefinition.entries = (_drawDefinition$entri2 = drawDefinition.entries) === null || _drawDefinition$entri2 === void 0 ? void 0 : _drawDefinition$entri2.filter(({
           participantId
         }) => !participantIds.includes(participantId));
         return true;
@@ -35192,8 +35191,8 @@ function participantInEntries({
 function addDrawEntry({
   entryStatus = DIRECT_ACCEPTANCE,
   entryStage = MAIN,
-  entryPosition,
   drawDefinition,
+  entryPosition,
   participantId,
   participant
 }) {
@@ -35225,7 +35224,7 @@ function addDrawEntry({
     };
   }
 
-  participantId = participantId || participant && participant.participantId;
+  participantId = participantId || (participant === null || participant === void 0 ? void 0 : participant.participantId);
   if (!participantId) return {
     error: MISSING_PARTICIPANT_ID
   };
@@ -35347,7 +35346,7 @@ function addDrawEntries$1({
     };
   }
 
-  participantIds.forEach(participantId => {
+  participantIds.filter(Boolean).forEach(participantId => {
     const entry = Object.assign({
       participantId
     }, {
@@ -42665,7 +42664,7 @@ function getTieMatchUpContext({
     drawDefinition,
     matchUpsMap
   });
-  const tieFormat = dualMatchUp.tieFormat || structure.tieFormat || drawDefinition.tieFormat || event.tieFormat;
+  const tieFormat = dualMatchUp.tieFormat || structure.tieFormat || drawDefinition.tieFormat || event.tieFormat || undefined;
   return {
     relevantAssignments,
     collectionPosition,
@@ -45705,7 +45704,7 @@ function getTieFormat({
   const structureDefaultTieFormat = (_structure = structure) === null || _structure === void 0 ? void 0 : _structure.tieFormat;
   const drawDefaultTieFormat = (_drawDefinition = drawDefinition) === null || _drawDefinition === void 0 ? void 0 : _drawDefinition.tieFormat;
   const eventDefaultTieFormat = event === null || event === void 0 ? void 0 : event.tieFormat;
-  const tieFormat = (matchUpResult === null || matchUpResult === void 0 ? void 0 : (_matchUpResult$matchU = matchUpResult.matchUp) === null || _matchUpResult$matchU === void 0 ? void 0 : _matchUpResult$matchU.tieFormat) || structureDefaultTieFormat || drawDefaultTieFormat || eventDefaultTieFormat;
+  const tieFormat = (matchUpResult === null || matchUpResult === void 0 ? void 0 : (_matchUpResult$matchU = matchUpResult.matchUp) === null || _matchUpResult$matchU === void 0 ? void 0 : _matchUpResult$matchU.tieFormat) || structureDefaultTieFormat || drawDefaultTieFormat || eventDefaultTieFormat || undefined;
   return {
     structureDefaultTieFormat,
     eventDefaultTieFormat,
@@ -49827,10 +49826,12 @@ function completeDrawMatchUps({
   completeAllMatchUps,
   randomWinningSide,
   drawDefinition,
+  completionGoal,
   matchUpFormat,
   event
 }) {
-  const sortedStructures = drawDefinition.structures.slice().sort(structureSort); // to support legacy tests it is possible to use completeAllMatchUps
+  const sortedStructures = drawDefinition.structures.slice().sort(structureSort);
+  let completedCount = 0; // to support legacy tests it is possible to use completeAllMatchUps
   // to pass a score string that will be applied to all matchUps
 
   const scoreString = typeof completeAllMatchUps === 'string' && completeAllMatchUps;
@@ -49854,6 +49855,7 @@ function completeDrawMatchUps({
     }) => !winningSide).sort(matchUpSort).map(getMatchUpId$1);
 
     for (const matchUpId of sortedMatchUpIds) {
+      if (!isNaN(completionGoal) && completedCount >= completionGoal) break;
       const {
         matchUps
       } = getAllStructureMatchUps({
@@ -49877,11 +49879,13 @@ function completeDrawMatchUps({
           scoreString
         });
         if (result.error) return result;
+        completedCount += 1;
       }
     }
   }
 
-  return { ...SUCCESS
+  return { ...SUCCESS,
+    completedCount
   };
 }
 function completeDrawMatchUp({
@@ -50061,18 +50065,21 @@ function generateFlightDrawDefinitions({
         } // TODO: enable { outcomes: [] } in eventProfile: { drawProfiles }
 
 
+        const completionGoal = drawProfile === null || drawProfile === void 0 ? void 0 : drawProfile.completionGoal;
         const manual = (drawProfile === null || drawProfile === void 0 ? void 0 : drawProfile.automated) === false;
 
-        if (!manual && completeAllMatchUps) {
+        if (!manual && (completeAllMatchUps || completionGoal)) {
           const matchUpFormat = drawProfile === null || drawProfile === void 0 ? void 0 : drawProfile.matchUpFormat;
           const result = completeDrawMatchUps({
             matchUpStatusProfile,
-            completeAllMatchUps,
+            completeAllMatchUps: !completionGoal && completeAllMatchUps,
             randomWinningSide,
+            completionGoal,
             drawDefinition,
             matchUpFormat
           });
           if (result.error) return result;
+          const completedCount = result.completedCount;
 
           if ((drawProfile === null || drawProfile === void 0 ? void 0 : drawProfile.drawType) === ROUND_ROBIN_WITH_PLAYOFF) {
             const mainStructure = drawDefinition.structures.find(structure => structure.stage === MAIN);
@@ -50083,12 +50090,14 @@ function generateFlightDrawDefinitions({
               event
             });
             if (result.error) return result;
+            const playoffCompletionGoal = completionGoal ? completionGoal - completedCount : undefined;
             result = completeDrawMatchUps({
-              completeAllMatchUps,
+              completeAllMatchUps: !completionGoal && completeAllMatchUps,
+              completionGoal: completionGoal ? playoffCompletionGoal : undefined,
               matchUpStatusProfile,
               randomWinningSide,
-              matchUpFormat,
-              drawDefinition
+              drawDefinition,
+              matchUpFormat
             });
             if (result.error) return result;
           }
@@ -50395,6 +50404,258 @@ function addScaleItem({
   }
 }
 
+function processTieFormat({
+  tieFormat,
+  tieFormatName,
+  drawSize,
+  alternatesCount = 0
+}) {
+  var _tieFormat, _tieFormat$collection;
+
+  let maxDoublesCount = 0,
+      maxSinglesCount = 0;
+  tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({
+    namedFormat: tieFormatName
+  });
+  (_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : (_tieFormat$collection = _tieFormat.collectionDefinitions) === null || _tieFormat$collection === void 0 ? void 0 : _tieFormat$collection.forEach(collectionDefinition => {
+    // ensure every collectionDefinition has a collectionId
+    if (!collectionDefinition.collectionId) collectionDefinition.collectionId = UUID();
+
+    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === DOUBLES$1) {
+      const doublesCount = collectionDefinition.matchUpCount;
+      maxDoublesCount = Math.max(maxDoublesCount, doublesCount);
+    }
+
+    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === SINGLES$1) {
+      const singlescount = collectionDefinition.matchUpCount;
+      maxSinglesCount = Math.max(maxSinglesCount, singlescount);
+    }
+  });
+  const teamSize = Math.max(maxSinglesCount, maxDoublesCount * 2);
+  const maxDoublesDraw = maxDoublesCount * (drawSize + alternatesCount);
+  const maxSinglesDraw = maxSinglesCount * (drawSize + alternatesCount);
+  return {
+    maxDoublesDraw,
+    maxSinglesDraw,
+    teamSize
+  };
+}
+
+function getParticipantsCount({
+  participantsProfile,
+  eventProfiles,
+  drawProfiles
+}) {
+  let {
+    participantsCount,
+    participantType = INDIVIDUAL$1
+  } = participantsProfile || {};
+  const specifiedParicipantsCount = participantsCount || 0; // capture this to ensure calculated participantsCount is not below
+
+  let largestDoublesDraw = 0,
+      largestSinglesDraw = 0,
+      largestTeamSize = 0,
+      largestTeamDraw = 0,
+      uniqueParticipantsCount = 0;
+
+  const processDrawProfile = ({
+    alternatesCount = 0,
+    uniqueParticipants,
+    tieFormatName,
+    drawSize = 0,
+    eventType,
+    tieFormat,
+    category,
+    gender,
+    stage
+  }) => {
+    const isDoubles = eventType === DOUBLES;
+    const isTeam = eventType === TEAM$2;
+    const requiresUniqueParticipants = uniqueParticipants || stage === QUALIFYING || category || gender;
+
+    if (requiresUniqueParticipants) {
+      if (isDoubles) {
+        uniqueParticipantsCount += (drawSize + alternatesCount) * 2;
+      } else {
+        uniqueParticipantsCount += drawSize + alternatesCount;
+      }
+    } else {
+      if (isTeam) {
+        largestTeamDraw = Math.max(largestTeamDraw, drawSize + alternatesCount);
+        tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({
+          namedFormat: tieFormatName
+        });
+        const {
+          teamSize,
+          maxDoublesDraw,
+          maxSinglesDraw
+        } = processTieFormat({
+          alternatesCount,
+          tieFormatName,
+          tieFormat,
+          drawSize
+        });
+        largestTeamSize = Math.max(largestTeamSize, teamSize);
+        largestDoublesDraw = Math.max(largestDoublesDraw, maxDoublesDraw);
+        largestSinglesDraw = Math.max(largestSinglesDraw, maxSinglesDraw);
+      }
+
+      if (isDoubles && drawSize + alternatesCount && drawSize + alternatesCount > largestDoublesDraw) {
+        largestDoublesDraw = drawSize + alternatesCount;
+      }
+
+      if (!isDoubles && !isTeam && drawSize && drawSize > largestSinglesDraw) {
+        largestSinglesDraw = drawSize + alternatesCount;
+      }
+    }
+  };
+
+  eventProfiles === null || eventProfiles === void 0 ? void 0 : eventProfiles.forEach(eventProfile => {
+    const {
+      tieFormatName: eventTieFormatName,
+      tieFormat: eventTieFormat,
+      drawProfiles,
+      eventType,
+      category,
+      gender
+    } = eventProfile;
+
+    if (drawProfiles) {
+      for (const drawProfile of drawProfiles) {
+        const {
+          tieFormatName,
+          tieFormat
+        } = drawProfile;
+        processDrawProfile({ ...drawProfile,
+          tieFormatName: tieFormatName || eventTieFormatName,
+          tieFormat: tieFormat || eventTieFormat,
+          eventType,
+          category,
+          gender
+        });
+      }
+    }
+  });
+
+  if (drawProfiles) {
+    for (const drawProfile of drawProfiles) {
+      processDrawProfile(drawProfile);
+    }
+  }
+
+  const individualCompetitorsCount = Math.max(largestTeamDraw * largestTeamSize, largestDoublesDraw * 2, largestSinglesDraw);
+  if (largestDoublesDraw) participantType = PAIR$1;
+  if ((participantsCount || specifiedParicipantsCount) < individualCompetitorsCount) participantsCount = individualCompetitorsCount;
+
+  if (participantsCount && largestDoublesDraw && [PAIR$1, TEAM$2].includes(participantType)) {
+    // if we are generating PAIRs or TEAMs...
+    if (largestSinglesDraw && Math.floor(largestSinglesDraw / 2) > largestDoublesDraw) {
+      // if the half the singles draw is still larger than doubles draw
+      participantsCount = Math.floor(largestSinglesDraw / 2);
+    } else if (!largestSinglesDraw || largestDoublesDraw * 2 >= largestSinglesDraw) {
+      // otherwise participantsCount can be cut in half
+      participantsCount = Math.ceil(participantsCount / 2);
+    }
+  } // if (participantsCount === undefined) participantsCount = 32;
+
+
+  if (participantsCount === undefined) {
+    participantsCount = !(eventProfiles !== null && eventProfiles !== void 0 && eventProfiles.length) && !(drawProfiles !== null && drawProfiles !== void 0 && drawProfiles.length) ? 32 : 0;
+  }
+
+  if (participantsCount < specifiedParicipantsCount) participantsCount = specifiedParicipantsCount;
+  return {
+    largestTeamDraw,
+    largestTeamSize,
+    participantsCount,
+    participantType,
+    uniqueParticipantsCount
+  };
+}
+
+function addTournamentParticipants({
+  participantsProfile,
+  tournamentRecord,
+  eventProfiles,
+  drawProfiles,
+  startDate,
+  uuids
+}) {
+  const {
+    participantsCount,
+    participantType,
+    largestTeamDraw,
+    largestTeamSize
+  } = getParticipantsCount({
+    participantsProfile,
+    eventProfiles,
+    drawProfiles
+  });
+  const {
+    nationalityCodesCount,
+    nationalityCodeType,
+    valuesInstanceLimit,
+    nationalityCodes,
+    personExtensions,
+    addressProps,
+    personData,
+    personIds,
+    inContext,
+    teamKey,
+    sex
+  } = participantsProfile || {};
+  const {
+    participants
+  } = generateParticipants({
+    consideredDate: startDate,
+    valuesInstanceLimit,
+    nationalityCodesCount,
+    nationalityCodeType,
+    nationalityCodes,
+    personExtensions,
+    addressProps,
+    personData,
+    sex,
+    participantsCount,
+    participantType,
+    personIds,
+    uuids,
+    inContext
+  });
+  let result = addParticipants({
+    tournamentRecord,
+    participants
+  });
+  if (!result.success) return result;
+
+  if (teamKey) {
+    const result = generateTeamsFromParticipantAttribute({
+      tournamentRecord,
+      ...teamKey
+    });
+    if (result.error) return result;
+  } // generate Team participants
+
+
+  const allIndividualParticipantIds = participants.filter(({
+    participantType
+  }) => participantType === INDIVIDUAL$1).map(getParticipantId);
+  const teamParticipants = generateRange(0, largestTeamDraw).map(teamIndex => {
+    const individualParticipantIds = allIndividualParticipantIds.slice(teamIndex * largestTeamSize, (teamIndex + 1) * largestTeamSize);
+    return {
+      participantName: `Team ${teamIndex + 1}`,
+      participantRole: COMPETITOR,
+      participantType: TEAM$1,
+      participantId: UUID(),
+      individualParticipantIds
+    };
+  });
+  return addParticipants({
+    tournamentRecord,
+    participants: teamParticipants
+  });
+}
+
 function generateEventParticipants({
   uniqueParticipantsCount,
   participantsProfile,
@@ -50422,6 +50683,7 @@ function generateEventParticipants({
   const mainParticipantsCount = uniqueParticipantsCount[MAIN] || 0;
   const qualifyingParticipantsCount = uniqueParticipantsCount[QUALIFYING] || 0;
   const participantsCount = mainParticipantsCount + qualifyingParticipantsCount;
+  const sex = [MALE, FEMALE].includes(gender) ? gender : undefined;
   const {
     participants: uniqueFlightParticipants
   } = generateParticipants({
@@ -50436,11 +50698,11 @@ function generateEventParticipants({
     ratingsParameters,
     nationalityCodes,
     addressProps,
-    sex: gender,
     personIds,
     inContext,
     category,
-    uuids
+    uuids,
+    sex
   });
   let result = addParticipants({
     participants: uniqueFlightParticipants,
@@ -50608,262 +50870,6 @@ function generateFlights({
   };
 }
 
-function modifyTournamentRecord({
-  matchUpStatusProfile,
-  completeAllMatchUps,
-  participantsProfile,
-  autoEntryPositions,
-  randomWinningSide,
-  tournamentRecord,
-  eventProfiles,
-  uuids
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  const allUniqueParticipantIds = [];
-  const drawIds = [];
-
-  if (participantsProfile) {
-    const {
-      nationalityCodesCount,
-      nationalityCodeType,
-      valuesInstanceLimit,
-      participantsCount,
-      nationalityCodes,
-      personExtensions,
-      participantType,
-      addressProps,
-      personData,
-      personIds,
-      inContext,
-      teamKey,
-      uuids,
-      sex
-    } = participantsProfile || {};
-    const {
-      participants
-    } = generateParticipants({
-      consideredDate: tournamentRecord.startDate,
-      valuesInstanceLimit,
-      nationalityCodesCount,
-      nationalityCodeType,
-      nationalityCodes,
-      personExtensions,
-      addressProps,
-      personData,
-      sex,
-      participantsCount,
-      participantType,
-      personIds,
-      uuids,
-      inContext
-    });
-    let result = addParticipants({
-      tournamentRecord,
-      participants
-    });
-    if (result.error) return result;
-
-    if (teamKey) {
-      const result = generateTeamsFromParticipantAttribute({
-        tournamentRecord,
-        ...teamKey
-      });
-      if (result.error) return result;
-    }
-  }
-
-  if (eventProfiles) {
-    for (const eventProfile of eventProfiles) {
-      let {
-        ratingsParameters
-      } = eventProfile;
-      const event = tournamentRecord.events.find(event => eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
-      if (!event) return {
-        error: EVENT_NOT_FOUND
-      };
-      const {
-        gender,
-        category,
-        eventType
-      } = event;
-      const {
-        drawProfiles
-      } = eventProfile;
-      const eventParticipantType = eventType === SINGLES ? INDIVIDUAL : eventType === DOUBLES ? PAIR : eventType;
-
-      if (drawProfiles) {
-        const {
-          stageParticipantsCount,
-          uniqueParticipantsCount,
-          uniqueParticipantStages
-        } = getStageParticipantsCount({
-          drawProfiles,
-          category,
-          gender
-        });
-        const {
-          uniqueDrawParticipants = [],
-          uniqueParticipantIds = []
-        } = uniqueParticipantStages ? generateEventParticipants({
-          event: {
-            eventType,
-            category,
-            gender
-          },
-          uniqueParticipantsCount,
-          participantsProfile,
-          ratingsParameters,
-          tournamentRecord,
-          eventProfile,
-          uuids
-        }) : {};
-        allUniqueParticipantIds.push(...uniqueParticipantIds);
-        const {
-          stageParticipants
-        } = getStageParticipants({
-          targetParticipants: tournamentRecord.participants || [],
-          allUniqueParticipantIds,
-          stageParticipantsCount,
-          eventParticipantType
-        });
-        let result = generateFlights({
-          uniqueDrawParticipants,
-          autoEntryPositions,
-          stageParticipants,
-          tournamentRecord,
-          drawProfiles,
-          category,
-          gender,
-          event
-        });
-        if (result.error) return result;
-        result = generateFlightDrawDefinitions({
-          matchUpStatusProfile,
-          completeAllMatchUps,
-          randomWinningSide,
-          tournamentRecord,
-          drawProfiles,
-          event
-        });
-        if (result.error) return result;
-        drawIds.push(...result.drawIds);
-      }
-    }
-  }
-
-  return { ...SUCCESS,
-    drawIds
-  };
-}
-
-const amendsGovernor = {
-  anonymizeTournamentRecord,
-  modifyTournamentRecord
-};
-
-function generateSchedulingProfile({
-  schedulingProfile,
-  tournamentRecord
-}) {
-  if (typeof schedulingProfile !== 'object') return {
-    error: INVALID_VALUES
-  };
-  const containedStructures = getContainedStructures({
-    tournamentRecord
-  }).containedStructures;
-  const {
-    matchUps
-  } = allTournamentMatchUps({
-    tournamentRecord
-  });
-  const {
-    tournamentId
-  } = tournamentRecord;
-  const scheduledRounds = [];
-
-  for (const dateProfile of schedulingProfile) {
-    const {
-      scheduleDate,
-      venues = []
-    } = dateProfile;
-
-    for (const venue of venues) {
-      const {
-        rounds,
-        venueId
-      } = venue;
-
-      for (const round of rounds) {
-        const {
-          drawId,
-          winnerFinishingPositionRange,
-          roundSegment
-        } = round;
-        const targetMatchUps = matchUps.filter(matchUp => {
-          var _matchUp$finishingPos;
-
-          const targetRange = (winnerFinishingPositionRange === null || winnerFinishingPositionRange === void 0 ? void 0 : winnerFinishingPositionRange.indexOf('-')) > 0 && winnerFinishingPositionRange.split('-').map(x => +x);
-          const range = (_matchUp$finishingPos = matchUp.finishingPositionRange) === null || _matchUp$finishingPos === void 0 ? void 0 : _matchUp$finishingPos.winner;
-          const target = matchUp.drawId === drawId && (!round.roundNumber || matchUp.roundNumber === round.roundNumber) && (!range || !targetRange || intersection(range, targetRange).length === 2);
-          return target;
-        });
-        const targetMatchUp = targetMatchUps[0];
-
-        if (targetMatchUp) {
-          const {
-            eventId,
-            roundNumber,
-            drawName,
-            structureName,
-            roundName
-          } = targetMatchUp;
-          let structureId = targetMatchUp.structureId;
-
-          if (roundNumber && !winnerFinishingPositionRange) {
-            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId));
-          }
-
-          const roundToSchedule = {
-            tournamentId,
-            eventId,
-            drawId,
-            structureId,
-            roundNumber,
-            roundSegment
-          };
-          let result = addSchedulingProfileRound({
-            tournamentRecords: {
-              [tournamentId]: tournamentRecord
-            },
-            scheduleDate,
-            venueId,
-            round: roundToSchedule
-          });
-          if (result.error) return result;
-          scheduledRounds.push({
-            drawName,
-            structureName,
-            roundName,
-            ...roundToSchedule
-          });
-        }
-      }
-    }
-  }
-
-  return {
-    scheduledRounds
-  };
-}
-
-// import { addDrawDefinition } from '../../tournamentEngine/governors/eventGovernor/drawDefinitions/addDrawDefinition';
-// import {
-//   MAIN,
-//   ROUND_ROBIN_WITH_PLAYOFF,
-// } from '../../constants/drawDefinitionConstants';
-
 function generateEventWithFlights({
   allUniqueParticipantIds,
   matchUpStatusProfile,
@@ -50874,7 +50880,6 @@ function generateEventWithFlights({
   ratingsParameters,
   tournamentRecord,
   eventProfile,
-  // startDate,
   uuids
 }) {
   let gender = eventProfile.gender;
@@ -51003,120 +51008,6 @@ function generateEventWithFlights({
   });
   if (result.error) return result;
   const drawIds = result.drawIds;
-  /*
-  const drawIds = [];
-  const { flightProfile } = getFlightProfile({ event });
-   if (Array.isArray(flightProfile?.flights)) {
-    for (const [index, flight] of flightProfile.flights.entries()) {
-      const { drawId, stage, drawName, drawEntries } = flight;
-      drawIds.push(flight.drawId);
-       const drawProfile = drawProfiles[index];
-      const { seedsCount, generate = true } = drawProfile || {};
-       if (generate) {
-        const drawParticipantIds = drawEntries
-          .filter(hasParticipantId)
-          .map(getParticipantId);
-         const seedingScaleName = categoryName || eventName;
-         if (
-          tournamentRecord &&
-          seedsCount &&
-          seedsCount <= drawParticipantIds.length
-        ) {
-          const scaleValues = generateRange(1, seedsCount + 1);
-          scaleValues.forEach((scaleValue, index) => {
-            let scaleItem = {
-              scaleValue,
-              scaleName: seedingScaleName,
-              scaleType: SEEDING,
-              eventType,
-              scaleDate: startDate,
-            };
-             const participantId = drawParticipantIds[index];
-            setParticipantScaleItem({
-              tournamentRecord,
-              participantId,
-              scaleItem,
-            });
-          });
-        }
-         let result = generateDrawDefinition({
-          ...drawProfile,
-          matchUpType: eventType,
-          seedingScaleName,
-          tournamentRecord,
-          isMock: true,
-          drawEntries,
-          drawName,
-          drawId,
-          event,
-          stage,
-        });
-         const { drawDefinition, error } = result;
-        if (error) return { error };
-         const drawExtensions = drawProfiles[index]?.drawExtensions;
-        if (Array.isArray(drawExtensions)) {
-          drawExtensions
-            .filter(isValidExtension)
-            .forEach((extension) =>
-              addExtension({ element: drawDefinition, extension })
-            );
-        }
-         result = addDrawDefinition({
-          drawDefinition,
-          event,
-        });
-        if (result.error) return result;
-         if (drawProfile?.withPlayoffs) {
-          const structureId = drawDefinition.structures[0].structureId;
-          const result = addPlayoffStructures({
-            idPrefix: drawProfile.idPrefix,
-            ...drawProfile.withPlayoffs,
-            tournamentRecord,
-            drawDefinition,
-            isMock: true,
-            structureId,
-            event,
-          });
-          if (result?.error) return result;
-        }
-         // TODO: enable { outcomes: [] } in eventProfile: { drawProfiles }
-         const manual = drawProfile?.automated === false;
-        if (!manual && completeAllMatchUps) {
-          const matchUpFormat = drawProfile?.matchUpFormat;
-          const result = completeDrawMatchUps({
-            matchUpStatusProfile,
-            completeAllMatchUps,
-            randomWinningSide,
-            drawDefinition,
-            matchUpFormat,
-          });
-          if (result.error) return result;
-          if (drawProfile?.drawType === ROUND_ROBIN_WITH_PLAYOFF) {
-            const mainStructure = drawDefinition.structures.find(
-              (structure) => structure.stage === MAIN
-            );
-            let result = automatedPlayoffPositioning({
-              structureId: mainStructure.structureId,
-              tournamentRecord,
-              drawDefinition,
-              event,
-            });
-            if (result.error) return result;
-             result = completeDrawMatchUps({
-              completeAllMatchUps,
-              matchUpStatusProfile,
-              randomWinningSide,
-              matchUpFormat,
-              drawDefinition,
-            });
-            if (result.error) return result;
-          }
-        }
-      }
-    }
-  }
-  */
-
   return {
     drawIds,
     eventId,
@@ -51124,43 +51015,6 @@ function generateEventWithFlights({
   };
 }
 
-function processTieFormat({
-  tieFormat,
-  tieFormatName,
-  drawSize,
-  alternatesCount = 0
-}) {
-  var _tieFormat, _tieFormat$collection;
-
-  let maxDoublesCount = 0,
-      maxSinglesCount = 0;
-  tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({
-    namedFormat: tieFormatName
-  });
-  (_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : (_tieFormat$collection = _tieFormat.collectionDefinitions) === null || _tieFormat$collection === void 0 ? void 0 : _tieFormat$collection.forEach(collectionDefinition => {
-    // ensure every collectionDefinition has a collectionId
-    if (!collectionDefinition.collectionId) collectionDefinition.collectionId = UUID();
-
-    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === DOUBLES$1) {
-      const doublesCount = collectionDefinition.matchUpCount;
-      maxDoublesCount = Math.max(maxDoublesCount, doublesCount);
-    }
-
-    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === SINGLES$1) {
-      const singlescount = collectionDefinition.matchUpCount;
-      maxSinglesCount = Math.max(maxSinglesCount, singlescount);
-    }
-  });
-  const teamSize = Math.max(maxSinglesCount, maxDoublesCount * 2);
-  const maxDoublesDraw = maxDoublesCount * (drawSize + alternatesCount);
-  const maxSinglesDraw = maxSinglesCount * (drawSize + alternatesCount);
-  return {
-    maxDoublesDraw,
-    maxSinglesDraw,
-    teamSize
-  };
-}
-
 function generateEventWithDraw({
   allUniqueParticipantIds = [],
   matchUpStatusProfile,
@@ -51272,7 +51126,7 @@ function generateEventWithDraw({
     });
 
     if (tournamentRecord) {
-      let result = addParticipants({
+      const result = addParticipants({
         tournamentRecord,
         participants: unique
       });
@@ -51332,22 +51186,26 @@ function generateEventWithDraw({
     participantId
   }) => !allUniqueParticipantIds.includes(participantId));
   const participantIds = consideredParticipants.slice(0, participantsCount).map(p => p.participantId);
-  let result = addEventEntries({
-    entryStage: stage,
-    autoEntryPositions,
-    tournamentRecord,
-    participantIds,
-    event
-  });
-  if (result.error) return result; // alternates can still be taken from existing participants
+
+  if (participantIds !== null && participantIds !== void 0 && participantIds.length) {
+    const result = addEventEntries({
+      autoEntryPositions,
+      entryStage: stage,
+      tournamentRecord,
+      participantIds,
+      event
+    });
+    if (result.error) return result;
+  } // alternates can still be taken from existing participants
   // when unique participants are used for DIRECT_ACCEPTANCE entries
 
+
   const alternatesParticipantIds = excessParticipantAlternates && (tournamentRecord === null || tournamentRecord === void 0 ? void 0 : (_tournamentRecord$par = tournamentRecord.participants) === null || _tournamentRecord$par === void 0 ? void 0 : _tournamentRecord$par.filter(({
     participantId
   }) => !participantIds.includes(participantId)).filter(isEventParticipantType).filter(isEventGender).slice(0, alternatesCount || drawSize - participantsCount).map(p => p.participantId));
 
   if (alternatesParticipantIds !== null && alternatesParticipantIds !== void 0 && alternatesParticipantIds.length) {
-    result = addEventEntries({
+    const result = addEventEntries({
       participantIds: alternatesParticipantIds,
       autoEntryPositions: false,
       entryStatus: ALTERNATE,
@@ -51519,9 +51377,6 @@ function generateEventWithDraw({
     }
   }
 
-  if (result.error) return {
-    error: result.error
-  };
   return { ...SUCCESS,
     event: definedAttributes(event),
     uniqueParticipantIds,
@@ -51579,6 +51434,322 @@ function generateVenues({
   return venueIds;
 }
 
+function modifyTournamentRecord({
+  ratingsParameters: ratingsParameters$1 = ratingsParameters,
+  matchUpStatusProfile,
+  completeAllMatchUps,
+  participantsProfile,
+  autoEntryPositions,
+  randomWinningSide,
+  schedulingProfile,
+  tournamentRecord,
+  eventProfiles,
+  venueProfiles,
+  autoSchedule,
+  drawProfiles,
+  goesTo,
+  uuids
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  const allUniqueParticipantIds = [];
+  const eventIds = [];
+  const drawIds = [];
+  eventProfiles === null || eventProfiles === void 0 ? void 0 : eventProfiles.forEach(eventProfile => {
+    const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
+
+    if (event !== null && event !== void 0 && event.gender) {
+      eventProfile.gender = event.gender;
+    }
+  });
+  const result = addTournamentParticipants({
+    startDate: tournamentRecord.startDate,
+    participantsProfile,
+    tournamentRecord,
+    eventProfiles,
+    drawProfiles,
+    uuids
+  });
+  if (!result.success) return result;
+
+  if (eventProfiles) {
+    for (const eventProfile of eventProfiles) {
+      let {
+        ratingsParameters
+      } = eventProfile;
+      const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
+
+      if (!event) {
+        const {
+          error,
+          eventId,
+          drawIds: generatedDrawIds,
+          uniqueParticipantIds
+        } = generateEventWithFlights({
+          startDate: tournamentRecord.startDate,
+          allUniqueParticipantIds,
+          matchUpStatusProfile,
+          participantsProfile,
+          completeAllMatchUps,
+          autoEntryPositions,
+          randomWinningSide,
+          ratingsParameters,
+          tournamentRecord,
+          eventProfile,
+          uuids
+        });
+        if (error) return {
+          error
+        };
+        if (generatedDrawIds) drawIds.push(...generatedDrawIds);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+      } else {
+        const {
+          gender,
+          category,
+          eventType
+        } = event;
+        const {
+          drawProfiles
+        } = eventProfile;
+        const eventParticipantType = eventType === SINGLES ? INDIVIDUAL : eventType === DOUBLES ? PAIR : eventType;
+
+        if (drawProfiles) {
+          const {
+            stageParticipantsCount,
+            uniqueParticipantsCount,
+            uniqueParticipantStages
+          } = getStageParticipantsCount({
+            drawProfiles,
+            category,
+            gender
+          });
+          const {
+            uniqueDrawParticipants = [],
+            uniqueParticipantIds = []
+          } = uniqueParticipantStages ? generateEventParticipants({
+            event: {
+              eventType,
+              category,
+              gender
+            },
+            uniqueParticipantsCount,
+            participantsProfile,
+            ratingsParameters,
+            tournamentRecord,
+            eventProfile,
+            uuids
+          }) : {};
+          allUniqueParticipantIds.push(...uniqueParticipantIds);
+          const {
+            stageParticipants
+          } = getStageParticipants({
+            targetParticipants: tournamentRecord.participants || [],
+            allUniqueParticipantIds,
+            stageParticipantsCount,
+            eventParticipantType
+          });
+          let result = generateFlights({
+            uniqueDrawParticipants,
+            autoEntryPositions,
+            stageParticipants,
+            tournamentRecord,
+            drawProfiles,
+            category,
+            gender,
+            event
+          });
+          if (result.error) return result;
+          result = generateFlightDrawDefinitions({
+            matchUpStatusProfile,
+            completeAllMatchUps,
+            randomWinningSide,
+            tournamentRecord,
+            drawProfiles,
+            event
+          });
+          if (result.error) return result;
+          drawIds.push(...result.drawIds);
+        }
+      }
+    }
+  }
+
+  if (drawProfiles) {
+    for (const drawProfile of drawProfiles) {
+      const {
+        drawId,
+        eventId,
+        event,
+        error,
+        uniqueParticipantIds
+      } = generateEventWithDraw({
+        startDate: tournamentRecord.startDate,
+        allUniqueParticipantIds,
+        matchUpStatusProfile,
+        participantsProfile,
+        completeAllMatchUps,
+        autoEntryPositions,
+        randomWinningSide,
+        ratingsParameters: ratingsParameters$1,
+        tournamentRecord,
+        drawProfile,
+        goesTo,
+        uuids
+      });
+      if (error) return {
+        error
+      };
+      const result = addEvent({
+        tournamentRecord,
+        event
+      });
+      if (result.error) return result;
+      if (drawId) drawIds.push(drawId);
+      eventIds.push(eventId);
+      if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+    }
+  }
+
+  const venueIds = venueProfiles !== null && venueProfiles !== void 0 && venueProfiles.length ? generateVenues({
+    tournamentRecord,
+    venueProfiles
+  }) : [];
+  let scheduledRounds;
+  let schedulerResult = {};
+
+  if (schedulingProfile) {
+    const result = generateScheduleTimes({
+      schedulingProfile,
+      tournamentRecord
+    });
+    if (result.error) return result;
+    scheduledRounds = result.scheduledRounds;
+
+    if (autoSchedule) {
+      const {
+        tournamentId
+      } = tournamentRecord;
+      const tournamentRecords = {
+        [tournamentId]: tournamentRecord
+      };
+      schedulerResult = scheduleProfileRounds({
+        tournamentRecords
+      });
+    }
+  }
+
+  return { ...SUCCESS,
+    drawIds,
+    eventIds,
+    venueIds,
+    scheduledRounds,
+    schedulerResult
+  };
+}
+
+const amendsGovernor = {
+  anonymizeTournamentRecord,
+  modifyTournamentRecord
+};
+
+function generateSchedulingProfile({
+  schedulingProfile,
+  tournamentRecord
+}) {
+  if (typeof schedulingProfile !== 'object') return {
+    error: INVALID_VALUES
+  };
+  const containedStructures = getContainedStructures({
+    tournamentRecord
+  }).containedStructures;
+  const {
+    matchUps
+  } = allTournamentMatchUps({
+    tournamentRecord
+  });
+  const {
+    tournamentId
+  } = tournamentRecord;
+  const scheduledRounds = [];
+
+  for (const dateProfile of schedulingProfile) {
+    const {
+      scheduleDate,
+      venues = []
+    } = dateProfile;
+
+    for (const venue of venues) {
+      const {
+        rounds,
+        venueId
+      } = venue;
+
+      for (const round of rounds) {
+        const {
+          drawId,
+          winnerFinishingPositionRange,
+          roundSegment
+        } = round;
+        const targetMatchUps = matchUps.filter(matchUp => {
+          var _matchUp$finishingPos;
+
+          const targetRange = (winnerFinishingPositionRange === null || winnerFinishingPositionRange === void 0 ? void 0 : winnerFinishingPositionRange.indexOf('-')) > 0 && winnerFinishingPositionRange.split('-').map(x => +x);
+          const range = (_matchUp$finishingPos = matchUp.finishingPositionRange) === null || _matchUp$finishingPos === void 0 ? void 0 : _matchUp$finishingPos.winner;
+          const target = matchUp.drawId === drawId && (!round.roundNumber || matchUp.roundNumber === round.roundNumber) && (!range || !targetRange || intersection(range, targetRange).length === 2);
+          return target;
+        });
+        const targetMatchUp = targetMatchUps[0];
+
+        if (targetMatchUp) {
+          const {
+            eventId,
+            roundNumber,
+            drawName,
+            structureName,
+            roundName
+          } = targetMatchUp;
+          let structureId = targetMatchUp.structureId;
+
+          if (roundNumber && !winnerFinishingPositionRange) {
+            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId));
+          }
+
+          const roundToSchedule = {
+            tournamentId,
+            eventId,
+            drawId,
+            structureId,
+            roundNumber,
+            roundSegment
+          };
+          let result = addSchedulingProfileRound({
+            tournamentRecords: {
+              [tournamentId]: tournamentRecord
+            },
+            scheduleDate,
+            venueId,
+            round: roundToSchedule
+          });
+          if (result.error) return result;
+          scheduledRounds.push({
+            drawName,
+            structureName,
+            roundName,
+            ...roundToSchedule
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    scheduledRounds
+  };
+}
+
 /**
  *
  * Generate a complete tournamentRecord from the following attributes
@@ -51624,12 +51795,6 @@ function generateTournamentRecord({
   goesTo,
   uuids
 } = {}) {
-  let {
-    participantsCount,
-    participantType = INDIVIDUAL$1
-  } = participantsProfile || {};
-  const specifiedParicipantsCount = participantsCount || 0; // capture this to ensure calculated participantsCount is not below
-
   if (startDate && !isValidDateString(startDate) || endDate && !isValidDateString(endDate)) return {
     error: INVALID_DATE
   };
@@ -51671,165 +51836,13 @@ function generateTournamentRecord({
     }
   }
 
-  let largestDoublesDraw = 0,
-      largestSinglesDraw = 0,
-      largestTeamSize = 0,
-      largestTeamDraw = 0;
-
-  const processDrawProfile = ({
-    alternatesCount = 0,
-    uniqueParticipants,
-    tieFormatName,
-    drawSize = 0,
-    eventType,
-    tieFormat,
-    category,
-    gender,
-    stage
-  }) => {
-    const isDoubles = eventType === DOUBLES;
-    const isTeam = eventType === TEAM$2;
-    const requiresUniqueParticipants = uniqueParticipants || stage === QUALIFYING || category || gender;
-
-    if (isTeam && !requiresUniqueParticipants) {
-      largestTeamDraw = Math.max(largestTeamDraw, drawSize + alternatesCount);
-      tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({
-        namedFormat: tieFormatName
-      });
-      const {
-        teamSize,
-        maxDoublesDraw,
-        maxSinglesDraw
-      } = processTieFormat({
-        alternatesCount,
-        tieFormatName,
-        tieFormat,
-        drawSize
-      });
-      largestTeamSize = Math.max(largestTeamSize, teamSize);
-      largestDoublesDraw = Math.max(largestDoublesDraw, maxDoublesDraw);
-      largestSinglesDraw = Math.max(largestSinglesDraw, maxSinglesDraw);
-    }
-
-    if (isDoubles && drawSize + alternatesCount && drawSize + alternatesCount > largestDoublesDraw) {
-      largestDoublesDraw = drawSize + alternatesCount;
-    }
-
-    if (!isDoubles && !isTeam && drawSize && drawSize > largestSinglesDraw) {
-      largestSinglesDraw = drawSize + alternatesCount;
-    }
-  };
-
-  eventProfiles === null || eventProfiles === void 0 ? void 0 : eventProfiles.forEach(eventProfile => {
-    const {
-      tieFormatName: eventTieFormatName,
-      tieFormat: eventTieFormat,
-      drawProfiles,
-      eventType,
-      category
-    } = eventProfile;
-
-    if (drawProfiles) {
-      for (const drawProfile of drawProfiles) {
-        const {
-          tieFormatName,
-          tieFormat
-        } = drawProfile;
-        processDrawProfile({ ...drawProfile,
-          tieFormatName: tieFormatName || eventTieFormatName,
-          tieFormat: tieFormat || eventTieFormat,
-          eventType,
-          category
-        });
-      }
-    }
-  });
-
-  if (drawProfiles) {
-    for (const drawProfile of drawProfiles) {
-      processDrawProfile(drawProfile);
-    }
-  }
-
-  const individualCompetitorsCount = Math.max(largestTeamDraw * largestTeamSize, largestDoublesDraw * 2, largestSinglesDraw);
-  if (largestDoublesDraw) participantType = PAIR$1;
-  if ((participantsCount || specifiedParicipantsCount) < individualCompetitorsCount) participantsCount = individualCompetitorsCount;
-
-  if (participantsCount && largestDoublesDraw && [PAIR$1, TEAM$2].includes(participantType)) {
-    // if we are generating PAIRs or TEAMs...
-    if (largestSinglesDraw && Math.floor(largestSinglesDraw / 2) > largestDoublesDraw) {
-      // if the half the singles draw is still larger than doubles draw
-      participantsCount = Math.floor(largestSinglesDraw / 2);
-    } else if (!largestSinglesDraw || largestDoublesDraw * 2 >= largestSinglesDraw) {
-      // otherwise participantsCount can be cut in half
-      participantsCount = Math.ceil(participantsCount / 2);
-    }
-  }
-
-  if (participantsCount === undefined) participantsCount = 32;
-  if (participantsCount < specifiedParicipantsCount) participantsCount = specifiedParicipantsCount;
-  const {
-    nationalityCodesCount,
-    nationalityCodeType,
-    valuesInstanceLimit,
-    nationalityCodes,
-    personExtensions,
-    addressProps,
-    personData,
-    personIds,
-    inContext,
-    teamKey,
-    sex
-  } = participantsProfile || {};
-  const {
-    participants
-  } = generateParticipants({
-    consideredDate: startDate,
-    valuesInstanceLimit,
-    nationalityCodesCount,
-    nationalityCodeType,
-    nationalityCodes,
-    personExtensions,
-    addressProps,
-    personData,
-    sex,
-    participantsCount,
-    participantType,
-    personIds,
-    uuids,
-    inContext
-  });
-  let result = addParticipants({
-    tournamentRecord,
-    participants
-  });
-  if (!result.success) return result;
-
-  if (teamKey) {
-    const result = generateTeamsFromParticipantAttribute({
-      tournamentRecord,
-      ...teamKey
-    });
-    if (result.error) return result;
-  } // generate Team participants
-
-
-  const allIndividualParticipantIds = participants.filter(({
-    participantType
-  }) => participantType === INDIVIDUAL$1).map(getParticipantId);
-  const teamParticipants = generateRange(0, largestTeamDraw).map(teamIndex => {
-    const individualParticipantIds = allIndividualParticipantIds.slice(teamIndex * largestTeamSize, (teamIndex + 1) * largestTeamSize);
-    return {
-      participantName: `Team ${teamIndex + 1}`,
-      participantRole: COMPETITOR,
-      participantType: TEAM$2,
-      participantId: UUID(),
-      individualParticipantIds
-    };
-  });
-  result = addParticipants({
+  const result = addTournamentParticipants({
+    participantsProfile,
     tournamentRecord,
-    participants: teamParticipants
+    eventProfiles,
+    drawProfiles,
+    startDate,
+    uuids
   });
   if (!result.success) return result;
   const drawIds = [],
@@ -51855,7 +51868,8 @@ function generateTournamentRecord({
         tournamentRecord,
         drawProfile,
         startDate,
-        goesTo
+        goesTo,
+        uuids
       });
       if (error) return {
         error
@@ -51888,7 +51902,8 @@ function generateTournamentRecord({
         ratingsParameters: ratingsParameters$1,
         tournamentRecord,
         eventProfile,
-        startDate
+        startDate,
+        uuids
       });
       if (error) return {
         error