tods-competition-factory 1.8.19 → 1.8.21

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.19";
+  return "1.8.21";
 }
 
 function getObjectTieFormat(obj) {
@@ -2971,8 +2971,8 @@ function validateCollectionDefinition({
   if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
     errors.push(`Invalid gender: ${gender}`);
     return decorateResult({
+      result: { error: INVALID_GENDER, errors },
       context: { referenceGender, gender },
-      result: { error: INVALID_GENDER },
       stack
     });
   }
@@ -5260,8 +5260,8 @@ function unlinkTournament({
   tournamentIds.every((currentTournamentId) => {
     const tournamentRecord = tournamentRecords[currentTournamentId];
     const { extension } = findTournamentExtension({
-      tournamentRecord,
-      name: LINKED_TOURNAMENTS
+      name: LINKED_TOURNAMENTS,
+      tournamentRecord
     });
     if (!extension)
       return true;
@@ -7778,6 +7778,9 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     namingConventions: {
       round: "Round"
     },
+    qualifyingFinishMap: {
+      1: "Final"
+    },
     abbreviatedRoundNamingMap: {
       // key is matchUpsCount for the round
       1: "F",
@@ -7791,7 +7794,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     },
     affixes: {
       roundNumber: "R",
-      preFeedRound: "Q"
+      preFeedRound: "Q",
+      preQualifying: "P"
     },
     stageConstants: {
       [MAIN]: "",
@@ -7804,6 +7808,7 @@ const POLICY_ROUND_NAMING_DEFAULT = {
 
 function getRoundContextProfile({
   roundNamingPolicy,
+  drawDefinition,
   structure,
   matchUps
 }) {
@@ -7814,21 +7819,31 @@ function getRoundContextProfile({
   const isRoundRobin = structure.structures;
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
+  const isQualifying = structure.stage === QUALIFYING;
+  const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
+  const qualifyingStageSequences = isQualifying ? Math.max(
+    ...(drawDefinition?.structures ?? []).filter((structure2) => structure2.stage === QUALIFYING).map(({ stageSequence }) => stageSequence ?? 1),
+    0
+  ) : 0;
+  const preQualifyingSequence = qualifyingStageSequences ? qualifyingStageSequences - (structure.stageSequence || 1) || "" : "";
+  const preQualifyingAffix = preQualifyingSequence ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || "" : "";
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
-  const roundNamePrefix = roundNamingPolicy?.affixes || defaultRoundNamingPolicy.affixes;
-  const roundNumberAffix = roundNamePrefix.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
+  const preFeedAffix = roundNamingPolicy?.affixes?.preFeedRound || defaultRoundNamingPolicy.affixes.preFeedRound;
+  const roundNumberAffix = roundNamingPolicy?.affixes?.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
   const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
   const roundNameFallback = namingConventions.round;
-  const stageInitial = stage && stage !== MAIN && stage[0];
-  const stageConstants = roundNamingPolicy?.stageConstants;
-  const stageConstant = stage && stageConstants?.[stage] || stageInitial;
+  const stageInitial = stage && stage !== MAIN ? stage[0] : "";
+  const stageConstants = roundNamingPolicy?.stageConstants || defaultRoundNamingPolicy.stageConstants;
+  const stageIndicator = stage && stageConstants?.[stage] || stageInitial;
+  const stageConstant = `${preQualifyingAffix}${stageIndicator}${preQualifyingSequence}`;
   const roundProfileKeys = roundProfile ? Object.keys(roundProfile) : [];
+  const qualifyingAffix = isQualifying && stageConstants?.[QUALIFYING] ? `${stageConstants?.[QUALIFYING]}-` : "";
   if (isRoundRobin || isAdHocStructure || isLuckyStructure) {
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((key) => {
-        const roundName = `${roundNameFallback} ${key}`;
+        const roundName = `${qualifyingAffix}${roundNameFallback} ${key}`;
         const abbreviatedRoundName = `${roundNumberAffix}${key}`;
         return { [key]: { roundName, abbreviatedRoundName } };
       })
@@ -7841,15 +7856,15 @@ function getRoundContextProfile({
           return;
         const { matchUpsCount, preFeedRound } = roundProfile[round];
         const participantsCount = matchUpsCount * 2;
-        const sizedRoundName = roundNamingMap[matchUpsCount] || `${roundNamePrefix.roundNumber}${participantsCount}`;
-        const suffix = preFeedRound ? `-${roundNamePrefix.preFeedRound}` : "";
+        const sizedRoundName = qualifyingFinishgMap?.[roundProfile?.[round].finishingRound] || qualifyingFinishgMap && `${roundNumberAffix}${participantsCount}` || roundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
+        const suffix = preFeedRound ? `-${preFeedAffix}` : "";
         const profileRoundName = `${sizedRoundName}${suffix}`;
         const roundName = [
           stageConstant,
           structureAbbreviation,
           profileRoundName
         ].filter(Boolean).join("-");
-        const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNamePrefix.roundNumber}${participantsCount}`;
+        const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
         const profileAbbreviation = `${sizedAbbreviation}${suffix}`;
         const abbreviatedRoundName = [
           stageConstant,
@@ -8033,6 +8048,7 @@ function getAllStructureMatchUps({
   const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
   const result = getRoundContextProfile({
     roundNamingPolicy,
+    drawDefinition,
     structure,
     matchUps
   });
@@ -29485,6 +29501,7 @@ function addCollectionDefinition$1({
   collectionDefinition,
   referenceCategory,
   tournamentRecord,
+  policyDefinitions,
   enforceCategory,
   referenceGender,
   drawDefinition,
@@ -29503,11 +29520,11 @@ function addCollectionDefinition$1({
     drawDefinition,
     event
   }).appliedPolicies ?? {};
-  const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS];
+  const matchUpActionsPolicy = policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS];
   enforceCategory = enforceCategory ?? matchUpActionsPolicy?.participants?.enforceCategory;
-  enforceGender = enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender;
+  const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const checkCategory = !!((referenceCategory ?? event?.category) && enforceCategory !== false);
-  const checkGender = !!((referenceGender ?? event?.gender) && enforceGender !== false);
+  const checkGender = !!((referenceGender ?? event?.gender) && genderEnforced);
   const validationResult = validateCollectionDefinition({
     referenceCategory: referenceCategory ?? event?.category,
     collectionDefinition,
@@ -36308,6 +36325,7 @@ function matchUpActions$2({
   inContextDrawMatchUps,
   tournamentRecord,
   drawDefinition,
+  enforceGender,
   participantId,
   matchUpsMap,
   sideNumber,
@@ -36339,8 +36357,8 @@ function matchUpActions$2({
     event
   }).appliedPolicies ?? {};
   Object.assign(appliedPolicies, specifiedPolicyDefinitions ?? {});
-  const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
   const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
   const { enabledStructures } = getEnabledStructures({
     actionType: MATCHUP_ACTION,
     appliedPolicies,
@@ -36554,7 +36572,8 @@ function matchUpActions$2({
     );
     const assignedGender = inContextMatchUp.gender === MIXED && inContextMatchUp.sideNumber && inContextMatchUp.sides?.filter((side2) => side2.particiapntId).length === 1 && firstFoundSide?.participant?.person?.sex;
     const matchUpType = inContextMatchUp.matchUpType;
-    const gender = matchUpActionsPolicy?.participants?.enforceGender ? inContextMatchUp.gender : void 0;
+    const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
+    const gender = genderEnforced ? inContextMatchUp.gender : void 0;
     const allParticipants = inContextMatchUp.sides?.flatMap(
       (side2) => side2.participant?.individualParticipants || side2.participant
     ).filter(Boolean);
@@ -36684,6 +36703,7 @@ function matchUpActions$1({
   policyDefinitions,
   tournamentRecord,
   drawDefinition,
+  enforceGender,
   participantId,
   sideNumber,
   matchUpId,
@@ -36718,6 +36738,7 @@ function matchUpActions$1({
       tournamentParticipants: tournamentRecord.participants,
       policyDefinitions,
       drawDefinition,
+      enforceGender,
       participantId,
       sideNumber,
       matchUpId,
@@ -36731,6 +36752,8 @@ function matchUpActions$1({
 function matchUpActions(params) {
   const {
     tournamentRecords,
+    policyDefinitions,
+    enforceGender,
     participantId,
     tournamentId,
     sideNumber,
@@ -36752,7 +36775,9 @@ function matchUpActions(params) {
     return result;
   return matchUpActions$1({
     drawDefinition: result.drawDefinition,
+    policyDefinitions,
     tournamentRecord,
+    enforceGender,
     participantId,
     sideNumber,
     matchUpId,
@@ -43405,7 +43430,7 @@ function generateQualifyingStructure$1(params) {
       let chainModified;
       while (!chainModified && nextStructureId) {
         targetStructure.stageSequence = nextStageSequence;
-        const targetTargetStructureId = drawDefinition.links.find(
+        const targetTargetStructureId = drawDefinition.links?.find(
           (link2) => link2.source.structureId === nextStructureId
         )?.target?.structureId;
         nextStructureId = targetTargetStructureId;
@@ -45417,9 +45442,10 @@ function addEventEntries(params) {
   const {
     entryStatus = DIRECT_ACCEPTANCE,
     autoEntryPositions = true,
+    enforceGender = true,
     participantIds = [],
     entryStageSequence,
-    ignoreEventGender,
+    policyDefinitions,
     entryStage = MAIN,
     tournamentRecord,
     ignoreStageSpace,
@@ -45441,6 +45467,9 @@ function addEventEntries(params) {
   }
   if (!event?.eventId)
     return { error: EVENT_NOT_FOUND };
+  const appliedPolicies = getAppliedPolicies({ tournamentRecord, event }).appliedPolicies ?? {};
+  const matchUpActionsPolicy = policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const addedParticipantIdEntries = [];
   const removedEntries = [];
   if (extensions && (!Array.isArray(extensions) || !extensions.every(isValidExtension)) || extension && !isValidExtension({ extension })) {
@@ -45452,14 +45481,14 @@ function addEventEntries(params) {
     });
   }
   const checkTypedParticipants = !!tournamentRecord;
-  const misMatchedGender = [];
+  const mismatchedGender = [];
   let info;
   const typedParticipantIds = tournamentRecord?.participants?.filter((participant) => {
     if (!participantIds.includes(participant.participantId))
       return false;
     const validSingles = event.eventType === SINGLES$1 && participant.participantType === INDIVIDUAL && !isUngrouped(entryStatus);
     const validDoubles = event.eventType === DOUBLES$1 && participant.participantType === PAIR;
-    if (validSingles && (!event.gender || ignoreEventGender || [MIXED, ANY].includes(event.gender) || event.gender === participant.person?.sex)) {
+    if (validSingles && (!event.gender || !genderEnforced || [MIXED, ANY].includes(event.gender) || event.gender === participant.person?.sex)) {
       return true;
     }
     if (validDoubles && !isUngrouped(entryStatus)) {
@@ -45468,8 +45497,8 @@ function addEventEntries(params) {
     if (event.eventType === DOUBLES$1 && participant.participantType === INDIVIDUAL && isUngrouped(entryStatus)) {
       return true;
     }
-    if (validSingles && event.gender && !ignoreEventGender && ![MIXED, ANY].includes(event.gender) && event.gender !== participant.person?.sex) {
-      misMatchedGender.push({
+    if (validSingles && event.gender && genderEnforced && ![MIXED, ANY].includes(event.gender) && event.gender !== participant.person?.sex) {
+      mismatchedGender.push({
         participantId: participant.participantId,
         sex: participant.person?.sex
       });
@@ -45551,7 +45580,7 @@ function addEventEntries(params) {
   const invalidParticipantIds = validParticipantIds.length !== participantIds.length;
   if (invalidParticipantIds)
     return decorateResult({
-      context: { misMatchedGender, gender: event.gender },
+      context: { mismatchedGender, gender: event.gender },
       result: { error: INVALID_PARTICIPANT_IDS },
       stack
     });
@@ -48550,7 +48579,8 @@ const entryGovernor = {
 };
 
 const linkGovernor = {
-  generateQualifyingLink
+  generateQualifyingLink,
+  getStructureLinks
 };
 
 const definitionTemplate = () => ({
@@ -52892,7 +52922,7 @@ function assignTieMatchUpParticipantId(params) {
   if (allTieIndividualParticipantIds?.includes(participantId)) {
     return decorateResult({ result: { ...SUCCESS }, stack });
   }
-  teamParticipantId = teamParticipantId || (params.sideNumber ? inContextDualMatchUp?.sides?.find(
+  teamParticipantId = teamParticipantId ?? (params.sideNumber ? inContextDualMatchUp?.sides?.find(
     (side) => side.sideNumber === params.sideNumber
   )?.participantId : void 0);
   const participantToAssign = getParticipants$1({
@@ -52907,8 +52937,9 @@ function assignTieMatchUpParticipantId(params) {
     drawDefinition,
     event
   });
-  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] || appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] || POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
-  if (matchUpActionsPolicy?.participants?.enforceGender && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== participantToAssign.person?.sex) {
+  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const genderEnforced = (params.enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
+  if (genderEnforced && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== participantToAssign.person?.sex) {
     return { error: INVALID_PARTICIPANT, info: "Gender mismatch" };
   }
   const { individualParticipantIds, participantType } = participantToAssign;
@@ -52935,7 +52966,7 @@ function assignTieMatchUpParticipantId(params) {
   const teamSide = inContextTieMatchUp?.sides?.find(
     (side) => side.drawPosition === teamDrawPosition
   );
-  const sideNumber = params.sideNumber || teamSide?.sideNumber;
+  const sideNumber = params.sideNumber ?? teamSide?.sideNumber;
   if (!tieFormat) {
     return { error: MISSING_TIE_FORMAT };
   }
@@ -54033,8 +54064,8 @@ function analyzeDraws({ tournamentRecord }) {
       ({ inactiveStructure }) => !inactiveStructure
     ).length;
     const { links } = getStructureLinks({
-      drawDefinition,
-      structureId: mainStructure.structureId
+      structureId: mainStructure.structureId,
+      drawDefinition
     });
     const isMatchPlay = ensureInt(mainStructure.activeRounds[0]) === 1 && mainStructure.activeRounds.length === 1 && activeStructuresCount === 1;
     const inactiveDraw = structuresData?.every(
@@ -55384,11 +55415,12 @@ function replaceTieMatchUpParticipantId(params) {
     drawDefinition,
     event
   });
-  const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] || POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
   const newParticipant = targetParticipants.find(
     ({ participantId }) => participantId === newParticipantId
   );
-  if (matchUpActionsPolicy?.participants?.enforceGender && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== newParticipant?.person?.sex) {
+  const genderEnforced = (params.enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
+  if (genderEnforced && [MALE, FEMALE].includes(inContextTieMatchUp?.gender) && inContextTieMatchUp?.gender !== newParticipant?.person?.sex) {
     return { error: INVALID_PARTICIPANT, info: "Gender mismatch" };
   }
   const substitutionProcessCodes = matchUpActionsPolicy?.processCodes?.substitution;
@@ -55457,16 +55489,16 @@ function replaceTieMatchUpParticipantId(params) {
       const assignment = { collectionId, collectionPosition };
       if (substitution) {
         assignment.previousParticipantId = existingParticipantId;
-        assignment.substitutionOrder = (substitutionOrder || 0) + 1;
+        assignment.substitutionOrder = (substitutionOrder ?? 0) + 1;
       }
       modifiedCompetitor.collectionAssignments.push(assignment);
     }
     return modifiedCompetitor;
-  }) || [];
+  }) ?? [];
   if (!newParticipantIdInLineUp) {
     const collectionAssignment = { collectionId, collectionPosition };
     if (substitution) {
-      collectionAssignment.substitutionOrder = (substitutionOrder || 0) + 1;
+      collectionAssignment.substitutionOrder = (substitutionOrder ?? 0) + 1;
       collectionAssignment.previousParticipantId = existingParticipantId;
     }
     const assignment = {
@@ -55538,7 +55570,7 @@ function replaceTieMatchUpParticipantId(params) {
   }
   if (substitution || side.substitutions?.length === 1) {
     if (substitution) {
-      const processCodes = tieMatchUp?.processCodes || [];
+      const processCodes = tieMatchUp?.processCodes ?? [];
       if (substitutionProcessCodes)
         processCodes.push(...substitutionProcessCodes);
       if (tieMatchUp)
@@ -55584,7 +55616,7 @@ function removeTieMatchUpParticipantId(params) {
     drawDefinition,
     event
   });
-  const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] || POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const matchUpActionsPolicy = params.policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
   const substitutionProcessCodes = matchUpActionsPolicy?.processCodes?.substitution;
   const {
     inContextDualMatchUp,
@@ -56208,24 +56240,34 @@ function addEventEntryPairs({
 }
 
 function checkValidEntries({
-  enforceGender = true,
   consideredEntries,
+  policyDefinitions,
   tournamentRecord,
+  appliedPolicies,
+  participantMap,
+  enforceGender,
   participants,
   event
 }) {
-  participants = participants || tournamentRecord?.participants;
+  if ((!participants || !participantMap) && tournamentRecord) {
+    ({ participants, participantMap } = getParticipants$1({
+      tournamentRecord
+    }));
+  }
   if (!participants)
     return { error: MISSING_PARTICIPANTS };
   if (!Array.isArray(participants))
     return { error: INVALID_VALUES };
   if (!event)
     return { error: MISSING_EVENT };
+  const matchUpActionsPolicy = policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const { eventType, gender: eventGender } = event;
-  const participantType = eventType === TEAM_EVENT && TEAM || eventType === DOUBLES_EVENT && PAIR || INDIVIDUAL;
+  const isDoubles = eventType === DOUBLES_EVENT;
+  const participantType = eventType === TEAM_EVENT && TEAM || isDoubles && PAIR || INDIVIDUAL;
   const entryStatusMap = Object.assign(
     {},
-    ...(consideredEntries || event.entries || []).map((entry) => ({
+    ...(consideredEntries ?? event.entries ?? []).map((entry) => ({
       [entry.participantId]: entry.entryStatus
     }))
   );
@@ -56237,9 +56279,14 @@ function checkValidEntries({
     const entryStatus = entryStatusMap[participant.participantId];
     const ungroupedParticipant = eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(eventType) && participant.participantType === INDIVIDUAL && (isUngrouped(entryStatus) || entryStatus === WITHDRAWN);
     const mismatch = participant.participantType !== participantType && !ungroupedParticipant;
+    const pairGender = !mismatch && isDoubles && unique(
+      participant?.individualParticipantIds?.map((id) => participantMap?.[id]?.participant?.person?.sex).filter(Boolean) ?? []
+    );
+    const validPairGender = !eventGender || !pairGender?.length || GenderEnum.Any === eventGender || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && pairGender[0] === eventGender || GenderEnum.Mixed === eventGender && (pairGender.length == 1 && participant.individualParticipantIds?.length === 1 || pairGender.length === 2);
     const personGender = participant?.person?.sex;
-    const wrongGender = enforceGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
-    return mismatch || wrongGender;
+    const validPersonGender = !participant?.person || !eventGender || [GenderEnum.Any, GenderEnum.Mixed].includes(eventGender) || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender === eventGender;
+    const validGender = !genderEnforced || validPairGender && validPersonGender;
+    return mismatch || !validGender;
   });
   if (invalidEntries.length) {
     const invalidParticipantIds = invalidEntries.map(
@@ -56247,7 +56294,7 @@ function checkValidEntries({
     );
     return { error: INVALID_ENTRIES, invalidParticipantIds };
   }
-  return { ...SUCCESS };
+  return { ...SUCCESS, valid: true };
 }
 
 function assignSeedPositions(params) {
@@ -58927,7 +58974,7 @@ function generateDrawDefinition(params) {
   }).appliedPolicies ?? {};
   const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
-  const { participants } = getParticipants$1({
+  const { participants, participantMap } = getParticipants$1({
     withIndividualParticipants: true,
     tournamentRecord
   });
@@ -58946,6 +58993,8 @@ function generateDrawDefinition(params) {
   const consideredEntries = (qualifyingOnly && [] || drawEntries || (considerEventEntries ? eventEntries : [])).filter(({ entryStage }) => !entryStage || entryStage === MAIN);
   const validEntriesResult = event && participants && checkValidEntries({
     consideredEntries,
+    appliedPolicies,
+    participantMap,
     enforceGender,
     participants,
     event
@@ -59369,6 +59418,25 @@ function generateDrawDefinition(params) {
   };
 }
 
+function isValidForQualifying({ structureId, drawDefinition }) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!isString(structureId))
+    return { error: INVALID_VALUES };
+  const result = getStructureLinks({
+    drawDefinition,
+    structureId
+  });
+  if (result.error)
+    return result;
+  const targetFeedProfiles = result.links.target.flatMap((t) => t.target.feedProfile).filter(Boolean);
+  const valid = !!intersection(
+    [BOTTOM_UP, TOP_DOWN, RANDOM],
+    targetFeedProfiles
+  ).length;
+  return { ...SUCCESS, valid };
+}
+
 function renameStructures(params) {
   return renameStructures$1(params);
 }
@@ -59566,6 +59634,7 @@ const eventGovernor = {
   attachQualifyingStructure,
   attachPlayoffStructures,
   addQualifyingStructure,
+  isValidForQualifying,
   setStructureOrder,
   attachStructures,
   renameStructures,