declare function factoryVersion(): string; type ServerRule$1 = 'ALTERNATE_GAMES' | 'WINNER_SERVES'; interface competitionFormat { competitionFormatId?: string; competitionFormatName?: string; matchUpFormat?: string; sport?: SportUnion; timerProfile?: TimerProfile$1; timeoutRules?: TimeoutRules$1; substitutionRules?: SubstitutionRules$1; playerRules?: PlayerRules$1; penaltyProfile?: PenaltyProfile$1; penaltyBoxProfile?: PenaltyBoxProfile$1; pointProfile?: PointProfile$1; pointMultipliers?: PointMultiplier$1[]; serverRule?: ServerRule$1; extensions?: Extension[]; notes?: string; } type SportUnion = 'TENNIS' | 'PADEL' | 'PICKLEBALL' | 'SQUASH' | 'BADMINTON' | 'TABLE_TENNIS' | 'INTENNSE' | 'TYPTI' | 'VOLLEYBALL' | 'FENCING' | 'OTHER'; interface TimerProfile$1 { shotClockSeconds?: number; segmentTimers?: SegmentTimer[]; changeoverSeconds?: number; setBreakSeconds?: number; } interface SegmentTimer { segmentType: 'set' | 'half' | 'quarter' | 'period' | 'round' | 'frame' | 'map'; minutes: number; direction?: 'up' | 'down'; stoppageTime?: boolean; } type TimeoutScope = 'MATCHUP' | 'SET' | 'HALF' | 'SEGMENT'; interface TimeoutRules$1 { count: number; per: TimeoutScope; durationSeconds?: number; maxPerSide?: number; } type SubstitutionTiming = 'BETWEEN_GAMES' | 'BETWEEN_POINTS' | 'ANY'; interface SubstitutionRules$1 { allowed: boolean; maxPerMatchUp?: number; maxPerSegment?: number; allowedMatchUpTypes?: ('SINGLES' | 'DOUBLES')[]; timing?: SubstitutionTiming; minRosterSize?: number; maxRosterSize?: number; } interface PlayerRules$1 { maxMinutesPerSegment?: number; matchUpTypes?: ('SINGLES' | 'DOUBLES')[]; } interface PenaltyProfile$1 { sport?: SportUnion; penaltyTypes: PenaltyTypeDefinition[]; escalation?: PenaltyEscalation[]; } interface PenaltyTypeDefinition { penaltyType: string; label: string; category?: 'code_violation' | 'time_violation' | 'conduct' | 'other'; } interface PenaltyEscalation { step: number; consequence: 'warning' | 'point' | 'game' | 'default'; } interface PenaltyBoxProfile$1 { durationSeconds: number; } interface PointProfile$1 { sport?: SportUnion; pointResults: PointResultDefinition[]; strokeTypes?: string[]; serveLocations?: string[]; } interface PointResultDefinition { result: string; label: string; isError?: boolean; isServe?: boolean; } interface PointMultiplier$1 { condition: { results?: string[]; strokes?: string[]; setTypes?: string[]; }; value: number; } interface Tournament { activeDates?: Date[] | string[]; createdAt?: Date | string; endDate?: string; events?: Event$1[]; extensions?: Extension[]; factory?: { version?: string; [key: string]: any; }; formalName?: string; hostCountryCode?: CountryCodeUnion; indoorOutdoor?: IndoorOutdoorUnion; isMock?: boolean; linkedTournamentIds?: string[]; localTimeZone?: string; matchUps?: MatchUp$1[]; notes?: string; onlineResources?: OnlineResource[]; parentOrganisationId?: string; parentOrganisation?: Organisation; participants?: Participant$1[]; processCodes?: string[]; promotionalName?: string; registrationProfile?: RegistrationProfile; scheduling?: { profile?: any; dailyLimits?: any; timing?: any; practice?: { defaultCapacity?: number | null; }; [key: string]: any; }; season?: string; startDate?: string; surfaceCategory?: SurfaceCategoryUnion; timeItems?: TimeItem[]; totalPrizeMoney?: PrizeMoney[]; tournamentCategories?: Category[]; tournamentGroups?: string[]; tournamentId: string; tournamentLevel?: TournamentLevelUnion; tournamentName?: string; tournamentOtherIds?: UnifiedTournamentID[]; tournamentRank?: string; tournamentStatus?: TournamentStatusUnion; tournamentTier?: TierClassification; updatedAt?: Date | string; venues?: Venue[]; weekdays?: WeekdayUnion[]; } type TournamentStatusUnion = 'ABANDONDED' | 'CANCELLED' | 'ACTIVE' | 'COMPLETED'; interface Organisation { onlineResources?: OnlineResource[]; organisationAbbreviation: string; parentOrganisationId?: string; extensions?: Extension[]; organisationName: string; organisationId: string; notes?: string; } interface Event$1 { activeDates?: Date[] | string[]; allowedDrawTypes?: DrawTypeUnion[]; category?: Category; competitionFormat?: competitionFormat; createdAt?: Date | string; discipline?: DisciplineUnion; drawDefinitions?: DrawDefinition[]; endDate?: string; entries?: Entry[]; eventAbbreviation?: string; eventId: string; eventLevel?: TournamentLevelUnion; eventName?: string; eventOrder?: number; eventRank?: string; eventTier?: TierClassification; eventType?: EventTypeUnion; extensions?: Extension[]; flightProfile?: any; gender?: GenderUnion; indoorOutdoor?: IndoorOutdoorUnion; isMock?: boolean; links?: DrawLink[]; matchUpFormat?: string; notes?: string; processCodes?: string[]; startDate?: string; surfaceCategory?: SurfaceCategoryUnion; tennisOfficialIds?: string[]; tieFormat?: TieFormat; tieFormatId?: string; tieFormats?: TieFormat[]; timeItems?: TimeItem[]; updatedAt?: Date | string; weekdays?: WeekdayUnion[]; wheelchairClass?: WheelchairClassUnion; } declare const DrawTypeEnum: { readonly AD_HOC: "AD_HOC"; readonly ADAPTIVE: "ADAPTIVE"; readonly COMPASS: "COMPASS"; readonly CURTIS_cONSOLATION: "CURTIS_CONSOLATION"; readonly DOUBLE_eLIMINATION: "DOUBLE_ELIMINATION"; readonly FEED_IN: "FEED_IN"; readonly FEED_IN_CHAMPIONSHIP: "FEED_IN_CHAMPIONSHIP"; readonly FEED_IN_CHAMPIONSHIP_TO_QF: "FEED_IN_CHAMPIONSHIP_TO_QF"; readonly FEED_IN_CHAMPIONSHIP_TO_R16: "FEED_IN_CHAMPIONSHIP_TO_R16"; readonly FEED_In_CHAMPIONSHIP_TO_SF: "FEED_IN_CHAMPIONSHIP_TO_SF"; readonly FIRST_MATCH_LOSER_CONSOLATION: "FIRST_MATCH_LOSER_CONSOLATION"; readonly FIRST_ROUND_LOSER_CONSOLATION: "FIRST_ROUND_LOSER_CONSOLATION"; readonly MODIFIED_FEED_IN_CHAMPIONSHIP: "MODIFIED_FEED_IN_CHAMPIONSHIP"; readonly LUCKY_DRAW: "LUCKY_DRAW"; readonly OLYMPIC: "OLYMPIC"; readonly OTHER: "OTHER"; readonly PAGE_PLAYOFF: "PAGE_PLAYOFF"; readonly PLAYOFF: "PLAYOFF"; readonly ROUND_ROBIN: "ROUND_ROBIN"; readonly ROUND_ROBIN_WITH_PLAYOFF: "ROUND_ROBIN_WITH_PLAYOFF"; readonly SINGLE_ELIMINATION: "SINGLE_ELIMINATION"; readonly SWISS: "SWISS"; }; type DrawTypeUnion = keyof typeof DrawTypeEnum; interface Category { ageCategoryCode?: string; ageMax?: number; ageMaxDate?: string; ageMin?: number; ageMinDate?: string; ballType?: BallTypeUnion; categoryName?: string; categoryType?: string; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; ratingMax?: number; ratingMin?: number; ratingType?: string; subType?: string; timeItems?: TimeItem[]; type?: CategoryUnion; updatedAt?: Date | string; } declare enum BallTypeEnum { HIGH_ALTITUDE = "HIGH_ALTITUDE", Stage1Green = "STAGE1GREEN", Stage2Orange = "STAGE2ORANGE", Stage3Red = "STAGE3RED", T2STANDARD_PRESSURELESS = "T2STANDARD_PRESSURELESS", T2STANDARD_PRESSURISED = "T2STANDARD_PRESSURISED", TYPE1FAST = "TYPE1FAST", TYPE3SLOW = "TYPE3SLOW" } type BallTypeUnion = keyof typeof BallTypeEnum; interface Extension { description?: string; name: string; value: any; } interface TimeItem { createdAt?: Date | string; itemDate?: Date | string; itemSubTypes?: string[]; itemType?: string; itemValue?: any; } type DisciplineUnion = 'BEACH_TENNIS' | 'TENNIS' | 'WHEELCHAIR_TENNIS'; type CategoryUnion = 'AGE' | 'BOTH' | 'LEVEL'; interface DrawDefinition { activeDates?: Date[] | string[]; automated?: boolean; competitionFormat?: competitionFormat; createdAt?: Date | string; drawId: string; drawName?: string; drawOrder?: number; drawRepresentativeIds?: string[]; drawStatus?: DrawStatusUnion; drawType?: DrawTypeUnion; endDate?: string; entries?: Entry[]; extensions?: Extension[]; competitionState?: any; draftState?: any; flightProfile?: any; flightNumber?: number; isMock?: boolean; lineUps?: any; links?: DrawLink[]; matchUpFormat?: string; matchUps?: MatchUp$1[]; matchUpType?: EventTypeUnion; notes?: string; processCodes?: string[]; startDate?: string; structures?: Structure[]; tieFormat?: TieFormat; tieFormatId?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } type DrawStatusUnion = 'COMPLETE' | 'IN_PROGRESS' | 'TO_BE_PLAYED'; interface Entry { createdAt?: Date | string; entryId?: string; entryPosition?: number; entryStage?: StageTypeUnion; entryStageSequence?: number; entryStatus?: EntryStatusUnion; extensions?: Extension[]; isMock?: boolean; notes?: string; participantId: string; roundTarget?: number; timeItems?: TimeItem[]; updatedAt?: Date | string; scaleValue?: number; } declare enum StageTypeEnum { CONSOLATION = "CONSOLATION", MAIN = "MAIN", PLAY_OFF = "PLAY_OFF", QUALIFYING = "QUALIFYING", VOLUNTARY_CONSOLATION = "VOLUNTARY_CONSOLATION" } type StageTypeUnion = keyof typeof StageTypeEnum; declare enum EntryStatusEnum { ALTERNATE = "ALTERNATE", CONFIRMED = "CONFIRMED", DIRECT_ACCEPTANCE = "DIRECT_ACCEPTANCE", FEED_IN = "FEED_IN", JUNIOR_EXEMPT = "JUNIOR_EXEMPT", LUCKY_LOSER = "LUCKY_LOSER", ORGANISER_ACCEPTANCE = "ORGANISER_ACCEPTANCE", QUALIFIER = "QUALIFIER", REGISTERED = "REGISTERED", SPECIAL_EXEMPT = "SPECIAL_EXEMPT", UNGROUPED = "UNGROUPED", UNPAIRED = "UNPAIRED", WILDCARD = "WILDCARD", WITHDRAWN = "WITHDRAWN" } type EntryStatusUnion = keyof typeof EntryStatusEnum; interface DrawLink { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; linkCondition?: string; linkType: LinkTypeUnion; notes?: string; source: DrawLinkSource; target: DrawLinkTarget; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum LinkTypeEnum { LOSER = "LOSER", POSITION = "POSITION", WINNER = "WINNER" } type LinkTypeUnion = keyof typeof LinkTypeEnum; interface DrawLinkSource { bestOf?: number; createdAt?: Date | string; drawId?: string; extensions?: Extension[]; finishingPositions?: number[]; isMock?: boolean; notes?: string; rankBy?: string; qualifyingPositions?: number; remainder?: boolean; roundNumber?: number; structureId: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface DrawLinkTarget { createdAt?: Date | string; drawId?: string; extensions?: Extension[]; feedProfile: PositioningProfileUnion; groupedOrder?: number[]; isMock?: boolean; notes?: string; positionInterleave?: Interleave; roundNumber: number; structureId: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum PositioningProfileEnum { BOTTOM_UP = "BOTTOM_UP", DRAW = "DRAW", LOSS_POSITION = "LOSS_POSITION", RANDOM = "RANDOM", TOP_DOWN = "TOP_DOWN", WATERFALL = "WATERFALL" } type PositioningProfileUnion = keyof typeof PositioningProfileEnum; declare enum SeedingProfileEnum { CLUSTER = "CLUSTER", SEPARATE = "SEPARATE", WATERFALL = "WATERFALL" } type SeedingProfileUnion = keyof typeof SeedingProfileEnum; interface Interleave { interleave: number; offset: number; } type EventTypeUnion = 'SINGLES' | 'DOUBLES' | 'TEAM' | 'HYBRID'; interface MatchUpSchedule { allocatedCourts?: any[]; calledAt?: string; courtAnnotation?: string; courtId?: string; courtOrder?: number; homeParticipantId?: string; official?: any; scheduledDate?: string; scheduledTime?: string; timeModifiers?: string[]; venueId?: string; [key: string]: any; } interface MatchUp$1 { collectionId?: string; collectionPosition?: number; createdAt?: Date | string; delegatedOutcome?: any; disableAutoCalc?: boolean; drawPositions?: number[]; endDate?: string; extensions?: Extension[]; finishingPositionRange?: MatchUpFinishingPositionRange; finishingRound?: number; indoorOutdoor?: IndoorOutdoorUnion; isMock?: boolean; loserMatchUpId?: string; matchUpDuration?: string; matchUpFormat?: string; matchUpId: string; matchUpStatus?: MatchUpStatusUnion; matchUpStatusCodes?: any[]; matchUpType?: EventTypeUnion; notes?: string; orderOfFinish?: number; processCodes?: string[]; roundName?: string; roundNumber?: number; roundPosition?: number; schedule?: MatchUpSchedule; score?: Score$1; sides?: Side$1[]; startDate?: string; surfaceCategory?: SurfaceCategoryUnion; tieFormat?: TieFormat; tieFormatId?: string; tieMatchUps?: MatchUp$1[]; timeItems?: TimeItem[]; updatedAt?: Date | string; winnerMatchUpId?: string; winningSide?: number; } interface MatchUpFinishingPositionRange { loser: number[]; winner: number[]; } type IndoorOutdoorUnion = 'INDOOR' | 'MIXED' | 'OUTDOOR'; declare enum MatchUpStatusEnum { ABANDONED = "ABANDONED", AWAITING_RESULT = "AWAITING_RESULT", BYE = "BYE", CANCELLED = "CANCELLED", COMPLETED = "COMPLETED", DEAD_RUBBER = "DEAD_RUBBER", DEFAULTED = "DEFAULTED", DOUBLE_DEFAULT = "DOUBLE_DEFAULT", DOUBLE_WALKOVER = "DOUBLE_WALKOVER", IN_PROGRESS = "IN_PROGRESS", INCOMPLETE = "INCOMPLETE", NOT_PLAYED = "NOT_PLAYED", RETIRED = "RETIRED", SUSPENDED = "SUSPENDED", TO_BE_PLAYED = "TO_BE_PLAYED", WALKOVER = "WALKOVER" } type MatchUpStatusUnion = keyof typeof MatchUpStatusEnum; interface Score$1 { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; scoreStringSide1?: string; scoreStringSide2?: string; sets?: Set[]; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface Set { createdAt?: Date | string; extensions?: Extension[]; games?: Game[]; isMock?: boolean; notes?: string; setDuration?: string; setFormat?: string; setNumber?: number; side1PointScore?: number | string; side1Score?: number; side1TiebreakScore?: number; side2PointScore?: number | string; side2Score?: number; side2TiebreakScore?: number; timeItems?: TimeItem[]; updatedAt?: Date | string; winningSide?: number; } interface Game { createdAt?: Date | string; extensions?: Extension[]; gameDuration?: string; gameFormat?: string; gameNumber?: number; isMock?: boolean; notes?: string; points?: Point$1[]; timeItems?: TimeItem[]; updatedAt?: Date | string; winningSide?: number; winReason?: WinReasonUnion; } interface Point$1 { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; pointDuration?: string; pointNumber?: number; shots?: Shot[]; side1Score?: string; side2Score?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; winningSide?: number; winReason?: WinReasonUnion; } interface Shot { bounceAt?: CourtPosition; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; participantId: string; shotDetail?: ShotDetailUnion; shotMadeFrom?: CourtPosition; shotNumber?: number; shotOutcome?: ShotOutcomeUnion; shotType?: ShotTypeUnion; sideNumber?: number; speed?: number; spin?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface CourtPosition { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; positionName?: CourtPositionUnion; timeAtPosition?: Date | string; timeItems?: TimeItem[]; updatedAt?: Date | string; x?: number; y?: number; } declare enum CourtPositionEnum { BaSELINE = "BASELINE", LEFT_SERVICE_COURT = "LEFT_SERVICE_COURT", NET = "NET", RIGHT_SERVICE_COURT = "RIGHT_SERVICE_COURT", SERVICELINE = "SERVICELINE" } type CourtPositionUnion = keyof typeof CourtPositionEnum; declare enum ShotDetailEnum { DRIVE = "DRIVE", DRIVE_VOLLEY = "DRIVE_VOLLEY", DROP_SHOT = "DROP_SHOT", GROUND_STROKE = "GROUND_STROKE", HALF_VOLLEY = "HALF_VOLLEY", LOB = "LOB", PASSING_SHOT = "PASSING_SHOT", SMASH = "SMASH", TRICK = "TRICK", VOLLEY = "VOLLEY" } type ShotDetailUnion = keyof typeof ShotDetailEnum; declare enum ShotOutcomeEnum { IN = "IN", LET = "LET", NET = "NET", OUT = "OUT" } type ShotOutcomeUnion = keyof typeof ShotOutcomeEnum; declare enum ShotTypeEnum { BACKHAND = "BACKHAND", FOREHAND = "FOREHAND", SERVE = "SERVE" } type ShotTypeUnion = keyof typeof ShotTypeEnum; declare enum WinReasonEnum { ACE = "ACE", DOUBLE_FAULT = "DOUBLE_FAULT", ERROR = "ERROR", FORCED = "FORCED", NETcORD = "NET_CORD", PENALTY = "PENALTY", UNFORCED = "UNFORCED", WINNER = "WINNER" } type WinReasonUnion = keyof typeof WinReasonEnum; interface Side$1 { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; lineUp?: TeamCompetitor$1[]; notes?: string; participantId?: string; participant?: Participant$1; sideNumber?: number; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface TeamCompetitor$1 { collectionAssignments?: CollectionAssignment$1[]; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; participantId: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface Team { gender?: GenderEnum; homeVenueIds?: string[]; nativeTeamName?: string; otherTeamNames?: string[]; parentOrganisationId?: string; personIds?: string[]; previousTeamNames?: string[]; teamId: string; teamName?: string; } interface CollectionAssignment$1 { collectionId: string; collectionPosition: number; previousParticipantId?: string; substitutionOrder?: number; } declare enum SurfaceCategoryEnum { ARTIFICIAL = "ARTIFICIAL", CARPET = "CARPET", CLAY = "CLAY", GRASS = "GRASS", HARD = "HARD" } type SurfaceCategoryUnion = keyof typeof SurfaceCategoryEnum; interface TieFormat { collectionDefinitions: CollectionDefinition[]; collectionGroups?: CollectionGroup[]; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; tieFormatId?: string; tieFormatName?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; winCriteria: WinCriteria; } interface CollectionDefinition { collectionValueProfiles?: CollectionValueProfile[]; collectionGroupNumber?: number; category?: Category; collectionId: string; collectionName?: string; collectionOrder?: number; collectionValue?: number; createdAt?: Date | string; extensions?: Extension[]; gender?: GenderUnion; isMock?: boolean; matchUpCount?: number; matchUpFormat?: string; matchUpType?: EventTypeUnion; matchUpValue?: number; notes?: string; processCodes?: string[]; scoreValue?: number; setValue?: number; timeItems?: TimeItem[]; updatedAt?: Date | string; winCriteria?: WinCriteria; } interface CollectionValueProfile { collectionPosition: number; createdAt?: Date | string; updatedAt?: Date | string; extensions?: Extension[]; timeItems?: TimeItem[]; matchUpValue: number; isMock?: boolean; notes?: string; } declare enum GenderEnum { FEMALE_ABBR = "F", MIXED_ABBR = "X", MALE_ABBR = "M", ANY_ABBR = "A", FEMALE = "FEMALE", OTHER = "OTHER", MIXED = "MIXED", MALE = "MALE", ANY = "ANY" } type GenderUnion = keyof typeof GenderEnum; interface WinCriteria { aggregateValue?: boolean; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; valueGoal: number; } interface CollectionGroup { createdAt?: Date | string; extensions?: Extension[]; groupName?: string; groupNumber: number; groupValue?: number; isMock?: boolean; notes?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; winCriteria?: WinCriteria; } interface Structure { competitionFormat?: competitionFormat; createdAt?: Date | string; extensions?: Extension[]; finishingPosition?: FinishingPositionUnion; isMock?: boolean; matchUpFormat?: string; matchUps?: MatchUp$1[]; matchUpType?: EventTypeUnion; notes?: string; positionAssignments?: PositionAssignment[]; processCodes?: string[]; qualifyingRoundNumber?: number; roundLimit?: number; roundOffset?: number; roundTarget?: number; seedAssignments?: SeedAssignment[]; seedingProfile?: SeedingProfileUnion; seedLimit?: number; stage?: StageTypeUnion; stageSequence?: number; structureAbbreviation?: string; structureId: string; structureName?: string; structures?: Structure[]; structureOrder?: number; structureType?: StructureTypeUnion; tieFormat?: TieFormat; tieFormatId?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum FinishingPositionEnum { ROUND_OUTCOME = "ROUND_OUTCOME", WIN_RATIO = "WIN_RATIO" } type FinishingPositionUnion = keyof typeof FinishingPositionEnum; interface TallyResult { GEMscore?: number; allDefaults?: number; defaults?: number; defeats?: any[]; gamesLost?: number; gamesPct?: number; gamesWon?: number; groupOrder?: number; matchUpsCancelled?: number; matchUpsLost?: number; matchUpsPct?: number; matchUpsWon?: number; pointsLost?: number; pointsPct?: number; pointsWon?: number; pressureOrder?: number; pressureScores?: number[]; provisionalOrder?: number; rankOrder?: number; retirements?: number; setsLost?: number; setsPct?: number; setsWon?: number; subOrder?: number; tieDoublesLost?: number; tieDoublesWon?: number; tieMatchUpsLost?: number; tieMatchUpsWon?: number; tieSinglesLost?: number; tieSinglesWon?: number; ties?: number; victories?: any[]; walkovers?: number; [key: string]: any; } interface PositionAssignment { bye?: boolean; createdAt?: Date | string; disableLinks?: boolean; drawPosition: number; extensions?: Extension[]; isMock?: boolean; notes?: string; participantId?: string; qualifier?: boolean; tally?: TallyResult; subOrder?: number; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface SeedAssignment { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; participantId?: string; seedNumber: number; seedValue: number | string; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum StructureTypeEnum { CONTAINER = "CONTAINER", ITEM = "ITEM" } type StructureTypeUnion = keyof typeof StructureTypeEnum; interface TierClassification { system: string; value: string; numericRank?: number; } declare enum TournamentLevelEnum { CLUB = "CLUB", DISTRICT = "DISTRICT", INTERNATIONAL = "INTERNATIONAL", LOCAL = "LOCAL", NATIONAL = "NATIONAL", Recreational = "RECREATIONAL", REGIONAL = "REGIONAL", ZONAL = "ZONAL" } type TournamentLevelUnion = keyof typeof TournamentLevelEnum; declare enum WheelchairClassEnum { QUAD = "QUAD", STANDARD = "STANDARD" } type WheelchairClassUnion = keyof typeof WheelchairClassEnum; declare enum CountryCodeEnum { ASM = "ASM", ATA = "ATA", Abw = "ABW", Afg = "AFG", Ago = "AGO", Aia = "AIA", Ala = "ALA", Alb = "ALB", And = "AND", Ant = "ANT", Are = "ARE", Arg = "ARG", Arm = "ARM", Atf = "ATF", Atg = "ATG", Aus = "AUS", Aut = "AUT", Aze = "AZE", Bdi = "BDI", Bel = "BEL", Ben = "BEN", Bfa = "BFA", Bgd = "BGD", Bgr = "BGR", Bhr = "BHR", Bhs = "BHS", Bih = "BIH", Blm = "BLM", Blr = "BLR", Blz = "BLZ", Bmu = "BMU", Bol = "BOL", Bra = "BRA", Brb = "BRB", Brn = "BRN", Btn = "BTN", Bvt = "BVT", Bwa = "BWA", COM = "COM", Caf = "CAF", Can = "CAN", Cck = "CCK", Cgd = "CGD", Che = "CHE", Chl = "CHL", Chn = "CHN", Civ = "CIV", Cmr = "CMR", Cod = "COD", Cog = "COG", Cok = "COK", Col = "COL", Cpv = "CPV", Cri = "CRI", Cub = "CUB", Cuw = "CUW", Cxr = "CXR", Cym = "CYM", Cyp = "CYP", Cze = "CZE", DMA = "DMA", DOM = "DOM", Deu = "DEU", Dji = "DJI", Dnk = "DNK", Dza = "DZA", Ecu = "ECU", Egy = "EGY", Eri = "ERI", Ese = "ESE", Esh = "ESH", Esp = "ESP", Eth = "ETH", FSM = "FSM", Fin = "FIN", Fji = "FJI", Flk = "FLK", Fra = "FRA", Fro = "FRO", Gab = "GAB", Gbr = "GBR", Geo = "GEO", Ggy = "GGY", Gha = "GHA", Gib = "GIB", Gin = "GIN", Glp = "GLP", Gmb = "GMB", Gnb = "GNB", Gnq = "GNQ", Grc = "GRC", Grd = "GRD", Grl = "GRL", Gtm = "GTM", Guf = "GUF", Gum = "GUM", Guy = "GUY", Hkg = "HKG", Hmd = "HMD", Hnd = "HND", Hrv = "HRV", Hti = "HTI", Hun = "HUN", IRQ = "IRQ", ISR = "ISR", Idn = "IDN", Imn = "IMN", Ind = "IND", Iot = "IOT", Irl = "IRL", Irn = "IRN", Isl = "ISL", Ita = "ITA", Jam = "JAM", Jey = "JEY", Jor = "JOR", Jpn = "JPN", Kaz = "KAZ", Ken = "KEN", Kgz = "KGZ", Khm = "KHM", Kir = "KIR", Kna = "KNA", Kor = "KOR", Kos = "KOS", Kwt = "KWT", Lao = "LAO", Lbn = "LBN", Lbr = "LBR", Lby = "LBY", Lca = "LCA", Lie = "LIE", Lka = "LKA", Lso = "LSO", Ltu = "LTU", Lux = "LUX", Lva = "LVA", MAC = "MAC", MDA = "MDA", MNG = "MNG", Maf = "MAF", Mar = "MAR", Mco = "MCO", Mdg = "MDG", Mdv = "MDV", Mex = "MEX", Mhl = "MHL", Mkd = "MKD", Mli = "MLI", Mlt = "MLT", Mmr = "MMR", Mne = "MNE", Mnp = "MNP", Moz = "MOZ", Mrt = "MRT", Msr = "MSR", Mtq = "MTQ", Mus = "MUS", Mwi = "MWI", Mys = "MYS", Myt = "MYT", NIC = "NIC", NPL = "NPL", Nam = "NAM", Ncl = "NCL", Ner = "NER", Nfk = "NFK", Nga = "NGA", Niu = "NIU", Nld = "NLD", Nmp = "NMP", Nor = "NOR", Nru = "NRU", Nzl = "NZL", Omn = "OMN", PNG = "PNG", Pak = "PAK", Pan = "PAN", Pcn = "PCN", Per = "PER", Phl = "PHL", Plw = "PLW", Pol = "POL", Pri = "PRI", Prk = "PRK", Prt = "PRT", Pry = "PRY", Pse = "PSE", Pyf = "PYF", Qat = "QAT", Reu = "REU", Rou = "ROU", Rus = "RUS", Rwa = "RWA", SDN = "SDN", SPM = "SPM", SSD = "SSD", Sau = "SAU", Sen = "SEN", Sgp = "SGP", Sgs = "SGS", Shn = "SHN", Sjm = "SJM", Slb = "SLB", Sle = "SLE", Slv = "SLV", Smr = "SMR", Smx = "SMX", Som = "SOM", Srb = "SRB", Stp = "STP", Sur = "SUR", Svk = "SVK", Svn = "SVN", Swe = "SWE", Swz = "SWZ", Syc = "SYC", Syr = "SYR", TLS = "TLS", Tca = "TCA", Tcd = "TCD", Tgo = "TGO", Tha = "THA", Tjk = "TJK", Tkl = "TKL", Tkm = "TKM", Ton = "TON", Tto = "TTO", Tun = "TUN", Tur = "TUR", Tuv = "TUV", Twn = "TWN", Tza = "TZA", Uga = "UGA", Ukr = "UKR", Umi = "UMI", Ury = "URY", Usa = "USA", Uzb = "UZB", Vat = "VAT", Vct = "VCT", Ven = "VEN", Vgb = "VGB", Vir = "VIR", Vnm = "VNM", Vut = "VUT", Wlf = "WLF", Wsm = "WSM", Yem = "YEM", Zaf = "ZAF", Zmb = "ZMB", Zwe = "ZWE" } type CountryCodeUnion = `${CountryCodeEnum}`; interface OnlineResource { createdAt?: Date | string; extensions?: Extension[]; identifier?: string; isMock?: boolean; name?: string; notes?: string; provider?: string; resourceSubType?: string; resourceType?: OnlineResourceTypeUnion; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum OnlineResourceTypeEnum { EMAIL = "EMAIL", OTHER = "OTHER", SOCIAl_MEDIA = "SOCIAL_MEDIA", URL = "URL" } type OnlineResourceTypeUnion = keyof typeof OnlineResourceTypeEnum; interface Participant$1 { contacts?: Contact[]; createdAt?: Date | string; extensions?: Extension[]; homeVenueIds?: string[]; individualParticipantIds?: string[]; isMock?: boolean; notes?: string; onlineResources?: OnlineResource[]; participantId: string; participantName?: string; participantOtherName?: string; participantRole?: ParticipantRoleUnion; participantRoleResponsibilities?: string[]; participantStatus?: ParticipantStatusUnion; participantType?: ParticipantTypeUnion; penalties?: Penalty[]; person?: Person$1; personId?: string; representing?: CountryCodeUnion; teamId?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; useOtherName?: boolean; } interface Contact { createdAt?: Date | string; emailAddress?: string; extensions?: Extension[]; fax?: string; isMock?: boolean; isPublic?: boolean; mobileTelephone?: string; name?: string; notes?: string; telephone?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum ParticipantRoleEnum { ADMINISTRATION = "ADMINISTRATION", CAPTAIN = "CAPTAIN", COACH = "COACH", COMPETITOR = "COMPETITOR", DIRECTOR = "DIRECTOR", HOSPITALITY = "HOSPITALITY", MEDIA = "MEDIA", MEDICAL = "MEDICAL", OFFICIAL = "OFFICIAL", OTHER = "OTHER", PHYSIO = "PHYSIO", SECURITY = "SECURITY", STRINGER = "STRINGER", SUPERVISOR = "SUPERVISOR", TRAINER = "TRAINER", TRANSPORT = "TRANSPORT", VOLUNTEER = "VOLUNTEER" } type ParticipantRoleUnion = keyof typeof ParticipantRoleEnum; declare enum ParticipantStatusEnum { ACTIVE = "ACTIVE", WITHDRAWN = "WITHDRAWN" } type ParticipantStatusUnion = keyof typeof ParticipantStatusEnum; declare enum ParticipantTypeEnum { GROUP = "GROUP", INDIVIDUAL = "INDIVIDUAL", PAIR = "PAIR", TEAM = "TEAM" } type ParticipantTypeUnion = keyof typeof ParticipantTypeEnum; interface Penalty { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; issuedAt?: string; matchUpId?: string; notes?: string; penaltyCode?: string; penaltyId: string; penaltyType: PenaltyTypeUnion; refereeParticipantId?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } declare enum PenaltyTypeEnum { BALL_ABUSE = "BALL_ABUSE", COACHING = "COACHING", DRESS_CODE_VIOLATION = "DRESS_CODE_VIOLATION", EQUIMENT_VIOLATION = "EQUIMENT_VIOLATION", FAILUIRE_TO_SIGN_IN = "FAILUIRE_TO_SIGN_IN", FAILURE_TO_COMPLETE = "FAILURE_TO_COMPLETE", INELIGIBILITY = "INELIGIBILITY", LEAVING_THE_COURT = "LEAVING_THE_COURT", NO_SHOW = "NO_SHOW", OTHER = "OTHER", PHYSICAL_ABUSE = "PHYSICAL_ABUSE", PROHIBITED_SUBSTANCE = "PROHIBITED_SUBSTANCE", PUNCTUALITY = "PUNCTUALITY", RACKET_ABUSE = "RACKET_ABUSE", REFUSAL_TO_PLAY = "REFUSAL_TO_PLAY", UNSPORTSMANLIKE_CONDUCT = "UNSPORTSMANLIKE_CONDUCT", VERBAL_ABUSE = "VERBAL_ABUSE" } type PenaltyTypeUnion = keyof typeof PenaltyTypeEnum; interface Person$1 { addresses?: Address[]; biographicalInformation?: BiographicalInformation; birthDate?: string; birthYear?: number; contacts?: Contact[]; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; nationalityCode?: string; nativeFamilyName?: string; nativeGivenName?: string; notes?: string; onlineResources?: OnlineResource[]; otherNames?: string[]; parentOrganisationId?: string; passportFamilyName?: string; passportGivenName?: string; personId: string; personOtherIds?: UnifiedPersonID[]; previousNames?: string[]; sectionId?: string; sex?: SexUnion; standardFamilyName?: string; standardGivenName?: string; status?: string; tennisId?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; wheelchair?: boolean; } interface Address { addressLine1?: string; addressLine2?: string; addressLine3?: string; addressName?: string; addressType?: AddressTypeUnion; city?: string; countryCode?: CountryCodeUnion; createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; latitude?: string; longitude?: string; notes?: string; postalCode?: string; state?: string; timeItems?: TimeItem[]; timeZone?: string; updatedAt?: Date | string; } declare enum AddressTypeEnum { HOME = "HOME", MAIL = "MAIL", PRIMARY = "PRIMARY", RESIDENTIAL = "RESIDENTIAL", VENUE = "VENUE", WORK = "WORK" } type AddressTypeUnion = keyof typeof AddressTypeEnum; interface TeamAttribute { teamId?: string; teamName?: string; jerseyNumber?: string; jerseyName?: string; position?: string; captain?: boolean; } interface BiographicalInformation { ageBeganTennis?: number; ageTurnedPro?: number; birthCountryCode?: CountryCodeUnion; coachId?: string; createdAt?: Date | string; doublePlayingHand?: PlayingDoubleHandCodeUnion; extensions?: Extension[]; height?: number; heightUnit?: LengthUnitUnion; isMock?: boolean; notes?: string; organisationIds?: string[]; placeOfResidence?: string; playingHand?: PlayingHandCodeUnion; residenceCountryCode?: CountryCodeUnion; teamAttributes?: TeamAttribute[]; timeItems?: TimeItem[]; updatedAt?: Date | string; weight?: number; weightUnit?: WeightUnitEnum; } declare enum PlayingDoubleHandCodeEnum { BACKHAND = "BACKHAND", BOTH = "BOTH", FOREHAND = "FOREHAND", NONE = "NONE" } type PlayingDoubleHandCodeUnion = keyof typeof PlayingDoubleHandCodeEnum; declare enum LengthUnitEnum { CENTIMETER = "CENTIMETER", METER = "METER", MILLIMETER = "MILLIMETER" } type LengthUnitUnion = keyof typeof LengthUnitEnum; declare enum PlayingHandCodeEnum { AMBIDEXTROUS = "AMBIDEXTROUS", LEFT = "LEFT", RIGHT = "RIGHT" } type PlayingHandCodeUnion = keyof typeof PlayingHandCodeEnum; declare enum WeightUnitEnum { GRAM = "GRAM", KILOGRAM = "KILOGRAM" } type WeightUnitUnion = keyof typeof WeightUnitEnum; interface UnifiedPersonID { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; organisationId: string; personId: string; timeItems?: TimeItem[]; uniqueOrganisationName?: string; updatedAt?: Date | string; } declare enum SexEnum { FEMALE = "FEMALE", MALE = "MALE", OTHER = "OTHER" } type SexUnion = keyof typeof SexEnum; interface RegistrationProfile { createdAt?: Date | string; entriesClose?: Date | string; entriesOpen?: Date | string; updatedAt?: Date | string; withdrawalDeadline?: Date | string; eligibilityNotes?: string; entryFees?: RegistrationEntryFee[]; entryMethod?: string; entryUrl?: string; accommodation?: LogisticsSection; hospitality?: LogisticsSection; medicalInfo?: LogisticsSection; transportation?: LogisticsSection; contingencyPlan?: string; dressCode?: string; awardsCeremonyDate?: string; awardsDescription?: string; drawCeremonyDate?: string; socialEvents?: SocialEvent[]; codeOfConduct?: DocumentLink; regulations?: DocumentLink[]; sponsors?: Sponsor[]; extensions?: Extension[]; isMock?: boolean; notes?: string; timeItems?: TimeItem[]; } interface LogisticsSection { notes?: string; options?: LogisticsOption[]; } interface LogisticsOption { address?: string; description?: string; email?: string; extensions?: Extension[]; name: string; notes?: string; phone?: string; priceRange?: string; url?: string; } interface SocialEvent { date?: string; description?: string; location?: string; name: string; time?: string; } interface Sponsor { logoUrl?: string; name: string; tier?: string; websiteUrl?: string; } interface DocumentLink { description?: string; name: string; url?: string; } interface RegistrationEntryFee { amount: number; category?: string; currencyCode: string; eventType?: EventTypeUnion; extensions?: Extension[]; } interface PrizeMoney { amount: number; createdAt?: Date | string; currencyCode: string; extensions?: Extension[]; isMock?: boolean; notes?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface UnifiedTournamentID { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; organisationId: string; timeItems?: TimeItem[]; tournamentId: string; uniqueOrganisationName?: string; updatedAt?: Date | string; } interface Venue { addresses?: Address[]; contacts?: Contact[]; courts?: Court[]; createdAt?: Date | string; dateAvailability?: Availability[]; defaultEndTime?: string; defaultStartTime?: string; disabled?: boolean | { dates?: string[]; }; extensions?: Extension[]; isMock?: boolean; isPrimary?: boolean; notes?: string; onlineResources?: OnlineResource[]; parentOrganisationId?: string; roles?: string[]; subVenues?: Venue[]; timeItems?: TimeItem[]; updatedAt?: Date | string; venueAbbreviation?: string; venueId: string; venueName?: string; venueOtherIds?: UnifiedVenueID[]; venueType?: string; } interface Court { altitude?: number; courtDimensions?: string; courtId: string; courtName?: string; createdAt?: Date | string; dateAvailability?: Availability[]; disabled?: boolean | { dates?: string[]; }; extensions?: Extension[]; floodlit?: boolean; indoorOutdoor?: IndoorOutdoorUnion; isMock?: boolean; latitude?: string; longitude?: string; notes?: string; onlineResources?: OnlineResource[]; pace?: string; surfaceCategory?: SurfaceCategoryUnion; surfacedDate?: Date | string; surfaceType?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface Availability { bookings?: Booking[]; createdAt?: Date | string; date?: string; endTime?: string; extensions?: Extension[]; isMock?: boolean; notes?: string; startTime?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface Booking { bookingId?: string; bookingType?: string; capacity?: number | null; createdAt?: Date | string; endTime?: string; extensions?: Extension[]; isMock?: boolean; notes?: string; registrations?: PracticeRegistration[]; startTime?: string; timeItems?: TimeItem[]; updatedAt?: Date | string; } type PracticeRegistrationStatus = 'CONFIRMED' | 'CANCELLED'; interface PracticeRegistration { cancelledAt?: Date | string; createdAt?: Date | string; endTime: string; extensions?: Extension[]; notes?: string; participantId: string; registeredAt?: Date | string; registrationId: string; startTime: string; status?: PracticeRegistrationStatus; timeItems?: TimeItem[]; updatedAt?: Date | string; } interface UnifiedVenueID { createdAt?: Date | string; extensions?: Extension[]; isMock?: boolean; notes?: string; organisationId: string; timeItems?: TimeItem[]; uniqueOrganisationName?: string; updatedAt?: Date | string; venueId: string; } declare enum WeekdayEnum { MON = "MON", TUE = "TUE", WED = "WED", THU = "THU", FRI = "FRI", SAT = "SAT", SUN = "SUN" } type WeekdayUnion = keyof typeof WeekdayEnum; type HydratedCourt = { [key: string]: any; } & Court; type HydratedVenue = { [key: string]: any; } & Venue; interface HydratedMatchUp extends MatchUp$1 { [key: string | number]: any; structureId: string; drawId: string; eventId: string; tournamentId: string; sides?: HydratedSide[]; } type HydratedParticipant = { individualParticipants?: HydratedParticipant[]; [key: string | number]: any; } & Participant$1; type HydratedSide = Side$1 & { participant?: HydratedParticipant; [key: string | number]: any; }; interface QueryFacade { tournament(args?: any): Tournament | undefined; tournamentInfo(args?: any): any; tournamentTimeItem(args?: any): TimeItem | undefined; linkedTournamentIds(args?: any): string[] | undefined; policyDefinitions(args?: any): PolicyDefinitions | undefined; participants(args?: any): HydratedParticipant[]; event(args?: any): Event$1 | undefined; events(args?: any): Event$1[]; eventData(args?: any): any; eventRankingPoints(args?: any): any; flightProfile(args?: any): FlightProfile | undefined; drawDefinition(args?: any): DrawDefinition | undefined; draftState(args?: any): any; publishState(args?: any): any; availablePlayoffProfiles(args?: any): any[]; validGroupSizes(args?: any): number[]; assignedParticipantIds(args?: any): string[]; swissChart(args?: any): any; structureSeedAssignments(args?: any): any[]; positionAssignments(args?: any): any[]; matchUp(args?: any): HydratedMatchUp | undefined; matchUps(args?: any): HydratedMatchUp[]; drawMatchUps(args?: any): HydratedMatchUp[]; eventMatchUps(args?: any): HydratedMatchUp[]; competitionMatchUps(args?: any): HydratedMatchUp[]; matchUpsMap(args?: any): MatchUpsMap | undefined; venue(args?: any): Venue | undefined; venuesAndCourts(args?: any): Venue[]; tally(args?: any): any; extension(args?: any): Extension | undefined; competitionVenues(args?: any): Venue[]; competitionParticipants(args?: any): HydratedParticipant[]; } type Unwrap = Exclude; declare function unwrap(result: T, opts?: { methodName?: string; }): Unwrap; declare function unwrapOr(result: T, fallback: F): Unwrap | F; type JsonPatchOp = { op: 'add'; path: string; value: unknown; } | { op: 'remove'; path: string; } | { op: 'replace'; path: string; value: unknown; }; type JsonPatch = JsonPatchOp[]; declare function generatePatch(before: unknown, after: unknown): JsonPatch; type EmittedNotice = { topic: string; payloads: unknown[]; }; type DryRunResult = { wouldSucceed: boolean; results: any[]; patch: JsonPatch; willEmitNotices: EmittedNotice[]; error?: any; rolledBack: true; }; declare function dryRun(engine: FactoryEngine, directives: Directives): DryRunResult; type ExplainResult = { wouldSucceed: boolean; reason?: { code?: string; message?: string; info?: string; }; willEmitTopics: string[]; touchesPaths: string[]; detail: DryRunResult; }; declare function explain(engine: FactoryEngine, method: string, params?: Record): ExplainResult; interface EngineInspectionCounts { tournaments: number; events: number; drawDefinitions: number; structures: number; matchUps: number; participants: number; venues: number; courts: number; } interface EngineInspection { version: string; schemaWriteMode: string; saveDrawDeletions: boolean; auditAuthorityServer: boolean; loaded: { tournamentIds: string[]; currentTournamentId?: string; counts: EngineInspectionCounts; }; subscriptions: { topics: string[]; }; devContext: any; } interface AddEventPayload { tournamentId: string; event: Event$1; } interface AddDrawDefinitionPayload { tournamentId: string; eventId: string; drawDefinition: DrawDefinition; } interface ModifyDrawDefinitionPayload { tournamentId: string; eventId: string; drawDefinition: DrawDefinition; } interface DeletedDrawIdsPayload { tournamentId: string; eventId?: string; drawId: string; } interface AddMatchUpsPayload { tournamentId: string; eventId: string; matchUps: MatchUp$1[]; } interface ModifyMatchUpPayload { tournamentId: string; matchUp: MatchUp$1; context?: { [key: string]: any; }; } interface DeletedMatchUpIdsPayload { tournamentId: string; eventId?: string; matchUpIds: string[]; action?: string; } interface AddParticipantsPayload { tournamentId?: string; participants: any[]; } interface ModifyParticipantsPayload { tournamentId?: string; participants: any[]; } interface DeleteParticipantsPayload { tournamentId?: string; participantIds: string[]; } interface PublishEventPayload { tournamentId: string; eventData: any; } interface ModifyTournamentDetailPayload { tournamentRecord: Tournament; } interface TopicPayloadMap { addEvent: AddEventPayload; addDrawDefinition: AddDrawDefinitionPayload; modifyDrawDefinition: ModifyDrawDefinitionPayload; deletedDrawIds: DeletedDrawIdsPayload; addMatchUps: AddMatchUpsPayload; modifyMatchUp: ModifyMatchUpPayload; deletedMatchUpIds: DeletedMatchUpIdsPayload; addParticipants: AddParticipantsPayload; modifyParticipants: ModifyParticipantsPayload; deleteParticipants: DeleteParticipantsPayload; publishEvent: PublishEventPayload; modifyTournamentDetail: ModifyTournamentDetailPayload; [topic: string]: unknown; } type Topic = keyof TopicPayloadMap & string; type Unsubscribe = () => void; type EventHandler = (payload: TopicPayloadMap[T]) => void; type EventPredicate = (payload: TopicPayloadMap[T]) => boolean; interface EventBus { on(topic: T, handler: EventHandler): Unsubscribe; once(topic: T, handler: EventHandler): Unsubscribe; off(topic: T, handler?: EventHandler): void; waitFor(topic: T, predicate?: EventPredicate): Promise; } type ErrorType = { message: string; info?: string; code: string; }; declare const INVALID_TIME_ZONE: { message: string; code: string; }; declare const errorConditionConstants: { ANACHRONISM: { message: string; code: string; }; BOOKING_NOT_FOUND: { message: string; code: string; }; CANNOT_CHANGE_WINNING_SIDE: { message: string; code: string; }; CAPACITY_EXCEEDED: { message: string; code: string; }; REGISTRATION_NOT_FOUND: { message: string; code: string; }; CANNOT_MODIFY_TIEFORMAT: { message: string; code: string; }; TOURNAMENT_CATEGORY_IN_USE: { message: string; code: string; }; CANNOT_MODIFY_PARTICIPANT_TYPE: { message: string; code: string; }; CANNOT_REMOVE_MAIN_STRUCTURE: { message: string; code: string; }; CANNOT_REMOVE_PARTICIPANTS: { message: string; code: string; }; CATEGORY_MISMATCH: { message: string; code: string; }; COURT_EXISTS: { message: string; code: string; }; COURT_NOT_FOUND: { message: string; code: string; }; EXISTING_DRAFT: { message: string; code: string; }; EXISTING_MATCHUPS: { message: string; code: string; }; DRAW_DEFINITION_NOT_FOUND: { message: string; code: string; }; DRAW_ID_EXISTS: { message: string; code: string; }; DRAW_POSITION_ACTIVE: { message: string; code: string; }; DRAW_POSITION_ASSIGNED: { message: string; code: string; }; DRAW_POSITION_NOT_CLEARED: { message: string; code: string; }; DRAW_POSITION_NOT_FOUND: { message: string; code: string; }; DRAW_SIZE_MISMATCH: { message: string; code: string; }; DUPLICATE_ENTRY: { message: string; code: string; }; DUPLICATE_VALUE: { message: string; code: string; }; ENTRY_STATUS_NOT_ALLOWED_FOR_EVENT: { message: string; code: string; }; ENTRY_STATUS_NOT_ALLOWED_IN_STAGE: { message: string; code: string; }; EVENT_EXISTS: { message: string; code: string; }; EVENT_NOT_FOUND: { message: string; code: string; }; EXISTING_DRAW_DEFINITIONS: { message: string; code: string; }; EXISTING_END_TIME: { message: string; code: string; }; EXISTING_FLIGHT: { message: string; code: string; }; EXISTING_MATCHUP_ID: { message: string; code: string; }; EXISTING_OUTCOME: { message: string; code: string; }; EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT: { message: string; code: string; }; EXISTING_PARTICIPANT: { message: string; code: string; }; EXISTING_POLICY_TYPE: { message: string; code: string; }; EXISTING_PROFILE: { message: string; code: string; }; EXISTING_ROUND: { message: string; code: string; }; EXISTING_STAGE: { message: string; code: string; }; EXISTING_STRUCTURE: { message: string; code: string; }; INCOMPATIBLE_MATCHUP_STATUS: { message: string; code: string; }; INCOMPLETE_SOURCE_STRUCTURE: { message: string; code: string; }; INSUFFICIENT_DRAW_POSITIONS: { message: string; code: string; }; INVALID_ACTION: { message: string; code: string; }; INVALID_ASSIGNMENT: { message: string; code: string; }; INVALID_BOOKINGS: { message: string; code: string; }; INVALID_CATEGORY: { message: string; code: string; }; INVALID_COLLECTION_DEFINITION: { message: string; code: string; }; INVALID_CONFIGURATION: { message: string; code: string; }; INVALID_DATE_AVAILABILITY: { message: string; code: string; }; INVALID_DATE: { message: string; code: string; }; INVALID_DRAW_DEFINITION: { message: string; code: string; }; INVALID_DRAW_POSITION_FOR_SEEDING: { message: string; code: string; }; INVALID_DRAW_POSITION: { message: string; code: string; }; INVALID_DRAW_SIZE: { message: string; code: string; }; INVALID_END_TIME: { message: string; code: string; }; INVALID_ENTRIES: { message: string; code: string; }; INVALID_EVENT_TYPE: { message: string; code: string; }; INVALID_GAME_SCORES: { message: string; code: string; }; INVALID_GENDER: { message: string; code: string; }; INVALID_MATCHUP_FORMAT: { message: string; code: string; }; INVALID_MATCHUP_STATUS: { message: string; code: string; }; INVALID_MATCHUP_STATUS_BYE: { message: string; code: string; }; INVALID_MATCHUP: { message: string; code: string; }; INVALID_OBJECT: { message: string; code: string; }; INVALID_PARTICIPANT_ID: { message: string; code: string; }; INVALID_PARTICIPANT_IDS: { message: string; code: string; }; INVALID_PARTICIPANT_ROLE: { message: string; code: string; }; INVALID_PARTICIPANT_SEEDING: { message: string; code: string; }; INVALID_PARTICIPANT_TYPE: { message: string; code: string; }; INVALID_PARTICIPANT: { message: string; code: string; }; INVALID_POLICY_DEFINITION: { message: string; code: string; }; INVALID_RECORDS: { message: string; code: string; }; INVALID_SCALE_ITEM: { message: string; code: string; }; INVALID_SEED_NUMBER: { message: string; code: string; }; INVALID_SEED_POSITION: { message: string; code: string; }; INVALID_SET_NUMBER: { message: string; code: string; }; INVALID_SIDE_NUMBER: { message: string; code: string; }; INVALID_SCORE: { message: string; code: string; }; INVALID_STAGE: { message: string; code: string; }; INVALID_START_TIME: { message: string; code: string; }; INVALID_STRUCTURE: { message: string; code: string; }; INVALID_STOP_TIME: { message: string; code: string; }; INVALID_TIE_FORMAT: { message: string; code: string; }; INVALID_TIME: { message: string; code: string; }; INVALID_TIME_ITEM: { message: string; code: string; }; INVALID_TOURNAMENT_DATES: { message: string; code: string; }; INVALID_TOURNAMENT_RECORD: { message: string; code: string; }; INVALID_VALUES: { message: string; code: string; }; INVALID_WINNING_SIDE: { message: string; code: string; }; LUCKY_DRAW_BYE_LIMIT: { message: string; code: string; }; MATCHUP_NOT_FOUND: { message: string; code: string; }; METHOD_NOT_FOUND: { message: string; code: string; }; MUTATION_LOCKED: { message: string; code: string; }; MUTATION_LOCK_EXISTS: { message: string; code: string; }; MUTATION_LOCK_NOT_FOUND: { message: string; code: string; }; MISSING_ASSIGNMENTS: { message: string; code: string; }; MISSING_ASYNC_STATE_PROVIDER: { message: string; code: string; }; MISSING_AVOIDANCE_POLICY: { message: string; code: string; }; MISSING_BIRTH_DATE: { message: string; code: string; }; MISSING_COLLECTION_DEFINITION: { message: string; code: string; }; MISSING_COURT_ID: { message: string; code: string; }; MISSING_COURTS_INFO: { message: string; code: string; }; MISSING_DATE_AVAILABILITY: { message: string; code: string; }; MISSING_DATE: { message: string; code: string; }; MISSING_DRAW_DEFINITION: { message: string; code: string; }; MISSING_DRAW_ID: { message: string; code: string; }; MISSING_DRAW_POSITION: { message: string; code: string; }; MISSING_DRAW_POSITIONS: { message: string; code: string; }; MISSING_DRAW_SIZE: { message: string; code: string; }; MISSING_ENTRIES: { message: string; code: string; }; MISSING_EVENT: { message: string; code: string; }; MISSING_QUALIFIED_PARTICIPANTS: { message: string; code: string; }; MISSING_MATCHUP_FORMAT: { message: string; code: string; }; MISSING_MATCHUP_ID: { message: string; code: string; }; MISSING_MATCHUP_IDS: { message: string; code: string; }; MISSING_MATCHUP: { message: string; code: string; }; MISSING_MATCHUPS: { message: string; code: string; }; MISSING_PARTICIPANT_COUNT: { message: string; code: string; }; MISSING_PARTICIPANT_ID: { message: string; code: string; }; MISSING_PARTICIPANT_IDS: { message: string; code: string; }; MISSING_PARTICIPANT_ROLE: { message: string; code: string; }; MISSING_PARTICIPANT: { message: string; code: string; }; MISSING_PARTICIPANTS: { message: string; code: string; }; MISSING_PENALTY_ID: { message: string; code: string; }; MISSING_PENALTY_TYPE: { message: string; code: string; }; MISSING_PERSON_DETAILS: { message: string; code: string; }; MISSING_POLICY_ATTRIBUTES: { message: string; code: string; }; MISSING_POLICY_DEFINITION: { message: string; code: string; }; MISSING_POLICY_TYPE: { message: string; code: string; }; MISSING_POSITION_ASSIGNMENTS: { message: string; code: string; }; MISSING_ROUND_NUMBER: { message: string; code: string; }; MISSING_SCHEDULE: { message: string; code: string; }; MISSING_SCORING_POLICY: { message: string; code: string; }; MISSING_SEED_ASSIGNMENTS: { message: string; code: string; }; MISSING_SEEDCOUNT_THRESHOLDS: { message: string; code: string; }; MISSING_SEEDING_POLICY: { message: string; code: string; }; MISSING_SET_NUMBER: { message: string; code: string; }; MISSING_SET_OBJECT: { message: string; code: string; }; MISSING_SIDE_NUMBER: { message: string; code: string; }; MISSING_STAGE: { message: string; code: string; }; MISSING_STRUCTURE_ID: { message: string; code: string; }; MISSING_STRUCTURE: { message: string; code: string; }; MISSING_MAIN_STRUCTURE: { message: string; code: string; }; MISSING_STRUCTURES: { message: string; code: string; }; MISSING_TARGET_LINK: { message: string; code: string; }; MISSING_TIE_FORMAT: { message: string; code: string; }; MISSING_TIME_ITEM: { message: string; code: string; }; MISSING_TIME_ITEMS: { message: string; code: string; }; MISSING_TOURNAMENT_ID: { message: string; code: string; }; MISSING_TOURNAMENT_RECORD: { message: string; code: string; }; MISSING_TOURNAMENT_RECORDS: { message: string; code: string; }; MISSING_VALUE: { message: string; code: string; }; MISSING_VENUE_ID: { message: string; code: string; }; MODIFICATIONS_FAILED: { message: string; code: string; }; NO_CANDIDATES: { message: string; code: string; }; NO_DRAW_POSITIONS_AVAILABLE_FOR_QUALIFIERS: { message: string; code: string; }; NO_MODIFICATIONS_APPLIED: { message: string; code: string; }; NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS: { message: string; code: string; }; NO_PARTICIPANT_REMOVED: { message: string; code: string; }; NO_VALID_ACTIONS: { message: string; code: string; }; NO_VALID_ATTRIBUTES: { message: string; code: string; }; NO_VALID_DATES: { message: string; code: string; }; NOT_FOUND: { message: string; code: string; }; NOT_IMPLEMENTED: { message: string; code: string; }; PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE: { message: string; code: string; }; PARTICIPANT_ID_EXISTS: { message: string; code: string; }; PARTICIPANT_NOT_CHECKED_IN: { message: string; code: string; }; PARTICIPANT_NOT_FOUND: { message: string; code: string; }; PARTICIPANT_PAIR_EXISTS: { message: string; code: string; }; PENALTY_NOT_FOUND: { message: string; code: string; }; POLICY_NOT_ATTACHED: { message: string; code: string; }; POLICY_NOT_FOUND: { message: string; code: string; }; SCHEDULE_NOT_CLEARED: { message: string; code: string; }; SCHEDULE_CONFLICT_DOUBLE_BOOKING: { message: string; code: string; }; SCHEDULE_CONFLICT_COURT_UNAVAILABLE: { message: string; code: string; }; SCHEDULED_MATCHUPS: { message: string; code: string; }; SCORES_PRESENT: { message: string; code: string; }; SEEDSCOUNT_GREATER_THAN_DRAW_SIZE: { message: string; code: string; }; STAGE_SEQUENCE_LIMIT: { message: string; code: string; }; STRUCTURE_NOT_FOUND: { message: string; code: string; }; TEAM_NOT_FOUND: { message: string; code: string; }; UNABLE_TO_ASSIGN_COURT: { message: string; code: string; }; UNAUTHORIZED_LOCK_OPERATION: { message: string; code: string; }; UNLINKED_STRUCTURES: { message: string; code: string; }; UNRECOGNIZED_DRAW_TYPE: { message: string; code: string; }; UNRECOGNIZED_MATCHUP_FORMAT: { message: string; code: string; }; UNRECOGNIZED_MATCHUP_STATUS: { message: string; code: string; }; VALUE_UNCHANGED: { message: string; code: string; }; VENUE_EXISTS: { message: string; code: string; }; }; type GenderInput = 'MALE' | 'FEMALE' | 'MIXED' | 'ANY' | 'OTHER'; interface EventSeed { eventName?: string; eventLevel?: string; category?: { categoryName?: string; ageCategoryCode?: string; ratingType?: string; ratingMin?: number; ratingMax?: number; }; startDate?: string; endDate?: string; } interface DrawOpts { drawType?: string; drawName?: string; seedsCount?: number; matchUpFormat?: string; automated?: boolean | { seedsOnly: boolean; }; qualifyingProfiles?: any[]; withPlayoffs?: any; drawEntries?: any[]; } interface EntriesOpts { entryStage?: string; entryStatus?: string; enforceGender?: boolean; enforceCategory?: boolean; } interface BuildResult { success: boolean; error?: ErrorType; eventId: string; drawIds: string[]; directives: Directives; results?: any[]; } interface ParticipantBuildResult { success: boolean; error?: ErrorType; participantId: string; directives: Directives; results?: any[]; } interface PersonInput { givenName: string; familyName: string; sex?: 'M' | 'F' | 'X'; nationalityCode?: string; personId?: string; } declare class EventBuilder { private readonly engine; private readonly _eventId; private eventState; private drawSpec; private entriesSpec; constructor(engine: FactoryEngine, seed?: Partial); singles(): this; doubles(): this; team(tieFormat?: any | string): this; hybrid(): this; named(eventName: string): this; gender(gender: GenderInput): this; category(category: EventSeed['category']): this; dates(startDate: string, endDate: string): this; tieFormat(tieFormat: any | string): this; entries(participantIds: string[], opts?: EntriesOpts): this; draw(drawSize: number, opts?: DrawOpts): this; get eventId(): string; get drawIds(): string[]; toDirectives(): Directives; toRequest(): { directives: Directives; eventId: string; drawIds: string[]; }; create(opts?: { rollbackOnError?: boolean; }): BuildResult; } declare class ParticipantBuilder { private readonly engine; private readonly _participantId; private shape; private participantRole; constructor(engine: FactoryEngine); individual(person: PersonInput): this; pair(individualParticipantIds: [string, string], name?: string): this; team(name: string, individualParticipantIds?: string[]): this; role(role: string): this; get participantId(): string; private buildParticipant; toDirectives(): Directives; toRequest(): { directives: Directives; participantId: string; }; create(opts?: { rollbackOnError?: boolean; }): ParticipantBuildResult; } interface BuildFacade { event(seed?: Partial): EventBuilder; participant(): ParticipantBuilder; } declare const forge: {}; declare const SINGLES_EVENT = "SINGLES"; declare const DOUBLES_EVENT = "DOUBLES"; declare const TEAM_EVENT = "TEAM"; declare const eventConstants: { AGE: string; BOTH: string; DOUBLES: string; DOUBLES_EVENT: string; HYBRID: string; HYBRID_EVENT: string; RATING: string; SINGLES: string; SINGLES_EVENT: string; TEAM_EVENT: string; TEAM: string; }; type SignedInStatusUnion = typeof SIGNED_IN | typeof SIGNED_OUT; declare const SIGNED_OUT = "SIGNED_OUT"; declare const SIGNED_IN = "SIGNED_IN"; type PaymentStatusUnion = typeof PAID | typeof UNPAID | typeof PARTIAL | typeof WAIVED | typeof REFUNDED; declare const REFUNDED = "REFUNDED"; declare const PARTIAL = "PARTIAL"; declare const WAIVED = "WAIVED"; declare const UNPAID = "UNPAID"; declare const PAID = "PAID"; declare const participantTypes: { TEAM_PARTICIPANT: string; INDIVIDUAL: string; GROUP: string; TEAM: string; PAIR: string; }; declare const participantConstants: { INDIVIDUAL: string; GROUP: string; PAIR: string; TEAM: string; SIGN_IN_STATUS: string; SIGNED_OUT: string; SIGNED_IN: string; PAYMENT_STATUS: string; REFUNDED: string; PARTIAL: string; WAIVED: string; UNPAID: string; PAID: string; }; declare const POLICY_TYPE_VOLUNTARY_CONSOLATION = "voluntaryConsolation"; declare const POLICY_TYPE_COMPETITIVE_BANDS = "competitiveBands"; declare const POLICY_TYPE_ROUND_ROBIN_TALLY = "roundRobinTally"; declare const POLICY_TYPE_POSITION_ACTIONS = "positionActions"; declare const POLICY_TYPE_MATCHUP_ACTIONS = "matchUpActions"; declare const POLICY_TYPE_RANKING_POINTS = "rankingPoints"; declare const POLICY_TYPE_ROUND_NAMING = "roundNaming"; declare const POLICY_TYPE_PARTICIPANT = "participant"; declare const POLICY_TYPE_PROGRESSION = "progression"; declare const POLICY_TYPE_SCHEDULING = "scheduling"; declare const POLICY_TYPE_AVOIDANCE = "avoidance"; declare const POLICY_TYPE_PRIVACY = "participant"; declare const POLICY_TYPE_DISPLAY = "display"; declare const POLICY_TYPE_SCORING = "scoring"; declare const POLICY_TYPE_SEEDING = "seeding"; declare const POLICY_TYPE_FEED_IN = "feedIn"; declare const POLICY_TYPE_SANCTIONING = "sanctioning"; declare const POLICY_TYPE_AUDIT = "audit"; declare const POLICY_TYPE_COMPETITION = "competition"; declare const POLICY_TYPE_DRAWS = "draws"; declare const POLICY_TYPE_PRINT = "print"; type ValidPolicyTypes = typeof POLICY_TYPE_VOLUNTARY_CONSOLATION | typeof POLICY_TYPE_COMPETITIVE_BANDS | typeof POLICY_TYPE_ROUND_ROBIN_TALLY | typeof POLICY_TYPE_POSITION_ACTIONS | typeof POLICY_TYPE_MATCHUP_ACTIONS | typeof POLICY_TYPE_RANKING_POINTS | typeof POLICY_TYPE_ROUND_NAMING | typeof POLICY_TYPE_PARTICIPANT | typeof POLICY_TYPE_PROGRESSION | typeof POLICY_TYPE_SCHEDULING | typeof POLICY_TYPE_AVOIDANCE | typeof POLICY_TYPE_DISPLAY | typeof POLICY_TYPE_PRIVACY | typeof POLICY_TYPE_COMPETITION | typeof POLICY_TYPE_FEED_IN | typeof POLICY_TYPE_SCORING | typeof POLICY_TYPE_SEEDING | typeof POLICY_TYPE_SANCTIONING | typeof POLICY_TYPE_AUDIT | typeof POLICY_TYPE_DRAWS | typeof POLICY_TYPE_PRINT; declare const policyConstants: { readonly POLICY_TYPE_VOLUNTARY_CONSOLATION: "voluntaryConsolation"; readonly POLICY_TYPE_COMPETITIVE_BANDS: "competitiveBands"; readonly POLICY_TYPE_ROUND_ROBIN_TALLY: "roundRobinTally"; readonly POLICY_TYPE_POSITION_ACTIONS: "positionActions"; readonly POLICY_TYPE_MATCHUP_ACTIONS: "matchUpActions"; readonly POLICY_TYPE_RANKING_POINTS: "rankingPoints"; readonly POLICY_TYPE_ROUND_NAMING: "roundNaming"; readonly POLICY_TYPE_PARTICIPANT: "participant"; readonly POLICY_TYPE_PROGRESSION: "progression"; readonly POLICY_TYPE_SCHEDULING: "scheduling"; readonly POLICY_TYPE_AVOIDANCE: "avoidance"; readonly POLICY_TYPE_COMPETITION: "competition"; readonly POLICY_TYPE_DISPLAY: "display"; readonly POLICY_TYPE_PRIVACY: "participant"; readonly POLICY_TYPE_FEED_IN: "feedIn"; readonly POLICY_TYPE_SCORING: "scoring"; readonly POLICY_TYPE_SEEDING: "seeding"; readonly POLICY_TYPE_SANCTIONING: "sanctioning"; readonly POLICY_TYPE_AUDIT: "audit"; readonly POLICY_TYPE_DRAWS: "draws"; readonly POLICY_TYPE_PRINT: "print"; }; type FactoryEngineMethod = 'addAdHocMatchUps' | 'addCertification' | 'addCertificationRequirement' | 'addCollectionDefinition' | 'addCollectionGroup' | 'addCourt' | 'addCourtGridBooking' | 'addCourts' | 'addDrawDefinition' | 'addDrawDefinitionExtension' | 'addDrawDefinitionTimeItem' | 'addDrawEntries' | 'addDynamicRatings' | 'addEvaluation' | 'addEvaluationPolicy' | 'addEvent' | 'addEventEntries' | 'addEventEntryPairs' | 'addEventExtension' | 'addEventTimeItem' | 'addExtension' | 'addFinishingRounds' | 'addFlight' | 'addGoesTo' | 'addIndividualParticipantIds' | 'addLinkedConsolationStructure' | 'addMatchUpCourtOrder' | 'addMatchUpEndTime' | 'addMatchUpOfficial' | 'addMatchUpResumeTime' | 'addMatchUpScheduledDate' | 'addMatchUpScheduledTime' | 'addMatchUpScheduleItems' | 'addMatchUpStartTime' | 'addMatchUpStopTime' | 'addMutationLock' | 'addNotes' | 'addOnlineResource' | 'addParticipant' | 'addParticipantExtension' | 'addParticipants' | 'addParticipantTimeItem' | 'addPenalty' | 'addPersonOtherId' | 'addPersonRequests' | 'addPersons' | 'addPlayoffStructures' | 'addPoint' | 'addPracticeRegistration' | 'addQualifyingStructure' | 'addSchedulingProfileRound' | 'addSuspension' | 'addTimeItem' | 'addTournamentExtension' | 'addTournamentTimeItem' | 'addVenue' | 'addVoluntaryConsolationStructure' | 'adHocPositionSwap' | 'aggregateTieFormats' | 'allCompetitionMatchUps' | 'allDrawMatchUps' | 'allEventMatchUps' | 'allocateTeamMatchUpCourts' | 'allPlayoffPositionsFilled' | 'allTournamentMatchUps' | 'alternateDrawPositionAssignment' | 'analyzeDraws' | 'analyzeMatchUp' | 'analyzeScore' | 'analyzeSequence' | 'analyzeSet' | 'analyzeTournament' | 'anonymizeTournamentRecord' | 'applyAvailabilityToTournamentRecord' | 'applyDerivedRankings' | 'applyLineUps' | 'applyTournamentRankingPoints' | 'assignDrawPosition' | 'assignDrawPositionBye' | 'assignMatchUpCourt' | 'assignMatchUpSideParticipant' | 'assignMatchUpVenue' | 'assignOfficial' | 'assignSeedPositions' | 'assignTieMatchUpParticipantId' | 'attachConsolationStructures' | 'attachFlightProfile' | 'attachPlayoffStructures' | 'attachPolicies' | 'attachQualifyingStructure' | 'attachStructures' | 'auditAuthorityServer' | 'automatedPlayoffPositioning' | 'automatedPositioning' | 'autoSeeding' | 'buildDayRange' | 'buildDrawHierarchy' | 'buildEdges' | 'buildReportContext' | 'buildSchedulingProfileFromUISelections' | 'bulkMatchUpStatusUpdate' | 'bulkRescheduleMatchUps' | 'bulkScheduleMatchUps' | 'bulkScheduleTournamentMatchUps' | 'bulkUpdateCourtAssignments' | 'bulkUpdatePublishedEventIds' | 'calculateCapacityStats' | 'calculateCourtHours' | 'calculateMatchStatistics' | 'calculateMatchUpMargin' | 'calculatePointsTo' | 'calculateScheduleTimes' | 'calculateWinCriteria' | 'categoryCanContain' | 'checkInParticipant' | 'checkMatchUpIsComplete' | 'checkOutParticipant' | 'checkScoreHasValue' | 'checkSetIsComplete' | 'checkValidEntries' | 'clampDragToCollisions' | 'clampToDayRange' | 'cleanExpiredMutationLocks' | 'clearMatchUpSchedule' | 'clearScheduledMatchUps' | 'compareCapacityCurves' | 'compareTieFormats' | 'competitionScheduleMatchUps' | 'completeDrawMatchUps' | 'computePlanItemId' | 'copyTournamentRecord' | 'courtDayKey' | 'courtGridRows' | 'courtKey' | 'createFollowByEvaluator' | 'createGroupParticipant' | 'createMatchUp' | 'createOfficialRecord' | 'createTeamsFromParticipantAttributes' | 'createTournamentRecord' | 'credits' | 'deduceMatchUpFormat' | 'deleteAdHocMatchUps' | 'deleteCourt' | 'deleteCourts' | 'deleteDrawDefinitions' | 'deleteEvents' | 'deleteFlightAndFlightDraw' | 'deleteFlightProfileAndFlightDraws' | 'deleteParticipants' | 'deleteVenue' | 'deleteVenues' | 'deriveRailSegments' | 'destroyPairEntries' | 'destroyPairEntry' | 'devContext' | 'diffMinutes' | 'disableCourts' | 'disableTieAutoCalc' | 'disableVenues' | 'drawMatchUps' | 'drawMatic' | 'dryRun' | 'enableCourts' | 'enableTieAutoCalc' | 'enableVenues' | 'enrichPointHistory' | 'EvaluatorRegistry' | 'eventMatchUps' | 'execute' | 'executionQueue' | 'explain' | 'exportMatchUpJSON' | 'extractDay' | 'filterCapacityCurve' | 'filterMatchUps' | 'filterParticipants' | 'findBlocksContainingTime' | 'findDrawDefinition' | 'findExtension' | 'findMatchUp' | 'findMatchUpFormatTiming' | 'findParticipant' | 'findPolicy' | 'findVenue' | 'formatConflicts' | 'generateAdHocMatchUps' | 'generateAdHocRounds' | 'generateAndPopulatePlayoffStructures' | 'generateBookings' | 'generateCapacityCurve' | 'generateConsolationStructure' | 'generateCourts' | 'generateDrawDefinition' | 'generateDrawMaticRound' | 'generateDrawStructuresAndLinks' | 'generateDrawTypeAndModifyDrawDefinition' | 'generateEventsFromTieFormat' | 'generateEventWithDraw' | 'generateFlightProfile' | 'generateLineUps' | 'generateOutcome' | 'generateOutcomeFromScoreString' | 'generateParticipants' | 'generateQualifyingStructure' | 'generateRankingList' | 'generateReport' | 'generateScoreString' | 'generateSeedingScaleItems' | 'generateStatCrew' | 'generateSwissRound' | 'generateTieMatchUpScore' | 'generateTournamentRecord' | 'generateVirtualCourts' | 'generateVoluntaryConsolation' | 'getAggregateTeamResults' | 'getAllDrawMatchUps' | 'getAllEventData' | 'getAllowedDrawTypes' | 'getAllowedMatchUpFormats' | 'getAllStructureMatchUps' | 'getApplicableAwardProfileLevels' | 'getAppliedPolicies' | 'getAssignedParticipantIds' | 'getAuditAuthorityServer' | 'getAvailableMatchUpsCount' | 'getAvailablePlayoffProfiles' | 'getAvailableReports' | 'getAwardPoints' | 'getAwardProfile' | 'getCategoryAgeDetails' | 'getCheckedInParticipantIds' | 'getCompetitionDateRange' | 'getCompetitionFormat' | 'getCompetitionLeaderboard' | 'getCompetitionMatchUps' | 'getCompetitionParticipants' | 'getCompetitionParticipantState' | 'getCompetitionPenalties' | 'getCompetitionPolicy' | 'getCompetitionState' | 'getCompetitionVenues' | 'getCourtInfo' | 'getCourts' | 'getDevContext' | 'getDraftState' | 'getDrawData' | 'getDrawDefinitionTimeItem' | 'getDrawParticipantRepresentativeIds' | 'getDrawStructures' | 'getDrawTypeCoercion' | 'getEligibleVoluntaryConsolationParticipants' | 'getEntriesAndSeedsCount' | 'getEntryStatusReports' | 'getEpisodes' | 'getEvaluations' | 'getEvaluationSummary' | 'getEvaluationTemplate' | 'getEvent' | 'getEventData' | 'getEventMatchUpFormatTiming' | 'getEventProperties' | 'getEventPublishStatus' | 'getEventRankingPoints' | 'getEvents' | 'getEventStructures' | 'getEventTimeItem' | 'getFlightProfile' | 'getHighestSeverity' | 'getHomeParticipantId' | 'getLinkedTournamentIds' | 'getLuckyDrawRoundStatus' | 'getMatchUpCompetitiveProfile' | 'getMatchUpContextIds' | 'getMatchUpDailyLimits' | 'getMatchUpDailyLimitsUpdate' | 'getMatchUpDependencies' | 'getMatchUpFormat' | 'getMatchUpFormatTiming' | 'getMatchUpFormatTimingUpdate' | 'getMatchUpScheduleDetails' | 'getMatchUpsMap' | 'getMatchUpsStats' | 'getMatchUpsToSchedule' | 'getMatchUpType' | 'getMaxEntryPosition' | 'getModifiedMatchUpFormatTiming' | 'getMutationLocks' | 'getOfficialAssignments' | 'getOfficialCertifications' | 'getOfficialEligibility' | 'getPairedParticipant' | 'getParticipantEventDetails' | 'getParticipantIdFinishingPositions' | 'getParticipantMembership' | 'getParticipantPaymentStatus' | 'getParticipantPoints' | 'getParticipantResults' | 'getParticipants' | 'getParticipantScaleItem' | 'getParticipantSchedules' | 'getParticipantSignInStatus' | 'getParticipantStats' | 'getParticipantTimeItem' | 'getPersonRequests' | 'getPolicyDefinitions' | 'getPositionAssignments' | 'getPositionsPlayedOff' | 'getPracticeRegistrations' | 'getPredictiveAccuracy' | 'getProfileRounds' | 'getPublishState' | 'getQualityWinPoints' | 'getQuickStats' | 'getRandomQualifierList' | 'getRegistrationProfile' | 'getRoundMatchUps' | 'getRounds' | 'getRoundVisibilityState' | 'getSaveDrawDeletions' | 'getScaledEntries' | 'getScaleValues' | 'getScheduledRoundsDetails' | 'getSchedulingProfile' | 'getSchedulingProfileIssues' | 'getSchemaWriteMode' | 'getScore' | 'getScoreboard' | 'getSeedingThresholds' | 'getSeedsCount' | 'getSetComplement' | 'getSetScoreString' | 'getState' | 'getStructureReports' | 'getStructureSeedAssignments' | 'getSwissChart' | 'getSwissStandings' | 'getTally' | 'getTeamLineUp' | 'getTiebreakComplement' | 'getTieFormat' | 'getTimeItem' | 'getTournament' | 'getTournamentId' | 'getTournamentIds' | 'getTournamentInfo' | 'getTournamentPenalties' | 'getTournamentPersons' | 'getTournamentPointAwards' | 'getTournamentPoints' | 'getTournamentPublishStatus' | 'getTournamentStructures' | 'getTournamentTimeItem' | 'getValidGroupSizes' | 'getVenueData' | 'getVenuesAndCourts' | 'getVenuesReport' | 'getWinner' | 'groupByMatch' | 'groupConflictsBySeverity' | 'hasLuckyRounds' | 'hhmmToMinutes' | 'hydrateTournamentRecord' | 'importMethods' | 'inferServeSide' | 'initializeCompetitionState' | 'initializeDraft' | 'inspect' | 'intervalsOverlap' | 'isAdHoc' | 'isAggregateFormat' | 'isComplete' | 'isCompletedStructure' | 'isEmbargoed' | 'isValid' | 'isValidForQualifying' | 'isValidMatchUpFormat' | 'isVisiblyPublished' | 'iterateDayTicks' | 'keyValueScore' | 'linkTournaments' | 'luckyDrawAdvancement' | 'luckyLoserDrawPositionAssignment' | 'matchUpActions' | 'matchUpScheduleChange' | 'mcpValidator' | 'mergeAdjacentSegments' | 'mergeOverlappingAvailability' | 'mergeParticipants' | 'migrateTournamentRecord' | 'minutesToHhmm' | 'modifyCertification' | 'modifyCollectionDefinition' | 'modifyCourt' | 'modifyCourtAvailability' | 'modifyDrawDefinition' | 'modifyDrawName' | 'modifyEntriesStatus' | 'modifyEvaluation' | 'modifyEvent' | 'modifyEventEntries' | 'modifyEventMatchUpFormatTiming' | 'modifyIndividualParticipantIds' | 'modifyMatchUpFormatTiming' | 'modifyPairAssignment' | 'modifyParticipant' | 'modifyParticipantName' | 'modifyParticipantOtherName' | 'modifyParticipantsPaymentStatus' | 'modifyParticipantsSignInStatus' | 'modifyPenalty' | 'modifyPersonRequests' | 'modifySeedAssignment' | 'modifyTieFormat' | 'modifyTournamentRecord' | 'modifyVenue' | 'newTournamentRecord' | 'off' | 'on' | 'once' | 'orderCollectionDefinitions' | 'overlappingRange' | 'parse' | 'parseCSV' | 'parseMatchUpFormat' | 'parseMCPPoint' | 'parseScoreString' | 'participantScaleItem' | 'participantScheduledMatchUps' | 'pbpValidator' | 'pointParser' | 'positionActions' | 'predictDrawCompetitiveBands' | 'predictMatchUpCompetitiveBands' | 'proAutoSchedule' | 'processCompetitionMatchUp' | 'processCompetitionRound' | 'proConflicts' | 'promoteAlternate' | 'promoteAlternates' | 'pruneDrawDefinition' | 'publicFindCourt' | 'publicFindVenue' | 'publishEvent' | 'publishEventSeeding' | 'publishOrderOfPlay' | 'publishParticipants' | 'qualifierDrawPositionAssignment' | 'qualifierProgression' | 'queryOfficialRecord' | 'railsToDateAvailability' | 'rangesOverlap' | 'refreshEventDrawOrder' | 'regenerateParticipantNames' | 'remapDrawDefinitionMatchUpIds' | 'removeCertification' | 'removeCollectionDefinition' | 'removeCollectionGroup' | 'removeCourtGridBooking' | 'removeDelegatedOutcome' | 'removeDrawDefinitionExtension' | 'removeDrawEntries' | 'removeDrawPositionAssignment' | 'removeEvaluation' | 'removeEventEntries' | 'removeEventExtension' | 'removeEventMatchUpFormatTiming' | 'removeExtension' | 'removeIndividualParticipantIds' | 'removeMatchUpCourtAssignment' | 'removeMatchUpOutcome' | 'removeMatchUpSideParticipant' | 'removeMutationLock' | 'removeNotes' | 'removeOfficialAssignment' | 'removeOnlineResource' | 'removeOrphanedTieFormats' | 'removeParticipantExtension' | 'removeParticipantIdsFromAllTeams' | 'removePenalty' | 'removePersonRequests' | 'removePolicy' | 'removePracticeRegistration' | 'removeRatings' | 'removeRoundMatchUps' | 'removeScaleValues' | 'removeSeededParticipant' | 'removeSeeding' | 'removeStageEntries' | 'removeStructure' | 'removeSuspension' | 'removeTieMatchUpParticipantId' | 'removeTournamentExtension' | 'removeTournamentRecord' | 'removeUnlinkedTournamentRecords' | 'renameStructures' | 'reorderUpcomingMatchUps' | 'replaceTieMatchUpParticipantId' | 'reset' | 'resetAdHocMatchUps' | 'resetCompetitionState' | 'resetDrawDefinition' | 'resetMatchUpLineUps' | 'resetQualifyingStructure' | 'resetScorecard' | 'resetTieFormat' | 'resetVoluntaryConsolationStructure' | 'resolveCourtId' | 'resolveDraftPositions' | 'resolvePointValue' | 'resolveStatus' | 'resolveVenueId' | 'reverseScore' | 'runValidationPipeline' | 'sampleCapacityCurve' | 'saveDrawDeletions' | 'scaledTeamAssignment' | 'scheduleMatchUps' | 'scheduleProfileGrid' | 'scheduleProfileRounds' | 'schemaWriteMode' | 'ScoringEngine' | 'seedWithdrawalCascade' | 'setDelegatedOutcome' | 'setDrawParticipantRepresentativeIds' | 'setDrawPositionPreferences' | 'setEntryPosition' | 'setEntryPositions' | 'setEventDates' | 'setEventDisplay' | 'setEventEndDate' | 'setEventStartDate' | 'setMatchUpCalledAt' | 'setMatchUpDailyLimits' | 'setMatchUpFormat' | 'setMatchUpHomeParticipantId' | 'setMatchUpState' | 'setMatchUpStatus' | 'setOrderOfFinish' | 'setParticipantScaleItem' | 'setParticipantScaleItems' | 'setPositionAssignments' | 'setPracticeDefaultCapacity' | 'setRegistrationProfile' | 'setSchedulingProfile' | 'setState' | 'setStructureOrder' | 'setSubOrder' | 'setTournamentCategories' | 'setTournamentDates' | 'setTournamentEndDate' | 'setTournamentId' | 'setTournamentLocalTimeZone' | 'setTournamentName' | 'setTournamentNotes' | 'setTournamentRecord' | 'setTournamentStartDate' | 'setTournamentStatus' | 'setTournamentTier' | 'shiftAdHocRounds' | 'shotParser' | 'shotSplitter' | 'snapIsoToGranularity' | 'snapToGranularity' | 'sortBlocksByStart' | 'sortEdges' | 'stringify' | 'stringifyMatchUpFormat' | 'substituteParticipant' | 'suggestFormatPlans' | 'swapAdHocRounds' | 'swapDrawPositionAssignments' | 'tallyParticipantResults' | 'tieFormatGenderValidityCheck' | 'timeInsideBlock' | 'todsAvailabilityToBlocks' | 'toggleParticipantCheckInState' | 'toStatObjects' | 'tournamentMatchUps' | 'transitionAssignmentStatus' | 'transitionCertificationStatus' | 'transitionEvaluationStatus' | 'unlinkTournament' | 'unlinkTournaments' | 'unPublishEvent' | 'unPublishEventSeeding' | 'unPublishOrderOfPlay' | 'unPublishParticipants' | 'updateDrawIdsOrder' | 'updatePracticeRegistration' | 'updateTeamLineUp' | 'updateTieMatchUpScore' | 'validateCategory' | 'validateCertification' | 'validateCollectionDefinition' | 'validateDateAvailability' | 'validateLineUp' | 'validateMatchUp' | 'validateMatchUpScore' | 'validateMCPMatch' | 'validateOfficiatingStatusTransition' | 'validatePlayoffGroups' | 'validateSchedulingProfile' | 'validateSchedulingProfileFormat' | 'validateScore' | 'validateSegments' | 'validateSet' | 'validateSetScore' | 'validateTieFormat' | 'validMatchUp' | 'validMatchUps' | 'venueDayKey' | 'venueKey' | 'version' | 'waitFor' | 'withdrawParticipantAtDrawPosition'; declare function modifyPersonRequests(params: any): ResultType & { valid?: boolean; }; type RemovePersonRequests = { tournamentRecords: TournamentRecords; requestType?: string; requestId?: string; personId?: string; date?: string; }; declare function removePersonRequests(params: RemovePersonRequests): { success?: boolean; error?: ErrorType; info?: any; }; type GenerateDrawMaticRoundArgs = { adHocRatings?: { [key: string]: number; }; updateParticipantRatings?: boolean; ignoreLastRoundNumber?: boolean; restrictEntryStatus?: boolean; iterationMatchUps?: MatchUp$1[]; drawDefinition: DrawDefinition; tournamentRecord: Tournament; generateMatchUps?: boolean; eventType?: EventTypeUnion; salted?: number | boolean; participantIds?: string[]; dynamicRatings?: boolean; convertToELO?: boolean; refreshDynamic?: boolean; minimizeDelta?: boolean; encounterValue?: number; sameTeamValue?: number; maxIterations?: number; matchUpIds?: string[]; structure?: Structure; random?: () => number; roundNumber?: number; structureId?: string; scaleName?: string; idPrefix?: string; isMock?: boolean; drawId?: string; event: Event$1; }; type DrawMaticRoundResult = { modifiedScaleValues?: { [key: string]: number; }; participantIdPairings?: string[][]; sourceRatingType?: string; candidatesCount?: number; outputScaleName?: string; deltaCandidate?: any; roundNumber?: number; matchUps?: MatchUp$1[]; iterations?: number; success?: boolean; maxDelta?: number; maxDiff?: number; }; declare function generateDrawMaticRound(params: GenerateDrawMaticRoundArgs): ResultType & DrawMaticRoundResult; type AddPersonRequestsArgs = { tournamentRecords: TournamentRecords; requests: Request[]; personId: string; }; declare function addPersonRequests(params: AddPersonRequestsArgs): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; }; declare function generateDrawDefinition(params: GenerateDrawDefinitionArgs): ResultType & { existingDrawDefinition?: boolean; drawDefinition?: DrawDefinition; qualifyingConflicts?: any[]; positioningReports?: any[]; structureId?: string; success?: boolean; error?: ErrorType; conflicts?: any[]; }; type GetValidGroupSizesArgs = { groupSizeLimit?: number; drawSize: number; }; declare function getValidGroupSizes(params: GetValidGroupSizesArgs): ResultType & { validGroupSizes?: number[]; }; type ShiftRoundsArgs = { drawDefinition: DrawDefinition; targetRoundNumber: number; roundNumber: number; structureId: string; }; declare function shiftAdHocRounds(params: ShiftRoundsArgs): ResultType; type GetAvailableMatchUpsCountArgs = { drawDefinition: DrawDefinition; structureId?: string; roundNumber?: number; }; declare function getAvailableMatchUpsCount(params: GetAvailableMatchUpsCountArgs): ResultType & { availableMatchUpsCount?: number; roundMatchUpsCount?: number; lastRoundNumber?: number; }; type SwapRoundsArgs = { roundNumbers: [number, number]; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; structureId: string; event?: Event$1; }; declare function swapAdHocRounds(params: SwapRoundsArgs): ResultType; type SwissPolicy = { totalRounds: number; tiebreakMethods?: string[]; pairingMethod?: 'SCORE_GROUP' | 'RATING_BASED'; allowDraws?: boolean; colorAlternation?: boolean; hardNoRepeat?: boolean; }; type ScoreGroup = { wins: number; losses: number; draws: number; participantIds: string[]; }; type SwissStanding = { participantId: string; wins: number; losses: number; draws: number; points: number; buchholz?: number; medianBuchholz?: number; sonnebornBerger?: number; progressiveScore?: number; opponentIds: string[]; rank: number; }; type SwissState = { roundsPlayed: number; totalRounds: number; scoreGroups: ScoreGroup[]; standings: SwissStanding[]; }; type OpponentOutcome = 'WIN' | 'LOSS' | 'DRAW'; type SwissParticipantRecord = { participantId: string; wins: number; losses: number; draws: number; points: number; opponentIds: string[]; opponentOutcomes: Map; roundPoints: number[]; }; type GenerateSwissRoundArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; swissPolicy?: SwissPolicy; participantIds?: string[]; structureId?: string; matchUpIds?: string[]; scaleName?: string; idPrefix?: string; isMock?: boolean; event: Event$1; }; type GenerateSwissRoundResult = ResultType & { byeParticipantId?: string; roundNumber?: number; matchUps?: MatchUp$1[]; }; declare function generateSwissRound(params: GenerateSwissRoundArgs): GenerateSwissRoundResult; type GenerateDrawTypeAndModify = { policyDefinitions?: PolicyDefinitions; appliedPolicies?: PolicyDefinitions; finishingPositionLimit?: number; tournamentRecord?: Tournament; matchUpType?: EventTypeUnion; drawDefinition: DrawDefinition; drawTypeCoercion?: boolean; qualifyingOnly?: boolean; modifyOriginal?: boolean; qualifiersCount?: number; stageSequence?: number; matchUpFormat?: string; structureOptions?: any; tieFormat?: TieFormat; drawType?: string; drawSize?: number; feedPolicy?: any; isMock?: boolean; event?: Event$1; }; declare function generateDrawTypeAndModifyDrawDefinition(params: GenerateDrawTypeAndModify): ResultType & { inContextDrawMatchUps?: HydratedMatchUp[]; drawDefinition?: DrawDefinition; matchUpsMap?: MatchUpsMap; structures?: Structure[]; matchUps?: MatchUp$1[]; links?: DrawLink[]; success?: boolean; }; declare function setMatchUpHomeParticipantId(params: AddScheduleAttributeArgs & { homeParticipantId?: string; }): ResultType; type ScaleItemsWithParticipantId = { participantId: string; scaleItems: any[]; }; type GenerateSeedingScaleItemsArgs = { scaleAttributes?: ScaleAttributes; scaledEntries: any[] | null; stageEntries: Entry[]; seedsCount: number; scaleName?: string; }; declare function generateSeedingScaleItems({ scaleAttributes, scaledEntries, stageEntries, seedsCount, scaleName, }: GenerateSeedingScaleItemsArgs): { scaleItemsWithParticipantIds?: ScaleItemsWithParticipantId[]; error?: ErrorType; info?: any; }; type GenerateVoluntaryConsolationArgs = { playoffAttributes?: PlayoffAttributes; tournamentRecord: Tournament; seedingProfile?: SeedingProfile; drawDefinition: DrawDefinition; matchUpType?: EventTypeUnion; applyPositioning?: boolean; staggeredEntry?: boolean; structureOptions?: { groupSize?: number; }; random?: () => number; structureName?: string; matchUpFormat?: string; tieFormat?: TieFormat; automated?: boolean; placeByes?: boolean; drawType?: string; isMock?: boolean; event?: Event$1; }; declare function generateVoluntaryConsolation(params: GenerateVoluntaryConsolationArgs): { structures?: Structure[]; links?: DrawLink[]; success?: boolean; error?: ErrorType; }; declare function getMatchUpFormatTimingUpdate({ tournamentRecords }: { tournamentRecords: any; }): { error?: ErrorType; } | { methods: QueueMethod[]; }; type CalculateScheduleTimesArgs = { tournamentRecords: { [key: string]: Tournament; }; calculateStartTimeFromCourts?: boolean; remainingScheduleTimes?: string[]; defaultRecoveryMinutes?: number; averageMatchUpMinutes?: number; clearScheduleDates?: boolean; periodLength?: number; scheduleDate: string; venueIds?: string[]; startTime?: string; endTime?: string; }; declare function calculateScheduleTimes({ calculateStartTimeFromCourts, defaultRecoveryMinutes, averageMatchUpMinutes, remainingScheduleTimes, clearScheduleDates, tournamentRecords, periodLength, scheduleDate, startTime, venueIds, endTime, }: CalculateScheduleTimesArgs): { dateScheduledMatchUpIds?: string[]; totalMatchUps?: number; scheduleTimes?: any[]; timingProfile?: any; error?: ErrorType; venueId?: string; }; type GenerateAdHocMatchUpsArgs = { participantIdPairings?: { participantIds: [string | undefined, string | undefined]; }[]; ignoreLastRoundNumber?: boolean; restrictMatchUpsCount?: boolean; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; matchUpsCount?: number; matchUpIds?: string[]; roundNumber?: number; structureId?: string; newRound?: boolean; idPrefix?: string; isMock?: boolean; event: Event$1; }; declare function generateAdHocMatchUps(params: GenerateAdHocMatchUpsArgs): { matchUpsCount?: number; roundNumber?: number; matchUps?: MatchUp$1[]; error?: ErrorType; info?: any; }; type GenerateQualifyingStructureArgs = { hasExistingDrawDefinition?: boolean; appliedPolicies?: PolicyDefinitions; qualifyingRoundNumber: number; drawDefinition: DrawDefinition; qualifyingPositions?: number; participantsCount?: number; targetStructureId: string; qualifyingOnly?: boolean; drawType?: DrawTypeUnion; structureOptions?: any; matchUpFormat?: string; structureName?: string; tieFormat?: TieFormat; structureId?: string; roundTarget: number; drawSize?: number; idPrefix?: string; isMock?: boolean; uuids?: string[]; event?: Event$1; }; declare function generateQualifyingStructure(params: GenerateQualifyingStructureArgs): { qualifyingDrawPositionsCount?: number; qualifiersCount?: number; structure?: Structure; error?: ErrorType; success?: boolean; link?: DrawLink; }; type GetEligibleVoluntaryConsolationParticipantsArgs = { excludedMatchUpStatuses?: MatchUpStatusUnion[]; policyDefinitions?: PolicyDefinitions; includeEventParticipants?: boolean; includeQualifyingStage?: boolean; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; finishingRoundLimit?: number; roundNumberLimit?: number; matchUpsLimit?: number; requirePlay?: boolean; requireLoss?: boolean; allEntries?: boolean; winsLimit?: number; event?: Event$1; }; declare function getEligibleVoluntaryConsolationParticipants({ excludedMatchUpStatuses, includeEventParticipants, includeQualifyingStage, finishingRoundLimit, policyDefinitions, roundNumberLimit, tournamentRecord, drawDefinition, matchUpsLimit, requirePlay, requireLoss, allEntries, winsLimit, event, }: GetEligibleVoluntaryConsolationParticipantsArgs): { eligibleParticipants?: Participant$1[]; losingParticipantIds?: string[]; error?: ErrorType; }; type GetEventMatchUpFormatTimingArgs = { tournamentRecord: Tournament; matchUpFormats?: string[]; categoryType?: string; event: Event$1; }; declare function getEventMatchUpFormatTiming({ tournamentRecord, matchUpFormats, categoryType, event, }: GetEventMatchUpFormatTimingArgs): { eventMatchUpFormatTiming?: any; error?: ErrorType; info?: string; }; type ProAutoScheduleArgs = { tournamentRecords: { [key: string]: Tournament; }; matchUpDailyLimits?: { [key: string]: number; }; matchUps: HydratedMatchUp[]; minCourtGridRows?: number; scheduledDate: string; courtIds?: string[]; }; declare function proAutoSchedule({ matchUpDailyLimits, minCourtGridRows, tournamentRecords, scheduledDate, courtIds, matchUps, }: ProAutoScheduleArgs): { mappedParticipants?: { [key: string]: HydratedParticipant; }; completedMatchUps?: HydratedMatchUp[]; dateMatchUps?: HydratedMatchUp[]; courtPrefix?: string; error?: ErrorType; venues?: Venue[]; courtsData?: any; rows?: any[]; } | { error: { message: string; code: string; }; info?: undefined; } | { info: string; error: { message: string; code: string; }; } | { scheduled: HydratedMatchUp[]; notScheduled: HydratedMatchUp[]; overLimitMatchUpIds: string[]; mappedParticipants?: { [key: string]: HydratedParticipant; }; completedMatchUps?: HydratedMatchUp[]; dateMatchUps?: HydratedMatchUp[]; courtPrefix?: string; error?: ErrorType; venues?: Venue[]; courtsData?: any; rows?: any[]; info?: undefined; }; type NamingEntry = { [key: string]: { name: string; abbreviation: string; structureId?: string; }; }; type GenerateAndPopulateArgs = { addNameBaseToAttributeName?: boolean; finishingPositionNaming?: NamingEntry; playoffStructureNameBase?: string; playoffAttributes?: NamingEntry; finishingPositionLimit?: number; tournamentRecord: Tournament; drawDefinition: DrawDefinition; roundProfiles?: RoundProfile[]; playoffPositions?: number[]; roundOffsetLimit?: number; exitProfileLimit?: boolean; playoffGroups?: any[]; roundNumbers?: number[]; structureId: string; idPrefix?: string; isMock?: boolean; uuids?: string[]; event?: Event$1; }; declare function generateAndPopulatePlayoffStructures(params: GenerateAndPopulateArgs): ResultType & { drawDefinition?: DrawDefinition; matchUpModifications?: any[]; structures?: Structure[]; links?: DrawLink[]; success?: boolean; }; type BaselineRatingSource = 'SCALE' | 'SEEDING' | 'MANUAL'; type ActualOutputMethod = 'POINT_SHARE' | 'WEIGHTED'; type PairingMethod = 'DRAW_MATIC' | 'SWISS' | 'LEVEL_BASED'; type RatingSource = 'DYNAMIC_FORM' | 'BASELINE'; type ProcessingGranularity = 'PER_MATCHUP' | 'PER_ROUND'; type RatingAggregation = 'AVERAGE' | 'MIN' | 'MAX' | 'SUM'; type PrimaryRanking = 'PRESSURE_RATING' | 'DYNAMIC_FORM_RATING' | 'WINS' | 'POINTS'; type CompetitionTiebreak = 'HEAD_TO_HEAD' | 'HEAD_TO_HEAD_PRESSURE' | 'POINT_DIFFERENTIAL' | 'STRENGTH_OF_OPPOSITION' | 'DYNAMIC_FORM_RATING' | 'PRESSURE_RATING' | 'BUCHHOLZ' | 'SONNEBORN_BERGER'; type CompetitionPolicy = { policyName?: string; ratingPolicy: { baselineRating: { source: BaselineRatingSource; scaleName?: string; frozenDuringEvent: true; }; dynamicFormRating: { enabled: boolean; initializeFrom: 'BASELINE'; kFactor: number; logisticScale: number; }; pressureRating?: { enabled: boolean; expectationSource: 'BASELINE_ONLY'; actualOutputMethod: ActualOutputMethod; weights?: { pointShare: number; pointDifferential?: number; contextFactor?: number; }; }; ratingAggregation?: RatingAggregation; }; pairingPolicy: { method: PairingMethod; ratingSource: RatingSource; laneSize?: number; avoidRepeatOpponents: boolean; sameTeamValue?: number; }; victoryPolicy: { primaryRanking: PrimaryRanking; tiebreakOrder?: CompetitionTiebreak[]; }; processingGranularity: ProcessingGranularity; }; type CompetitionParticipantState = { participantId: string; baselineRating: number; dynamicFormRating: number; pressureRating: number; roundsPlayed: number; wins: number; losses: number; draws: number; totalPointsWon: number; totalPointsLost: number; ratingHistory: CompetitionRatingHistoryEntry[]; }; type CompetitionRatingHistoryEntry = { roundNumber: number; opponentParticipantId: string; dynamicFormRatingBefore: number; dynamicFormRatingAfter: number; pressureDelta: number; actualOutput: number; expectedOutput: number; }; type CompetitionRoundState = { roundNumber: number; laneAssignments?: Array<{ laneNumber: number; participantIds: string[]; }>; processed: boolean; }; type CompetitionLeaderboardRow = { participantId: string; rank: number; baselineRating: number; dynamicFormRating: number; pressureRating: number; wins: number; losses: number; draws: number; pointsWon: number; pointsLost: number; }; type CompetitionState = { participantStates: Record; roundStates: Record; leaderboard?: CompetitionLeaderboardRow[]; }; type GetCompetitionParticipantStateArgs = { drawDefinition: DrawDefinition; participantId: string; }; type GetCompetitionParticipantStateResult = ResultType & { participantState?: CompetitionParticipantState; }; declare function getCompetitionParticipantState({ drawDefinition, participantId, }: GetCompetitionParticipantStateArgs): GetCompetitionParticipantStateResult; type GetMatchUpsToScheduleArgs = { matchUpPotentialParticipantIds?: { [key: string]: string[]; }; matchUpScheduleTimes?: { [key: string]: string; }; matchUpNotBeforeTimes?: { [key: string]: any; }; scheduleCompletedMatchUps?: boolean; dateScheduledMatchUpIds?: string[]; orderedMatchUpIds?: string[]; clearDate?: boolean; matchUps: any[]; }; declare function getMatchUpsToSchedule(params: GetMatchUpsToScheduleArgs): { matchUpsToSchedule?: any[]; error?: ErrorType; matchUpMap?: any; }; declare function addMatchUpScheduledDate({ scheduledDate: dateToSchedule, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, }: AddScheduleAttributeArgs & { scheduledDate?: string; }): ResultType; declare function drawMatic(params: DrawMaticArgs): ResultType & { matchUps?: MatchUp$1[]; roundResults?: DrawMaticRoundResult[]; }; type GenerateAdHocRoundsArgs = { restrictMatchUpsCount?: boolean; restrictRoundsCount?: boolean; drawDefinition: DrawDefinition; matchUpsCount?: number; matchUpIds?: string[]; roundNumber?: number; structureId?: string; roundsCount: number; newRound?: boolean; idPrefix?: string; isMock?: boolean; event: Event$1; }; declare function generateAdHocRounds(params: GenerateAdHocRoundsArgs): ResultType & { matchUps?: MatchUp$1[]; }; declare function setPositionAssignments({ structurePositionAssignments, provisionalPositioning, tournamentRecord, drawDefinition, event, }: any): any; type GenerateFlightProfileArgs = { scaleAttributes: ScaleAttributes; attachFlightProfile?: boolean; tournamentRecord: Tournament; deleteExisting?: boolean; sortDescending?: boolean; random?: () => number; drawNameRoot?: string; scaleSortMethod?: any; stage?: StageTypeUnion; drawNames?: string[]; scaledEntries?: any; flightsCount: number; splitMethod: string; uuids?: string[]; event: Event$1; }; declare function generateFlightProfile(params: GenerateFlightProfileArgs): { flightProfile?: FlightProfile; splitEntries?: Entry[][]; success?: boolean; error?: ErrorType; }; type TieMatchUpScore = { scoreStringSide1?: string; scoreStringSide2?: string; winningSide?: number; set?: any; }; type GenerateTieMatchUpScoreArgs = { sideAdjustments?: [number, number]; drawDefinition?: DrawDefinition; matchUpsMap?: MatchUpsMap; matchUp: HydratedMatchUp; structure?: Structure; tieFormat?: TieFormat; separator?: string; event?: Event$1; }; declare function generateTieMatchUpScore(params: GenerateTieMatchUpScoreArgs): TieMatchUpScore & ResultType; type GetModifiedMatchUpFormatTimingArgs = { tournamentRecord: Tournament; matchUpFormat: string; event: Event$1; }; declare function getModifiedMatchUpFormatTiming(params: GetModifiedMatchUpFormatTimingArgs): ResultType & { matchUpFormat?: string; recoveryTimes?: any[]; averageTimes?: any[]; }; type InitializeCompetitionStateArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; participantIds: string[]; event?: Event$1; }; type InitializeCompetitionStateResult = ResultType & { competitionState?: CompetitionState; }; declare function initializeCompetitionState(params: InitializeCompetitionStateArgs): InitializeCompetitionStateResult; type ProConflictsArgs = { tournamentRecords: { [key: string]: Tournament; }; useDeepDependencies?: boolean; matchUps: HydratedMatchUp[]; }; declare function proConflicts({ useDeepDependencies, tournamentRecords, matchUps, }: ProConflictsArgs): { error: ErrorType; info?: any; } | { courtIssues: { [key: string]: any; }; rowIssues: { [key: string]: any; }; }; type ProcessCompetitionMatchUpArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; matchUp: MatchUp$1; event?: Event$1; }; declare function processCompetitionMatchUp(params: ProcessCompetitionMatchUpArgs): ResultType; interface QualifierProgressionArgs { drawDefinition: DrawDefinition; tournamentRecord: Tournament; targetRoundNumber?: number; event: Event$1; randomList?: number[]; } declare function qualifierProgression({ targetRoundNumber, tournamentRecord, drawDefinition, event, randomList, }: QualifierProgressionArgs): ResultType; type GetMatchUpFormatTimingArgs = { defaultRecoveryMinutes?: number; defaultAverageMinutes?: number; tournamentRecord: Tournament; matchUpFormat: string; categoryName?: string; categoryType?: string; eventType?: EventTypeUnion; event?: Event$1; }; declare function getMatchUpFormatTiming({ defaultAverageMinutes, defaultRecoveryMinutes, tournamentRecord, matchUpFormat, categoryName, categoryType, eventType, event, }: GetMatchUpFormatTimingArgs): (ResultType & { typeChangeRecoveryMinutes?: number; recoveryMinutes?: number; averageMinutes?: number; }) | { error: { message: string; code: string; }; }; type AssignMatchUpSideParticipantArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; participantId: string; sideNumber: number; matchUpId: string; event: Event$1; }; declare function assignMatchUpSideParticipant({ tournamentRecord, drawDefinition, participantId, sideNumber, matchUpId, event, }: AssignMatchUpSideParticipantArgs): ResultType & { sidesSwapped?: boolean; }; type GetCompetitionLeaderboardArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; event?: Event$1; }; type GetCompetitionLeaderboardResult = ResultType & { leaderboard?: CompetitionLeaderboardRow[]; }; declare function getCompetitionLeaderboard(params: GetCompetitionLeaderboardArgs): GetCompetitionLeaderboardResult; type ProcessCompetitionRoundArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; roundNumber: number; matchUps: MatchUp$1[]; event?: Event$1; }; declare function processCompetitionRound(params: ProcessCompetitionRoundArgs): ResultType; declare function scheduleMatchUps(params: any): (ResultType & { valid?: boolean; }) | { requestConflicts: unknown[]; remainingScheduleTimes: any[] | undefined; individualParticipantProfiles: any; matchUpNotBeforeTimes: any; participantIdsAtLimit: any; skippedScheduleTimes: string[]; overLimitMatchUpIds: any; scheduledMatchUpIds: string[]; noTimeMatchUpIds: any[]; recoveryTimeDeferred: {}; dependencyDeferred: {}; success: boolean; }; declare function setDrawParticipantRepresentativeIds({ representativeParticipantIds, drawDefinition }: { representativeParticipantIds: any; drawDefinition: any; }): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; declare function setStructureOrder({ drawDefinition, orderMap }: { drawDefinition: any; orderMap: any; }): ResultType; type ValidateOfficiatingStatusTransitionArgs = { entityType: 'certification' | 'evaluation' | 'assignment'; fromStatus: string; toStatus: string; }; declare function validateOfficiatingStatusTransition({ entityType, fromStatus, toStatus, }: ValidateOfficiatingStatusTransitionArgs): { error: { message: string; code: string; }; context: { message: string; entityType?: undefined; fromStatus?: undefined; toStatus?: undefined; validTargets?: undefined; }; } | { error: ErrorType; context: { entityType: "certification" | "evaluation" | "assignment"; fromStatus: string; message: string; toStatus?: undefined; validTargets?: undefined; }; } | { error: ErrorType; context: { entityType: "certification" | "evaluation" | "assignment"; fromStatus: string; toStatus: string; validTargets: string[]; message?: undefined; }; } | { valid: boolean; success: boolean; error?: undefined; context?: undefined; }; type GenerateDrawStructuresAndLinksArgs = { playoffAttributes?: PlayoffAttributes; appliedPolicies?: PolicyDefinitions; enforceMinimumDrawSize?: boolean; drawDefinition: DrawDefinition; overwriteExisting?: boolean; drawTypeCoercion?: boolean; staggeredEntry?: boolean; qualifyingOnly?: boolean; qualifyingProfiles?: any; structureName?: string; tieFormat?: TieFormat; matchUpType?: string; drawType?: string; drawSize?: number; idPrefix?: string; isMock?: boolean; uuids?: string[]; }; declare function generateDrawStructuresAndLinks(params: GenerateDrawStructuresAndLinksArgs): any; type ModifySeedAssignmentArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; seedValue?: string | number; participantId: string; validation?: boolean; structureId: string; event?: Event$1; }; declare function modifySeedAssignment({ validation, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }: ModifySeedAssignmentArgs): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type RenameStructuresArgs = { drawDefinition: DrawDefinition; structureDetails: { structureId: string; structureName: string; }[]; }; declare function renameStructures({ drawDefinition, structureDetails }: RenameStructuresArgs): ResultType; declare function resetVoluntaryConsolationStructure({ tournamentRecord, drawDefinition, resetEntries, event }: { tournamentRecord: any; drawDefinition: any; resetEntries: any; event: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function enableTieAutoCalc({ tournamentRecord, drawDefinition, matchUpId, event }: { tournamentRecord: any; drawDefinition: any; matchUpId: any; event: any; }): any; declare function getDrawParticipantRepresentativeIds({ drawDefinition }: { drawDefinition: any; }): (ResultType & { extension?: Extension; }) | { representativeParticipantIds: any; }; type RemoveStructureArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; structureId: string; force?: boolean; event: Event$1; }; declare function removeStructure(params: RemoveStructureArgs): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; } | { removedMatchUpIds: string[]; removedStructureIds: string[]; success: boolean; error?: undefined; }; type ResetCompetitionStateArgs = { drawDefinition: DrawDefinition; }; declare function resetCompetitionState({ drawDefinition }: ResetCompetitionStateArgs): ResultType; declare function withdrawParticipantAtDrawPosition(params: any): ResultType & { participantId?: string; }; type AddVoluntaryConsolationStructureArgs = { structureAbbreviation?: string; drawDefinition: DrawDefinition; structureName?: string; matchUpType?: string; structureId?: string; }; declare function addVoluntaryConsolationStructure({ structureName, structureAbbreviation, drawDefinition, matchUpType, structureId, }: AddVoluntaryConsolationStructureArgs): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type BulkScheduleMachUpsArgs = { tournamentRecords?: { [key: string]: Tournament; }; scheduleCompletedMatchUps?: boolean; tournamentRecord?: Tournament; scheduleByeMatchUps?: boolean; errorOnAnachronism?: boolean; removePriorValues?: boolean; checkChronology?: boolean; matchUpDependencies?: any; matchUpIds?: string[]; matchUpDetails?: any; schedule?: any; }; declare function bulkScheduleTournamentMatchUps({ scheduleCompletedMatchUps, scheduleByeMatchUps, errorOnAnachronism, checkChronology, matchUpDependencies, removePriorValues, tournamentRecords, tournamentRecord, matchUpDetails, matchUpIds, schedule, }: BulkScheduleMachUpsArgs): { error?: ErrorType; scheduled?: number; warnings?: any[]; }; declare function luckyLoserDrawPositionAssignment(params: any): ResultType | { error: { message: string; code: string; }; }; type ModifyEventMatchUpFormatTimingArgs = { tournamentRecord: Tournament; recoveryMinutes?: number; averageMinutes?: number; matchUpFormat: string; categoryType?: string; tournamentId?: string; eventId: string; event?: Event$1; }; declare function modifyEventMatchUpFormatTiming(params: ModifyEventMatchUpFormatTimingArgs): (ResultType & { valid?: boolean; }) | { success: boolean; error?: undefined; } | { error: { message: string; code: string; }; }; type RemoveEventMatchUpFormatTimingArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; eventId: string; event?: Event$1; }; declare function removeEventMatchUpFormatTiming(params: RemoveEventMatchUpFormatTimingArgs): { success?: boolean; error?: ErrorType; info?: any; } | { error: { message: string; code: string; }; }; type SetDrawPositionPreferencesArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; participantId: string; preferences: number[]; }; declare function setDrawPositionPreferences({ drawDefinition, participantId, preferences, }: SetDrawPositionPreferencesArgs): { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; } | { success: boolean; error?: undefined; info?: undefined; }; type ToggleParticipantCheckInStateArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; activeTournamentId?: string; participantId: string; tournamentId?: string; matchUpIds?: string[]; matchUpId: string; }; declare function toggleParticipantCheckInState(params: ToggleParticipantCheckInStateArgs): any; declare function anonymizeTournamentRecord({ keepExtensions, anonymizeParticipantNames, tournamentRecord, tournamentName, personIds, tournamentId, }: { keepExtensions?: never[] | undefined; anonymizeParticipantNames?: boolean | undefined; tournamentRecord: any; tournamentName: any; personIds?: never[] | undefined; tournamentId: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type TallyParticipantResultsArgs = { policyDefinitions?: PolicyDefinitions; generateReport?: boolean; pressureRating?: string; matchUpFormat?: string; perPlayer?: number; subOrderMap?: any; matchUps: any[]; }; type TallyResultType = { completedTieMatchUps?: boolean; bracketComplete?: boolean; participantResults?: any; readableReport?: string; report?: string[]; order?: any[]; }; declare function tallyParticipantResults({ policyDefinitions, generateReport, pressureRating, matchUpFormat, matchUps, subOrderMap, perPlayer, }: TallyParticipantResultsArgs): TallyResultType & ResultType; type GetCompetitionPolicyArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; event?: Event$1; }; type GetCompetitionPolicyResult = ResultType & { competitionPolicy?: CompetitionPolicy; }; declare function getCompetitionPolicy(params: GetCompetitionPolicyArgs): GetCompetitionPolicyResult; declare function removeMatchUpCourtAssignment(params: any): any; type LoserLinkDefinition = { sourceRoundNumber: number; targetRoundNumber: number; }; type GenerateConsolationArgs = { structureName?: string; structureType?: string; matchUpFormat?: string; matchUpType?: string; drawSize?: number; }; type AddLinkedConsolationStructureArgs = GenerateConsolationArgs & { drawDefinition: any; structureId?: string; links: LoserLinkDefinition[]; }; declare function generateConsolationStructure({ structureName, structureType, drawSize, matchUpFormat, matchUpType, }: GenerateConsolationArgs): any; declare function addLinkedConsolationStructure({ drawDefinition, structureId: mainStructureId, structureName, structureType, drawSize, matchUpFormat, matchUpType, links: linkDefs, }: AddLinkedConsolationStructureArgs): any; type AddMatchUpScheduleItemsArgs = { inContextMatchUps?: HydratedMatchUp[]; drawMatchUps?: HydratedMatchUp[]; proConflictDetection?: boolean; drawDefinition: DrawDefinition; errorOnAnachronism?: boolean; removePriorValues?: boolean; checkChronology?: boolean; matchUpDependencies?: any; disableNotice?: boolean; tournamentRecords: any; tournamentRecord: any; matchUpId: string; schedule: any; event?: Event$1; }; declare function addMatchUpScheduleItems(params: AddMatchUpScheduleItemsArgs): { error?: ErrorType; success?: boolean; warnings?: any[]; info?: any; }; declare function addMatchUpCourtOrder({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, courtOrder, matchUpId, }: AddScheduleAttributeArgs & { courtOrder?: number; }): ResultType | { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; }; declare function addMatchUpOfficial({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, participantId, officialType, matchUpId, }: AddScheduleAttributeArgs & { participantId?: string; officialType?: string; }): ResultType | { error: { message: string; code: string; }; }; declare function addMatchUpStartTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, startTime, event, }: AddScheduleAttributeArgs & { startTime?: string; }): any; declare function addMatchUpEndTime({ validateTimeSeries, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, endTime, event, }: AddScheduleAttributeArgs & { validateTimeSeries?: boolean; endTime?: string; }): any; declare function addMatchUpStopTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, stopTime, event, }: AddScheduleAttributeArgs & { stopTime?: string; }): any; declare function addMatchUpResumeTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, resumeTime, matchUpId, event, }: AddScheduleAttributeArgs & { resumeTime?: string; }): any; type GenerateLineUpsArgs = { useDefaultEventRanking?: boolean; tournamentRecord: Tournament; drawDefinition?: DrawDefinition; scaleAccessor: any; singlesOnly?: boolean; tieFormat?: TieFormat; attach?: boolean; event: Event$1; }; declare function generateLineUps(params: GenerateLineUpsArgs): ResultType & { lineUps?: { [key: string]: LineUp; }; participantsToAdd?: any[]; }; type GetCompetitionStateArgs = { drawDefinition: DrawDefinition; }; type GetCompetitionStateResult = ResultType & { competitionState?: CompetitionState; }; declare function getCompetitionState({ drawDefinition }: GetCompetitionStateArgs): GetCompetitionStateResult; type GetParticipantResultsArgs = { matchUps: HydratedMatchUp[]; participantIds?: string[]; pressureRating?: string; groupingTotal?: string; matchUpFormat?: string; perPlayer?: number; tallyPolicy?: any; }; declare function getParticipantResults({ participantIds, pressureRating, groupingTotal, matchUpFormat, tallyPolicy, perPlayer, matchUps, }: GetParticipantResultsArgs): { participantResults: {}; }; type GetSchedulingProfileIssuesArgs = { tournamentRecords: TournamentRecords; scheduleDates?: string[]; periodLength?: number; }; declare function getSchedulingProfileIssues(params?: GetSchedulingProfileIssuesArgs): { error: { message: string; code: string; }; } | { success: boolean; issues: any[]; error?: undefined; } | { success: boolean; issuesCount: number; profileIssues: { matchUpIdShouldBeAfter: any; }; roundIndexShouldBeAfter: {}; error?: undefined; }; declare function modifyMatchUpFormatTiming(params: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type PositionActionsArgs = { inContextDrawMatchUps?: HydratedMatchUp[]; restrictAdHocRoundParticipants?: boolean; tournamentParticipants?: Participant$1[]; policyDefinitions?: PolicyDefinitions; provisionalPositioning?: boolean; tournamentRecord?: Tournament; returnParticipants?: boolean; drawDefinition: DrawDefinition; matchUpsMap?: MatchUpsMap; drawPosition: number; structureId: string; matchUpId?: string; event?: Event$1; }; declare function positionActions(params: PositionActionsArgs): ResultType & { isActiveDrawPosition?: boolean; hasPositionAssigned?: boolean; isDrawPosition?: boolean; isByePosition?: boolean; validActions?: any[]; }; type RemapArgs = { targetMatchUpIds: TargetMatchUpId[]; drawDefinition: DrawDefinition; }; declare function remapDrawDefinitionMatchUpIds({ targetMatchUpIds, drawDefinition, }: RemapArgs): ResultType & { remappedCount?: number; }; type ReplaceTieMatchUpParticipantIdArgs = { policyDefinitions?: PolicyDefinitions; existingParticipantId: string; tournamentRecord: Tournament; drawDefinition: DrawDefinition; newParticipantId: string; enforceGender?: boolean; substitution?: boolean; tieMatchUpId: string; event: Event$1; }; declare function replaceTieMatchUpParticipantId(params: ReplaceTieMatchUpParticipantIdArgs): ResultType & { participantRemoved?: string; participantAdded?: string; modifiedLineUp?: LineUp; }; type AssignDrawPositionByeArgs = { provisionalPositioning?: boolean; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; isPositionAction?: boolean; matchUpsMap?: MatchUpsMap; structure?: Structure; drawPosition: number; structureId?: string; loserMatchUp?: MatchUp$1; event?: Event$1; }; declare function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, loserMatchUp, matchUpsMap, structureId, structure, event, }: AssignDrawPositionByeArgs): any; type AssignMatchUpSideParticipantIdArgs = { policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; drawDefinition: DrawDefinition; teamParticipantId?: string; enforceGender?: boolean; participantId: string; tieMatchUpId: string; sideNumber?: number; event: Event$1; }; declare function assignTieMatchUpParticipantId(params: AssignMatchUpSideParticipantIdArgs): ResultType & { deletedParticipantId?: string; modifiedLineUp?: LineUp; }; type BulkUpdateCourtAssignmentsParams = { tournamentRecords: TournamentRecords; courtAssignments: any[]; courtDayDate: string; }; declare function bulkUpdateCourtAssignments(params: BulkUpdateCourtAssignmentsParams): any; declare function createTournamentRecord(params: any): any; type GetScheduledRoundsDetailsArgs = { tournamentRecords?: { [key: string]: Tournament; }; scheduleCompletedMatchUps?: boolean; containedStructureIds?: string[]; matchUps?: HydratedMatchUp[]; tournamentRecord?: Tournament; periodLength?: number; rounds: any[]; }; type RoundsDetailsResult = { greatestAverageMinutes?: number; scheduledRoundsDetails?: any[]; orderedMatchUpIds?: string[]; matchUpFormatCohorts?: any; recoveryMinutesMap?: any; averageMinutesMap?: any; error?: ErrorType; success?: boolean; minutesMap?: any; info?: string; }; declare function getScheduledRoundsDetails(params: GetScheduledRoundsDetailsArgs): RoundsDetailsResult; type ModifyParticipantsPaymentStatusArgs = { tournamentRecord: any; participantIds: string[]; paymentState: PaymentStatusUnion; }; declare function modifyParticipantsPaymentStatus({ tournamentRecord, participantIds, paymentState, }: ModifyParticipantsPaymentStatusArgs): any; declare function removeDrawPositionAssignment(params: any): ResultType & { participantId?: string; }; type MutationLockScope = 'SCHEDULING' | 'SCORING' | 'DRAWS' | 'MATCHUPS' | 'PARTICIPANTS' | 'ENTRIES' | 'EVENTS' | 'VENUES' | 'PUBLISHING' | 'TOURNAMENT' | 'TIE_FORMAT' | 'POLICY' | 'COMPETITION' | 'RANKING'; interface MutationLock { lockId: string; lockToken: string; scope: MutationLockScope; methods?: string[]; expiresAt: string | null; createdAt: string; } type RemoveMutationLockArgs = { tournamentRecord: Tournament; drawDefinition?: { drawId: string; extensions?: any[]; }; event?: { eventId: string; extensions?: any[]; }; venueId?: string; lockId?: string; scope?: MutationLockScope; lockToken?: string; forceRelease?: boolean; }; declare function removeMutationLock(params: RemoveMutationLockArgs): { success?: boolean; error?: ErrorType; info?: string; }; type RemoveTieMatchUpParticipantIdArgs = { policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; drawDefinition: DrawDefinition; participantId: string; tieMatchUpId: string; event: Event$1; }; declare function removeTieMatchUpParticipantId(params: RemoveTieMatchUpParticipantIdArgs): ResultType & { modifiedLineUp?: LineUp; }; declare function addSchedulingProfileRound({ tournamentRecords, scheduleDate, venueId, round }: { tournamentRecords: any; scheduleDate: any; venueId: any; round: any; }): any; type AllocateTeamMatchUpCourtsArgs = { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; removePriorValues?: boolean; disableNotice?: boolean; courtDayDate?: string; matchUpId: string; courtIds: any; }; declare function allocateTeamMatchUpCourts({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, courtDayDate, matchUpId, courtIds, }: AllocateTeamMatchUpCourtsArgs): ResultType | { matchUp?: HydratedMatchUp; structure?: Structure; error?: ErrorType; } | { error: { message: string; code: string; }; context?: undefined; } | { error: { message: string; code: string; }; context: { courtIds: any; }; }; type StructurePositionAssignmentType = { positionAssignments: PositionAssignment[]; structureId: string; }; type AutomatedPlayoffPositioningArgs = { provisionalPositioning?: boolean; seedingProfile?: SeedingProfile; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; applyPositioning?: boolean; random?: () => number; structureId: string; placeByes?: boolean; seedsOnly?: boolean; event?: Event$1; }; declare function automatedPlayoffPositioning(params: AutomatedPlayoffPositioningArgs): { structurePositionAssignments?: StructurePositionAssignmentType[]; positioningReports?: { [key: string]: any; }[]; success?: boolean; error?: ErrorType; }; type GenerateScoreString = { addOutcomeString?: boolean; autoComplete?: boolean; matchUpStatus?: string; matchUpFormat?: string; winnerFirst?: boolean; winningSide?: number; setTBlast?: boolean; reversed?: boolean; sets: any; }; declare function generateScoreString(params: GenerateScoreString): string | { error?: ErrorType; info?: ErrorType | string; }; type MatchUpActionsArgs = { inContextDrawMatchUps?: HydratedMatchUp[]; restrictAdHocRoundParticipants?: boolean; tournamentParticipants?: Participant$1[]; tournamentRecords?: TournamentRecords; policyDefinitions?: PolicyDefinitions; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; matchUpsMap?: MatchUpsMap; enforceGender?: boolean; participantId?: string; tournamentId?: string; sideNumber?: number; matchUpId?: string; eventId?: string; drawId?: string; event?: Event$1; }; declare function matchUpActions(params?: MatchUpActionsArgs): ResultType & { structureIsComplete?: boolean; isDoubleExit?: boolean; isByeMatchUp?: boolean; validActions?: any[]; }; declare function modifyIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, tournamentRecord }: { individualParticipantIds: any; groupingParticipantId: any; tournamentRecord: any; }): ResultType; declare function modifyParticipantsSignInStatus({ tournamentRecord, participantIds, signInState }: { tournamentRecord: any; participantIds: any; signInState: any; }): any; type RemoveIndividualParticipantIdsArgs = { addIndividualParticipantsToEvents?: boolean; individualParticipantIds: string[]; groupingParticipantId: string; tournamentRecord: Tournament; suppressErrors?: boolean; }; declare function removeIndividualParticipantIds({ addIndividualParticipantsToEvents, individualParticipantIds, groupingParticipantId, tournamentRecord, suppressErrors, }: RemoveIndividualParticipantIdsArgs): ResultType; type RemoveParticipantIdsFromAllTeamsArgs = { participantRole?: ParticipantRoleUnion; individualParticipantIds?: string[]; tournamentRecord: Tournament; groupingTypes?: string[]; }; declare function removeParticipantIdsFromAllTeams({ participantRole, individualParticipantIds, groupingTypes, tournamentRecord, }: RemoveParticipantIdsFromAllTeamsArgs): { success: boolean; } | { error: { message: string; code: string; }; }; type RemoveMatchUpSideParticipantArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; sideNumber?: number; matchUpId: string; event?: Event$1; }; declare function removeMatchUpSideParticipant(params: RemoveMatchUpSideParticipantArgs): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; sideNumber: number; } | { error: { message: string; code: string; }; sideNumber?: undefined; }; type ResolveDraftPositionsArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; random?: () => number; applyResults?: boolean; tierIndex?: number; event?: Event$1; }; declare function resolveDraftPositions({ tournamentRecord, drawDefinition, applyResults, tierIndex: targetTierIndex, random, event, }: ResolveDraftPositionsArgs): any; type CopyTournamentRecordArgs = { tournamentRecord: Tournament; copyParticipants?: boolean; extensionList?: string[]; itemTypeList?: string[]; tournamentName: string; startDate: string; endDate?: string; }; declare function copyTournamentRecord(params: CopyTournamentRecordArgs): (ResultType & { valid?: boolean; }) | { tournamentRecord: { participants: any[]; parentOrganisation: any; venues: any; extensions: any; timeItems: any; events: any[]; weekdays: ("MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT" | "SUN")[]; tournamentName: string; startDate: string; tournamentId: string; endDate: string; }; success: boolean; }; declare function generateVirtualCourts(params: any): { error: { message: string; code: string; }; courts: any; virtualCourts?: undefined; assignedBookings?: undefined; } | { error: { message: string; code: string; }; courts?: undefined; virtualCourts?: undefined; assignedBookings?: undefined; } | { virtualCourts: any[]; assignedBookings: any[]; error?: undefined; courts?: undefined; }; declare function removeDelegatedOutcome({ drawDefinition, event, matchUpId }: { drawDefinition: any; event: any; matchUpId: any; }): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; declare function addDrawDefinitionTimeItem({ drawDefinition, timeItem }: { drawDefinition: any; timeItem: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function addDynamicRatings(params: any): any; type AddMutationLockArgs = { tournamentRecord: Tournament; drawDefinition?: { drawId: string; extensions?: any[]; }; event?: { eventId: string; extensions?: any[]; }; venueId?: string; scope: MutationLockScope; lockToken: string; expiresAt?: string | null; methods?: string[]; }; declare function addMutationLock(params: AddMutationLockArgs): { success?: boolean; error?: ErrorType; lockId?: string; info?: string; }; declare function attachQualifyingStructure(params: any): ResultType; type GetAvailablePlayoffProfileArgs = { drawDefinition: DrawDefinition; structureId?: string; }; declare function getAvailablePlayoffProfiles({ drawDefinition, structureId }: GetAvailablePlayoffProfileArgs): any; type PredictionAnchor = { probability: number; delta: number; }; type PredictionModel = { competitiveAnchors: PredictionAnchor[]; decisiveAnchors: PredictionAnchor[]; }; type BandPrediction = { competitive: number; decisive: number; routine: number; }; type ProjectionMode = 'BALANCED_BRACKET' | 'ROUND_ROBIN' | 'MIN_DELTA'; type ProjectedPair = [number, number]; type PredictDrawCompetitiveBandsArgs = { predictionModel?: PredictionModel; projectionMode?: ProjectionMode; tournamentRecord?: Tournament; groupSize?: number; ratings: number[]; drawType?: string; drawSize?: number; }; type PredictDrawCompetitiveBandsResult = BandPrediction & { perMatchUpPredictions?: BandPrediction[]; projectionMode?: ProjectionMode; projectedPairs?: ProjectedPair[]; expectedMatchCount?: number; error?: ErrorType; }; declare function predictDrawCompetitiveBands({ tournamentRecord, projectionMode, predictionModel, groupSize, ratings, drawType, }: PredictDrawCompetitiveBandsArgs): PredictDrawCompetitiveBandsResult; declare function reorderUpcomingMatchUps(params: any): { success: boolean; } | ResultType; declare const SanctioningStatusEnum: { readonly DRAFT: "DRAFT"; readonly SUBMITTED: "SUBMITTED"; readonly UNDER_REVIEW: "UNDER_REVIEW"; readonly APPROVED: "APPROVED"; readonly CONDITIONALLY_APPROVED: "CONDITIONALLY_APPROVED"; readonly REJECTED: "REJECTED"; readonly WITHDRAWN: "WITHDRAWN"; readonly MODIFICATION_REQUESTED: "MODIFICATION_REQUESTED"; readonly ACTIVE: "ACTIVE"; readonly POST_EVENT: "POST_EVENT"; readonly CLOSED: "CLOSED"; readonly ISSUES_FLAGGED: "ISSUES_FLAGGED"; }; type SanctioningStatus = (typeof SanctioningStatusEnum)[keyof typeof SanctioningStatusEnum]; declare const EndorsementStatusEnum: { readonly PENDING: "PENDING"; readonly ENDORSED: "ENDORSED"; readonly DECLINED: "DECLINED"; readonly NOT_REQUIRED: "NOT_REQUIRED"; }; type EndorsementStatus = (typeof EndorsementStatusEnum)[keyof typeof EndorsementStatusEnum]; declare const AmendmentStatusEnum: { readonly PROPOSED: "PROPOSED"; readonly UNDER_REVIEW: "UNDER_REVIEW"; readonly APPROVED: "APPROVED"; readonly REJECTED: "REJECTED"; }; type AmendmentStatus = (typeof AmendmentStatusEnum)[keyof typeof AmendmentStatusEnum]; declare const ComplianceStatusEnum: { readonly NOT_APPLICABLE: "NOT_APPLICABLE"; readonly PENDING: "PENDING"; readonly IN_PROGRESS: "IN_PROGRESS"; readonly COMPLIANT: "COMPLIANT"; readonly ISSUES_FLAGGED: "ISSUES_FLAGGED"; }; type ComplianceStatus = (typeof ComplianceStatusEnum)[keyof typeof ComplianceStatusEnum]; declare const ComplianceItemStatusEnum: { readonly PENDING: "PENDING"; readonly SUBMITTED: "SUBMITTED"; readonly VERIFIED: "VERIFIED"; readonly OVERDUE: "OVERDUE"; readonly WAIVED: "WAIVED"; }; type ComplianceItemStatus = (typeof ComplianceItemStatusEnum)[keyof typeof ComplianceItemStatusEnum]; declare const SanctioningRelationshipEnum: { readonly PRIMARY: "PRIMARY"; readonly SECONDARY: "SECONDARY"; readonly INDEPENDENT: "INDEPENDENT"; }; type SanctioningRelationship = (typeof SanctioningRelationshipEnum)[keyof typeof SanctioningRelationshipEnum]; declare const AmendmentSeverityEnum: { readonly MINOR: "MINOR"; readonly SUBSTANTIAL: "SUBSTANTIAL"; }; type AmendmentSeverity = (typeof AmendmentSeverityEnum)[keyof typeof AmendmentSeverityEnum]; interface SanctioningRecord { sanctioningId: string; status: SanctioningStatus; version: number; createdAt: string; updatedAt: string; submittedAt?: string; reviewedAt?: string; approvedAt?: string; applicant: Applicant; endorsement?: Endorsement; endorsements?: Endorsement[]; reviewer?: Reviewer; proposal: TournamentProposal; governingBodyId: string; governingBody?: Organisation; sanctioningLevel?: string; applicantProviderId?: string; sanctioningPolicy?: string; policyVersion?: string; policySnapshot?: SanctioningPolicy; linkedSanctioningIds?: string[]; parentSanctioningId?: string; sanctioningRelationship?: SanctioningRelationship; conditions?: Condition[]; reviewNotes?: ReviewNote[]; amendments?: Amendment[]; statusHistory?: StatusTransition[]; compliance?: ComplianceRecord; extensions?: Extension[]; timeItems?: TimeItem[]; } interface Applicant { organisationId?: string; organisationName?: string; contactName?: string; contactEmail?: string; contactPhone?: string; credentials?: Credential[]; extensions?: Extension[]; } interface Credential { credentialType: string; credentialId?: string; issuedBy?: string; issuedDate?: string; expirationDate?: string; verified?: boolean; } interface Endorsement { status: EndorsementStatus; endorserId?: string; endorserName?: string; endorsedAt?: string; declinedAt?: string; declineReason?: string; endorserNotes?: string; endorserContact?: PersonReference; conditions?: string[]; endorsementLevel?: number; prerequisiteEndorserId?: string; extensions?: Extension[]; } interface PersonReference { personName?: string; email?: string; phone?: string; role?: string; certificationLevel?: string; } interface Reviewer { reviewerId?: string; reviewerName?: string; extensions?: Extension[]; } interface TournamentProposal { tournamentName: string; formalName?: string; promotionalName?: string; tournamentLevel?: TournamentLevelUnion; sanctioningTier?: string; discipline?: DisciplineUnion; proposedStartDate: string; proposedEndDate: string; hostCountryCode?: CountryCodeUnion; venues?: VenueProposal[]; indoorOutdoor?: IndoorOutdoorUnion; surfaceCategory?: SurfaceCategoryUnion; localTimeZone?: string; events: EventProposal[]; totalPrizeMoney?: PrizeMoney[]; entryFees?: EntryFee[]; sanctionFee?: PrizeMoney; officials?: OfficialProposal[]; tournamentDirector?: PersonReference; referee?: PersonReference; insuranceCertificate?: DocumentReference; safetyPlan?: DocumentReference; medicalPlan?: DocumentReference; antiCorruptionCompliance?: boolean; safeguardingCompliance?: boolean; registrationProfile?: RegistrationProfile; calendarSection?: string; calendarConflictCheck?: boolean; extensions?: Extension[]; } interface EventProposal { eventProposalId?: string; eventName: string; eventType: EventTypeUnion; gender?: GenderUnion; category?: Category; drawType?: DrawTypeUnion; allowedDrawTypes?: DrawTypeUnion[]; drawSize?: number; qualifyingDrawSize?: number; matchUpFormat?: string; allowedMatchUpFormats?: string[]; tieFormat?: TieFormat; indoorOutdoor?: IndoorOutdoorUnion; surfaceCategory?: SurfaceCategoryUnion; prizeMoney?: PrizeMoney[]; wheelchairClass?: WheelchairClassUnion; extensions?: Extension[]; } interface VenueProposal { venueName: string; venueId?: string; address?: string; city?: string; state?: string; countryCode?: CountryCodeUnion; numberOfCourts?: number; surfaceCategory?: SurfaceCategoryUnion; indoorOutdoor?: IndoorOutdoorUnion; coordinates?: Coordinates; extensions?: Extension[]; } interface Coordinates { latitude: number; longitude: number; } interface EntryFee { amount: number; currencyCode: string; eventType?: EventTypeUnion; category?: string; extensions?: Extension[]; } interface OfficialProposal { role: string; personName?: string; certificationLevel?: string; certificationBody?: string; extensions?: Extension[]; } interface DocumentReference { documentType: string; documentId?: string; documentUrl?: string; uploadedAt?: string; verified?: boolean; extensions?: Extension[]; } interface Condition { conditionId: string; description: string; met: boolean; metAt?: string; metNotes?: string; createdAt?: string; extensions?: Extension[]; } interface ReviewNote { noteId: string; reviewerId?: string; reviewerName?: string; note: string; createdAt: string; extensions?: Extension[]; } interface StatusTransition { fromStatus: SanctioningStatus; toStatus: SanctioningStatus; transitionedAt: string; transitionedBy?: string; reason?: string; } interface Amendment { amendmentId: string; status: AmendmentStatus; proposedAt: string; resolvedAt?: string; proposedBy?: string; reviewerNotes?: string; changes: ProposalChange[]; severity: AmendmentSeverity; withinTimeline: boolean; extensions?: Extension[]; } interface ProposalChange { field: string; previousValue: any; proposedValue: any; changeType: 'MODIFIED' | 'ADDED' | 'REMOVED'; } interface ComplianceRecord { status: ComplianceStatus; items: ComplianceItem[]; notes?: ReviewNote[]; completedAt?: string; } declare const ComplianceItemTypeEnum: { readonly RESULTS_SUBMISSION: "RESULTS_SUBMISSION"; readonly FINANCIAL_RECONCILIATION: "FINANCIAL_RECONCILIATION"; readonly INCIDENT_REPORT: "INCIDENT_REPORT"; readonly PRIZE_MONEY_CONFIRMATION: "PRIZE_MONEY_CONFIRMATION"; readonly SANCTION_FEE_PAYMENT: "SANCTION_FEE_PAYMENT"; readonly SUPERVISOR_REPORT: "SUPERVISOR_REPORT"; readonly FACILITY_REPORT: "FACILITY_REPORT"; readonly SAFEGUARDING_REPORT: "SAFEGUARDING_REPORT"; readonly CUSTOM: "CUSTOM"; }; type ComplianceItemType = (typeof ComplianceItemTypeEnum)[keyof typeof ComplianceItemTypeEnum]; interface ComplianceItem { itemId: string; itemType: ComplianceItemType; description: string; required: boolean; status: ComplianceItemStatus; deadline?: string; submittedAt?: string; verifiedAt?: string; value?: any; extensions?: Extension[]; } interface SanctioningPolicy { policyName: string; policyVersion: string; effectiveDate: string; supersededDate?: string; governingBodyId: string; tiers: SanctioningTier[]; calendarRules?: CalendarRules; personnelRules?: PersonnelRules; amendmentRules?: AmendmentRules; postEventRequirements?: PostEventRequirement[]; transitionGuards?: TransitionGuard[]; requireEndorsement?: boolean; requiredEndorsementCount?: number; requireInsurance?: boolean; requireSafetyPlan?: boolean; requireMedicalPlan?: boolean; requireAntiCorruption?: boolean; requireSafeguarding?: boolean; minimumLeadWeeks?: number; resultsDeadlineDays?: number; requirePostEventReport?: boolean; extensions?: Extension[]; } interface SanctioningTier { tierName: string; tierLevel: number; allowedEventTypes?: EventTypeUnion[]; allowedCategories?: Category[]; allowedGenders?: GenderUnion[]; allowedDisciplines?: DisciplineUnion[]; allowedDrawTypes?: DrawTypeUnion[]; allowedDrawSizes?: number[]; maxQualifyingDrawSize?: number; qualifyingAllowed?: boolean; maxWildcards?: number; maxAlternates?: number; maxQualifiers?: number; allowedMatchUpFormats?: string[]; minimumPrizeMoney?: number; maximumPrizeMoney?: number; currencyCode?: string; sanctionFeePercent?: number; sanctionFeeFixed?: number; minimumCourts?: number; requireBackdrops?: boolean; requireScoreboards?: boolean; minimumOfficials?: number; officialCertificationLevel?: string; tdRefereeSameAllowed?: boolean; minimumParticipants?: number; rankingPointsProfile?: string; prerequisiteTiers?: string[]; prerequisiteEventCount?: number; minimumLeadWeeks?: number; extensions?: Extension[]; } interface CalendarRules { proximityRadiusKm?: number; proximityWeeks?: number; blackoutDates?: string[]; mandatoryWeeks?: string[]; maxEventsPerWeek?: number; calendarSections?: CalendarSection[]; } interface CalendarSection { sectionId: string; sectionName: string; countryCodes?: CountryCodeUnion[]; regionCodes?: string[]; } interface CalendarEvent { sanctioningId?: string; tournamentId?: string; tournamentName?: string; startDate: string; endDate: string; sanctioningTier?: string; calendarSection?: string; countryCode?: CountryCodeUnion; coordinates?: Coordinates; } interface CalendarContext { existingEvents: CalendarEvent[]; calendarRules: CalendarRules; } interface PersonnelRules { roles: PersonnelRole[]; } interface PersonnelRole { roleName: string; required: boolean; minimumCount?: number; certificationRequired?: string; safeguardingRequired?: boolean; } interface AmendmentRules { substantialChangeFields?: string[]; noChangeWindowWeeks?: number; substantialChangeWindowWeeks?: number; prizeMoneyIncrease?: 'ALLOWED' | 'REQUIRES_REVIEW' | 'PROHIBITED'; prizeMoneyDecrease?: 'ALLOWED' | 'REQUIRES_REVIEW' | 'PROHIBITED'; lateChangePenalty?: boolean; } interface PostEventRequirement { itemType: ComplianceItemType; description: string; required: boolean; deadlineDays: number; tiers?: string[]; } type TransitionGuardType = 'ENDORSEMENT_REQUIRED' | 'PROPOSAL_VALID' | 'ALL_CONDITIONS_MET' | 'COMPLIANCE_COMPLETE' | 'CUSTOM'; interface TransitionGuard { from: SanctioningStatus; to: SanctioningStatus; guard: TransitionGuardType; customGuardField?: string; message?: string; tiers?: string[]; } type SanctioningRecords = { [sanctioningId: string]: SanctioningRecord; }; type SanctioningDirective = { pipe?: { [key: string]: boolean; }; params?: { [key: string]: any; }; method: string; }; type SanctioningDirectives = SanctioningDirective[]; declare const CertificationStatusEnum: { readonly ACTIVE: "ACTIVE"; readonly EXPIRED: "EXPIRED"; readonly SUSPENDED: "SUSPENDED"; readonly REVOKED: "REVOKED"; readonly PENDING_RENEWAL: "PENDING_RENEWAL"; }; type CertificationStatus = (typeof CertificationStatusEnum)[keyof typeof CertificationStatusEnum]; declare const EvaluationStatusEnum: { readonly DRAFT: "DRAFT"; readonly SUBMITTED: "SUBMITTED"; readonly REVIEWED: "REVIEWED"; readonly APPROVED: "APPROVED"; readonly REJECTED: "REJECTED"; }; type EvaluationStatus = (typeof EvaluationStatusEnum)[keyof typeof EvaluationStatusEnum]; declare const AssignmentStatusEnum: { readonly PROPOSED: "PROPOSED"; readonly CONFIRMED: "CONFIRMED"; readonly DECLINED: "DECLINED"; readonly CANCELLED: "CANCELLED"; readonly COMPLETED: "COMPLETED"; }; type AssignmentStatus = (typeof AssignmentStatusEnum)[keyof typeof AssignmentStatusEnum]; declare const OfficialRoleSubtypeEnum: { readonly CHAIR_UMPIRE: "CHAIR_UMPIRE"; readonly LINE_UMPIRE: "LINE_UMPIRE"; readonly REFEREE: "REFEREE"; readonly CHIEF_UMPIRE: "CHIEF_UMPIRE"; readonly DEPUTY_REFEREE: "DEPUTY_REFEREE"; readonly REVIEW_OFFICIAL: "REVIEW_OFFICIAL"; readonly COURT_SUPERVISOR: "COURT_SUPERVISOR"; }; type OfficialRoleSubtype = (typeof OfficialRoleSubtypeEnum)[keyof typeof OfficialRoleSubtypeEnum]; declare const CertificationFamilyEnum: { readonly UMPIRE: "UMPIRE"; readonly REFEREE: "REFEREE"; readonly CHIEF_UMPIRE: "CHIEF_UMPIRE"; readonly REVIEW_OFFICIAL: "REVIEW_OFFICIAL"; }; type CertificationFamily = (typeof CertificationFamilyEnum)[keyof typeof CertificationFamilyEnum]; declare const CertificationLevelEnum: { readonly WHITE_BADGE: "WHITE_BADGE"; readonly BRONZE_BADGE: "BRONZE_BADGE"; readonly SILVER_BADGE: "SILVER_BADGE"; readonly GOLD_BADGE: "GOLD_BADGE"; }; type CertificationLevel = (typeof CertificationLevelEnum)[keyof typeof CertificationLevelEnum]; declare const ScoringTypeEnum: { readonly NUMERIC: "NUMERIC"; readonly SCALE: "SCALE"; readonly CHECKLIST: "CHECKLIST"; readonly TEXT: "TEXT"; }; type ScoringType = (typeof ScoringTypeEnum)[keyof typeof ScoringTypeEnum]; declare const ScoringMethodEnum: { readonly WEIGHTED_AVERAGE: "WEIGHTED_AVERAGE"; readonly SIMPLE_AVERAGE: "SIMPLE_AVERAGE"; readonly SUM: "SUM"; }; type ScoringMethod = (typeof ScoringMethodEnum)[keyof typeof ScoringMethodEnum]; interface OfficiatingStatusTransition { fromStatus: string; toStatus: string; transitionedAt: string; transitionedBy?: string; reason?: string; } interface OfficialCertification { certificationId: string; personId: string; organisationId: string; certificationFamily: string; certificationLevel?: string; status: CertificationStatus; validFrom?: string; validUntil?: string; requirements?: CertificationRequirementResult[]; documentReferences?: DocumentReference[]; notes?: string; statusHistory?: OfficiatingStatusTransition[]; extensions?: Extension[]; timeItems?: TimeItem[]; } interface CertificationRequirementResult { requirementId: string; description?: string; met: boolean; metAt?: string; notes?: string; } interface CertificationRequirement { requirementId: string; certificationFamily: string; certificationLevel: string; organisationId: string; description?: string; requirements: RequirementItem[]; prerequisiteLevels?: string[]; minimumAssignments?: number; minimumEvaluationScore?: number; validityPeriodMonths?: number; extensions?: Extension[]; } interface RequirementItem { itemId: string; description: string; required: boolean; } interface OfficialEvaluation { evaluationId: string; evaluatorPersonId: string; subjectPersonId: string; tournamentId?: string; tournamentName?: string; matchUpId?: string; evaluationDate: string; overallRating: number; status: EvaluationStatus; policyName?: string; scores: EvaluationScore[]; comments?: string; documentReference?: DocumentReference; statusHistory?: OfficiatingStatusTransition[]; extensions?: Extension[]; timeItems?: TimeItem[]; } interface EvaluationScore { criterionId: string; sectionId: string; value: number | boolean | string; notes?: string; } interface EvaluationPolicy { policyName: string; policyVersion: string; organisationId: string; officialRoleSubtype: string; sections: EvaluationSection[]; scoringMethod: ScoringMethod; passingThreshold?: number; extensions?: Extension[]; } interface EvaluationSection { sectionId: string; sectionName: string; weight?: number; criteria: EvaluationCriterion[]; } interface EvaluationCriterion { criterionId: string; criterionName: string; description?: string; scoringType: ScoringType; scaleOptions?: ScaleOption[]; numericRange?: { min: number; max: number; }; required: boolean; weight?: number; } interface ScaleOption { value: number; label: string; } interface EvaluationFormField { fieldId: string; sectionId: string; sectionName: string; criterionId: string; criterionName: string; description?: string; scoringType: ScoringType; scaleOptions?: ScaleOption[]; numericRange?: { min: number; max: number; }; required: boolean; weight?: number; sectionWeight?: number; } interface OfficialAssignment { assignmentId: string; personId: string; tournamentId: string; roleSubtype: string; status: AssignmentStatus; assignedDate: string; startDate?: string; endDate?: string; assignedBy?: string; notes?: string; statusHistory?: OfficiatingStatusTransition[]; extensions?: Extension[]; timeItems?: TimeItem[]; } interface OfficialSuspension { suspensionId: string; personId: string; organisationId?: string; suspensionType?: string; suspensionNotes?: string; suspendedFrom?: string; suspendedUntil?: string; extensions?: Extension[]; } interface OfficialRecord { officialRecordId: string; personId: string; organisationId?: string; certifications: OfficialCertification[]; evaluations: OfficialEvaluation[]; assignments: OfficialAssignment[]; suspensions: OfficialSuspension[]; certificationRequirements: CertificationRequirement[]; evaluationPolicies: EvaluationPolicy[]; createdAt: string; updatedAt: string; extensions?: Extension[]; timeItems?: TimeItem[]; } type OfficialRecords = { [officialRecordId: string]: OfficialRecord; }; type OfficiatingDirective = { pipe?: { [key: string]: boolean; }; params?: { [key: string]: any; }; method: string; }; type OfficiatingDirectives = OfficiatingDirective[]; type TransitionCertificationStatusArgs = { officialRecord: OfficialRecord; certificationId: string; toStatus: CertificationStatus; transitionedBy?: string; reason?: string; }; declare function transitionCertificationStatus({ officialRecord, certificationId, toStatus, transitionedBy, reason, }: TransitionCertificationStatusArgs): { error?: any; certification?: OfficialCertification; success?: boolean; }; type AddIndividualParticipantIdsType = { individualParticipantIds: string[]; removeFromOtherTeams?: boolean; groupingParticipantId: string; tournamentRecord: Tournament; }; declare function addIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, removeFromOtherTeams, tournamentRecord, }: AddIndividualParticipantIdsType): ResultType & { groupingParticipant?: Participant$1; added?: number; }; type AdHocPositionSwapArgs = { drawDefinition: DrawDefinition; tournamentRecord: Tournament; participantIds: string[]; structureId: string; roundNumber: number; event: Event$1; }; declare function adHocPositionSwap(params: AdHocPositionSwapArgs): ResultType; declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, event, }: { alternateParticipantId: any; tournamentRecord: any; drawDefinition: any; drawPosition: any; structureId: any; event: any; }): ResultType | { error: { message: string; code: string; }; }; type BulkRescheduleMatchUpsArgs = { tournamentRecords: TournamentRecords; tournamentRecord: Tournament; matchUpIds: string[]; scheduleChange: any; dryRun?: boolean; }; declare function bulkRescheduleMatchUps(params: BulkRescheduleMatchUpsArgs): ResultType & { allRescheduled?: boolean; notRescheduled?: any[]; rescheduled?: any[]; }; type ClearScheduledMatchUpsArgs = { ignoreMatchUpStatuses?: MatchUpStatusUnion[]; tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; scheduleAttributes?: string[]; scheduledDates: string[]; venueIds?: string[]; }; declare function clearScheduledMatchUps(params: ClearScheduledMatchUpsArgs): ResultType & { clearedScheduleCount?: number; }; type CompareTieFormatsArgs = { considerations?: { collectionName?: boolean; collectionOrder?: boolean; }; ancestor: TieFormat; descendant: any; }; declare function compareTieFormats({ considerations, descendant, ancestor }: CompareTieFormatsArgs): { different: any; invalid: 0 | any[]; success: boolean; matchUpFormatDifferences: any[]; matchUpCountDifference: number; descendantDifferences: any; ancestorDifferences: any; orderDifference: boolean; valueDifference: number; nameDifference: boolean; descendantDesc: any; ancestorDesc: any; }; declare function deleteFlightProfileAndFlightDraws({ autoPublish, tournamentRecord, auditData, event, force }: { autoPublish?: boolean | undefined; tournamentRecord: any; auditData: any; event: any; force: any; }): { success?: boolean; error?: ErrorType; } | { error: any; }; declare function generateOutcomeFromScoreString(params: any): any; declare function qualifierDrawPositionAssignment({ qualifyingParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }: { qualifyingParticipantId: any; tournamentRecord: any; drawDefinition: any; drawPosition: any; structureId: any; }): ResultType | { error: { message: string; code: string; }; }; interface ResetQualifyingStructureArgs { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; structureId: string; event?: Event$1; } declare function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, structureId, }: ResetQualifyingStructureArgs): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type AddCertificationRequirementArgs = { officialRecord: OfficialRecord; requirementId?: string; certificationFamily: string; certificationLevel: string; organisationId: string; description?: string; requirements: RequirementItem[]; prerequisiteLevels?: string[]; minimumAssignments?: number; minimumEvaluationScore?: number; validityPeriodMonths?: number; extensions?: any[]; }; declare function addCertificationRequirement({ officialRecord, requirementId, certificationFamily, certificationLevel, organisationId, description, requirements, prerequisiteLevels, minimumAssignments, minimumEvaluationScore, validityPeriodMonths, extensions, }: AddCertificationRequirementArgs): { error?: any; certificationRequirement?: CertificationRequirement; success?: boolean; }; type GetAssignedParticipantIdsArgs = { drawDefinition: DrawDefinition; stages?: StageTypeUnion[]; }; declare function getAssignedParticipantIds({ drawDefinition, stages }: GetAssignedParticipantIdsArgs): ResultType & { assignedParticipantIds?: string[]; }; type getDrawTypeCoercionArgs = { policyDefinitions?: PolicyDefinitions; appliedPolicies?: PolicyDefinitions; drawType?: string; }; declare function getDrawTypeCoercion({ policyDefinitions, appliedPolicies, drawType }: getDrawTypeCoercionArgs): any; declare function matchUpScheduleChange(params: any): { success: boolean; } | ResultType | { error: { message: string; code: string; }; }; declare function modifyParticipantOtherName({ tournamentRecord, participantId, participantOtherName }: { tournamentRecord: any; participantId: any; participantOtherName: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; }; type RegenArgs = { formats: { [key: string]: { personFormat: string; doublesJoiner: string; }; }[]; tournamentRecord: Tournament; }; declare function regenerateParticipantNames({ tournamentRecord, formats }: RegenArgs): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type RemoveSeededParticipantArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; participantId: string; structureId: string; }; declare function removeSeededParticipant({ tournamentRecord, drawDefinition, participantId, structureId, }: RemoveSeededParticipantArgs): ResultType; type ScheduleProfileRoundsArgs = { checkPotentialRequestConflicts?: boolean; tournamentRecords: TournamentRecords; scheduleCompletedMatchUps?: boolean; excludeNoDateCompleted?: boolean; clearScheduleDates?: boolean; excludePriorDates?: boolean; scheduleDates?: string[]; periodLength?: number; useGarman?: boolean; courtIds?: string[]; dryRun?: boolean; pro?: boolean; }; declare function scheduleProfileRounds(params: ScheduleProfileRoundsArgs): (ResultType & { valid?: boolean; }) | { schedulingProfile?: any; modifications?: number; error?: ErrorType; issues?: string[]; } | { schedulingProfileModifications: any; schedulingProfileIssues: any[] | undefined; dateSchedulingProfiles: any[]; recoveryTimeDeferredMatchUpIds: {}; dependencyDeferredMatchUpIds: {}; matchUpScheduleTimes: {}; overLimitMatchUpIds: {}; scheduledMatchUpIds: {}; noTimeMatchUpIds: {}; requestConflicts: {}; scheduledDates: any[]; success: boolean; } | { schedulingProfileModifications: any; schedulingProfileIssues: any; scheduleTimesRemaining: {}; dateSchedulingProfiles: any; skippedScheduleTimes: {}; recoveryTimeDeferredMatchUpIds: {}; dependencyDeferredMatchUpIds: {}; matchUpScheduleTimes: {}; overLimitMatchUpDetails: {}; overLimitMatchUpIds: {}; scheduledMatchUpIds: {}; noTimeMatchUpIds: {}; requestConflicts: {}; scheduledDates: any; success: boolean; } | { error: { message: string; code: string; }; }; type SetMatchUpStatusArgs$1 = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; scheduledDates?: string[]; stageSequences?: number[]; structureIds?: string[]; matchUpFormat: string; structureId?: string; eventIds?: string[]; eventType?: string; matchUpId?: string; drawIds?: string[]; stages?: string[]; eventId?: string; drawId?: string; force?: boolean; event?: Event$1; }; declare function setMatchUpFormat(params: SetMatchUpStatusArgs$1): ResultType | { success?: boolean; error?: ErrorType; info?: string; } | { modificationsCount: number; success: boolean; }; type SetMatchUpStatusArgs = { tournamentRecords?: { [key: string]: Tournament; }; policyDefinitions?: PolicyDefinitions; disableScoreValidation?: boolean; allowChangePropagation?: boolean; propagateExitStatus?: boolean; tournamentRecord: Tournament; drawDefinition: DrawDefinition; disableAutoCalc?: boolean; enableAutoCalc?: boolean; matchUpFormat?: string; tournamentId?: string; setTBlast?: boolean; matchUpId: string; eventId?: string; drawId?: string; schedule?: any; notes?: string; event?: Event$1; outcome?: any; }; declare function setMatchUpStatus(params: SetMatchUpStatusArgs): ResultType | { success?: boolean; error?: ErrorType; info?: string; } | { error: { message: string; code: string; }; }; type AddFinishingRoundsArgs = { finishingPositionOffset?: number; finishingPositionLimit?: number; positionsFed?: number; roundsCount?: number; roundLimit?: number; matchUps: MatchUp$1[]; lucky?: boolean; fmlc?: boolean; }; declare function addFinishingRounds({ finishingPositionOffset, finishingPositionLimit, positionsFed, roundsCount, roundLimit, matchUps, lucky, fmlc, }: AddFinishingRoundsArgs): MatchUp$1[]; type AddQualifyingstructureArgs = { qualifyingRoundNumber: number; tournamentRecord: Tournament; drawDefinition: DrawDefinition; qualifyingPositions: number; targetStructureId: string; roundTarget: number; structureName: string; matchUpType: string; drawSize: number; drawType: string; eventId: string; event: Event$1; }; declare function addQualifyingStructure(params: AddQualifyingstructureArgs): ResultType | { qualifyingDrawPositionsCount?: number; qualifiersCount?: number; structure?: Structure; error?: ErrorType; success?: boolean; link?: DrawLink; } | { error: { message: string; code: string; }; }; type BulkScheduleMatchUpsArgs = { tournamentRecords: { [key: string]: Tournament; }; scheduleCompletedMatchUps?: boolean; tournamentRecord?: Tournament; scheduleByeMatchUps?: boolean; errorOnAnachronism?: boolean; removePriorValues?: boolean; checkChronology?: boolean; matchUpContextIds?: any; matchUpIds?: string[]; matchUpDetails: any; schedule?: any; }; declare function bulkScheduleMatchUps(params: BulkScheduleMatchUpsArgs): (ResultType & { valid?: boolean; }) | { error?: ErrorType; scheduled?: number; warnings?: any[]; } | { error: { message: string; code: string; }; info: string; }; declare function checkOutParticipant(params: CheckInOutParticipantArgs): any; declare function clearMatchUpSchedule({ scheduleAttributes, tournamentRecord, drawDefinition, matchUpId, }: { scheduleAttributes?: string[] | undefined; tournamentRecord: any; drawDefinition: any; matchUpId: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type GenerateTeamsArgs = { participantAttribute?: string; tournamentRecord: Tournament; addParticipants?: boolean; personAttribute?: string; teamNames?: string[]; accessor?: string; uuids?: string[]; }; declare function createTeamsFromParticipantAttributes({ addParticipants, participantAttribute, tournamentRecord, personAttribute, teamNames, accessor, uuids, }: GenerateTeamsArgs): { error: { message: string; code: string; }; } | { participantsAdded: number; success: boolean; error?: undefined; } | { newParticipants: any[]; success: boolean; error?: undefined; }; declare function disableTieAutoCalc({ drawDefinition, matchUpId, event }: { drawDefinition: any; matchUpId: any; event: any; }): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; type GenerateCourtsArgs = { tournamentRecord?: Tournament; courtNames?: string[]; namePrefix?: string; startTime?: string; endTime?: string; idPrefix?: string; uuids?: string[]; dates?: string[]; count: number; }; type GenerateCourtsResult = { courts?: Court[]; }; declare function generateCourts(params: GenerateCourtsArgs): ResultType & GenerateCourtsResult; type GenerateEventsFromTieFormatArgs = { entryStatus?: EntryStatusUnion; addEntriesFromTeams?: boolean; tournamentRecord: Tournament; tieFormatName?: string; tieFormat?: TieFormat; addEvents?: boolean; uuids?: string[]; }; declare function generateEventsFromTieFormat(params: GenerateEventsFromTieFormatArgs): any; declare function generateStatCrew(params: any): (ResultType & { valid?: boolean; }) | { success: boolean; json: any[]; xml: string[]; }; declare function getCompetitionParticipants(params: any): ResultType & { mappedMatchUps?: { [key: string]: HydratedMatchUp; }; participantIdsWithConflicts?: string[]; participants?: HydratedParticipant[]; participantMap?: ParticipantMap; matchUps?: MatchUp$1[]; derivedEventInfo?: any; derivedDrawInfo?: any; success?: boolean; }; type getParticipantEventDetailsType = { tournamentRecord: Tournament; participantId: string; }; declare function getParticipantEventDetails({ tournamentRecord, participantId, }: getParticipantEventDetailsType): ResultType & { eventDetails?: { eventName?: string; eventId: string; }[]; }; type GetSwissStandingsArgs = { tiebreakMethods?: string[]; drawDefinition: DrawDefinition; structureId?: string; }; type GetSwissStandingsResult = { standings?: SwissStanding[]; scoreGroups?: ScoreGroup[]; roundsPlayed?: number; error?: ErrorType; success?: boolean; }; declare function getSwissStandings({ tiebreakMethods, drawDefinition, structureId, }: GetSwissStandingsArgs): GetSwissStandingsResult; type SetMatchUpStateArgs = { tournamentRecords?: { [key: string]: Tournament; }; policyDefinitions?: PolicyDefinitions; appliedPolicies?: PolicyDefinitions; matchUpStatus?: MatchUpStatusUnion; allowChangePropagation?: boolean; disableScoreValidation?: boolean; projectedWinningSide?: number; propagateExitStatus?: boolean; matchUpStatusCodes?: string[]; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; autoCalcDisabled?: boolean; disableAutoCalc?: boolean; enableAutoCalc?: boolean; matchUpFormat?: string; matchUpTieId?: string; tieMatchUpId?: string; removeScore?: boolean; winningSide?: number; matchUpId: string; schedule?: any; notes?: string; outcome?: any; event?: Event$1; score?: any; }; declare function setMatchUpState(params: SetMatchUpStateArgs): any; type TransitionAssignmentStatusArgs = { officialRecord: OfficialRecord; assignmentId: string; toStatus: AssignmentStatus; transitionedBy?: string; reason?: string; }; declare function transitionAssignmentStatus({ officialRecord, assignmentId, toStatus, transitionedBy, reason, }: TransitionAssignmentStatusArgs): { error?: any; assignment?: OfficialAssignment; success?: boolean; }; type TransitionEvaluationStatusArgs = { officialRecord: OfficialRecord; evaluationId: string; toStatus: EvaluationStatus; transitionedBy?: string; reason?: string; }; declare function transitionEvaluationStatus({ officialRecord, evaluationId, toStatus, transitionedBy, reason, }: TransitionEvaluationStatusArgs): { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; declare function checkInParticipant(params: CheckInOutParticipantArgs): any; type GenerateBookingsArgs = { tournamentRecords: { [key: string]: Tournament; }; dateScheduledMatchUps?: HydratedMatchUp[]; defaultRecoveryMinutes?: number; averageMatchUpMinutes?: number; matchUps?: HydratedMatchUp[]; periodLength?: number; scheduleDate?: string; venueIds?: string[]; }; declare function generateBookings({ defaultRecoveryMinutes, averageMatchUpMinutes, dateScheduledMatchUps, tournamentRecords, venueIds, periodLength, scheduleDate, matchUps, }: GenerateBookingsArgs): { error: { message: string; code: string; }; bookings?: undefined; relevantMatchUps?: undefined; dateScheduledMatchUps?: undefined; } | { bookings: { recoveryMinutes: number | undefined; averageMinutes: number | undefined; periodLength: number; startTime: string | undefined; courtId: string | undefined; endTime: string; venueId: string | undefined; }[] | undefined; relevantMatchUps: HydratedMatchUp[] | undefined; dateScheduledMatchUps: HydratedMatchUp[] | undefined; error?: undefined; }; type GetApplicableAwardProfileLevelsArgs = { policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; eventId?: string; drawId?: string; }; declare function getApplicableAwardProfileLevels({ policyDefinitions, tournamentRecord, eventId, drawId, }: GetApplicableAwardProfileLevelsArgs): { error: { message: string; code: string; }; } | { success: boolean; levels: number[]; error?: undefined; }; type LuckyParticipantInfo = { participantId: string; participantName?: string; matchUpId: string; scoreString?: string; margin?: number; gameRatio?: number; pointRatio?: number; setRatio?: number; gameDifferential?: number; setsWonByLoser?: number; }; type ConsolidationLinkInfo = { targetStructureId: string; targetRoundNumber: number; feedProfile?: string; losersPlaced: boolean; }; type LuckyRoundInfo = { roundNumber: number; matchUpsCount: number; completedCount: number; isComplete: boolean; isPreFeedRound: boolean; needsLuckySelection: boolean; nextRoundHasOpenPosition: boolean; requiredLuckyLoserCount: number; advancingWinners?: LuckyParticipantInfo[]; eligibleLosers?: LuckyParticipantInfo[]; consolidationLinks?: ConsolidationLinkInfo[]; }; type GetLuckyDrawRoundStatusArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; structureId?: string; cumulativeMargin?: boolean; }; type GetLuckyDrawRoundStatusResult = { isLuckyDraw?: boolean; rounds?: LuckyRoundInfo[]; success?: boolean; error?: ErrorType; }; declare function getLuckyDrawRoundStatus({ tournamentRecord, drawDefinition, structureId, cumulativeMargin, }: GetLuckyDrawRoundStatusArgs): GetLuckyDrawRoundStatusResult; declare function getMatchUpDailyLimitsUpdate({ tournamentRecords }: { tournamentRecords: any; }): { error?: ErrorType; } | { methods: QueueMethod[]; }; declare function getTournamentPublishStatus(params: any): any; type TierMethod = 'ENTRY_ORDER' | 'RANKING' | 'RATING'; type InitializeDraftArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; scaleAttributes?: ScaleAttributes; preferencesCount?: number; tierMethod?: TierMethod; ascending?: boolean; structureId?: string; tierCount?: number; event?: Event$1; force?: boolean; }; declare function initializeDraft({ tournamentRecord, drawDefinition, scaleAttributes, preferencesCount, tierMethod, ascending, structureId, tierCount, event, force, }: InitializeDraftArgs): { error: { message: string; code: string; }; } | { draftState: { status: "SEEDS_PLACED"; structureId: string; preferencesCount: number; tierMethod: TierMethod; scaleAttributes: ScaleAttributes | undefined; ascending: boolean; tiers: { participantIds: string[]; resolved: boolean; }[]; preferences: Record; unassignedDrawPositions: any[]; }; unassignedDrawPositions: any[]; tiers: { participantIds: string[]; resolved: boolean; }[]; success: boolean; error?: undefined; }; type PredictMatchUpCompetitiveBandsArgs = { predictionModel?: PredictionModel; tournamentRecord?: Tournament; side1Rating?: number; side2Rating?: number; }; declare function predictMatchUpCompetitiveBands({ tournamentRecord, predictionModel, side1Rating, side2Rating, }: PredictMatchUpCompetitiveBandsArgs): BandPrediction & { delta?: number; error?: ErrorType; }; declare function removeRatings(params: { tournamentRecord: Tournament; eventType: EventTypeUnion; asDynamic?: boolean; ratingType: string; }): ResultType & { valid?: boolean; }; type ScheduleProfileGridArgs = { tournamentRecords: TournamentRecords; matchUpDailyLimits?: { [key: string]: number; }; scheduleCompletedMatchUps?: boolean; clearScheduleDates?: boolean; minCourtGridRows?: number; scheduleDates?: string[]; courtIds?: string[]; }; declare function scheduleProfileGrid(params: ScheduleProfileGridArgs): (ResultType & { valid?: boolean; }) | { schedulingProfile?: any; modifications?: number; error?: ErrorType; issues?: string[]; } | { error: { message: string; code: string; }; } | { scheduledMatchUpIds: Record; notScheduledMatchUpIds: Record; overLimitMatchUpIds: Record; scheduledDates: string[]; success: boolean; error?: undefined; }; type SeedWithdrawalCascadeArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; structureId?: string; drawPosition: number; event?: Event$1; }; declare function seedWithdrawalCascade({ tournamentRecord, drawDefinition, structureId, drawPosition, event, }: SeedWithdrawalCascadeArgs): ResultType & { vacatedDrawPosition?: number; }; type SetParticipantScaleItemArgs = { tournamentRecord: Tournament; removePriorValues?: boolean; participantId: string; scaleItem?: ScaleItem; }; declare function setParticipantScaleItem(params: SetParticipantScaleItemArgs): any; type SetParticipantScaleItemsArgs = { scaleItemsWithParticipantIds: { scaleItems: ScaleItem[]; participantId: string; }[]; context?: { [key: string]: any; }; tournamentRecord: Tournament; removePriorValues?: boolean; auditData?: any; }; declare function setParticipantScaleItems(params: SetParticipantScaleItemsArgs): any; declare function substituteParticipant(params: any): ResultType | { error: { message: string; code: string; }; }; type ValidateCertificationArgs = { officialRecord: OfficialRecord; certificationId: string; asOfDate?: string; }; declare function validateCertification({ officialRecord, certificationId, asOfDate, }: ValidateCertificationArgs): { error?: any; success?: boolean; valid?: boolean; certification?: OfficialCertification; reasons?: string[]; }; declare function addPlayoffStructures(params: any): ResultType & { addedStructureIds?: string[]; }; type AssignMatchUpCourtArgs = { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord: Tournament; drawDefinition: DrawDefinition; removePriorValues?: boolean; disableNotice?: boolean; courtDayDate: string; matchUpId: string; courtId: string; }; declare function assignMatchUpCourt({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, courtDayDate, matchUpId, courtId, }: AssignMatchUpCourtArgs): { error?: ErrorType; success?: boolean; }; type AssignMatchUpVenueArgs = { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; removePriorValues?: boolean; disableNotice?: boolean; matchUpId: string; venueId?: string; }; declare function assignMatchUpVenue({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, matchUpId, venueId, }: AssignMatchUpVenueArgs): ResultType | { success?: boolean; venue?: Venue; error?: ErrorType; } | { error: { message: string; code: string; }; }; type AutomatedPositioningArgs = { inContextDrawMatchUps?: HydratedMatchUp[]; participants?: HydratedParticipant[]; appliedPolicies?: PolicyDefinitions; provisionalPositioning?: boolean; seedingProfile?: SeedingProfile; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; multipleStructures?: boolean; applyPositioning?: boolean; matchUpsMap?: MatchUpsMap; placementGroup?: number; random?: () => number; placeByes?: boolean; structureId: string; seedsOnly?: boolean; seedLimit?: number; drawType?: string; drawSize?: number; event?: Event$1; }; declare function automatedPositioning(params: AutomatedPositioningArgs): ResultType & { positionAssignments?: PositionAssignment[]; positioningReport?: { [key: string]: any; }[]; success?: boolean; conflicts?: any[]; }; type CleanExpiredArgs = { tournamentRecord: Tournament; }; declare function cleanExpiredMutationLocks(params: CleanExpiredArgs): { success?: boolean; error?: ErrorType; removedCount?: number; }; type GetOfficialCertificationsArgs = { officialRecord: OfficialRecord; certificationFamily?: string; certificationLevel?: string; organisationId?: string; activeOnly?: boolean; }; declare function getOfficialCertifications({ officialRecord, certificationFamily, certificationLevel, organisationId, activeOnly, }: GetOfficialCertificationsArgs): { error?: any; success?: boolean; certifications?: OfficialCertification[]; }; type GetMembershipArgs = { tournamentRecord: Tournament; participantId: string; }; declare function getParticipantMembership({ tournamentRecord, participantId, }: GetMembershipArgs): ResultType | { [key: string]: string[]; }; type GetPersonRequestsArgs = { tournamentRecords: { [key: string]: Tournament; }; requestType?: string; }; declare function getPersonRequests(params: GetPersonRequestsArgs): { personRequests?: PersonRequests; error?: ErrorType; }; interface GetRandomQualifierListParams { drawDefinition: DrawDefinition; random?: () => number; } declare const getRandomQualifierList: ({ drawDefinition, random }: GetRandomQualifierListParams) => any[] | ResultType; type GetStructureSeedAssignmentsArgs = { provisionalPositioning?: boolean; drawDefinition?: DrawDefinition; returnAllProxies?: boolean; structure?: Structure; structureId?: string; }; declare function getStructureSeedAssignments({ provisionalPositioning, returnAllProxies, drawDefinition, structureId, structure, }: GetStructureSeedAssignmentsArgs): { seedAssignments?: SeedAssignment[]; stageSequence?: number; stage?: StageTypeUnion; seedLimit?: number; error?: ErrorType; }; declare function isAggregateFormat(parsed: any): boolean; type LuckyDrawAdvancementArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; participantId?: string; participantIds?: string[]; structureId?: string; random?: () => number; roundNumber: number; event?: Event$1; }; declare function luckyDrawAdvancement({ tournamentRecord, drawDefinition, participantId, participantIds, structureId, roundNumber, random, event, }: LuckyDrawAdvancementArgs): ResultType; type ModifyCollectionDefinitionArgs = { updateInProgressMatchUps?: boolean; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; collectionOrder?: number; collectionName?: string; tieFormatName?: string; matchUpFormat?: string; matchUpType?: EventTypeUnion; matchUpCount?: number; gender?: GenderUnion; collectionId: string; structureId?: string; category?: Category; matchUpId?: string; eventId?: string; event?: Event$1; collectionValueProfiles?: CollectionValueProfile[]; collectionValue?: number; matchUpValue?: number; scoreValue?: number; setValue?: number; }; declare function modifyCollectionDefinition({ updateInProgressMatchUps, tournamentRecord, collectionOrder, collectionName, tieFormatName, drawDefinition, matchUpFormat, matchUpCount, collectionId, matchUpType, structureId, matchUpId, category, eventId, gender, event, collectionValueProfiles, collectionValue, matchUpValue, scoreValue, setValue, }: ModifyCollectionDefinitionArgs): ResultType & { tieFormat?: TieFormat; modifications?: any[]; }; type ModifyDrawArgs = { drawUpdates: { drawName: string; policyDefinitions: PolicyDefinitions; }; tournamentRecord: Tournament; drawDefinition: DrawDefinition; drawId: string; event: Event$1; }; declare function modifyDrawDefinition({ tournamentRecord, drawDefinition, drawUpdates, drawId, event, }: ModifyDrawArgs): ResultType; declare function modifyPairAssignment(params: any): any; declare function modifyPenalty(params: any): { modifications?: any; error?: ErrorType; success?: boolean; penalty?: Penalty; } | { error: { message: string; code: string; }; }; type OrderCollectionDefinitionsArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; structureId?: string; matchUpId?: string; matchUp?: MatchUp$1; eventId?: string; orderMap: any; event?: Event$1; }; declare function orderCollectionDefinitions({ tournamentRecord, drawDefinition, structureId, matchUpId, orderMap, eventId, matchUp, event, }: OrderCollectionDefinitionsArgs): ResultType | { matchUp?: HydratedMatchUp; structure?: Structure; error?: ErrorType; } | { error: { message: string; code: string; }; }; type ParticiapntScheduledMatchUps = { scheduleAttributes?: string[]; matchUps?: HydratedMatchUp[]; }; declare function participantScheduledMatchUps({ scheduleAttributes, matchUps, }: ParticiapntScheduledMatchUps): { error: { message: string; code: string; }; } | { scheduledMatchUps: {}; success: boolean; error?: undefined; }; type RemoveCollectionDefinitionArgs = { updateInProgressMatchUps?: boolean; tieFormatComparison?: boolean; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; tieFormatName?: string; collectionId: string; structureId?: string; matchUpId?: string; matchUp?: MatchUp$1; eventId?: string; event?: Event$1; }; declare function removeCollectionDefinition({ updateInProgressMatchUps, tieFormatComparison, tournamentRecord, drawDefinition, tieFormatName, collectionId, structureId, matchUpId, eventId, matchUp, event, }: RemoveCollectionDefinitionArgs): { targetMatchUps?: MatchUp$1[]; deletedMatchUpIds?: string[]; tieFormat?: TieFormat; success?: boolean; error?: ErrorType; }; type RemoveOfficialAssignmentArgs = { officialRecord: OfficialRecord; assignmentId: string; }; declare function removeOfficialAssignment({ officialRecord, assignmentId }: RemoveOfficialAssignmentArgs): any; declare function removePenalty(params: any): { error?: ErrorType; success?: boolean; penalty?: Penalty; } | { error: { message: string; code: string; }; }; type ResetMatchUpLineUps = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; inheritance?: boolean; matchUpId: string; event?: Event$1; }; declare function resetMatchUpLineUps({ inheritance, tournamentRecord, drawDefinition, matchUpId, event, }: ResetMatchUpLineUps): { error: { message: string; code: string; }; } | { modificationsCount: number; success: boolean; error?: undefined; }; type SetMatchUpCalledAtArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; disableNotice?: boolean; calledAt?: string | null; matchUpId: string; event?: Event$1; }; declare function setMatchUpCalledAt(params: SetMatchUpCalledAtArgs): ResultType; type UpdateTieMatchUpScoreArgs = { tournamentRecords?: TournamentRecords; appliedPolicies?: PolicyDefinitions; tournamentRecord?: Tournament; drawDefinition: DrawDefinition; exitWhenNoValues?: boolean; matchUpsMap?: MatchUpsMap; matchUpStatus?: string; tournamentId?: string; removeScore?: boolean; matchUpId: string; event?: Event$1; }; declare function updateTieMatchUpScore(params: UpdateTieMatchUpScoreArgs): { removeWinningSide?: boolean; tieFormatRemoved?: boolean; winningSide?: number; error?: ErrorType; success?: boolean; score?: any; }; type ApplyTournamentRankingPointsArgs = { tournamentRecord: Tournament; policyDefinitions?: PolicyDefinitions; participantFilters?: ParticipantFilters; scaleName?: string; level?: number; removePriorValues?: boolean; }; declare function applyTournamentRankingPoints({ tournamentRecord, policyDefinitions, participantFilters, scaleName, level, removePriorValues, }: ApplyTournamentRankingPointsArgs): any; type CompetitionScheduleMatchUpsArgs = { tournamentRecords: TournamentRecords; policyDefinitions?: PolicyDefinitions; courtCompletedMatchUps?: boolean; alwaysReturnCompleted?: boolean; contextFilters?: MatchUpFilters; matchUpFilters?: MatchUpFilters; hydrateParticipants?: boolean; withCourtGridRows?: boolean; activeTournamentId?: string; sortDateMatchUps?: boolean; minCourtGridRows?: number; usePublishState?: boolean; sortCourtsData?: boolean; nextMatchUps?: boolean; status?: string; }; declare function competitionScheduleMatchUps(params: CompetitionScheduleMatchUpsArgs): { mappedParticipants?: { [key: string]: HydratedParticipant; }; completedMatchUps?: HydratedMatchUp[]; dateMatchUps?: HydratedMatchUp[]; courtPrefix?: string; error?: ErrorType; venues?: Venue[]; courtsData?: any; rows?: any[]; }; type CreateGroupParticipantType = { participantRoleResponsibilities?: string[]; individualParticipantIds: string[]; tournamentRecord: Tournament; participantRole?: string; participantId: string; groupName: string; }; declare function createGroupParticipant({ individualParticipantIds, participantRoleResponsibilities, participantRole, tournamentRecord, participantId, groupName, }: CreateGroupParticipantType): { participant?: Participant$1; participantId?: string; success?: boolean; error?: ErrorType; info?: any; }; type GetCompetitionPenaltiesArgs = { tournamentRecords: TournamentRecords; }; declare function getCompetitionPenalties({ tournamentRecords }: GetCompetitionPenaltiesArgs): { error: { message: string; code: string; }; penalties?: undefined; } | { penalties: Penalty[]; error?: undefined; }; type GetMatchUpCompetitivenessArgs = { tournamentRecord?: Tournament; profileBands?: any; matchUp: MatchUp$1; }; declare function getMatchUpCompetitiveProfile({ tournamentRecord, profileBands, matchUp, }: GetMatchUpCompetitivenessArgs): { competitiveness?: any; pctSpread?: number; success?: boolean; error?: ErrorType; }; type GetParticipantSchedulesArgs = { tournamentRecord: Tournament; participantFilters?: any; }; declare function getParticipantSchedules({ participantFilters, tournamentRecord }: GetParticipantSchedulesArgs): { error: { message: string; code: string; }; context?: undefined; } | { error: { message: string; code: string; }; context: { participantFilters: any; }; } | { success: boolean; participantSchedules: any[]; error?: undefined; context?: undefined; }; type GetPositionsPlayedOff = { drawDefinition: DrawDefinition; matchUpsMap?: MatchUpsMap; structureIds?: string[]; }; declare function getPositionsPlayedOff({ drawDefinition, structureIds, matchUpsMap }: GetPositionsPlayedOff): { error: { message: string; code: string; }; context: { structureIds: never; }; positionsNotPlayedOff?: undefined; positionsPlayedOff?: undefined; } | { error: { message: string; code: string; }; context?: undefined; positionsNotPlayedOff?: undefined; positionsPlayedOff?: undefined; } | { positionsNotPlayedOff: any[]; positionsPlayedOff: any[]; error?: undefined; context?: undefined; }; type GetProfileRoundsArgs = { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord?: Tournament; schedulingProfile?: any; withRoundId?: boolean; }; declare function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentRecord, withRoundId, }: GetProfileRoundsArgs): { segmentedRounds?: { [key: string]: any; }; profileRounds?: any[]; error?: ErrorType; }; type MigrationCounts = { tournament: number; events: number; entries: number; drawDefinitions: number; structures: number; positionAssignments: number; matchUps: number; matchUpScheduleTimeItems: number; venues: number; courts: number; }; type MigrationResult = ResultType & { promoted?: MigrationCounts; totalPromoted?: number; }; type MigrateTournamentRecordArgs = { tournamentRecord: Tournament; clearLegacy?: boolean; }; declare function migrateTournamentRecord({ tournamentRecord, clearLegacy, }: MigrateTournamentRecordArgs): MigrationResult; declare function pruneDrawDefinition({ matchPlayDrawPositions, tournamentRecord, drawDefinition, drawId, }: { matchPlayDrawPositions?: boolean | undefined; tournamentRecord: any; drawDefinition: any; drawId: any; }): { error: { message: string; code: string; }; } | { matchUps: MatchUp$1[]; success: boolean; error?: undefined; }; type RemovePracticeRegistrationArgs = { tournamentRecord: Tournament; courtId: string; date: string; bookingId: string; registrationId: string; disableNotice?: boolean; }; declare function removePracticeRegistration(params: RemovePracticeRegistrationArgs): ResultType; declare function resetDrawDefinition({ tournamentRecord, removeScheduling, removeAssignments, drawDefinition }: { tournamentRecord: any; removeScheduling: any; removeAssignments: any; drawDefinition: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function setDelegatedOutcome(params: any): { success?: boolean; error?: ErrorType; } | { matchUp?: HydratedMatchUp; structure?: Structure; error?: ErrorType; } | { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; }; type SetPracticeDefaultCapacityArgs = { tournamentRecord: Tournament; defaultCapacity: number | null; disableNotice?: boolean; }; declare function setPracticeDefaultCapacity({ tournamentRecord, defaultCapacity, disableNotice, }: SetPracticeDefaultCapacityArgs): ResultType; declare function swapDrawPositionAssignments({ tournamentRecord, drawDefinition, drawPositions, structureId, event }: { tournamentRecord: any; drawDefinition: any; drawPositions: any; structureId: any; event: any; }): any; type MatchUpConflict = { matchUpId: string; scheduledDate?: string; scheduledTime?: string; }; type PracticeConflict = { bookingId?: string; courtId: string; date: string; registrationId: string; startTime: string; endTime: string; }; type ConflictReport = { matchUps: MatchUpConflict[]; practiceRegistrations: PracticeConflict[]; }; type Updates = { startTime?: string; endTime?: string; notes?: string; status?: PracticeRegistrationStatus; }; type UpdatePracticeRegistrationArgs = { tournamentRecord: Tournament; courtId: string; date: string; bookingId: string; registrationId: string; updates: Updates; disableNotice?: boolean; }; type UpdatePracticeRegistrationResult = ResultType & { registration?: PracticeRegistration; conflicts?: ConflictReport; }; declare function updatePracticeRegistration(params: UpdatePracticeRegistrationArgs): UpdatePracticeRegistrationResult; type AssignDrawPositionArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; participantId?: string; drawPosition?: number; structureId?: string; qualifier?: boolean; event?: Event$1; bye?: boolean; }; declare function assignDrawPosition({ tournamentRecord, drawDefinition, participantId, drawPosition, structureId, qualifier, event, bye, }: AssignDrawPositionArgs): ResultType; type AttachPoliciesArgs = { tournamentRecords?: TournamentRecords; policyDefinitions: PolicyDefinitions; drawDefinition?: DrawDefinition; tournamentRecord?: Tournament; allowReplacement?: boolean; tournamentId?: string; event?: Event$1; }; declare function attachPolicies(params: AttachPoliciesArgs): ResultType & { applied?: string[]; }; type GenerateTournamentRecordArgs = { participants?: Participant$1[]; participantsProfile?: ParticipantsProfile; scheduleCompletedMatchUps?: boolean; tournamentExtensions?: Extension[]; policyDefinitions?: PolicyDefinitions; completeAllMatchUps?: boolean; tournamentAttributes?: any; ratingsParameters?: any; tournamentName?: string; schedulingProfile?: any; random?: () => number; autoSchedule?: boolean; leagueProfiles?: any[]; eventProfiles?: any[]; venueProfiles?: any[]; drawProfiles?: any[]; startDate?: string; endDate?: string; isMock?: boolean; uuids?: string[]; }; declare function generateTournamentRecord(params: GenerateTournamentRecordArgs): any; declare function getCompetitionDateRange({ tournamentRecords }: { tournamentRecords: TournamentRecords; }): { startDate?: string; endDate?: string; error?: ErrorType; }; type GetParticipantScaleItemArgs = { tournamentRecords?: TournamentRecords; scaleAttributes: ScaleAttributes; tournamentRecord?: Tournament; participantId: string; }; declare function getParticipantScaleItem(params: GetParticipantScaleItemArgs): { tournamentId?: string; scaleItem?: ScaleItem; error?: ErrorType; }; type SwissChartNode = { wins: number; losses: number; draws: number; participantIds: string[]; }; type SwissChartRound = { roundNumber: number; nodes: SwissChartNode[]; }; type GetSwissChartArgs = { drawDefinition: DrawDefinition; structureId?: string; }; type GetSwissChartResult = { rounds?: SwissChartRound[]; totalRounds?: number; error?: ErrorType; success?: boolean; }; declare function getSwissChart({ drawDefinition, structureId }: GetSwissChartArgs): GetSwissChartResult; type GetTournamentPenaltiesArgs = { tournamentRecord: Tournament; }; declare function getTournamentPenalties({ tournamentRecord }: GetTournamentPenaltiesArgs): { error?: ErrorType; penalties?: Penalty[]; }; declare function isValidForQualifying({ structureId, drawDefinition }: { structureId: any; drawDefinition: any; }): any; declare function modifyParticipantName({ tournamentRecord, participantName, participantId }: { tournamentRecord: any; participantName: any; participantId: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; info: string; } | { error: { message: string; code: string; }; info?: undefined; }; declare function removeStageEntries({ drawDefinition, entryStage }: { drawDefinition: any; entryStage: string; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type AddCollectionDefinitionArgs = { collectionDefinition: CollectionDefinition; policyDefinitions?: PolicyDefinitions; updateInProgressMatchUps?: boolean; referenceGender?: GenderUnion; drawDefinition: DrawDefinition; referenceCategory?: Category; tournamentRecord: Tournament; enforceCategory?: boolean; enforceGender?: boolean; tieFormatName?: string; structureId?: string; matchUpId?: string; matchUp?: MatchUp$1; eventId?: string; uuids?: string[]; event?: Event$1; }; declare function addCollectionDefinition({ updateInProgressMatchUps, collectionDefinition, referenceCategory, tournamentRecord, policyDefinitions, enforceCategory, referenceGender, drawDefinition, tieFormatName, enforceGender, structureId, matchUpId, matchUp, eventId, uuids, event, }: AddCollectionDefinitionArgs): ResultType & { tieFormat?: TieFormat; targetMatchUps?: any; addedMatchUps?: any; }; type AddDrawDefinitionArgs = { flight?: { flightNumber: number; }; suppressNotifications?: boolean; tournamentRecord?: Tournament; modifyEventEntries?: boolean; drawDefinition: DrawDefinition; existingDrawCount?: number; allowReplacement?: boolean; checkEntryStatus?: boolean; tournamentId?: string; event: Event$1; }; declare function addDrawDefinition(params: AddDrawDefinitionArgs): ResultType & { modifiedEventEntryStatusCount?: number; }; type AddPenaltyArgs = { refereeParticipantId?: string; tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; penaltyType: PenaltyTypeUnion; participantIds: string[]; extensions?: Extension[]; penaltyCode: string; penaltyId?: string; matchUpId?: string; issuedAt?: string; notes?: string; }; declare function addPenalty(params: AddPenaltyArgs): ResultType & { penaltyId?: string; }; type CompetitionMatchUpsArgs$1 = { scheduleVisibilityFilters?: ScheduleVisibilityFilters; participantsProfile?: ParticipantsProfile; tournamentRecords: TournamentRecords; policyDefinitions?: PolicyDefinitions; matchUpFilters?: MatchUpFilters; contextFilters?: MatchUpFilters; afterRecoveryTimes?: boolean; usePublishState?: boolean; nextMatchUps?: boolean; inContext?: boolean; }; declare function allCompetitionMatchUps({ scheduleVisibilityFilters, afterRecoveryTimes, participantsProfile, tournamentRecords, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs$1): { matchUps?: HydratedMatchUp[]; error?: ErrorType; }; type BuildDrawHierarchyArgs = { matchUpType?: string; matchUps: any[]; }; declare function buildDrawHierarchy({ matchUps, matchUpType }: BuildDrawHierarchyArgs): any; declare function getCheckedInParticipantIds({ matchUp }: { matchUp: HydratedMatchUp; }): ResultType & { allRelevantParticipantIds?: string[]; allParticipantsCheckedIn?: boolean; checkedInParticipantIds?: string[]; }; type GetDraftStateArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; }; declare function getDraftState({ drawDefinition }: GetDraftStateArgs): { error: { message: string; code: string; }; info?: undefined; draftState?: undefined; summary?: undefined; } | { error: { message: string; code: string; }; info: string; draftState?: undefined; summary?: undefined; } | { draftState: any; summary: { status: any; totalParticipants: any; preferencesSubmitted: number; preferencesOutstanding: number; tiersTotal: any; tiersResolved: any; unassignedDrawPositions: any; preferencesCount: any; }; error?: undefined; info?: undefined; }; declare function getLinkedTournamentIds({ tournamentRecords, }: { tournamentRecords: TournamentRecords; }): ResultType & { linkedTournamentIds?: string[]; }; type GetOfficialAssignmentsArgs = { officialRecord: OfficialRecord; tournamentId?: string; roleSubtype?: string; status?: AssignmentStatus; }; declare function getOfficialAssignments({ officialRecord, tournamentId, roleSubtype, status, }: GetOfficialAssignmentsArgs): { error?: any; success?: boolean; assignments?: OfficialAssignment[]; }; type GetOfficialEligibilityArgs = { officialRecord: OfficialRecord; certificationFamily: string; certificationLevel?: string; organisationId?: string; asOfDate?: string; }; declare function getOfficialEligibility({ officialRecord, certificationFamily, certificationLevel, organisationId, asOfDate, }: GetOfficialEligibilityArgs): { error?: any; success?: boolean; eligible?: boolean; reasons?: string[]; }; declare function getRegistrationProfile(params?: { tournamentRecord: Tournament; }): { registrationProfile?: RegistrationProfile; error?: any; }; type ScheduledRoundDetail = { published?: boolean; embargo?: string; }; type PublishingDetail = { scheduledRounds?: { [roundNumber: number]: ScheduledRoundDetail; }; roundLimit?: number; published?: boolean; embargo?: string; }; type DrawPublishingDetails = { structureDetails?: { [key: string]: PublishingDetail; }; stageDetails?: { [key: string]: PublishingDetail; }; publishingDetail: PublishingDetail; structureIdsToRemove?: string[]; structureIdsToAdd?: string[]; stagesToRemove?: string[]; stagesToAdd?: string[]; }; type PublishEventType = { includePositionAssignments?: boolean; policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; removePriorValues?: boolean; returnEventData?: boolean; eventDataParams?: any; drawIds?: string[]; status?: string; event?: Event$1; drawDetails?: { [key: string]: DrawPublishingDetails; }; drawIdsToRemove?: string[]; drawIdsToAdd?: string[]; }; declare function publishEvent(params: PublishEventType): ResultType & { eventData?: any; }; interface RoundVisibility { hidden?: boolean; embargoed?: boolean; } declare function getRoundVisibilityState(structureDetail?: PublishingDetail, matchUps?: { roundNumber?: number; }[]): Record | undefined; declare function removeDrawEntries({ autoEntryPositions, participantIds, drawDefinition, drawId, stages, event, }: { autoEntryPositions?: boolean | undefined; participantIds: any; drawDefinition: any; drawId: any; stages: any; event: any; }): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function reverseScore(params?: any): { reversedScore?: any; success?: boolean; error?: ErrorType; }; type ScaledTeamAssignmentArgs = { individualParticipantIds?: string[]; clearExistingAssignments?: boolean; reverseAssignmentOrder?: boolean; teamParticipantIds?: string[]; tournamentRecord: Tournament; scaledParticipants?: any[]; initialTeamIndex?: number; scaleAttributes?: any; teamNameBase?: string; teamsCount?: number; eventId?: string; event?: Event$1; }; declare function scaledTeamAssignment({ clearExistingAssignments, individualParticipantIds, reverseAssignmentOrder, initialTeamIndex, scaledParticipants, teamParticipantIds, tournamentRecord, scaleAttributes, teamNameBase, teamsCount, eventId, event, }: ScaledTeamAssignmentArgs): { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; } | { error: { message: string; code: string; }; teamParticipantIds?: undefined; } | { error: { message: string; code: string; }; participant: any; } | { error: { message: string; code: string; }; participant?: undefined; } | { error: { message: string; code: string; }; scaledParticipant: any; } | { scaledParticipants: any[]; success: boolean; error?: undefined; scaledParticipant?: undefined; }; interface MatchUp { matchUpId: string; matchUpFormat: string; matchUpStatus: MatchUpStatus; matchUpType: MatchUpType; sides: Side[]; score: Score; winningSide?: number; startTime?: string; endTime?: string; schedule?: Schedule; collectionPosition?: number; roundNumber?: number; roundPosition?: number; createdAt?: string; updatedAt?: string; serverFlip?: boolean; history?: MatchUpHistory; } interface Side { sideNumber: number; participantId?: string; participant?: Participant; lineUp?: TeamCompetitor[]; } interface Participant { participantId: string; participantName?: string; participantType: ParticipantType; participantRole: ParticipantRole; participantStatus?: ParticipantStatus; person?: Person; individualParticipants?: Participant[]; } interface Person { personId?: string; standardGivenName?: string; standardFamilyName?: string; nationalityCode?: string; sex?: 'MALE' | 'FEMALE' | 'OTHER'; } interface TeamCompetitor { participantId: string; collectionAssignments?: CollectionAssignment[]; } interface CollectionAssignment { collectionId: string; collectionPosition?: number; previousParticipantId?: string; substitutionOrder?: number; } interface SubstitutionEvent { sideNumber: 1 | 2; outParticipantId: string; inParticipantId: string; beforePointIndex: number; timestamp?: string; } interface Score { sets: SetScore[]; scoreStringSide1?: string; scoreStringSide2?: string; } interface SetScore { setNumber: number; side1Score?: number; side2Score?: number; side1TiebreakScore?: number; side2TiebreakScore?: number; side1GameScores?: number[]; side2GameScores?: number[]; winningSide?: number; setFormat?: string; hardBoundaries?: number[]; currentStreak?: { side: 0 | 1; count: number; }; isTiebreakOnly?: boolean; isTimed?: boolean; } interface Schedule { scheduledTime?: string; scheduledDate?: string; venueId?: string; courtId?: string; } interface MatchUpHistory { points: Point[]; states?: MatchUpState[]; entries?: ScoreEntry[]; substitutions?: SubstitutionEvent[]; } interface ScoreEntry { type: 'point' | 'game' | 'set' | 'endSegment' | 'setInitialScore' | 'substitution' | 'setServer'; data: any; timestamp: string; pointIndex?: number; } interface Point { pointNumber: number; winner: 0 | 1; winningSide?: 1 | 2; server?: 0 | 1; serverSideNumber?: 1 | 2; serverParticipantId?: string; timestamp?: string; rallyLength?: number; score?: string; result?: PointResult; stroke?: StrokeType; hand?: 'Forehand' | 'Backhand'; serve?: 1 | 2; serveLocation?: ServeLocation; rally?: RallyShot[]; location?: string; breakpoint?: boolean; code?: string; pointsToGame?: [number, number]; pointsToSet?: [number, number]; pointsToMatch?: [number, number]; gamesToSet?: [number, number]; serveSide?: 'deuce' | 'ad'; isBreakpoint?: boolean; scoreValue?: number; activePlayers?: [string, string] | [string[], string[]]; wrongSide?: boolean; wrongServer?: boolean; penaltyPoint?: boolean; penaltyType?: string; hardBoundary?: boolean; } type PointResult = 'Ace' | 'Winner' | 'Serve Winner' | 'Forced Error' | 'Unforced Error' | 'Double Fault' | 'Penalty' | 'Unknown'; type StrokeType = 'Forehand' | 'Backhand' | 'Forehand Slice' | 'Backhand Slice' | 'Forehand Volley' | 'Backhand Volley' | 'Overhead Smash' | 'Backhand Overhead Smash' | 'Forehand Drop Shot' | 'Backhand Drop Shot' | 'Forehand Lob' | 'Backhand Lob' | 'Forehand Half-volley' | 'Backhand Half-volley' | 'Forehand Drive Volley' | 'Backhand Drive Volley' | 'Trick Shot' | 'Unknown Shot'; type ServeLocation = 'Wide' | 'Body' | 'T'; interface RallyShot { shotNumber: number; player: 0 | 1; stroke: StrokeType; direction?: 1 | 2 | 3; depth?: 'shallow' | 'deep' | 'very deep'; position?: 'baseline' | 'net' | 'approach'; code?: string; } interface MatchUpState { score: Score; matchUpStatus: MatchUpStatus; winningSide?: number; } type MatchUpStatus = 'TO_BE_PLAYED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED' | 'ABANDONED' | 'DEFAULTED' | 'RETIRED' | 'WALKOVER'; type MatchUpType = 'SINGLES' | 'DOUBLES' | 'TEAM'; type ParticipantType = 'INDIVIDUAL' | 'PAIR' | 'TEAM'; type ParticipantRole = 'COMPETITOR' | 'ALTERNATE' | 'SEED'; type ParticipantStatus = 'ACTIVE' | 'INACTIVE' | 'WITHDRAWN'; interface CreateMatchUpOptions { matchUpId?: string; matchUpFormat: string; participants?: Participant[]; isDoubles?: boolean; matchUpType?: MatchUpType; } interface AddPointOptions { winner?: 0 | 1; server?: 0 | 1; winningSide?: 1 | 2; serverSideNumber?: 1 | 2; serverParticipantId?: string; scoreValue?: number; timestamp?: string; rallyLength?: number; result?: PointResult; penaltyType?: string; wrongSide?: boolean; wrongServer?: boolean; penaltyPoint?: boolean; } interface GetScoreboardOptions { perspective?: number; } interface ValidationResult { isValid: boolean; errors: string[]; warnings?: string[]; } interface FormatStructure { bestOf?: number; exactly?: number; aggregate?: boolean; matchRoot?: string; matchMods?: string[]; setFormat?: SetFormatStructure; finalSetFormat?: SetFormatStructure; gameFormat?: GameFormatStructure; matchUpConstraint?: MatchUpConstraintStructure; simplified?: boolean; } interface MatchUpConstraintStructure { timed?: boolean; minutes?: number; } interface SetFormatStructure { setTo?: number; tiebreakAt?: number | string; tiebreakFormat?: TiebreakFormatStructure; noTiebreak?: boolean; NoAD?: boolean; winBy?: number; tiebreakSet?: TiebreakFormatStructure; timed?: boolean; minutes?: number; based?: string; modifier?: string; outs?: number; gameFormat?: GameFormatStructure; } interface TiebreakFormatStructure { tiebreakTo?: number; modifier?: string; NoAD?: boolean; } interface GameFormatStructure { type?: 'CONSECUTIVE' | 'TRADITIONAL'; count?: number; deuceAfter?: number; NoAD?: boolean; } interface EndSegmentOptions { setNumber?: number; timestamp?: string; reason?: 'time' | 'mercy' | 'manual'; } interface InitialScoreOptions { sets: Array<{ side1Score: number; side2Score: number; side1TiebreakScore?: number; side2TiebreakScore?: number; winningSide?: number; }>; currentSetScore?: { side1Score: number; side2Score: number; }; currentGameScore?: { side1Points: number; side2Points: number; }; server?: 0 | 1; } interface AddSetOptions { side1Score: number; side2Score: number; side1TiebreakScore?: number; side2TiebreakScore?: number; winningSide?: 1 | 2; timestamp?: string; } interface AddGameOptions { winner: 0 | 1; tiebreakScore?: [number, number]; timestamp?: string; } interface PointSituation { isBreakPoint: boolean; isGamePoint: boolean; isSetPoint: boolean; isMatchPoint: boolean; isGoldenPoint: boolean; isTiebreak: boolean; server?: 0 | 1; } interface ScoreResult { sets: SetScore[]; scoreString: string; games?: number[]; points?: number[]; pointDisplay?: [string, string]; situation?: PointSituation; } interface Statistics { totalPoints: number; pointsWon: number[]; gamesWon: number[]; setsWon: number[]; aces?: number[]; doubleFaults?: number[]; breakPoints?: number[]; } interface EpisodePoint { index: number; number: number; winner: 0 | 1; server?: 0 | 1; score?: string; result?: string; } interface EpisodeGame { index: number; isTiebreak: boolean; complete: boolean; winner?: 0 | 1; } interface EpisodeSet { index: number; complete: boolean; winner?: 0 | 1; } interface EpisodeNeeded { pointsToGame?: [number, number]; pointsToSet?: [number, number]; pointsToMatch?: [number, number]; gamesToSet?: [number, number]; isBreakpoint?: boolean; } interface Episode { action: 'addPoint'; point: EpisodePoint; game: EpisodeGame; set: EpisodeSet; needed: EpisodeNeeded; nextService: number; result?: string; complete: boolean; } declare function getScoreboard(matchUp: MatchUp, options?: GetScoreboardOptions): string; interface GetScoreOptions { useBracketNotation?: boolean; } declare function getScore(matchUp: MatchUp, options?: GetScoreOptions): ScoreResult; interface PointWithMetadata { winner?: 0 | 1; server?: 0 | 1; index?: number; set?: number; game?: number; result?: 'Ace' | 'Winner' | 'Serve Winner' | 'Unforced Error' | 'Forced Error' | 'Double Fault' | 'Net' | 'Out' | 'Penalty'; stroke?: 'Forehand' | 'Backhand' | 'Volley' | 'Forehand Volley' | 'Backhand Volley' | 'Overhead' | 'Smash' | 'Drop Shot' | 'Lob' | 'Slice'; hand?: 'Forehand' | 'Backhand' | 'Right' | 'Left'; serve?: 1 | 2; location?: string; rally?: number; first_serve?: { error: string; serves: string[]; }; breakpoint?: boolean; gamepoint?: boolean; setpoint?: boolean; matchpoint?: boolean; tiebreak?: boolean; code?: string; timestamp?: number; [key: string]: any; } interface StatCounters$1 { players: Record>; teams: Record>; } interface CalculatedStat { category: string; teams: StatTeamValue[]; } interface StatTeamValue { value: number; display: string; numerators?: string[]; } interface StatisticsOptions { setFilter?: number; playerFilter?: number; includeStrokeBreakdown?: boolean; includeRallyStats?: boolean; } interface MatchStatistics { counters: StatCounters$1; calculated: CalculatedStat[]; summary?: { totalPoints: number; bySet?: number[]; byPlayer?: number[]; }; } interface StatObject { name: string; numerator: [number, number]; denominator?: [number, number]; pct?: [number, number]; default?: 'numerator'; } interface PointMultiplier { condition: { results?: string[]; strokes?: string[]; setTypes?: string[]; }; value: number; } declare function resolvePointValue(point: Partial, multipliers: PointMultiplier[]): number; interface TimerProfile { shotClockSeconds?: number; segmentTimers?: { segmentType: string; minutes: number; direction?: string; stoppageTime?: boolean; }[]; changeoverSeconds?: number; setBreakSeconds?: number; } interface TimeoutRules { count: number; per: string; durationSeconds?: number; maxPerSide?: number; } interface PenaltyBoxProfile { durationSeconds: number; } interface SubstitutionRules { allowed: boolean; maxPerMatchUp?: number; maxPerSegment?: number; allowedMatchUpTypes?: string[]; timing?: string; minRosterSize?: number; maxRosterSize?: number; } interface PlayerRules { maxMinutesPerSegment?: number; matchUpTypes?: string[]; } interface PenaltyProfile { sport?: string; penaltyTypes: { penaltyType: string; label: string; category?: string; }[]; escalation?: { step: number; consequence: string; }[]; } interface PointProfile { sport?: string; pointResults: { result: string; label: string; isError?: boolean; isServe?: boolean; }[]; strokeTypes?: string[]; serveLocations?: string[]; } type ServerRule = 'ALTERNATE_GAMES' | 'WINNER_SERVES'; interface CompetitionFormat { competitionFormatId?: string; competitionFormatName?: string; matchUpFormat?: string; sport?: string; timerProfile?: TimerProfile; timeoutRules?: TimeoutRules; substitutionRules?: SubstitutionRules; playerRules?: PlayerRules; penaltyProfile?: PenaltyProfile; penaltyBoxProfile?: PenaltyBoxProfile; pointProfile?: PointProfile; pointMultipliers?: PointMultiplier[]; serverRule?: ServerRule; notes?: string; } interface ScoringEventContext { state: MatchUp; score: ReturnType; } interface ScoringEventHandlers { onPoint?: (context: ScoringEventContext) => void; onUndo?: (context: ScoringEventContext) => void; onRedo?: (context: ScoringEventContext) => void; onReset?: (context: ScoringEventContext) => void; onGameComplete?: (context: ScoringEventContext & { gameWinner: 0 | 1; }) => void; onSetComplete?: (context: ScoringEventContext & { setWinner: 0 | 1; }) => void; onMatchComplete?: (context: ScoringEventContext & { matchWinner: 0 | 1; }) => void; } interface ScoringEngineOptions { competitionFormat?: CompetitionFormat; pointMultipliers?: PointMultiplier[]; eventHandlers?: ScoringEventHandlers; matchUpFormat?: string; isDoubles?: boolean; matchUpId?: string; } interface ScoringEngineSupplementaryState { initialLineUps?: Record; redoStack?: ScoreEntry[]; } declare class ScoringEngine { private readonly competitionFormat?; private initialLineUps?; private pointMultipliers; private cachedFormatStructure?; private eventHandlers?; private initialScore?; private redoStack; private matchUpFormat; private matchUpId?; private isDoubles; private state; constructor(options?: ScoringEngineOptions); setState(matchUp: MatchUp): void; getState(): MatchUp; addPoint(options: AddPointOptions): void; addSet(options: AddSetOptions): void; addGame(options: AddGameOptions): void; endSegment(options?: EndSegmentOptions): void; setInitialScore(options: InitialScoreOptions): void; undo(count?: number): boolean; redo(count?: number): boolean; canUndo(): boolean; canRedo(): boolean; getUndoDepth(): number; getRedoDepth(): number; getScore(): ReturnType; getScoreboard(options?: Parameters[1]): string; getWinner(): number | undefined; isComplete(): boolean; getPointCount(): number; getFormat(): string; getStatistics(options?: StatisticsOptions): MatchStatistics; getStatObjects(options?: StatisticsOptions): StatObject[]; getNextServer(): 0 | 1; setServer(side: 0 | 1, options?: { recordEntry?: boolean; }): void; getEpisodes(): Episode[]; isNoAd(): boolean; getSetsToWin(): number; getTiebreakAt(): number | null; hasFinalSetTiebreak(): boolean; getFormatStructure(): FormatStructure | undefined; getInputMode(): 'points' | 'games' | 'sets' | 'mixed' | 'none'; setLineUp(sideNumber: 1 | 2, lineUp: TeamCompetitor[]): void; substitute(options: { sideNumber: 1 | 2; outParticipantId: string; inParticipantId: string; timestamp?: string; }): void; getActivePlayers(): { side1: string[]; side2: string[]; }; private hasLineUp; setPointMultipliers(multipliers: PointMultiplier[]): void; getPointMultipliers(): PointMultiplier[]; getSupplementaryState(): ScoringEngineSupplementaryState; loadSupplementaryState(state: ScoringEngineSupplementaryState): void; getPenaltyProfile(): PenaltyProfile | undefined; getPointProfile(): PointProfile | undefined; getTimerProfile(): TimerProfile | undefined; getTimeoutRules(): TimeoutRules | undefined; getPenaltyBoxProfile(): PenaltyBoxProfile | undefined; getSubstitutionRules(): SubstitutionRules | undefined; getPlayerRules(): PlayerRules | undefined; setEventHandlers(handlers: ScoringEventHandlers | undefined): void; getEventHandlers(): ScoringEventHandlers | undefined; decoratePoint(pointIndex: number, metadata: Record): void; markHardBoundary(options: { setIndex: number; gameIndex: number; }): void; editPoint(pointIndex: number, newData: Partial, options?: { recalculate?: boolean; }): void; removePoint(pointIndex: number, options?: { recalculate?: boolean; }): void; reset(): void; private ensureHistory; private buildEventContext; private cacheFormatStructure; private getInitialLineUps; private applyAddSet; private applyAddGame; private applySubstitution; private applyEndSegment; private checkSetCompletion; private checkMatchCompletion; private rebuildFromEntries; private prepareRebuildState; private replaySetServerEntry; private rebuildState; private applyInitialScore; } type SetMatchUpDailyLimitsArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; tournamentId: string; dailyLimits: any; }; declare function setMatchUpDailyLimits(params: SetMatchUpDailyLimitsArgs): ResultType; type AddPracticeRegistrationArgs = { tournamentRecord: Tournament; courtId: string; date: string; bookingId: string; participantId: string; startTime: string; endTime: string; notes?: string; disableNotice?: boolean; }; type AddPracticeRegistrationResult = ResultType & { registration?: PracticeRegistration; conflicts?: ConflictReport; }; declare function addPracticeRegistration(params: AddPracticeRegistrationArgs): AddPracticeRegistrationResult; declare function allTournamentMatchUps(params?: GetMatchUpsArgs): ResultType & { matchUps?: HydratedMatchUp[]; }; declare function attachConsolationStructures(params: any): ResultType & { addedStructureIds?: string[]; }; declare function attachPlayoffStructures(params: any): ResultType & { addedStructureIds?: string[]; }; type AttachStructuresArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; matchUpModifications?: any[]; structures: Structure[]; links?: DrawLink[]; itemType?: string; event?: Event$1; }; declare function attachStructures({ itemType, matchUpModifications, tournamentRecord, drawDefinition, structures, links, event, }: AttachStructuresArgs): ResultType & { addedStructureIds?: string[]; }; declare function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }: { tournamentRecord: any; outcomes: any; }): { error: { message: string; code: string; }; info?: undefined; publishedEventIds?: undefined; eventIdPublishedDrawIdsMap?: undefined; } | { error: { message: string; code: string; }; info: string; publishedEventIds?: undefined; eventIdPublishedDrawIdsMap?: undefined; } | { publishedEventIds: any; eventIdPublishedDrawIdsMap: any; error?: undefined; info?: undefined; }; type CreateOfficialRecordArgs = { officialRecordId?: string; personId: string; organisationId?: string; extensions?: any[]; }; declare function createOfficialRecord({ officialRecordId, personId, organisationId, extensions, }: CreateOfficialRecordArgs): { error?: any; officialRecord?: OfficialRecord; success?: boolean; }; declare function deleteFlightAndFlightDraw({ autoPublish, tournamentRecord, auditData, drawId, event, force }: { autoPublish?: boolean | undefined; tournamentRecord: any; auditData: any; drawId: any; event: any; force: any; }): ResultType | { error: any; } | { success: boolean; error?: undefined; info?: undefined; }; type GetCompetitionFormatArgs = { tournamentRecord: Tournament; drawDefinition?: DrawDefinition; structureId?: string; matchUpId?: string; eventId?: string; drawId?: string; event?: Event$1; }; declare function getCompetitionFormat(params: GetCompetitionFormatArgs): { structureDefaultCompetitionFormat?: competitionFormat; drawDefaultCompetitionFormat?: competitionFormat; eventDefaultCompetitionFormat?: competitionFormat; competitionFormat?: competitionFormat; error?: any; success?: boolean; }; type GetEvaluationTemplateArgs = { officialRecord?: OfficialRecord; policyName?: string; evaluationPolicy?: EvaluationPolicy; }; declare function getEvaluationTemplate({ officialRecord, policyName, evaluationPolicy, }: GetEvaluationTemplateArgs): { error?: any; success?: boolean; fields?: EvaluationFormField[]; evaluationPolicy?: EvaluationPolicy; }; type GetMatchUpScheduleDetailsArgs = { scheduleVisibilityFilters?: ScheduleVisibilityFilters; scheduleTiming?: ScheduleTiming; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; matchUpType?: EventTypeUnion; afterRecoveryTimes?: boolean; usePublishState?: boolean; matchUp: HydratedMatchUp; matchUpFormat?: string; publishStatus?: any; event?: Event$1; }; declare function getMatchUpScheduleDetails(params: GetMatchUpScheduleDetailsArgs): { error: { message: string; code: string; }; schedule?: undefined; endDate?: undefined; } | { schedule: any; endDate: string | undefined; error?: undefined; }; type GetParticipantIdFinishingPositionsArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; byeAdvancements?: boolean; event?: Event$1; }; declare function getParticipantIdFinishingPositions({ byeAdvancements, tournamentRecord, drawDefinition, event, }: GetParticipantIdFinishingPositionsArgs): any; type PracticeRegistrationRecord = { registration: PracticeRegistration; courtId: string; venueId: string; date: string; bookingId: string; bookingStartTime?: string; bookingEndTime?: string; }; type RegistrationFilter = { courtId?: string; date?: string; participantId?: string; includeCancelled?: boolean; }; type GetPracticeRegistrationsArgs = { tournamentRecord: Tournament; } & RegistrationFilter; declare function getPracticeRegistrations(params: GetPracticeRegistrationsArgs): { registrations: PracticeRegistrationRecord[]; }; declare function modifyTournamentRecord(params: any): any; type RemovePolicyArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; tournamentId?: string; policyType: string; event?: Event$1; }; declare function removePolicy(params: RemovePolicyArgs): (ResultType & { valid?: boolean; }) | { success: boolean; error?: undefined; } | { error: { message: string; code: string; }; }; declare function setOrderOfFinish(params: any): ResultType | { error: { message: string; code: string; }; }; type GenderValidityCheckArgs = { referenceGender?: GenderUnion; matchUpType?: string; gender?: GenderUnion; }; declare function tieFormatGenderValidityCheck(params: GenderValidityCheckArgs): ResultType; type UpdateTeamLineUpArgs = { drawDefinition: DrawDefinition; participantId: string; tieFormat: TieFormat; drawId?: string; lineUp: LineUp; }; declare function updateTeamLineUp({ drawDefinition, participantId, tieFormat, lineUp }: UpdateTeamLineUpArgs): { success?: boolean; error?: ErrorType; }; type ValidateCollectionDefinitionArgs = { collectionDefinition: CollectionDefinition; referenceGender?: GenderUnion; referenceCategory?: Category; checkCollectionIds?: boolean; eventType?: EventTypeUnion; checkCategory?: boolean; checkGender?: boolean; event?: Event$1; }; declare function validateCollectionDefinition({ checkCategory, collectionDefinition, checkCollectionIds, checkGender, referenceCategory, referenceGender, event, }: ValidateCollectionDefinitionArgs): ResultType; type AddEvaluationPolicyArgs = { officialRecord: OfficialRecord; evaluationPolicy: EvaluationPolicy; }; declare function addEvaluationPolicy({ officialRecord, evaluationPolicy, }: AddEvaluationPolicyArgs): { error?: any; evaluationPolicy?: EvaluationPolicy; success?: boolean; }; type AddMatchUpScheduledTimeArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; removePriorValues?: boolean; disableNotice?: boolean; scheduledTime?: string; matchUpId?: string; matchUp?: MatchUp$1; }; declare function addMatchUpScheduledTime(params: AddMatchUpScheduledTimeArgs): any; type AutoSeedingParams = { sortDescending: boolean; stage: StageTypeUnion; tournamentRecord: any; policyDefinitions: any; scaleAttributes: any; scaleSortMethod: any; drawDefinition: any; scaleName: string; drawSize: number; drawId: string; event: any; }; declare function autoSeeding({ tournamentRecord, drawDefinition, policyDefinitions, scaleAttributes, scaleName, drawSize, drawId, event, stage, sortDescending, scaleSortMethod, }: AutoSeedingParams): { stageEntries?: Entry[]; seedsCount?: number; entries?: Entry[]; error?: ErrorType; } | { error: { message: string; code: string; }; scaleItemsWithParticipantIds?: undefined; } | { scaleItemsWithParticipantIds: { participantId: string; scaleItems: any[]; }[] | undefined; error?: undefined; }; type DeleteParticipantsArgs = { addIndividualParticipantsToEvents?: boolean; tournamentRecord: Tournament; participantIds: string[]; }; declare function deleteParticipants(params: DeleteParticipantsArgs): { participantsRemovedCount?: number; success?: boolean; error?: ErrorType; }; declare function generateEventWithDraw(params: any): any; type GetAllStructureMatchUps = { scheduleVisibilityFilters?: ScheduleVisibilityFilters; tournamentAppliedPolicies?: PolicyDefinitions; participantsProfile?: ParticipantsProfile; tournamentParticipants?: Participant$1[]; policyDefinitions?: PolicyDefinitions; seedAssignments?: SeedAssignment[]; provisionalPositioning?: boolean; context?: { [key: string]: any; }; contextContent?: ContextContent; contextFilters?: MatchUpFilters; matchUpFilters?: MatchUpFilters; participantMap?: ParticipantMap; scheduleTiming?: ScheduleTiming; hydrateParticipants?: boolean; drawDefinition?: DrawDefinition; contextProfile?: ContextProfile; tournamentRecord?: Tournament; afterRecoveryTimes?: boolean; useParticipantMap?: boolean; usePublishState?: boolean; exitProfiles?: ExitProfiles; matchUpsMap?: MatchUpsMap; structure?: Structure; publishStatus?: any; inContext?: boolean; event?: Event$1; }; declare function getAllStructureMatchUps(params: GetAllStructureMatchUps): { collectionPositionMatchUps: {}; error: { message: string; code: string; }; roundMatchUps: {}; matchUps: never[]; isRoundRobin?: undefined; roundProfile?: undefined; matchUpsMap?: undefined; } | { collectionPositionMatchUps: {}; roundMatchUps: {}; matchUps: never[]; error?: undefined; isRoundRobin?: undefined; roundProfile?: undefined; matchUpsMap?: undefined; } | { collectionPositionMatchUps: {}; roundMatchUps: {}; isRoundRobin: boolean; roundProfile: RoundProfile | undefined; matchUpsMap: MatchUpsMap; matchUps: any; error?: undefined; }; type GetEvaluationSummaryArgs = { officialRecord: OfficialRecord; policyName?: string; approvedOnly?: boolean; }; interface EvaluationSummary { evaluationCount: number; averageRating: number; latestRating?: number; latestDate?: string; sectionAverages?: { sectionId: string; sectionName: string; average: number; }[]; meetsThreshold?: boolean; } declare function getEvaluationSummary({ officialRecord, policyName, approvedOnly }: GetEvaluationSummaryArgs): { error?: any; success?: boolean; summary?: EvaluationSummary; }; type GetMatchUpDailyLimitsArgs = { tournamentRecords: { [key: string]: Tournament; }; tournamentId?: string; }; declare function getMatchUpDailyLimits({ tournamentRecords, tournamentId }: GetMatchUpDailyLimitsArgs): ResultType & { matchUpDailyLimits?: any; }; type GetPairedParticipantArgs = { tournamentParticipants?: any[]; tournamentRecord?: Tournament; participantIds: string[]; }; declare function getPairedParticipant({ tournamentParticipants, tournamentRecord, participantIds, }: GetPairedParticipantArgs): { duplicatedPairParticipants?: any[]; participant?: Participant$1; error?: ErrorType; success?: boolean; }; type GetPositionAssignmentsArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; structure?: Structure; structureId?: string; stage?: string; }; declare function getPositionAssignments({ tournamentRecord, drawDefinition, stage, structureId, structure, }: GetPositionAssignmentsArgs): { error: { message: string; code: string; }; positionAssignments?: undefined; structureId?: undefined; } | { positionAssignments: PositionAssignment[]; structureId: string | undefined; error: ErrorType | undefined; }; declare function getTournamentPersons({ tournamentRecord, participantFilters }: { tournamentRecord: any; participantFilters: any; }): { error: { message: string; code: string; }; tournamentPersons?: undefined; } | { tournamentPersons: unknown[]; error?: undefined; }; type ModifyCertificationArgs = { officialRecord: OfficialRecord; certificationId: string; updates: Partial>; }; declare function modifyCertification({ officialRecord, certificationId, updates, }: ModifyCertificationArgs): { error?: any; certification?: OfficialCertification; success?: boolean; }; interface ParticipantScaleItemArgs { scaleAttributes: ScaleAttributes; requireTimeStamp?: boolean; participant: Participant$1; } declare function participantScaleItem({ requireTimeStamp, scaleAttributes, participant, }: ParticipantScaleItemArgs): ResultType & { scaleItem?: ScaleItem; }; type RemoveCertificationArgs = { officialRecord: OfficialRecord; certificationId: string; }; declare function removeCertification({ officialRecord, certificationId }: RemoveCertificationArgs): any; type RemoveCollectionGroupArgs = { updateInProgressMatchUps?: boolean; collectionGroupNumber: number; tournamentRecord: Tournament; drawDefinition: DrawDefinition; tieFormatName?: string; structureId: string; matchUpId: string; matchUp?: MatchUp$1; eventId?: string; event?: Event$1; }; declare function removeCollectionGroup({ updateInProgressMatchUps, collectionGroupNumber, tournamentRecord, drawDefinition, tieFormatName, structureId, matchUpId, matchUp, eventId, event, }: RemoveCollectionGroupArgs): ResultType | { error: { message: string; code: string; }; }; declare function setTournamentStatus({ tournamentRecord, status }: { tournamentRecord: any; status: any; }): { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; } | { success: boolean; error?: undefined; info?: undefined; }; declare function toStatObjects(stats: MatchStatistics): StatObject[]; declare function unPublishParticipants(params: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type AddExtensionArgs$1 = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; participantId?: string; creationTime?: boolean; extension: Extension; event?: Event$1; }; declare function addTournamentExtension(params: AddExtensionArgs$1): { success?: boolean; error?: ErrorType; }; declare function addDrawDefinitionExtension(params: AddExtensionArgs$1): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; declare function addEventExtension(params: AddExtensionArgs$1): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; declare function addParticipantExtension(params?: any): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; declare function removeTournamentExtension(params: any): { success?: boolean; error?: ErrorType; info?: any; }; declare function removeDrawDefinitionExtension(params: any): { success?: boolean; error?: ErrorType; info?: any; } | { error: { message: string; code: string; }; }; declare function removeEventExtension(params: any): { success?: boolean; error?: ErrorType; info?: any; } | { error: { message: string; code: string; }; }; declare function removeParticipantExtension(params?: any): { success?: boolean; error?: ErrorType; info?: any; } | { error: { message: string; code: string; }; }; declare function addDrawEntries({ suppressDuplicateEntries, autoEntryPositions, entryStageSequence, ignoreStageSpace, participantIds, drawDefinition, entryStatus, roundTarget, entryStage, extension, drawId, event, }: { suppressDuplicateEntries?: boolean | undefined; autoEntryPositions?: boolean | undefined; entryStageSequence: any; ignoreStageSpace: any; participantIds: any; drawDefinition: any; entryStatus: any; roundTarget: any; entryStage: any; extension: any; drawId: any; event: any; }): ResultType | { error: { message: string; code: string; }; }; type StructureActionsArgs = { drawDefinition: DrawDefinition; structureId: string; }; type StructureQueryArgs = { drawDefinition: DrawDefinition; structure?: Structure; structureId?: string; }; declare function isCompletedStructure(params: StructureQueryArgs): boolean; declare function allPlayoffPositionsFilled(params: StructureActionsArgs): boolean | { error: { message: string; code: string; }; }; declare function bulkMatchUpStatusUpdate(params: any): ResultType | { success?: boolean; error?: ErrorType; info?: string; } | { error: { message: string; code: string; }; } | { error: { message: string; code: string; }; info: { outcomes: any; }; }; declare function completeDrawMatchUps(params: any): { completeRoundRobinPlayoffs?: boolean; completedCount?: number; success?: boolean; error?: ErrorType; }; type DeleteAdHocMatchUpsArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; removeUnAssigned?: boolean; removeIncomplete?: boolean; removeCompleted?: boolean; roundNumbers?: number[]; matchUpIds?: string[]; structureId?: string; event?: Event$1; }; declare function deleteAdHocMatchUps(params: DeleteAdHocMatchUpsArgs): ResultType & { deletedMatchUpsCount?: number; }; type FilterParticipantsArgs = { participantFilters: ParticipantFilters; participants: HydratedParticipant[]; tournamentRecord: Tournament; }; declare function filterParticipants({ participantFilters, tournamentRecord, participants, }: FilterParticipantsArgs): HydratedParticipant[]; declare function generateParticipants(params: any): { participants?: any[]; error?: ErrorType; }; type CompetitionMatchUpsArgs = { scheduleVisibilityFilters?: ScheduleVisibilityFilters; participantsProfile?: ParticipantsProfile; tournamentRecords: TournamentRecords; policyDefinitions?: PolicyDefinitions; matchUpFilters?: MatchUpFilters; contextFilters?: MatchUpFilters; hydrateParticipants?: boolean; afterRecoveryTimes?: boolean; useParticipantMap?: boolean; usePublishState?: boolean; nextMatchUps?: boolean; inContext?: boolean; }; declare function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, useParticipantMap, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs): ResultType & { mappedParticipants?: { [key: string]: HydratedParticipant; }; abandonedMatchUps?: HydratedMatchUp[]; completedMatchUps?: HydratedMatchUp[]; upcomingMatchUps?: HydratedMatchUp[]; pendingMatchUps?: HydratedMatchUp[]; byeMatchUps?: HydratedMatchUp[]; groupInfo?: GroupInfo; }; type GetEntriesAndSeedsCountArgs = { policyDefinitions: PolicyDefinitions; drawDefinition: DrawDefinition; stage: StageTypeUnion; drawSize?: number; drawId?: string; event: Event$1; }; declare function getEntriesAndSeedsCount({ policyDefinitions, drawDefinition, drawSize, drawId, event, stage, }: GetEntriesAndSeedsCountArgs): { stageEntries?: Entry[]; seedsCount?: number; entries?: Entry[]; error?: ErrorType; }; type GetMatchUpDependenciesArgs = { includeParticipantDependencies?: boolean; tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; matchUps?: HydratedMatchUp[]; matchUpIds?: string[]; drawIds?: string[]; }; declare function getMatchUpDependencies(params: GetMatchUpDependenciesArgs): { sourceMatchUpIds?: { [key: string]: any[]; }; matchUps?: HydratedMatchUp[]; positionDependencies?: any; matchUpDependencies?: any; error?: ErrorType; success?: boolean; }; type StatCounters = { participantName: string; competitorIds: string[]; participantId: string; matchUpStatuses: { [key: string]: number; }; competitiveness: { [key: string]: Tally; }; competitiveRatio?: number; decisiveRatio?: number; routineRatio?: number; tiebreaksRatio?: number; matchUpsRatio?: number; pointsRatio?: number; gamesRatio?: number; setsRatio?: number; tiebreaksRank?: number; matchUpsRank?: number; pointsRank?: number; gamesRank?: number; setsRank?: number; tiebreaks: Tally; matchUps: Tally; points: Tally; games: Tally; sets: Tally; }; type GetTeamStatistics = { withCompetitiveProfiles?: boolean; opponentParticipantId?: string; withIndividualStats?: boolean; tournamentRecord: Tournament; matchUps?: HydratedMatchUp[]; teamParticipantId?: string; withScaleValues?: boolean; tallyPolicy?: any; }; type TeamStatsResults = { allParticipantStats?: StatCounters[]; relevantMatchUps: HydratedMatchUp[]; participatingTeamsCount?: number; opponentStats?: StatCounters; teamStats?: StatCounters; success: boolean; }; declare function getParticipantStats({ withCompetitiveProfiles, opponentParticipantId, withIndividualStats, teamParticipantId, tournamentRecord, withScaleValues, tallyPolicy, matchUps, }: GetTeamStatistics): ResultType | TeamStatsResults; type GetTournamentPointAwardsArgs = { participantFilters?: ParticipantFilters; policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; level?: number; }; declare function getTournamentPointAwards({ participantFilters, policyDefinitions, tournamentRecord, level, }: GetTournamentPointAwardsArgs): { error: { message: string; code: string; }; } | { success: boolean; pointAwards: any[]; }; declare function mergeParticipants({ participants: incomingParticipants, tournamentRecord, arraysToMerge }: { participants?: never[] | undefined; tournamentRecord: any; arraysToMerge: any; }): { error: { message: string; code: string; }; } | { success: boolean; modifiedParticipantsCount: number; newParticipantsCount: number; error?: undefined; }; type ModifyDrawNameArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; flightProfile: FlightProfile; drawName: string; drawId: string; event: Event$1; }; declare function modifyDrawName({ tournamentRecord, drawDefinition, flightProfile, drawName, drawId, event, }: ModifyDrawNameArgs): ResultType & { flight?: Flight; }; declare function modifyParticipant(params: any): any; declare function removeMatchUpOutcome({ tournamentRecord, drawId, matchUpId, event, drawDefinition }: { tournamentRecord: any; drawId: any; matchUpId: any; event: any; drawDefinition: any; }): ResultType | { success?: boolean; error?: ErrorType; info?: string; } | { error: { message: string; code: string; }; }; type RemoveRoundMatchUpsArgs = { removeCompletedMatchUps?: boolean; tournamentRecord: Tournament; drawDefinition: DrawDefinition; structureId: string; roundNumber: number; event: Event$1; }; declare function removeRoundMatchUps({ removeCompletedMatchUps, tournamentRecord, drawDefinition, structureId, roundNumber, event, }: RemoveRoundMatchUpsArgs): ResultType & { deletedMatchUpsCount?: number; roundRemoved?: boolean; }; type SetTournamentDatesArgs = { tournamentRecord: Tournament; weekdays?: WeekdayUnion[]; activeDates?: string[]; startDate?: string; endDate?: string; }; declare function setTournamentDates(params: SetTournamentDatesArgs): ResultType & { unscheduledMatchUpIds?: string[]; datesRemoved?: string[]; datesAdded?: string[]; }; declare function setTournamentStartDate({ tournamentRecord, startDate }: { tournamentRecord: any; startDate: any; }): (ResultType & { unscheduledMatchUpIds?: string[]; datesRemoved?: string[]; datesAdded?: string[]; }) | { error: { message: string; code: string; }; }; declare function setTournamentEndDate({ tournamentRecord, endDate }: { tournamentRecord: any; endDate: any; }): (ResultType & { unscheduledMatchUpIds?: string[]; datesRemoved?: string[]; datesAdded?: string[]; }) | { error: { message: string; code: string; }; }; type WizardParticipant = { participantId: string; rating: number; category?: string; gender?: string; }; type ConsolationAppetite = 'NONE' | 'LIGHT' | 'FULL'; type WizardConstraints = { consolationAppetite?: ConsolationAppetite; allowCollapsedCategories?: boolean; voluntaryConsolation?: boolean; targetMatchesPerPlayer?: number; targetCompetitivePct?: number; allowMixedGender?: boolean; matchUpFormat?: string; hoursPerDay?: number; avgMinutes?: number; courts: number; days: number; }; type WizardGovernance = { allowedMatchUpFormats?: string[]; allowedDrawTypes?: string[]; }; type DistributionBin = { binStart: number; binEnd: number; count: number; }; type DistributionGap = { start: number; end: number; size: number; }; type RatingDistributionStats = { histogram: DistributionBin[]; gaps: DistributionGap[]; stddev: number; median: number; count: number; mean: number; iqr: number; min: number; max: number; }; type FlightingStrategyType = 'STAGGERED_SINGLE' | 'NATURAL_CLUSTER' | 'EQUAL_COUNT' | 'EQUAL_BAND'; type WizardFlight = { participantIds: string[]; ratings: number[]; category?: string; gender?: string; label: string; }; type FlightingStrategy = { type: FlightingStrategyType; flights: WizardFlight[]; variant?: string; }; type StructureKind = 'FIRST_ROUND_LOSER_CONSOLATION' | 'FIRST_MATCH_LOSER_CONSOLATION' | 'ROUND_ROBIN_WITH_PLAYOFF' | 'DOUBLE_ELIMINATION' | 'SINGLE_ELIMINATION' | 'ROUND_ROBIN' | 'DRAW_MATIC' | 'LUCKY_DRAW' | 'ADAPTIVE' | 'COMPASS' | 'FEED_IN' | 'SWISS'; type StructureRecommendation = { withdrawalRiskFactor: number; minMatchesPerPlayer: number; kind: StructureKind; totalMatches: number; voluntaryConsolation?: boolean; groupSize?: number; variantId?: string; rounds?: number; }; type FlightStructure = { predictedBands: { competitive: number; decisive: number; routine: number; }; structure: StructureRecommendation; flight: WizardFlight; }; type PlanWarning = 'MIXED_GENDER_VARIANT' | 'COLLAPSED_CATEGORY' | 'WITHDRAWAL_RISK' | 'OVER_CAPACITY' | 'BELOW_FLOOR'; type RankedPlanAggregate = { minMatchesPerPlayer: number; courtHoursAvailable: number; courtHoursRequired: number; courtUtilization: number; totalMatches: number; competitive: number; decisive: number; routine: number; }; type RankedPlan = { flightStructures: FlightStructure[]; aggregate: RankedPlanAggregate; strategy: FlightingStrategyType; warnings: PlanWarning[]; variant?: string; score: number; rank: number; }; type RejectedStrategy = { strategy: FlightingStrategyType; reason: string; }; type SuggestFormatPlansArgs = { predictionModel?: PredictionModel; tournamentRecord?: Tournament; participants: WizardParticipant[]; governance?: WizardGovernance; constraints: WizardConstraints; }; type SuggestFormatPlansResult = { rejected?: RejectedStrategy[]; distribution: RatingDistributionStats; plans: RankedPlan[]; error?: ErrorType; }; declare function suggestFormatPlans({ predictionModel, tournamentRecord, participants, governance, constraints, }: SuggestFormatPlansArgs): SuggestFormatPlansResult; declare function unPublishOrderOfPlay(params: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function addPersonOtherId({ tournamentRecord, participantId, organisationId, personId, }: { tournamentRecord: any; participantId: string; organisationId: string; personId: string; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; info: string; } | { error: { message: string; code: string; }; info?: undefined; }; type AggreateTieFormatsArgs = { tournamentRecord: Tournament; }; declare function aggregateTieFormats({ tournamentRecord, }: AggreateTieFormatsArgs): ResultType & { addedCount?: number; }; type ApplyLineUps = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; lineUps: TeamCompetitor$1[]; matchUpId: string; event: Event$1; }; declare function applyLineUps(params: ApplyLineUps): any; type CalculateMatchUpMarginArgs = { matchUp: MatchUp$1; }; type CalculateMatchUpMarginResult = { margin?: number; setRatio?: number; gameRatio?: number; pointRatio?: number; setsWonByLoser?: number; setsWonByWinner?: number; gameDifferential?: number; success?: boolean; error?: ErrorType; }; declare function calculateMatchUpMargin({ matchUp }: CalculateMatchUpMarginArgs): CalculateMatchUpMarginResult; declare function checkMatchUpIsComplete({ matchUp }: { matchUp: any; }): any; type GetAggregateTeamResultsArgs = { finishingPositionRangeBounsPoints?: { [key: string]: number; }; tournamentRecord: Tournament; }; declare function getAggregateTeamResults(params: GetAggregateTeamResultsArgs): (ResultType & { valid?: boolean; }) | { individualResults: {}; teamResults: {}; success: boolean; }; type getPredictiveAccuracyArgs = { exclusionRule?: { valueAccessor: string; range: [number, number]; }; tournamentRecord: Tournament; drawDefinition: DrawDefinition; matchUps?: HydratedMatchUp[]; singlesForDoubles?: boolean; valueAccessor?: string; excludeMargin?: number; zoneDoubling?: boolean; matchUpType: EventTypeUnion; zoneMargin?: number; ascending?: boolean; scaleName: string; eventId?: string; zonePct?: number; drawId?: string; event?: Event$1; }; declare function getPredictiveAccuracy(params: getPredictiveAccuracyArgs): { error: { message: string; code: string; }; info?: undefined; context?: undefined; } | { error: { message: string; code: string; }; info: { matchUpType: EventTypeUnion; }; context?: undefined; } | { error: { message: string; code: string; }; context: { matchUps: HydratedMatchUp[]; }; info?: undefined; } | { relevantMatchUps: HydratedMatchUp[]; zoneDistribution: any; zoneData: { competitiveness: any; valuesGap: number; score: Score$1 | undefined; }[]; accuracy: any; nonZone: number; success: boolean; error?: undefined; info?: undefined; context?: undefined; }; type GetSchedulingProfileArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; }; declare function getSchedulingProfile({ tournamentRecords, tournamentRecord }: GetSchedulingProfileArgs): { schedulingProfile?: any; modifications?: number; error?: ErrorType; issues?: string[]; }; type SetSchedulingProfileArgs = { tournamentRecords: TournamentRecords; tournamentRecord?: Tournament; schedulingProfile?: any[]; }; declare function setSchedulingProfile({ tournamentRecords, tournamentRecord, schedulingProfile, }: SetSchedulingProfileArgs): any; declare function publishParticipants(params: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type RemoveCourtGridBookingArgs = { tournamentRecord: Tournament; disableNotice?: boolean; scheduledDate: string; courtOrder: number; courtId: string; }; declare function removeCourtGridBooking(params: RemoveCourtGridBookingArgs): ResultType & { booking?: any; }; type ResetAdHocMatchUps = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; removeAssignments?: boolean; roundNumbers?: number[]; matchUpIds?: string[]; structureId?: string; event: Event$1; }; declare function resetAdHocMatchUps(params: ResetAdHocMatchUps): any; declare function setTournamentName({ tournamentRecord, promotionalName, tournamentName, formalName }: { tournamentRecord: any; promotionalName: any; tournamentName: any; formalName: any; }): ResultType & { valid?: boolean; }; declare function setTournamentNotes({ tournamentRecord, notes }: { tournamentRecord: any; notes: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; }; declare function setTournamentLocalTimeZone({ tournamentRecord, localTimeZone }: { tournamentRecord: any; localTimeZone: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; }; declare function setTournamentTier({ tournamentRecord, tournamentTier }: { tournamentRecord: any; tournamentTier: any; }): (ResultType & { valid?: boolean; }) | { error: string; }; declare function setRegistrationProfile({ tournamentRecord, registrationProfile }: { tournamentRecord: any; registrationProfile: any; }): ResultType & { valid?: boolean; }; declare function setTournamentCategories({ tournamentRecord, categories }: { tournamentRecord: any; categories: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; referenced: string[]; }; declare function tournamentMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult; declare function validateSchedulingProfile({ tournamentRecords, schedulingProfile }: { tournamentRecords: any; schedulingProfile: any; }): any; type AddCertificationArgs = { officialRecord: OfficialRecord; certificationId?: string; personId?: string; organisationId: string; certificationFamily: string; certificationLevel?: string; status?: string; validFrom?: string; validUntil?: string; documentReferences?: any[]; notes?: string; extensions?: any[]; }; declare function addCertification({ officialRecord, certificationId, organisationId, certificationFamily, certificationLevel, status, validFrom, validUntil, documentReferences, notes, extensions, }: AddCertificationArgs): { error?: any; certification?: OfficialCertification; success?: boolean; }; declare function addCollectionGroup({ updateInProgressMatchUps, tournamentRecord, groupDefinition, drawDefinition, collectionIds, tieFormatName, structureId, matchUpId, matchUp, eventId, event, }: { updateInProgressMatchUps?: boolean | undefined; tournamentRecord: any; groupDefinition: any; drawDefinition: any; collectionIds: any; tieFormatName: any; structureId: any; matchUpId: any; matchUp: any; eventId: any; event: any; }): ResultType | { error: { message: string; code: string; }; }; type AddParticipantsType = { allowDuplicateParticipantIdPairs?: boolean; returnParticipants?: boolean; participants?: Participant$1[]; tournamentRecord: Tournament; }; declare function addParticipants({ allowDuplicateParticipantIdPairs, returnParticipants, tournamentRecord, participants, }: AddParticipantsType): any; declare function analyzeTournament({ tournamentRecord }: { tournamentRecord: any; }): { error: { message: string; code: string; }; } | { analysis: any; success: boolean; error?: undefined; }; declare function calculateMatchStatistics(_matchUp: MatchUp, points: PointWithMetadata[], options?: StatisticsOptions): MatchStatistics; declare function enrichPointHistory(rawPoints: any[]): PointWithMetadata[]; declare function getQuickStats(points: PointWithMetadata[], options?: StatisticsOptions): { aces: [number, number]; doubleFaults: [number, number]; winners: [number, number]; unforcedErrors: [number, number]; totalPoints: [number, number]; }; declare function courtGridRows({ courtPrefix, minRowsCount, courtsData, scheduledDate }: { courtPrefix?: string | undefined; minRowsCount: any; courtsData: any; scheduledDate: any; }): { error: { message: string; code: string; }; courtPrefix?: undefined; rows?: undefined; } | { courtPrefix: string; rows: any[]; error?: undefined; }; type DeleteDrawDefinitionArgs = { policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; eventDataParams?: any; autoPublish?: boolean; drawIds?: string[]; auditData?: any; eventId?: string; force?: boolean; event?: Event$1; }; declare function deleteDrawDefinitions(params: DeleteDrawDefinitionArgs): ResultType | { error: any; }; type GetAppliedPoliciesArgs = { onlySpecifiedPolicyTypes?: boolean; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; policyTypes?: string[]; structure?: Structure; event?: Event$1; }; declare function getAppliedPolicies({ onlySpecifiedPolicyTypes, policyTypes, tournamentRecord, drawDefinition, structure, event, }: GetAppliedPoliciesArgs): { appliedPolicies?: PolicyDefinitions; error?: ErrorType; }; type GetPolicyDefinitionsArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; policyTypes?: string[]; structure?: Structure; event?: Event$1; }; declare function getPolicyDefinitions({ policyTypes, tournamentRecord, drawDefinition, structure, event, }: GetPolicyDefinitionsArgs): { policyDefinitions?: PolicyDefinitions; error?: ErrorType; info?: string; }; type GetMatchUpFormatArgs = { tournamentRecord: Tournament; drawDefinition?: DrawDefinition; structureId?: string; matchUpId?: string; eventId?: string; drawId?: string; event?: Event$1; }; declare function getMatchUpFormat(params: GetMatchUpFormatArgs): any; type GetRoundsArgs = { tournamentRecords?: { [key: string]: Tournament; }; excludeScheduleDateProfileRounds?: string; inContextMatchUps?: HydratedMatchUp[]; excludeScheduledRounds?: boolean; excludeCompletedRounds?: boolean; context?: { [key: string]: any; }; matchUpFilters?: MatchUpFilters; tournamentRecord?: Tournament; withSplitRounds?: boolean; schedulingProfile?: any; scheduleDate?: string; withRoundId?: boolean; venueId?: string; }; declare function getRounds({ excludeScheduleDateProfileRounds, excludeScheduledRounds, excludeCompletedRounds, inContextMatchUps, tournamentRecords, schedulingProfile, tournamentRecord, withSplitRounds, matchUpFilters, scheduleDate, withRoundId, venueId, context, }: GetRoundsArgs): { error: { message: string; code: string; }; inContextMatchUps: HydratedMatchUp[]; } | { error: { message: string; code: string; }; inContextMatchUps?: undefined; } | { rounds: any[]; excludedRounds: any[]; success: boolean; error?: undefined; inContextMatchUps?: undefined; }; declare function getTournamentInfo(params?: { withStructureDetails?: boolean; tournamentRecord: Tournament; withMatchUpStats?: boolean; usePublishState?: boolean; withVenueData?: boolean; }): { tournamentInfo?: any; eventInfo?: any[]; error?: ErrorType; }; declare function hydrateTournamentRecord(params: any): { error: { message: string; code: string; }; tournamentRecord?: undefined; } | { tournamentRecord: any; error?: undefined; }; declare function keyValueScore(params: any): { updated: any; info: any; scoreString?: undefined; sets?: undefined; winningSide?: undefined; matchUpStatus?: undefined; } | { updated: any; scoreString: any; sets: any; winningSide: any; matchUpStatus: any; info: any; }; type ModifyEvaluationArgs = { officialRecord: OfficialRecord; evaluationId: string; updates: Partial & { scores?: EvaluationScore[]; }>; }; declare function modifyEvaluation({ officialRecord, evaluationId, updates }: ModifyEvaluationArgs): { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; declare function publishOrderOfPlay(params: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type GetOfficialRecordArgs = { officialRecord: OfficialRecord; }; declare function queryOfficialRecord({ officialRecord }: GetOfficialRecordArgs): { error?: any; success?: boolean; officialRecord?: OfficialRecord; }; declare function refreshEventDrawOrder({ tournamentRecord, event }: { tournamentRecord: any; event: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; } | { success: boolean; error?: undefined; info?: undefined; }; type RemoveEvaluationArgs = { officialRecord: OfficialRecord; evaluationId: string; }; declare function removeEvaluation({ officialRecord, evaluationId }: RemoveEvaluationArgs): any; type RemoveSuspensionArgs = { officialRecord: OfficialRecord; suspensionId: string; }; declare function removeSuspension({ officialRecord, suspensionId }: RemoveSuspensionArgs): any; declare function stringify(matchUpFormatObject: any, preserveRedundant?: boolean): string | undefined; type AddAdHocMatchUpsParams = { suppressNotifications?: boolean; tournamentRecord: any; structureId?: string; drawDefinition: any; matchUps: any[]; event: any; }; declare function addAdHocMatchUps(params: AddAdHocMatchUpsParams): ResultType; type AddParticipantType = { allowDuplicateParticipantIdPairs?: boolean; tournamentRecords?: TournamentRecords; tournamentRecord: Tournament; activeTournamentId?: string; returnParticipant?: boolean; disableNotice?: boolean; pairOverride?: boolean; tournamentId?: string; participant: any; }; declare function addParticipant(params: AddParticipantType): any; declare function allEventMatchUps(params: GetMatchUpsArgs): { error: { message: string; code: string; }; matchUps?: undefined; groupInfo?: undefined; } | { matchUps: HydratedMatchUp[]; groupInfo: any; error?: undefined; }; type CalculateWinCriteriaArgs = { collectionGroups?: { groupValue?: number; groupNumber?: number; }[]; collectionDefinitions?: CollectionDefinition[]; }; declare function calculateWinCriteria({ collectionDefinitions, collectionGroups, }: CalculateWinCriteriaArgs): ResultType & { aggregateValue?: boolean; valueGoal?: number; }; type GetVenuesAndCourtsArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; convertExtensions?: boolean; ignoreDisabled?: boolean; tournamentId?: string; venueIds?: string[]; dates?: string[]; }; declare function getVenuesAndCourts(params: GetVenuesAndCourtsArgs): ResultType & { venues?: HydratedVenue[]; courts?: HydratedCourt[]; }; type GetCompeitionVenuesArgs = { tournamentRecords: TournamentRecords; requireCourts?: boolean; dates?: string[]; }; declare function getCompetitionVenues({ tournamentRecords, requireCourts, dates }: GetCompeitionVenuesArgs): { venueIds?: string[]; error?: ErrorType; venues?: Venue[]; }; type GetEventRankingPointsArgs = { policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; policyName?: string; eventId: string; level?: number; }; declare function getEventRankingPoints({ policyDefinitions, tournamentRecord, policyName, eventId, level, }: GetEventRankingPointsArgs): { error: { message: string; code: string; }; } | { success: boolean; eventAwards: any[]; eventName: string | undefined; eventType: EventTypeUnion | undefined; isDoubles: boolean; error?: undefined; }; declare function getHomeParticipantId(params: ScheduledMatchUpArgs): any; declare function getMatchUpContextIds({ matchUps, matchUpId }: { matchUps: any; matchUpId: any; }): { error: { message: string; code: string; }; matchUpId?: undefined; drawId?: undefined; eventId?: undefined; structureId?: undefined; tournamentId?: undefined; } | { matchUpId: any; drawId: any; eventId: any; structureId: any; tournamentId: any; error?: undefined; }; type MutationLockEntry = MutationLock & { drawId?: string; eventId?: string; venueId?: string; }; type GetMutationLocksArgs = { tournamentRecord: Tournament; scope?: MutationLockScope; }; declare function getMutationLocks(params: GetMutationLocksArgs): { success?: boolean; error?: ErrorType; mutationLocks?: MutationLockEntry[]; }; type GetParticipantsArgs = { withIndividualParticipants?: boolean | { [key: string]: any; }; participantFilters?: ParticipantFilters; scheduleAnalysis?: ScheduleAnalysis; policyDefinitions?: PolicyDefinitions; withPotentialMatchUps?: boolean; contextFilters?: MatchUpFilters; matchUpFilters?: MatchUpFilters; returnParticipantMap?: boolean; contextProfile?: ContextProfile; tournamentRecord: Tournament; withRankingProfile?: boolean; convertExtensions?: boolean; withScheduleItems?: boolean; withSignInStatus?: boolean; withTeamMatchUps?: boolean; withScaleValues?: boolean; usePublishState?: boolean; returnMatchUps?: boolean; withStatistics?: boolean; withOpponents?: boolean; withMatchUps?: boolean; internalUse?: boolean; withSeeding?: boolean; withEvents?: boolean; withDraws?: boolean; withISO2?: boolean; withIOC?: boolean; }; declare function getParticipants(params: GetParticipantsArgs): { eventsPublishStatuses?: { [key: string]: any; }; participantIdsWithConflicts?: string[]; participants?: HydratedParticipant[]; missingParticipantIds?: string[]; participantMap?: ParticipantMap; matchUps?: HydratedMatchUp[]; derivedEventInfo?: any; derivedDrawInfo?: any; mappedMatchUps?: any; error?: ErrorType; success?: boolean; }; type GetSeedingThresholdsArgs = { roundRobinGroupsCount?: number; participantsCount: number; }; declare function getSeedingThresholds({ roundRobinGroupsCount, participantsCount, }: GetSeedingThresholdsArgs): ResultType & { seedingThresholds?: any; success?: boolean; }; type GetSeedsCountArgs = { policyDefinitions?: PolicyDefinitions; requireParticipantCount?: boolean; drawSizeProgression?: boolean; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; participantsCount?: number; participantCount?: number; drawSize?: any; event?: Event$1; }; declare function getSeedsCount(params: GetSeedsCountArgs): ResultType & { seedsCount?: number; }; interface ValidateMatchUpOptions { matchUp: MatchUp; expectedScore?: { sets?: Array<{ side1Score?: number; side2Score?: number; side1TiebreakScore?: number; side2TiebreakScore?: number; }>; scoreString?: string; }; } interface ValidationDetails { isValid: boolean; errors: string[]; warnings: string[]; actual: { sets: SetScore[]; scoreString: string; }; expected: { sets?: any[]; scoreString?: string; }; pointsProcessed: number; pointsRejected: number; } declare function validateMatchUp(options: ValidateMatchUpOptions): ValidationDetails; declare function getSetScoreString(set: SetScore): string; declare function validateSet(options: { points: Array<{ winner: number; server?: number; }>; matchUpFormat: string; expectedGames: [number, number]; expectedTiebreak?: [number, number]; }): ValidationDetails; declare function getTeamLineUp({ drawDefinition, participantId }: { drawDefinition: any; participantId: any; }): { error: { message: string; code: string; }; lineUp?: undefined; } | { lineUp: any; error?: undefined; }; declare function getTournamentIds({ tournamentRecords }: { tournamentRecords: any; }): { success: boolean; tournamentIds: string[]; }; type SetType = 'standard' | 'tiebreakOnly' | 'timed' | 'matchTiebreak'; declare function inferServeSide(matchUp: MatchUp, formatStructure: FormatStructure, setType: SetType): 'deuce' | 'ad' | undefined; type ModifyEntriesStatusArgs = { drawDefinition?: DrawDefinition; autoEntryPositions?: boolean; tournamentRecord: Tournament; entryStatus?: EntryStatusUnion; ignoreAssignment?: boolean; entryStage?: StageTypeUnion; participantIds: string[]; extension?: Extension; eventSync?: boolean; drawId: string; stage?: StageTypeUnion; event?: Event$1; }; declare function modifyEntriesStatus({ autoEntryPositions, ignoreAssignment, tournamentRecord, drawDefinition, participantIds, entryStatus, entryStage, extension, eventSync, drawId, stage, event, }: ModifyEntriesStatusArgs): ResultType | { error: { message: string; code: string; }; method: string; participantIds: any; } | { error: { message: string; code: string; }; method?: undefined; participantIds?: undefined; }; type AddCourtGridBookingArgs = { tournamentRecord: Tournament; disableNotice?: boolean; bookingType: string; courtOrder: number; scheduledDate: string; courtId: string; rowCount?: number; notes?: string; }; declare function addCourtGridBooking(params: AddCourtGridBookingArgs): ResultType & { booking?: any; }; type AddEventEntryPairsArgs = { allowDuplicateParticipantIdPairs?: boolean; participantIdPairs?: string[][]; entryStatus?: EntryStatusUnion; tournamentRecord: Tournament; drawDefinition: DrawDefinition; entryStage?: StageTypeUnion; enforceCategory?: boolean; uuids?: string[]; event: Event$1; }; declare function addEventEntryPairs(params: AddEventEntryPairsArgs): any; declare function allDrawMatchUps(params: GetMatchUpsArgs): { groupInfo: any; context?: { [key: string]: any; }; stack?: string | string[]; errors?: string[]; error?: ErrorType; success?: boolean; valid?: boolean; info?: any; matchUps?: HydratedMatchUp[]; matchUpsMap?: MatchUpsMap; }; declare const POINTS_AUTHORITIES: readonly ["ATP", "WTA", "ITF", "ITF_JUNIOR", "ITF_WHEELCHAIR", "TENNIS_EUROPE", "USTA", "LTA", "FFT", "DTB", "PPA", "BWF", "UTR", "UNSPECIFIED"]; type PointsAuthority = (typeof POINTS_AUTHORITIES)[number]; declare const pointsAuthorityConstants: { readonly ATP: "ATP"; readonly WTA: "WTA"; readonly ITF: "ITF"; readonly ITF_JUNIOR: "ITF_JUNIOR"; readonly ITF_WHEELCHAIR: "ITF_WHEELCHAIR"; readonly TENNIS_EUROPE: "TENNIS_EUROPE"; readonly USTA: "USTA"; readonly LTA: "LTA"; readonly FFT: "FFT"; readonly DTB: "DTB"; readonly PPA: "PPA"; readonly BWF: "BWF"; readonly UTR: "UTR"; readonly UNSPECIFIED: "UNSPECIFIED"; readonly POINTS_AUTHORITIES: readonly ["ATP", "WTA", "ITF", "ITF_JUNIOR", "ITF_WHEELCHAIR", "TENNIS_EUROPE", "USTA", "LTA", "FFT", "DTB", "PPA", "BWF", "UTR", "UNSPECIFIED"]; }; interface RankingPolicy { policyName?: string; policyVersion?: string; pointsAuthority?: PointsAuthority; validDateRange?: DateRange; awardProfiles: AwardProfile[]; qualityWinProfiles?: QualityWinProfile[]; aggregationRules?: AggregationRules$2; requireWinForPoints?: boolean; requireWinFirstRound?: boolean; doublesAttribution?: DoublesAttribution; categoryResolution?: 'eventCategory' | 'participantPrimary'; tierToLevel?: Record>; pointPoolModel?: PointPoolModel; derivedRankings?: DerivedRanking[]; } type PointPoolModel = 'per-category' | 'shared'; interface CategoryScope { ageCategoryCodes?: string[]; genders?: string[]; categoryNames?: string[]; categoryTypes?: string[]; ratingTypes?: string[]; ballTypes?: string[]; wheelchairClasses?: string[]; subTypes?: string[]; } interface AwardProfileScope { dateRanges?: DateRange[]; eventTypes?: EventTypeUnion[]; drawTypes?: string[]; drawSizes?: number[]; maxDrawSize?: number; stages?: string[]; stageSequences?: number[]; levels?: number[]; maxLevel?: number; flights?: FlightConfig; maxFlightNumber?: number; participationOrder?: number; category?: CategoryScope; priority?: number; } interface AwardProfile extends AwardProfileScope { profileName?: string; pointsAuthority?: PointsAuthority; finishingPositionRanges?: Record; finishingRound?: Record; perWinPoints?: PerWinPointsDef | PerWinPointsDef[]; pointsPerWin?: number | LevelKeyed; finishingPositionPoints?: { participationOrders: number[]; }; maxCountableMatches?: number | LevelKeyed; bonusPoints?: BonusPointDef[]; requireWinForPoints?: boolean; requireWinFirstRound?: boolean; } type PositionValue = number | PositionValueObject | PositionValueObject[]; interface PositionValueObject { value?: number; level?: Record | (number | FlightValues)[]; flights?: number[]; f?: number[]; drawSize?: number; drawSizes?: number[]; threshold?: boolean; requireWin?: boolean; won?: number | PositionValueObject; lost?: number | PositionValueObject; } interface FlightValues { flights?: number[]; f?: number[]; } interface PerWinPointsDef { participationOrders?: number[]; value?: number; level?: Record | (number | LineValues)[]; line?: number[]; limit?: number; } interface LineValues { line?: number[]; limit?: number; f?: number[]; } interface BonusPointDef { finishingPositions: number[]; value: number | LevelKeyed; } interface QualityWinProfile { rankingRanges: QualityWinRange[]; rankingScaleName: string; rankingEventType?: string; rankingSnapshot?: 'tournamentStart' | 'matchDate' | 'latestAvailable'; unrankedOpponentBehavior?: 'noBonus' | 'useDefaultRank'; defaultRank?: number; levels?: number[]; eventTypes?: EventTypeUnion[]; drawTypes?: string[]; stages?: string[]; dateRanges?: DateRange[]; category?: CategoryScope; maxBonusPerTournament?: number; includeWalkovers?: boolean; } interface QualityWinRange { rankRange: [number, number]; value: number; } interface AggregationRules$2 { countingBuckets?: CountingBucket$2[]; bestOfCount?: number; rollingPeriodDays?: number; decayFunction?: 'none' | 'linear' | 'stepped'; decaySteps?: { afterDays: number; multiplier: number; }[]; separateByGender?: boolean; perCategory?: boolean; minCountableResults?: number; maxResultsPerLevel?: Record; doublesAttribution?: DoublesAttribution; tiebreakCriteria?: TiebreakCriterion[]; categoryAggregation?: CategoryAggregationRule[]; } interface CategoryAggregationRule { ruleName?: string; source: CategoryScope; target: CategoryScope; multiplier?: number; rerateTo?: { profileName: string; }; requireParticipationInTarget?: boolean; minResultsFromTarget?: number; eligibleSourceWindow?: { olderBy?: number; youngerBy?: number; }; retentionMonthsAfterAging?: number; maxCarriedResults?: number; subjectToBucketLimits?: boolean; carryComponents?: PointComponent[]; excludedSourceFilters?: SourceFilter[]; } interface SourceFilter { levels?: number[]; drawTypes?: string[]; eventTiers?: string[]; ageEligibility?: 'agingUpToTarget' | 'agingDownFromSource'; } interface DerivedRanking { category: CategoryScope; derivedFrom: CategoryScope; filter: DerivedFilter; } interface DerivedFilter { excludePlayersAgingUp?: boolean; ageRange?: { min?: number; max?: number; }; additionalScope?: CategoryScope; } interface CountingBucket$2 { bucketName?: string; eventTypes?: EventTypeUnion[]; pointComponents?: PointComponent[]; bestOfCount?: number; maxResultsPerLevel?: Record; minResults?: number; levels?: number[]; mandatoryRules?: MandatoryRule[]; } interface MandatoryRule { ruleName?: string; levels: number[]; bestOfCount?: number; } type PointComponent = 'positionPoints' | 'perWinPoints' | 'bonusPoints' | 'qualityWinPoints'; type DoublesAttribution = 'fullToEach' | 'splitEven' | 'teamOnly'; type TiebreakCriterion = 'headToHead' | 'mostWins' | 'highestSingleResult' | 'mostCountingResults' | 'rating'; interface PointAward$2 { participantId: string; personId?: string; tournamentId?: string; eventId?: string; drawId: string; structureId?: string; eventType: string; drawType?: string; stage?: string; stageSequence?: number; category?: { ageCategoryCode?: string; categoryName?: string; ratingType?: string; gender?: string; }; points: number; positionPoints: number; perWinPoints: number; qualityWinPoints: number; bonusPoints: number; linePoints?: number; collectionPosition?: number; winCount: number; rangeAccessor: string | number; startDate?: string; endDate?: string; level?: number; profileName?: string; pointsAuthority?: PointsAuthority; } interface RankingListEntry$1 { rank: number; participantId: string; personId?: string; totalPoints: number; countingResults: number; bucketTotals?: Record; tournamentResults: PointAward$2[]; tiebreakValues?: Record; meetsMinimum: boolean; } interface DateRange { startDate?: string; endDate?: string; } interface FlightConfig { flightNumbers?: number[]; pct?: Record; } type LevelKeyed = { level: Record | T[]; }; type PointAward$1 = Record; type CountingBucket$1 = { bucketName: string; eventTypes?: string[]; pointComponents: string[]; bestOfCount: number; maxResultsPerLevel?: Record; mandatoryRules?: MandatoryRule[]; }; type AggregationRules$1 = { rollingPeriodDays?: number; separateByGender?: boolean; perCategory?: boolean; countingBuckets?: CountingBucket$1[]; tiebreakCriteria?: TiebreakCriterion[]; minCountableResults?: number; maxResultsPerLevel?: Record; bestOfCount?: number; doublesAttribution?: DoublesAttribution; categoryAggregation?: CategoryAggregationRule[]; }; type CategoryFilter = { ageCategoryCodes?: string[]; genders?: string[]; eventTypes?: string[]; }; type RankingListEntry = { personId: string; totalPoints: number; rank: number; meetsMinimum: boolean; countingResults: PointAward$1[]; droppedResults: PointAward$1[]; bucketBreakdown?: { bucketName: string; countingResults: PointAward$1[]; droppedResults: PointAward$1[]; bucketTotal: number; }[]; }; type GenerateRankingListArgs = { pointAwards: PointAward$1[]; aggregationRules?: AggregationRules$1; categoryFilter?: CategoryFilter; asOfDate?: string; pointPoolModel?: PointPoolModel; }; declare function generateRankingList({ pointAwards, aggregationRules, categoryFilter, asOfDate, pointPoolModel, }: GenerateRankingListArgs): RankingListEntry[]; interface ParticipantContext { ageAtDate?: (personId: string, asOfDate?: string) => number | undefined; isAgingUpAtPeriodEnd?: (personId: string) => boolean; } type ApplyDerivedRankingsArgs = { entries: RankingListEntry[]; filter: DerivedFilter; asOfDate?: string; participantContext?: ParticipantContext; }; declare function applyDerivedRankings({ entries, filter, asOfDate, participantContext, }: ApplyDerivedRankingsArgs): RankingListEntry[]; type AssignOfficialArgs = { officialRecord: OfficialRecord; assignmentId?: string; tournamentId: string; roleSubtype: string; assignedDate?: string; startDate?: string; endDate?: string; assignedBy?: string; notes?: string; extensions?: any[]; }; declare function assignOfficial({ officialRecord, assignmentId, tournamentId, roleSubtype, assignedDate, startDate, endDate, assignedBy, notes, extensions, }: AssignOfficialArgs): { error?: any; assignment?: OfficialAssignment; success?: boolean; }; type AssignSeedPositionsArgs = { provisionalPositioning?: boolean; useExistingSeedLimit?: boolean; seedingProfile?: SeedingProfile; assignments: SeedAssignment[]; tournamentRecord: Tournament; drawDefinition: DrawDefinition; structureId: string; drawId: string; event: Event; }; declare function assignSeedPositions(params: AssignSeedPositionsArgs): ResultType | { modifications?: number; success?: boolean; }; declare function attachFlightProfile({ deleteExisting, event, flightProfile }: { deleteExisting: any; event: any; flightProfile: any; }): ResultType | { success: boolean; flightProfile: any; }; interface PointsToDecoration { pointsToGame: [number, number]; pointsToSet: [number, number]; pointsToMatch: [number, number]; gamesToSet: [number, number]; isBreakpoint: boolean; } declare function calculatePointsTo(matchUp: MatchUp, formatStructure: FormatStructure, setType: SetType, activeSetFormat: SetFormatStructure | undefined, server: 0 | 1 | undefined): PointsToDecoration | undefined; declare function deduceMatchUpFormat(scoreString: string): string; type ReportColumn = { key: string; title: string; type?: 'string' | 'number' | 'boolean' | 'date'; width?: number; }; type ReportDefinition = { reportId: string; name: string; description: string; category: string; source?: 'factory' | 'server'; }; type ReportResult = { reportId: string; generatedAt: string; parameters?: Record; columns: ReportColumn[]; rows: Record[]; summary?: Record; }; type ReportAvailability = ReportDefinition & { computableNow: boolean; }; type ReportContext = { tournamentRecord: any; participantMap?: Record; matchUps?: any[]; venues?: any[]; }; type GetAvailableReportsArgs = { tournamentRecord: Tournament; }; declare function getAvailableReports({ tournamentRecord, }: GetAvailableReportsArgs): { availableReports: ReportAvailability[]; } | { error: any; }; type ParseArgs = { consideredDate?: string; category?: Category; }; declare function getCategoryAgeDetails(params: ParseArgs): any; declare function getEventPublishStatus({ event, status }: { event: any; status?: string | undefined; }): any; declare function getMaxEntryPosition(params: any): number; type PointAward = Record; type CountingBucket = { bucketName: string; eventTypes?: string[]; pointComponents: string[]; bestOfCount: number; maxResultsPerLevel?: Record; mandatoryRules?: MandatoryRule[]; }; type AggregationRules = { countingBuckets?: CountingBucket[]; maxResultsPerLevel?: Record; bestOfCount?: number; }; type BucketBreakdown = { bucketName: string; countingResults: PointAward[]; droppedResults: PointAward[]; bucketTotal: number; }; type GetParticipantPointsArgs = { pointAwards: PointAward[]; personId: string; aggregationRules?: AggregationRules; }; declare function getParticipantPoints({ pointAwards, personId, aggregationRules, }: GetParticipantPointsArgs): { buckets: BucketBreakdown[]; totalPoints: number; }; type ModifyEventEntriesArgs = { unpairedParticipantIds?: string[]; participantIdPairs?: string[][]; entryStatus?: EntryStatusUnion; tournamentRecord: Tournament; entryStage?: string; event: Event$1; }; declare function modifyEventEntries({ entryStatus, unpairedParticipantIds, participantIdPairs, entryStage, tournamentRecord, event, }: ModifyEventEntriesArgs): any; type RemoveEventEntriesArgs = { tournamentParticipants?: HydratedParticipant[]; entryStatuses?: EntryStatusUnion[]; tournamentRecord?: Tournament; autoEntryPositions?: boolean; participantIds: string[]; stage?: StageTypeUnion; event: Event$1; }; declare function removeEventEntries({ autoEntryPositions, participantIds, entryStatuses, stage, event, }: RemoveEventEntriesArgs): { participantIdsRemoved?: string[]; success?: boolean; error?: ErrorType; }; type RemoveExtensionResult = { success?: boolean; error?: ErrorType; info?: any; }; declare function removeExtension(params?: { tournamentRecords?: TournamentRecords; element?: { extensions?: any[]; }; discover?: boolean; name?: string; }): RemoveExtensionResult; type AddEvaluationArgs = { officialRecord: OfficialRecord; evaluationId?: string; evaluatorPersonId: string; subjectPersonId?: string; tournamentId?: string; tournamentName?: string; matchUpId?: string; evaluationDate?: string; overallRating: number; policyName?: string; scores?: EvaluationScore[]; comments?: string; documentReference?: any; extensions?: any[]; }; declare function addEvaluation({ officialRecord, evaluationId, evaluatorPersonId, subjectPersonId, tournamentId, tournamentName, matchUpId, evaluationDate, overallRating, policyName, scores, comments, documentReference, extensions, }: AddEvaluationArgs): { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; type AddSuspensionArgs = { officialRecord: OfficialRecord; suspensionId?: string; organisationId?: string; suspensionType?: string; suspensionNotes?: string; suspendedFrom?: string; suspendedUntil?: string; extensions?: any[]; }; declare function addSuspension({ officialRecord, suspensionId, organisationId, suspensionType, suspensionNotes, suspendedFrom, suspendedUntil, extensions, }: AddSuspensionArgs): { error?: any; suspension?: OfficialSuspension; success?: boolean; }; type BuildReportContextArgs = { tournamentRecord: Tournament; }; declare function buildReportContext({ tournamentRecord }: BuildReportContextArgs): ReportContext | { error: any; }; declare function checkScoreHasValue(params: any): boolean; type CheckSetIsCompleteArgs = { matchUpScoringFormat?: any; ignoreTiebreak?: boolean; isDecidingSet?: boolean; isTiebreakSet?: boolean; matchUpFormat?: string; isTimedSet?: boolean; set: any; }; declare function checkSetIsComplete({ ignoreTiebreak, matchUpScoringFormat, matchUpFormat, isTiebreakSet, isDecidingSet, isTimedSet, set, }: CheckSetIsCompleteArgs): boolean | { error: { message: string; code: string; }; info: string; }; declare function generateOutcome(params: any): { error: { message: string; code: string; }; } | { outcome: { score: { sets: never[]; scoreStringSide1: string; side2ScoreString: string; }; matchUpStatus: any; }; } | { outcome: { winningSide: any; matchUpStatus: any; score: { sets: any; scoreStringSide1: string | { error?: ErrorType; info?: ErrorType | string; }; scoreStringSide2: string | { error?: ErrorType; info?: ErrorType | string; }; } | undefined; }; }; declare function getDrawData(params: any): { structures?: any[]; success?: boolean; error?: ErrorType; drawInfo?: any; }; type GetEvaluationsArgs = { officialRecord: OfficialRecord; evaluatorPersonId?: string; status?: EvaluationStatus; tournamentId?: string; policyName?: string; }; declare function getEvaluations({ officialRecord, evaluatorPersonId, status, tournamentId, policyName, }: GetEvaluationsArgs): { error?: any; success?: boolean; evaluations?: OfficialEvaluation[]; }; type GetPublishStateArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; eventIds?: string[]; drawIds?: string[]; eventId?: string; drawId?: string; event?: Event$1; }; declare function getPublishState(params: GetPublishStateArgs): ResultType & { publishState?: any; }; type QualityWin = { opponentParticipantId: string; opponentRank: number; matchUpId: string; points: number; }; type GetQualityWinPointsArgs = { qualityWinProfiles: any[]; wonMatchUpIds: string[]; mappedMatchUps: Record; participantId?: string; participantSideMap: Record; tournamentParticipants: any[]; tournamentStartDate?: string; level?: number; }; declare function getQualityWinPoints({ qualityWinProfiles, wonMatchUpIds, mappedMatchUps, participantSideMap, tournamentParticipants, tournamentStartDate, level, }: GetQualityWinPointsArgs): { qualityWinPoints: number; qualityWins: QualityWin[]; }; type ScaleType = { scaleName: string; scaleDate: string; scaleValue: any; }; type ScalesType = { [SINGLES_EVENT]?: ScaleType; [DOUBLES_EVENT]?: ScaleType; [TEAM_EVENT]?: ScaleType; }; declare function getScaleValues(params: any): ResultType & { seedings?: ScalesType; rankings?: ScalesType; ratings?: ScalesType; }; type GetTournamentPointsArgs = { participantFilters?: ParticipantFilters; policyDefinitions?: PolicyDefinitions; tournamentRecord: Tournament; policyName?: string; level?: number; }; declare function getTournamentPoints({ participantFilters, policyDefinitions, tournamentRecord, policyName, level, }: GetTournamentPointsArgs): { error: { message: string; code: string; }; } | { success: boolean; participantsWithOutcomes: HydratedParticipant[] | undefined; personPoints: {}; pairPoints: {}; teamPoints: {}; error?: undefined; }; type ModifyTieFormatArgs = { considerations?: { collectionName?: boolean; collectionOrder?: boolean; }; updateInProgressMatchUps?: boolean; tieFormatComparison?: boolean; tournamentRecord: Tournament; drawDefinition: DrawDefinition; modifiedTieFormat: TieFormat; structureId?: string; matchUpId?: string; eventId?: string; uuids?: string[]; event?: Event$1; }; declare function modifyTieFormat({ updateInProgressMatchUps, tieFormatComparison, modifiedTieFormat, tournamentRecord, considerations, drawDefinition, structureId, matchUpId, eventId, uuids, event, }: ModifyTieFormatArgs): ResultType | { success: boolean; processedTieFormat: any; modifications: any[]; }; type RemoveOnlineResourceArgs = { onlineResource: OnlineResource; drawDefinition?: DrawDefinition; tournamentRecord: Tournament; organisationId?: string; participantId?: string; personId?: string; courtId?: string; venueId?: string; event?: Event; }; declare function removeOnlineResource(params: RemoveOnlineResourceArgs): ResultType; declare function removeScaleValues({ tournamentRecord, scaleAttributes, drawDefinition, entryStatuses, drawId, event, stage, }: { tournamentRecord: any; scaleAttributes: any; drawDefinition: any; entryStatuses: any; drawId: any; event: any; stage: any; }): ResultType | { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; }; declare function setEntryPosition({ tournamentRecord, drawDefinition, participantId, entryPosition, skipRefresh, event, }: { tournamentRecord: any; drawDefinition: any; participantId: any; entryPosition: any; skipRefresh: any; event: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; entryPosition: any; }; declare function setEntryPositions({ tournamentRecord, entryPositions, drawDefinition, event }: { tournamentRecord: any; entryPositions: any; drawDefinition: any; event: any; }): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; entryPosition: any; } | { error: { message: string; code: string; }; }; declare function unPublishEvent({ removePriorValues, tournamentRecord, status, event }: { removePriorValues?: boolean | undefined; tournamentRecord: any; status?: string | undefined; event: any; }): (ResultType & { valid?: boolean; }) | { success: boolean; eventId: any; }; declare function updateDrawIdsOrder({ event, orderedDrawIdsMap }: { event: any; orderedDrawIdsMap: any; }): { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; } | { success: boolean; error?: undefined; info?: undefined; }; type PlayoffGroupConfig = { structureOptions?: { groupSize?: number; }; addNameBaseToAttributeName?: boolean; playoffStructureNameBase?: string; finishingPositionLimit?: number; finishingPositionNaming?: any; finishingPositions?: number[]; playoffAttributes?: any; structureNameMap?: any; sequenceLimit?: number; structureName?: string; structureId?: string; remainder?: boolean; drawType?: string; bestOf?: number; rankBy?: string; }; type ValidatePlayoffGroupsArgs = { playoffGroups: PlayoffGroupConfig[]; groupCount: number; groupSize: number; }; declare function validatePlayoffGroups({ playoffGroups, groupCount, groupSize, }: ValidatePlayoffGroupsArgs): ResultType & { valid?: boolean; consumptionMap?: { [finishingPosition: number]: number; }; info?: string; }; type DestroyPairEntryArgs = { removeGroupParticipant?: boolean; tournamentRecord: Tournament; drawDefinition: DrawDefinition; participantId: string; drawId?: string; event: Event$1; }; declare function destroyPairEntry({ removeGroupParticipant, tournamentRecord, drawDefinition, participantId, drawId, event, }: DestroyPairEntryArgs): { success?: boolean; error?: ErrorType; participantRemoved?: boolean; }; declare function destroyPairEntries(params: any): { error: { message: string; code: string; }; } | { success: boolean; destroyedCount: number; error?: undefined; } | { error: any[]; }; declare function eventMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult; interface MCPPoint { match_id: string; Pt: string; Set1: string; Set2: string; Gm1: string; Gm2: string; Pts: string; Svr: string; Ret: string; '1st': string; '2nd': string; PtWinner: string; isAce: string; isDouble: string; isUnforced: string; isForced: string; isRallyWinner: string; rallyCount: string; [key: string]: string; } interface MCPMatch { match_id: string; points: MCPPoint[]; } interface ParsedMCPPoint { winner: 0 | 1; server: 0 | 1; result?: PointResult; stroke?: StrokeType; hand?: 'Forehand' | 'Backhand'; serve?: 1 | 2; serveLocation?: ServeLocation; rally?: RallyShot[]; rallyLength?: number; code?: string; } interface ShotParseResult { serves: string[]; rally: string[]; lets?: number; terminator?: string; result?: string; winner?: 'S' | 'R'; error?: string; parse_notes?: string; first_serve?: { serves: string[]; lets?: number; error?: string; parse_notes?: string; }; serve?: 1 | 2; code?: string; } declare function shotSplitter(shotSequence: string): string[]; declare function analyzeSequence(shotSequence: string): ShotParseResult; declare function pointParser(serves: [string, string]): ShotParseResult; declare function shotParser(shotSequence: string, whichServe: 1 | 2): ShotParseResult; declare function parseMCPPoint(mcpPoint: MCPPoint, serverIndex: 0 | 1): ParsedMCPPoint; declare function parseCSV(csvContent: string): MCPPoint[]; declare function groupByMatch(points: MCPPoint[]): MCPMatch[]; interface MCPValidationOptions { csvData: string; matchId?: string; matchUpFormat?: string; validateScore?: boolean; debug?: boolean; } interface MCPValidationResult { valid: boolean; errors: string[]; warnings: string[]; matchesProcessed: number; pointsProcessed: number; matchUps: MatchUp[]; totalAces: number; totalDoubleFaults: number; totalWinners: number; totalUnforcedErrors: number; totalForcedErrors: number; } interface MCPMatchResult { valid: boolean; errors: string[]; warnings: string[]; matchUp: MatchUp; pointsProcessed: number; expectedScore?: string; actualScore: string; scoreMatches?: boolean; formatDeduced: boolean; aces: number; doubleFaults: number; winners: number; unforcedErrors: number; forcedErrors: number; } declare function validateMCPMatch(mcpMatch: MCPMatch, options?: { matchUpFormat?: string; validateScore?: boolean; debug?: boolean; }): MCPMatchResult; declare function mcpValidator(options: MCPValidationOptions): MCPValidationResult; declare function exportMatchUpJSON(matchUp: MatchUp): string; type FindMatchUpFormatTiming = { tournamentRecords: { [key: string]: Tournament; }; defaultRecoveryMinutes?: number; defaultAverageMinutes?: number; matchUpFormat: string; categoryName?: string; categoryType?: string; tournamentId: string; eventType?: EventTypeUnion; eventId?: string; }; declare function findMatchUpFormatTiming({ defaultRecoveryMinutes, defaultAverageMinutes, tournamentRecords, matchUpFormat, categoryName, categoryType, tournamentId, eventType, eventId, }: FindMatchUpFormatTiming): { error: { message: string; code: string; }; recoveryMinutes?: undefined; averageMinutes?: undefined; typeChangeRecoveryMinutes?: undefined; } | { recoveryMinutes: any; averageMinutes: any; typeChangeRecoveryMinutes: any; error?: undefined; }; type GetEntryStatusReportsArgs = { tournamentRecord: Tournament; }; declare function getEntryStatusReports({ tournamentRecord }: GetEntryStatusReportsArgs): { error: { message: string; code: string; }; entryStatusReports?: undefined; participantEntryReports?: undefined; eventReports?: undefined; withDrawnParticipantIds?: undefined; tournamentEntryReport?: undefined; } | { entryStatusReports: unknown[]; participantEntryReports: unknown[]; eventReports: unknown[]; withDrawnParticipantIds: string[]; tournamentEntryReport: { nonParticipatingEntriesCount: number; individualParticipantsCount: number; eventsCount: number; nonParticipatingParticipantIds: string[]; drawDefinitionsCount: number; tournamentId: string; }; error?: undefined; }; declare function getEventStructures({ withStageGrouping, stageSequences, stageSequence, roundTarget, stages, event, stage, }: { withStageGrouping: any; stageSequences: any; stageSequence: any; roundTarget: any; stages: any; event: any; stage: any; }): { error: { message: string; code: string; }; structures?: undefined; stageStructures?: undefined; } | { structures: Structure[]; stageStructures: {}; error?: undefined; }; declare function getTournamentStructures({ withStageGrouping, tournamentRecord, stageSequences, stageSequence, roundTarget, stages, stage, }: { withStageGrouping: any; tournamentRecord: any; stageSequences: any; stageSequence: any; roundTarget: any; stages: any; stage: any; }): { error: { message: string; code: string; }; structures?: undefined; stageStructures?: undefined; } | { structures: Structure[]; stageStructures: {}; error?: undefined; }; declare function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }: { profileBands: any; tournamentRecord: any; matchUps: any; }): { error: { message: string; code: string; }; } | { success: boolean; competitiveBands: any; error?: undefined; }; declare function getParticipantPaymentStatus({ tournamentRecord, participantId }: { tournamentRecord: any; participantId: any; }): "WAIVED" | "REFUNDED" | "PARTIAL" | "UNPAID" | "PAID" | (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; } | undefined; type GetRoundMatchUpsArgs = { matchUps?: MatchUp$1[]; interpolate?: boolean; }; type RoundMatchUpsResult = { roundMatchUps?: { [roundNumber: number]: HydratedMatchUp[]; }; hasNoRoundPositions?: boolean; roundsNotPowerOf2?: boolean; maxMatchUpsCount?: number; roundProfile?: RoundProfile; roundNumbers?: number[]; error?: ErrorType; }; declare function getRoundMatchUps({ matchUps, interpolate }: GetRoundMatchUpsArgs): RoundMatchUpsResult; type GetStructureReportsArgs = { firstStageSequenceOnly?: boolean; tournamentRecord: Tournament; extensionProfiles?: any[]; firstFlightOnly?: boolean; }; declare function getStructureReports(params: GetStructureReportsArgs): { error: { message: string; code: string; }; eventStructureReports?: undefined; structureReports?: undefined; flightReports?: undefined; } | { eventStructureReports: unknown[]; structureReports: any[] | undefined; flightReports: any[]; error?: undefined; }; type GetTieFormatArgs = { tournamentRecord: Tournament; drawDefinition?: DrawDefinition; structure?: Structure; structureId?: string; matchUpId: string; eventId?: string; drawId?: string; event?: Event$1; }; declare function getTieFormat({ tournamentRecord, drawDefinition, structureId, matchUpId, structure, eventId, drawId, event, }: GetTieFormatArgs): { structureDefaultTieFormat?: TieFormat; eventDefaultTieFormat?: TieFormat; drawDefaultTieFormat?: TieFormat; tieFormat?: TieFormat; structure?: Structure; error?: ErrorType; success?: boolean; matchUp?: MatchUp$1; }; declare function isValidMatchUpFormat({ matchUpFormat }: { matchUpFormat: string; }): boolean; type ModifyCourtAvailabilityArgs = { venueMatchUps?: HydratedMatchUp[]; dateAvailability: Availability[]; tournamentRecord: Tournament; disableNotice?: boolean; courtId: string; force?: boolean; }; declare function modifyCourtAvailability({ tournamentRecord, dateAvailability, disableNotice, venueMatchUps, courtId, force, }: ModifyCourtAvailabilityArgs): { error?: ErrorType; success?: boolean; totalMergeCount?: number; matchUpIds?: string[]; info?: string; }; type GameFormat = { type: 'CONSECUTIVE'; count: number; deuceAfter?: number; } | { type: 'TRADITIONAL'; deuceAfter?: number; }; type ParsedFormat = { matchRoot?: string; aggregate?: boolean; matchMods?: string[]; finalSetFormat?: any; simplified?: boolean; exactly?: number; setFormat?: any; bestOf?: number; gameFormat?: GameFormat; matchUpConstraint?: { timed?: boolean; minutes?: number; }; }; declare function parse(matchUpFormatCode: string): ParsedFormat | undefined; interface PBPValidationOptions { points: string; expectedScore?: string; matchUpFormat?: string; allowExtraPoints?: boolean; debug?: boolean; } interface PBPValidationResult { valid: boolean; errors: string[]; warnings: string[]; pointsProcessed: number; pointsRejected: string[]; expectedScore?: string; actualScore: string; matchUpFormat: string; formatDeduced: boolean; sets: Array<{ games: [number, number]; tiebreak?: [number, number]; scoreString: string; }>; } declare function pbpValidator(options: PBPValidationOptions): PBPValidationResult; declare function promoteAlternate(params: any): ResultType | { error: { message: string; code: string; }; invalidEntryStatus?: undefined; invalidStage?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidEntryStatus: any; invalidStage?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidStage: any; invalidEntryStatus?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidStageSequence: any; invalidEntryStatus?: undefined; invalidStage?: undefined; } | { error: { message: string; code: string; }; participantIds: any; } | { error: { message: string; code: string; }; participantId: any; }; declare function promoteAlternates({ tournamentRecord, drawDefinition, participantIds, stageSequence, stage, eventId, event, }: { tournamentRecord: any; drawDefinition: any; participantIds: any; stageSequence: any; stage?: string | undefined; eventId: any; event: any; }): ResultType | { error: { message: string; code: string; }; invalidEntryStatus?: undefined; invalidStage?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidEntryStatus: any; invalidStage?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidStage: any; invalidEntryStatus?: undefined; invalidStageSequence?: undefined; } | { error: { message: string; code: string; }; invalidStageSequence: any; invalidEntryStatus?: undefined; invalidStage?: undefined; } | { error: { message: string; code: string; }; participantIds: any; }; declare function removeOrphanedTieFormats({ event }: { event: Event$1; }): void; type ResetTieFormatArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; matchUpId: string; uuids?: string[]; event?: Event$1; }; declare function resetTieFormat(params: ResetTieFormatArgs): ResultType & { deletedMatchUpIds?: string[]; newMatchUps?: MatchUp$1[]; success?: boolean; }; declare function validateSetScore(set: any, matchUpFormat?: string, isDecidingSet?: boolean, allowIncomplete?: boolean): { isValid: boolean; error?: string; }; declare function validateMatchUpScore(sets: any[], matchUpFormat?: string, matchUpStatus?: string): { isValid: boolean; error?: string; }; type AddEventEntriesArgs = { policyDefinitions?: PolicyDefinitions; suppressDuplicateEntries?: boolean; entryStatus?: EntryStatusUnion; drawDefinition?: DrawDefinition; autoEntryPositions?: boolean; tournamentRecord?: Tournament; entryStageSequence?: number; ignoreStageSpace?: boolean; entryStage?: StageTypeUnion; participantIds?: string[]; extensions?: Extension[]; enforceCategory?: boolean; enforceGender?: boolean; extension?: Extension; roundTarget?: number; drawId?: string; event: Event$1; }; declare function addEventEntries(params: AddEventEntriesArgs): ResultType; type AddExtensionArgs = { tournamentRecords?: TournamentRecords; activeTournamentId?: string; creationTime?: boolean; tournamentId?: string; extension: Extension; discover?: boolean; element?: any; }; declare function addExtension(params?: AddExtensionArgs): { success?: boolean; error?: ErrorType; }; declare function addPersons({ participantRole, tournamentRecord, persons }: { participantRole?: any; tournamentRecord: any; persons: any; }): any; declare function analyzeDraws({ tournamentRecord }: { tournamentRecord: any; }): { error?: ErrorType; drawsAnalysis?: any; success?: boolean; }; type CategoryCanContainArgs = { childCategory: Category; withDetails?: boolean; category: Category; }; declare function categoryCanContain({ childCategory, withDetails, category }: CategoryCanContainArgs): any; declare function drawMatchUps({ participants: tournamentParticipants, tournamentAppliedPolicies, scheduleVisibilityFilters, participantsProfile, afterRecoveryTimes, policyDefinitions, useParticipantMap, tournamentRecord, usePublishState, contextFilters, contextContent, matchUpFilters, participantMap, publishStatus, contextProfile, drawDefinition, nextMatchUps, tournamentId, inContext, context, event, }: GetMatchUpsArgs): { groupInfo: any; abandonedMatchUps?: HydratedMatchUp[]; completedMatchUps?: HydratedMatchUp[]; upcomingMatchUps?: HydratedMatchUp[]; participants?: HydratedParticipant[]; pendingMatchUps?: HydratedMatchUp[]; byeMatchUps?: HydratedMatchUp[]; matchUpsMap?: MatchUpsMap; matchUpsCount?: number; success?: boolean; error?: ErrorType; }; declare function getAllowedMatchUpFormats({ tournamentRecord, categoryName, categoryType }: { tournamentRecord: any; categoryName: any; categoryType: any; }): any; declare function getAllowedDrawTypes({ tournamentRecord, categoryName, categoryType }: { tournamentRecord: any; categoryName: any; categoryType: any; }): any; declare function getEventProperties({ tournamentRecord, event }: { tournamentRecord: any; event: any; }): (ResultType & { valid?: boolean; }) | { entryScaleAttributes: any; hasSeededParticipants: any; hasRankedParticipants: any; hasRatedParticipants: any; }; declare function getParticipantSignInStatus({ tournamentRecord, participantId }: { tournamentRecord: any; participantId: any; }): false | "SIGNED_IN" | (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; } | undefined; declare function publishEventSeeding({ removePriorValues, stageSeedingScaleNames, seedingScaleNames, tournamentRecord, status, drawIds, event, }: { removePriorValues?: boolean | undefined; stageSeedingScaleNames: any; seedingScaleNames: any; tournamentRecord: any; status?: string | undefined; drawIds?: never[] | undefined; event: any; }): ResultType & { valid?: boolean; }; declare function unPublishEventSeeding({ removePriorValues, seedingScaleNames, tournamentRecord, status, drawIds, stages, event, }: { removePriorValues?: boolean | undefined; seedingScaleNames: any; tournamentRecord: any; status?: string | undefined; drawIds: any; stages: any; event: any; }): ResultType & { valid?: boolean; }; type ResetScoreCardArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; tiebreakReset?: boolean; matchUpStatus?: string; matchUpId: string; event?: Event$1; }; declare function resetScorecard(params: ResetScoreCardArgs): ResultType; type AddOnlineResourceArgs = { onlineResource: OnlineResource; drawDefinition?: DrawDefinition; tournamentRecord: Tournament; organisationId?: string; participantId?: string; personId?: string; courtId?: string; venueId?: string; event?: Event$1; }; declare function addOnlineResource(params: AddOnlineResourceArgs): ResultType; type PublicFindParticipantArgs = { tournamentRecords?: TournamentRecords; policyDefinitions?: PolicyDefinitions; tournamentRecord?: Tournament; contextProfile?: ContextProfile; participantId?: string; personId?: string; }; declare function publicFindParticipant(params: PublicFindParticipantArgs): { participant?: HydratedParticipant; tournamentId?: string; error?: ErrorType; stack?: any; }; type GetMatchUpsMapArgs = { drawDefinition?: DrawDefinition; structure?: Structure; }; declare function getMatchUpsMap({ drawDefinition, structure }: GetMatchUpsMapArgs): MatchUpsMap; type ScheduleDetails = { attributes: { [key: string]: boolean; }; dates: string[]; }; type DisplayAttributes = { participantAttributes?: { [key: string]: any; }; scheduleDetails?: ScheduleDetails[]; [key: string]: any; theme?: string; }; type DisplaySettings = { draws: { [key: string]: DisplayAttributes; default: DisplayAttributes; }; [key: string]: any; }; type SetEventDisplaySettings = { displaySettings: DisplaySettings; tournamentRecord: Tournament; removePriorValues?: boolean; eventId?: string; status?: string; event: Event$1; }; declare function setEventDisplay({ removePriorValues, tournamentRecord, displaySettings, status, event, }: SetEventDisplaySettings): ResultType; type SetSubOrderArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; drawPosition: number; structureId: string; subOrder: number; event?: Event$1; }; declare function setSubOrder({ tournamentRecord, drawDefinition, drawPosition, structureId, subOrder, event, }: SetSubOrderArgs): ResultType; type ValidateLineUpArgs = { tieFormat?: TieFormat; lineUp: LineUp; }; declare function validateLineUp({ lineUp, tieFormat }: ValidateLineUpArgs): { valid: boolean; errors: string[]; error: { message: string; code: string; } | undefined; }; type AddTimeItemArgs = { tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; removePriorValues?: boolean; duplicateValues?: boolean; participantId?: string; creationTime?: boolean; timeItem: TimeItem; event?: Event$1; element: any; }; declare function addTimeItem(params: AddTimeItemArgs): any; type AddParticipantTimeItemArgs = { tournamentRecord: Tournament; removePriorValues?: boolean; duplicateValues?: boolean; creationTime?: boolean; participantId: string; timeItem: TimeItem; }; declare function addParticipantTimeItem({ creationTime, removePriorValues, tournamentRecord, duplicateValues, participantId, timeItem, }: AddParticipantTimeItemArgs): any; declare function addTournamentTimeItem(params: any): any; declare function addEventTimeItem(params: any): any; declare function analyzeMatchUp(params?: any): ResultType & { completedSetsHaveValidOutcomes?: boolean; validMatchUpWinningSide?: boolean; calculatedWinningSide?: number; isLastSetWithValues?: boolean; validMatchUpOutcome?: boolean; sideTiebreakScores?: number[]; isCompletedMatchUp?: boolean; completedSetsCount?: number; isValidSideNumber?: boolean; matchUpScoringFormat?: any; hasExistingValue?: boolean; sidePointScores?: number[]; sideGameScores?: number[]; expectTimedSet?: boolean; isCompletedSet?: boolean; isExistingSet?: boolean; existingValue?: number; isActiveSet?: boolean; winningSide?: number; }; type CheckValidEntriesArgs = { policyDefinitions?: PolicyDefinitions; appliedPolicies?: PolicyDefinitions; participantMap?: ParticipantMap; tournamentRecord?: Tournament; participants?: Participant$1[]; consideredEntries?: Entry[]; enforceGender?: boolean; event: Event$1; }; declare function checkValidEntries({ consideredEntries, policyDefinitions, tournamentRecord, appliedPolicies, participantMap, enforceGender, participants, event, }: CheckValidEntriesArgs): { error: { message: string; code: string; }; invalidParticipantIds?: undefined; } | { error: { message: string; code: string; }; invalidParticipantIds: string[]; } | { valid: boolean; success: boolean; error?: undefined; invalidParticipantIds?: undefined; }; declare function createMatchUp(options: CreateMatchUpOptions): MatchUp; type GenerateReportArgs = { tournamentRecord: Tournament; reportId: string; parameters?: Record; }; declare function generateReport({ tournamentRecord, reportId }: GenerateReportArgs): ReportResult | { error: any; }; declare function getAwardProfile(params: any): { awardProfile: any; }; type GetFlightProfileArgs = { eventId?: string; event: Event$1; }; declare function getFlightProfile({ event, eventId }: GetFlightProfileArgs): { error: { message: string; code: string; }; flightProfile?: undefined; } | { flightProfile: any; error?: undefined; }; declare function getMatchUpType(params: { matchUp: { sides?: { participant?: { participantType?: string; }; }[]; matchUpType?: string; }; }): ResultType & { matchUpType?: string; }; type GetScaledEntriesArgs = { scaleAttributes: ScaleAttributes; tournamentRecord: Tournament; sortDescending?: boolean; stageSequence?: number; scaleSortMethod?: any; entries?: Entry[]; stage?: string; event?: Event$1; }; declare function getScaledEntries({ sortDescending, tournamentRecord, scaleAttributes, scaleSortMethod, stageSequence, entries, event, stage, }: GetScaledEntriesArgs): { error?: ErrorType; scaledEntries?: any[]; }; declare function hasLuckyRounds({ structure, matchUps }: { structure?: Structure; matchUps?: MatchUp$1[]; }): boolean; type IsAdHocArgs = { structure?: any; }; declare function isAdHoc({ structure }: IsAdHocArgs): boolean; declare function isEmbargoed(detail?: PublishingDetail): boolean; declare function isVisiblyPublished(detail?: PublishingDetail): boolean; declare function removeSeeding({ tournamentRecord, drawDefinition, entryStatuses, scaleName, drawId, event, stage }: { tournamentRecord: any; drawDefinition: any; entryStatuses: any; scaleName: any; drawId: any; event: any; stage: any; }): ResultType | { error: { message: string; code: string; }; info?: undefined; } | { error: { message: string; code: string; }; info: string; }; type ValidateTieFormatArgs = { checkCollectionIds?: boolean; enforceCategory?: boolean; enforceGender?: boolean; gender?: GenderUnion; category?: Category; tieFormat?: any; event?: Event$1; }; declare function validateTieFormat(params: ValidateTieFormatArgs): ResultType; type DisableCourtsArgs = { tournamentRecords: any; tournamentId?: string; courtIds: string[]; dates?: string[]; }; declare function disableCourts(params: DisableCourtsArgs): ResultType & { valid?: boolean; }; type DisableVenuesArgs = { tournamentRecords: any; tournamentId?: string; venueIds: string[]; }; declare function disableVenues(params: DisableVenuesArgs): ResultType & { valid?: boolean; }; declare function getAllDrawMatchUps(params: any): ResultType & { matchUps?: HydratedMatchUp[]; matchUpsMap?: MatchUpsMap; }; declare function getAllEventData({ tournamentRecord, policyDefinitions }: { tournamentRecord: any; policyDefinitions: any; }): { error: { message: string; code: string; }; allEventData?: undefined; } | { allEventData: { tournamentInfo: any; venuesData: HydratedVenue[] | undefined; eventsData: any; }; error?: undefined; }; type GetAwardPointsArgs = { participantWon?: boolean; flightNumber?: number; drawSize: number; valueObj: any; flights?: any; level?: number; }; declare function getAwardPoints({ participantWon, flightNumber, valueObj, drawSize, flights, level, }: GetAwardPointsArgs): { awardPoints: number; requireWin: any; }; type SetComplementArgs = { lowValue?: string | number; tiebreakAt?: number; isSide1?: boolean; NoAD?: boolean; setTo: number; winBy?: number; }; declare const getSetComplement: (params: SetComplementArgs) => number[] | false; type TiebreakComplementArgs = { lowValue?: number | string; tiebreakNoAd?: boolean; tiebreakTo: number; isSide1?: boolean; }; declare const getTiebreakComplement: (params: TiebreakComplementArgs) => number[] | false; declare function setEventStartDate({ tournamentRecord, event, startDate }: { tournamentRecord: any; event: any; startDate: any; }): ResultType | { error: { message: string; code: string; }; }; declare function setEventEndDate(params: any): (ResultType & { valid?: boolean; }) | { error: { message: string; code: string; }; }; type SetEventDatesArgs = { tournamentRecord: Tournament; weekdays?: WeekdayUnion[]; activeDates?: string[]; startDate?: string; endDate?: string; event: Event$1; }; declare function setEventDates(params: SetEventDatesArgs): ResultType; declare function validateCategory({ category }: { category: any; }): any; declare function addNotes(params?: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; declare function removeNotes(params?: any): { error: { message: string; code: string; }; } | { success: boolean; error?: undefined; }; type AnalyzeScoreArgs = { existingMatchUpStatus?: string; matchUpStatus?: string; matchUpFormat?: string; winningSide?: number; score: Score$1; }; declare function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: AnalyzeScoreArgs): { valid: boolean; }; declare function enableCourts(params: any): ResultType & { valid?: boolean; }; type EnableVenuesArgs = { tournamentRecords: TournamentRecords; enableAll?: boolean; venueIds: string[]; }; declare function enableVenues(params: EnableVenuesArgs): ResultType & { valid?: boolean; }; type GetDrawDefinitionArgs = { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord?: Tournament; tournamentId?: string; drawId: string; }; declare function publicFindDrawDefinition(params: GetDrawDefinitionArgs): { error: ErrorType; drawDefinition?: undefined; } | { drawDefinition: any; error?: undefined; }; type DeleteCourtArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; disableNotice?: boolean; courtId: string; force?: boolean; }; declare function deleteCourt(params: DeleteCourtArgs): any; type DeleteCourtsArgs = { tournamentRecord?: Tournament; courtIds: string[]; force?: boolean; }; declare function deleteCourts(params: DeleteCourtsArgs): { success?: boolean; error?: ErrorType; }; declare function deleteEvents(params: any): ResultType & { valid?: boolean; }; type DeleteVenueArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; venueId: string; force?: boolean; }; declare function deleteVenue(params: DeleteVenueArgs): { success?: boolean; error?: ErrorType; }; declare function deleteVenues({ tournamentRecord, venueIds, force }: { tournamentRecord: any; venueIds: any; force: any; }): { success?: boolean; error?: ErrorType; } | { error: { message: string; code: string; }; }; type GetCourtInfoArgs = { tournamentRecord: Tournament; internalUse?: boolean; courtId: string; }; declare function getCourtInfo({ tournamentRecord, internalUse, courtId }: GetCourtInfoArgs): { error?: ErrorType; success?: boolean; courtInfo?: any; }; declare function getEpisodes(matchUp: MatchUp): Episode[]; type GetVenueDataArgs = { tournamentRecord: Tournament; venueId: string; }; declare function getVenueData(params: GetVenueDataArgs): { success?: boolean; error?: ErrorType; venueData?: any; }; type GetVenueReportArgs = { tournamentRecords: TournamentRecords; ignoreDisabled?: boolean; tournamentId?: string; venueIds?: string[]; dates?: string[]; }; declare function getVenuesReport({ ignoreDisabled, tournamentRecords, tournamentId, venueIds, dates, }: GetVenueReportArgs): (ResultType & { venues?: HydratedVenue[]; courts?: HydratedCourt[]; }) | { error: { message: string; code: string; }; dates: never; venueIds?: undefined; venuesReport?: undefined; } | { error: { message: string; code: string; }; venueIds: never; dates?: undefined; venuesReport?: undefined; } | { error: { message: string; code: string; }; dates?: undefined; venueIds?: undefined; venuesReport?: undefined; } | { venuesReport: { venueId: any; venueName: any; venueReport: {}; }[] | undefined; error?: undefined; dates?: undefined; venueIds?: undefined; }; type ModifyCourtArgs = { tournamentRecords?: TournamentRecords; venueMatchUps?: HydratedMatchUp[]; tournamentRecord?: Tournament; disableNotice?: boolean; modifications: any; courtId: string; force?: boolean; }; declare function modifyCourt(params: ModifyCourtArgs): (ResultType & { court?: HydratedCourt; }) | { error: { message: string; code: string; }; } | undefined; type ModifyEventArgs = { tournamentRecord: Tournament; eventUpdates: { eventType?: EventTypeUnion; gender?: GenderUnion; startDate?: string; endDate?: string; category?: Category; eventName?: string; }; eventId: string; event: Event$1; }; declare function modifyEvent(params: ModifyEventArgs): ResultType; type ModifyVenueArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; modifications: any; venueId: string; force?: boolean; }; declare function modifyVenue(params: ModifyVenueArgs): any; type AddGoesToArgs = { inContextDrawMatchUps?: HydratedMatchUp[]; drawDefinition: DrawDefinition; matchUpsMap?: MatchUpsMap; }; declare function addGoesTo({ inContextDrawMatchUps, drawDefinition, matchUpsMap }: AddGoesToArgs): { error: { message: string; code: string; }; inContextDrawMatchUps?: undefined; goesToMap?: undefined; } | { inContextDrawMatchUps: HydratedMatchUp[] | undefined; goesToMap: { loserMatchUpIds: {}; winnerMatchUpIds: {}; }; error?: undefined; }; declare function analyzeSet(params: any): { [key: string]: any; }; type GetEventDataArgs = { participantsProfile?: ParticipantsProfile; includePositionAssignments?: boolean; policyDefinitions?: PolicyDefinitions; allParticipantResults?: boolean; sortConfig?: StructureSortConfig; hydrateParticipants?: boolean; tournamentRecord: Tournament; usePublishState?: boolean; refreshResults?: boolean; pressureRating?: boolean; participantFilters?: any; contextProfile?: any; eventId?: string; status?: string; event?: Event$1; }; declare function getEventData(params: GetEventDataArgs): { participants?: HydratedParticipant[]; error?: ErrorType; success?: boolean; eventData?: any; }; type GetTallyArgs = { positionAssignment?: any; }; declare function getTally({ positionAssignment }: GetTallyArgs): { error: { message: string; code: string; }; tally?: undefined; } | { tally: any; error?: undefined; }; declare function isComplete(matchUp: MatchUp): boolean; type validateScoreTypes = { existingMatchUpStatus?: string; matchUpStatus?: string; matchUpFormat?: string; winningSide?: number; score: Score$1; }; declare function validateScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: validateScoreTypes): ResultType & { valid?: boolean; }; type AddFlightArgs = { qualifyingPositions?: number; drawEntries?: Entry[]; drawName?: string; drawId: string; stage?: string; event: Event$1; }; declare function addFlight({ qualifyingPositions, drawEntries, drawName, drawId, event, stage, }: AddFlightArgs): { success?: boolean; error?: ErrorType; }; interface AddPointConfig { pointMultipliers?: PointMultiplier[]; } declare function addPoint(matchUp: MatchUp, options: AddPointOptions, config?: AddPointConfig): MatchUp; declare function getWinner(matchUp: MatchUp): number | undefined; declare function validMatchUp(matchUp: any): boolean; declare function validMatchUps(matchUps: any): boolean; type AddCourtArgs = { tournamentRecord: Tournament; disableNotice?: boolean; courtId?: string; venueId: string; court?: any; }; declare function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court }: AddCourtArgs): any; type ACArgs = AddCourtsArgs & { tournamentRecords?: { [key: string]: Tournament; }; tournamentRecord?: Tournament; venueId: string; }; declare function addCourts(params: ACArgs): (ResultType & { courts?: Court[]; }) | { error: { message: string; code: string; }; } | { courtIds: string[]; success: boolean; error?: undefined; }; type AddCourtsArgs = { dateAvailability?: Availability[]; venueAbbreviationRoot?: string; tournamentRecord: Tournament; courtNameRoot?: string; courtNames?: string[]; courtTimings?: any[]; courtsCount?: number; courtIds?: string[]; startTime?: string; endTime?: string; idPrefix?: string; venueId: string; dates: string[]; }; type AddEventArgs = { suppressNotifications?: boolean; tournamentRecord: Tournament; internalUse?: boolean; event: any; }; declare function addEvent({ suppressNotifications, tournamentRecord, internalUse, event }: AddEventArgs): { context?: { [key: string]: any; }; error?: ErrorType; event?: Event$1; info?: any; }; declare function addVenue(params: any): any; type FindVenueArgs = { tournamentRecords?: TournamentRecords; tournamentRecord?: Tournament; venueId: string; }; declare function findVenue({ tournamentRecords, tournamentRecord, venueId }: FindVenueArgs): { success?: boolean; venue?: Venue; error?: ErrorType; }; declare function publicFindVenue({ convertExtensions, ...params }: { [x: string]: any; convertExtensions: any; }): any; declare function getCourts({ tournamentRecord, venueId, venueIds }: { tournamentRecord: any; venueId: any; venueIds: any; }): { error: { message: string; code: string; }; courts?: undefined; } | { courts: any; error?: undefined; }; type RankingStat = { median: number; avg: number; max: number; min: number; }; type EventScaleValues = { [key: string]: { ratingsStats: { [key: string]: RankingStat; }; ratings: { [key: string]: number[]; }; ranking: { [key: string]: any; }; draws: { [key: string]: { ratingsStats: { [key: string]: RankingStat; }; ratings: { [key: string]: number[]; }; ranking: { [key: string]: any; }; }; }; }; }; type GetEventsArgs = { tournamentRecord: Tournament; withScaleValues?: boolean; scaleEventType?: EventTypeUnion; inContext?: boolean; eventIds?: string[]; drawIds?: string[]; context?: any; }; declare function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContext, eventIds, drawIds, context, }: GetEventsArgs): ResultType & { eventScaleValues?: EventScaleValues; events?: Event$1[]; }; type ParseScoreArgs = { scoreString: string; tiebreakTo?: number; matchUpFormat?: string; }; type ParsedSetString = { winningSide: number | undefined; side1TiebreakScore?: number; side2TiebreakScore?: number; side1Score?: number; side2Score?: number; setNumber: number; NoAD?: boolean; tiebreakSet?: boolean; }; declare function parseScoreString({ tiebreakTo, scoreString, matchUpFormat }: ParseScoreArgs): ParsedSetString[]; declare function publicFindCourt(params: any): any; type FindExtensionType = { tournamentRecords?: TournamentRecords; params?: { [key: string]: any; }; discover?: boolean | string[]; element?: any; name: string; }; type ExtensionResult = ResultType & { extension?: Extension; }; declare function findExtension({ discover, element, name, ...params }: FindExtensionType): ExtensionResult; type GetDrawStructuresArgs = { sortConfig?: StructureSortConfig; drawDefinition?: DrawDefinition; withStageGrouping?: boolean; stageSequences?: string[]; stageSequence?: number; roundTarget?: number; stages?: string[]; stage?: string; }; type FoundDrawStructure = { stageStructures: { [key: string]: Structure[]; }; structures: Structure[]; }; declare function getDrawStructures({ withStageGrouping, drawDefinition, stageSequences, stageSequence, roundTarget, sortConfig, stages, stage, }: GetDrawStructuresArgs): ResultType & FoundDrawStructure; type GetEventArgs = { context: { [key: string]: any; }; tournamentRecord: Tournament; drawDefinition: DrawDefinition; event: Event$1; }; declare function getEvent({ tournamentRecord, drawDefinition, context, event }: GetEventArgs): any; type FilterMatchUpsArgs = MatchUpFilters & { matchUps: HydratedMatchUp[]; }; declare function filterMatchUps(params: FilterMatchUpsArgs): HydratedMatchUp[]; type TimeItemResult = { timeItem?: TimeItem; previousItems?: any; success?: boolean; code?: string; info?: any; }; type TimeItemArgs = { returnPreviousValues?: boolean; tournamentRecord?: Tournament; drawDefinition?: DrawDefinition; itemSubTypes?: string[]; participantId?: string; itemType: string; event?: Event$1; element: any; }; declare function getTimeItem(params: TimeItemArgs): TimeItemResult & ResultType; declare function getDrawDefinitionTimeItem({ returnPreviousValues, drawDefinition, itemSubTypes, itemType }: { returnPreviousValues: any; drawDefinition: any; itemSubTypes: any; itemType: any; }): { error: { message: string; code: string; }; timeItem?: undefined; previousItems?: undefined; info?: undefined; } | { timeItem: TimeItem; previousItems: any; error?: undefined; info?: undefined; } | { info: any; error?: undefined; timeItem?: undefined; previousItems?: undefined; }; type GetEventTimeItemArgs = { returnPreviousValues?: boolean; itemSubTypes?: string[]; itemType: string; event: Event$1; }; declare function getEventTimeItem({ returnPreviousValues, itemSubTypes, itemType, event }: GetEventTimeItemArgs): { error: { message: string; code: string; }; timeItem?: undefined; previousItems?: undefined; info?: undefined; } | { timeItem: TimeItem; previousItems: any; error?: undefined; info?: undefined; } | { info: any; error?: undefined; timeItem?: undefined; previousItems?: undefined; }; type GetTournamentTimeItemArgs = { returnPreviousValues?: boolean; tournamentRecord: Tournament; itemSubTypes?: string[]; itemType: string; }; declare function getTournamentTimeItem({ returnPreviousValues, tournamentRecord, itemSubTypes, itemType, }: GetTournamentTimeItemArgs): { error: { message: string; code: string; }; timeItem?: undefined; previousItems?: undefined; info?: undefined; } | { timeItem: TimeItem; previousItems: any; error?: undefined; info?: undefined; } | { info: any; error?: undefined; timeItem?: undefined; previousItems?: undefined; }; declare function getParticipantTimeItem({ returnPreviousValues, tournamentRecord, participantId, itemSubTypes, itemType, }: { returnPreviousValues: any; tournamentRecord: any; participantId: any; itemSubTypes: any; itemType: any; }): (ResultType & { valid?: boolean; }) | { participant?: Participant$1; tournamentId?: string; error?: ErrorType; } | { timeItem: TimeItem; previousItems: any; }; type FindMatchUpType = { participantsProfile?: ParticipantsProfile; contextContent?: ContextContent; contextProfile?: ContextProfile; drawDefinition?: DrawDefinition; afterRecoveryTimes?: boolean; tournamentRecord: Tournament; nextMatchUps?: boolean; inContext?: boolean; matchUpId: string; eventId?: string; drawId?: string; event?: Event$1; }; type FindMatchUpResult = { drawDefinition?: DrawDefinition; matchUp?: HydratedMatchUp; structure?: Structure; error?: ErrorType; }; declare function publicFindMatchUp(params: FindMatchUpType): FindMatchUpResult; type FindPolicyArgs = { drawDefinition?: DrawDefinition; tournamentRecord?: Tournament; structure?: Structure; policyType: string; event?: Event$1; }; declare function findPolicy({ tournamentRecord, drawDefinition, policyType, structure, event }: FindPolicyArgs): { policy?: any; error?: ErrorType; info?: string; }; declare function credits(): string; interface MethodSignatures { addAdHocMatchUps: EngineMethod; addCertification: EngineMethod; addCertificationRequirement: EngineMethod; addCollectionDefinition: EngineMethod; addCollectionGroup: EngineMethod; addCourt: EngineMethod; addCourtGridBooking: EngineMethod; addCourts: EngineMethod; addDrawDefinition: EngineMethod; addDrawDefinitionExtension: EngineMethod; addDrawDefinitionTimeItem: EngineMethod; addDrawEntries: EngineMethod; addDynamicRatings: EngineMethod; addEvaluation: EngineMethod; addEvaluationPolicy: EngineMethod; addEvent: EngineMethod; addEventEntries: EngineMethod; addEventEntryPairs: EngineMethod; addEventExtension: EngineMethod; addEventTimeItem: EngineMethod; addExtension: EngineMethod; addFinishingRounds: EngineMethod; addFlight: EngineMethod; addGoesTo: EngineMethod; addIndividualParticipantIds: EngineMethod; addLinkedConsolationStructure: EngineMethod; addMatchUpCourtOrder: EngineMethod; addMatchUpEndTime: EngineMethod; addMatchUpOfficial: EngineMethod; addMatchUpResumeTime: EngineMethod; addMatchUpScheduledDate: EngineMethod; addMatchUpScheduledTime: EngineMethod; addMatchUpScheduleItems: EngineMethod; addMatchUpStartTime: EngineMethod; addMatchUpStopTime: EngineMethod; addMutationLock: EngineMethod; addNotes: EngineMethod; addOnlineResource: EngineMethod; addParticipant: EngineMethod; addParticipantExtension: EngineMethod; addParticipants: EngineMethod; addParticipantTimeItem: EngineMethod; addPenalty: EngineMethod; addPersonOtherId: EngineMethod; addPersonRequests: EngineMethod; addPersons: EngineMethod; addPlayoffStructures: EngineMethod; addPoint: EngineMethod; addPracticeRegistration: EngineMethod; addQualifyingStructure: EngineMethod; addSchedulingProfileRound: EngineMethod; addSuspension: EngineMethod; addTimeItem: EngineMethod; addTournamentExtension: EngineMethod; addTournamentTimeItem: EngineMethod; addVenue: EngineMethod; addVoluntaryConsolationStructure: EngineMethod; adHocPositionSwap: EngineMethod; aggregateTieFormats: EngineMethod; allCompetitionMatchUps: EngineMethod; allDrawMatchUps: EngineMethod; allEventMatchUps: EngineMethod; allocateTeamMatchUpCourts: EngineMethod; allPlayoffPositionsFilled: EngineMethod; allTournamentMatchUps: EngineMethod; alternateDrawPositionAssignment: EngineMethod; analyzeDraws: EngineMethod; analyzeMatchUp: EngineMethod; analyzeScore: EngineMethod; analyzeSequence: EngineMethod; analyzeSet: EngineMethod; analyzeTournament: EngineMethod; anonymizeTournamentRecord: EngineMethod; applyDerivedRankings: EngineMethod; applyLineUps: EngineMethod; applyTournamentRankingPoints: EngineMethod; assignDrawPosition: EngineMethod; assignDrawPositionBye: EngineMethod; assignMatchUpCourt: EngineMethod; assignMatchUpSideParticipant: EngineMethod; assignMatchUpVenue: EngineMethod; assignOfficial: EngineMethod; assignSeedPositions: EngineMethod; assignTieMatchUpParticipantId: EngineMethod; attachConsolationStructures: EngineMethod; attachFlightProfile: EngineMethod; attachPlayoffStructures: EngineMethod; attachPolicies: EngineMethod; attachQualifyingStructure: EngineMethod; attachStructures: EngineMethod; automatedPlayoffPositioning: EngineMethod; automatedPositioning: EngineMethod; autoSeeding: EngineMethod; buildDrawHierarchy: EngineMethod; buildReportContext: EngineMethod; bulkMatchUpStatusUpdate: EngineMethod; bulkRescheduleMatchUps: EngineMethod; bulkScheduleMatchUps: EngineMethod; bulkScheduleTournamentMatchUps: EngineMethod; bulkUpdateCourtAssignments: EngineMethod; bulkUpdatePublishedEventIds: EngineMethod; calculateMatchStatistics: EngineMethod; calculateMatchUpMargin: EngineMethod; calculatePointsTo: EngineMethod; calculateScheduleTimes: EngineMethod; calculateWinCriteria: EngineMethod; categoryCanContain: EngineMethod; checkInParticipant: EngineMethod; checkMatchUpIsComplete: EngineMethod; checkOutParticipant: EngineMethod; checkScoreHasValue: EngineMethod; checkSetIsComplete: EngineMethod; checkValidEntries: EngineMethod; cleanExpiredMutationLocks: EngineMethod; clearMatchUpSchedule: EngineMethod; clearScheduledMatchUps: EngineMethod; compareTieFormats: EngineMethod; competitionScheduleMatchUps: EngineMethod; completeDrawMatchUps: EngineMethod; copyTournamentRecord: EngineMethod; courtGridRows: EngineMethod; createGroupParticipant: EngineMethod; createMatchUp: EngineMethod; createOfficialRecord: EngineMethod; createTeamsFromParticipantAttributes: EngineMethod; createTournamentRecord: EngineMethod; credits: EngineMethod; deduceMatchUpFormat: EngineMethod; deleteAdHocMatchUps: EngineMethod; deleteCourt: EngineMethod; deleteCourts: EngineMethod; deleteDrawDefinitions: EngineMethod; deleteEvents: EngineMethod; deleteFlightAndFlightDraw: EngineMethod; deleteFlightProfileAndFlightDraws: EngineMethod; deleteParticipants: EngineMethod; deleteVenue: EngineMethod; deleteVenues: EngineMethod; destroyPairEntries: EngineMethod; destroyPairEntry: EngineMethod; disableCourts: EngineMethod; disableTieAutoCalc: EngineMethod; disableVenues: EngineMethod; drawMatchUps: EngineMethod; drawMatic: EngineMethod; enableCourts: EngineMethod; enableTieAutoCalc: EngineMethod; enableVenues: EngineMethod; enrichPointHistory: EngineMethod; eventMatchUps: EngineMethod; exportMatchUpJSON: EngineMethod; filterMatchUps: EngineMethod; filterParticipants: EngineMethod; findDrawDefinition: EngineMethod; findExtension: EngineMethod; findMatchUp: EngineMethod; findMatchUpFormatTiming: EngineMethod; findParticipant: EngineMethod; findPolicy: EngineMethod; findVenue: EngineMethod; generateAdHocMatchUps: EngineMethod; generateAdHocRounds: EngineMethod; generateAndPopulatePlayoffStructures: EngineMethod; generateBookings: EngineMethod; generateConsolationStructure: EngineMethod; generateCourts: EngineMethod; generateDrawDefinition: EngineMethod; generateDrawMaticRound: EngineMethod; generateDrawStructuresAndLinks: EngineMethod; generateDrawTypeAndModifyDrawDefinition: EngineMethod; generateEventsFromTieFormat: EngineMethod; generateEventWithDraw: EngineMethod; generateFlightProfile: EngineMethod; generateLineUps: EngineMethod; generateOutcome: EngineMethod; generateOutcomeFromScoreString: EngineMethod; generateParticipants: EngineMethod; generateQualifyingStructure: EngineMethod; generateRankingList: EngineMethod; generateReport: EngineMethod; generateScoreString: EngineMethod; generateSeedingScaleItems: EngineMethod; generateStatCrew: EngineMethod; generateSwissRound: EngineMethod; generateTieMatchUpScore: EngineMethod; generateTournamentRecord: EngineMethod; generateVirtualCourts: EngineMethod; generateVoluntaryConsolation: EngineMethod; getAggregateTeamResults: EngineMethod; getAllDrawMatchUps: EngineMethod; getAllEventData: EngineMethod; getAllowedDrawTypes: EngineMethod; getAllowedMatchUpFormats: EngineMethod; getAllStructureMatchUps: EngineMethod; getApplicableAwardProfileLevels: EngineMethod; getAppliedPolicies: EngineMethod; getAssignedParticipantIds: EngineMethod; getAvailableMatchUpsCount: EngineMethod; getAvailablePlayoffProfiles: EngineMethod; getAvailableReports: EngineMethod; getAwardPoints: EngineMethod; getAwardProfile: EngineMethod; getCategoryAgeDetails: EngineMethod; getCheckedInParticipantIds: EngineMethod; getCompetitionDateRange: EngineMethod; getCompetitionFormat: EngineMethod; getCompetitionLeaderboard: EngineMethod; getCompetitionMatchUps: EngineMethod; getCompetitionParticipants: EngineMethod; getCompetitionParticipantState: EngineMethod; getCompetitionPenalties: EngineMethod; getCompetitionPolicy: EngineMethod; getCompetitionState: EngineMethod; getCompetitionVenues: EngineMethod; getCourtInfo: EngineMethod; getCourts: EngineMethod; getDraftState: EngineMethod; getDrawData: EngineMethod; getDrawDefinitionTimeItem: EngineMethod; getDrawParticipantRepresentativeIds: EngineMethod; getDrawStructures: EngineMethod; getDrawTypeCoercion: EngineMethod; getEligibleVoluntaryConsolationParticipants: EngineMethod; getEntriesAndSeedsCount: EngineMethod; getEntryStatusReports: EngineMethod; getEpisodes: EngineMethod; getEvaluations: EngineMethod; getEvaluationSummary: EngineMethod; getEvaluationTemplate: EngineMethod; getEvent: EngineMethod; getEventData: EngineMethod; getEventMatchUpFormatTiming: EngineMethod; getEventProperties: EngineMethod; getEventPublishStatus: EngineMethod; getEventRankingPoints: EngineMethod; getEvents: EngineMethod; getEventStructures: EngineMethod; getEventTimeItem: EngineMethod; getFlightProfile: EngineMethod; getHomeParticipantId: EngineMethod; getLinkedTournamentIds: EngineMethod; getLuckyDrawRoundStatus: EngineMethod; getMatchUpCompetitiveProfile: EngineMethod; getMatchUpContextIds: EngineMethod; getMatchUpDailyLimits: EngineMethod; getMatchUpDailyLimitsUpdate: EngineMethod; getMatchUpDependencies: EngineMethod; getMatchUpFormat: EngineMethod; getMatchUpFormatTiming: EngineMethod; getMatchUpFormatTimingUpdate: EngineMethod; getMatchUpScheduleDetails: EngineMethod; getMatchUpsMap: EngineMethod; getMatchUpsStats: EngineMethod; getMatchUpsToSchedule: EngineMethod; getMatchUpType: EngineMethod; getMaxEntryPosition: EngineMethod; getModifiedMatchUpFormatTiming: EngineMethod; getMutationLocks: EngineMethod; getOfficialAssignments: EngineMethod; getOfficialCertifications: EngineMethod; getOfficialEligibility: EngineMethod; getPairedParticipant: EngineMethod; getParticipantEventDetails: EngineMethod; getParticipantIdFinishingPositions: EngineMethod; getParticipantMembership: EngineMethod; getParticipantPaymentStatus: EngineMethod; getParticipantPoints: EngineMethod; getParticipantResults: EngineMethod; getParticipants: EngineMethod; getParticipantScaleItem: EngineMethod; getParticipantSchedules: EngineMethod; getParticipantSignInStatus: EngineMethod; getParticipantStats: EngineMethod; getParticipantTimeItem: EngineMethod; getPersonRequests: EngineMethod; getPolicyDefinitions: EngineMethod; getPositionAssignments: EngineMethod; getPositionsPlayedOff: EngineMethod; getPracticeRegistrations: EngineMethod; getPredictiveAccuracy: EngineMethod; getProfileRounds: EngineMethod; getPublishState: EngineMethod; getQualityWinPoints: EngineMethod; getQuickStats: EngineMethod; getRandomQualifierList: EngineMethod; getRegistrationProfile: EngineMethod; getRoundMatchUps: EngineMethod; getRounds: EngineMethod; getRoundVisibilityState: EngineMethod; getScaledEntries: EngineMethod; getScaleValues: EngineMethod; getScheduledRoundsDetails: EngineMethod; getSchedulingProfile: EngineMethod; getSchedulingProfileIssues: EngineMethod; getScore: EngineMethod; getScoreboard: EngineMethod; getSeedingThresholds: EngineMethod; getSeedsCount: EngineMethod; getSetComplement: EngineMethod; getSetScoreString: EngineMethod; getStructureReports: EngineMethod; getStructureSeedAssignments: EngineMethod; getSwissChart: EngineMethod; getSwissStandings: EngineMethod; getTally: EngineMethod; getTeamLineUp: EngineMethod; getTiebreakComplement: EngineMethod; getTieFormat: EngineMethod; getTimeItem: EngineMethod; getTournamentIds: EngineMethod; getTournamentInfo: EngineMethod; getTournamentPenalties: EngineMethod; getTournamentPersons: EngineMethod; getTournamentPointAwards: EngineMethod; getTournamentPoints: EngineMethod; getTournamentPublishStatus: EngineMethod; getTournamentStructures: EngineMethod; getTournamentTimeItem: EngineMethod; getValidGroupSizes: EngineMethod; getVenueData: EngineMethod; getVenuesAndCourts: EngineMethod; getVenuesReport: EngineMethod; getWinner: EngineMethod; groupByMatch: EngineMethod; hasLuckyRounds: EngineMethod; hydrateTournamentRecord: EngineMethod; inferServeSide: EngineMethod; initializeCompetitionState: EngineMethod; initializeDraft: EngineMethod; isAdHoc: EngineMethod; isAggregateFormat: EngineMethod; isComplete: EngineMethod; isCompletedStructure: EngineMethod; isEmbargoed: EngineMethod; isValid: EngineMethod; isValidForQualifying: EngineMethod; isValidMatchUpFormat: EngineMethod; isVisiblyPublished: EngineMethod; keyValueScore: EngineMethod; linkTournaments: EngineMethod; luckyDrawAdvancement: EngineMethod; luckyLoserDrawPositionAssignment: EngineMethod; matchUpActions: EngineMethod; matchUpScheduleChange: EngineMethod; mcpValidator: EngineMethod; mergeParticipants: EngineMethod; migrateTournamentRecord: EngineMethod; modifyCertification: EngineMethod; modifyCollectionDefinition: EngineMethod; modifyCourt: EngineMethod; modifyCourtAvailability: EngineMethod; modifyDrawDefinition: EngineMethod; modifyDrawName: EngineMethod; modifyEntriesStatus: EngineMethod; modifyEvaluation: EngineMethod; modifyEvent: EngineMethod; modifyEventEntries: EngineMethod; modifyEventMatchUpFormatTiming: EngineMethod; modifyIndividualParticipantIds: EngineMethod; modifyMatchUpFormatTiming: EngineMethod; modifyPairAssignment: EngineMethod; modifyParticipant: EngineMethod; modifyParticipantName: EngineMethod; modifyParticipantOtherName: EngineMethod; modifyParticipantsPaymentStatus: EngineMethod; modifyParticipantsSignInStatus: EngineMethod; modifyPenalty: EngineMethod; modifyPersonRequests: EngineMethod; modifySeedAssignment: EngineMethod; modifyTieFormat: EngineMethod; modifyTournamentRecord: EngineMethod; modifyVenue: EngineMethod; orderCollectionDefinitions: EngineMethod; parse: EngineMethod; parseCSV: EngineMethod; parseMatchUpFormat: EngineMethod; parseMCPPoint: EngineMethod; parseScoreString: EngineMethod; participantScaleItem: EngineMethod; participantScheduledMatchUps: EngineMethod; pbpValidator: EngineMethod; pointParser: EngineMethod; positionActions: EngineMethod; predictDrawCompetitiveBands: EngineMethod; predictMatchUpCompetitiveBands: EngineMethod; proAutoSchedule: EngineMethod; processCompetitionMatchUp: EngineMethod; processCompetitionRound: EngineMethod; proConflicts: EngineMethod; promoteAlternate: EngineMethod; promoteAlternates: EngineMethod; pruneDrawDefinition: EngineMethod; publicFindCourt: EngineMethod; publicFindVenue: EngineMethod; publishEvent: EngineMethod; publishEventSeeding: EngineMethod; publishOrderOfPlay: EngineMethod; publishParticipants: EngineMethod; qualifierDrawPositionAssignment: EngineMethod; qualifierProgression: EngineMethod; queryOfficialRecord: EngineMethod; refreshEventDrawOrder: EngineMethod; regenerateParticipantNames: EngineMethod; remapDrawDefinitionMatchUpIds: EngineMethod; removeCertification: EngineMethod; removeCollectionDefinition: EngineMethod; removeCollectionGroup: EngineMethod; removeCourtGridBooking: EngineMethod; removeDelegatedOutcome: EngineMethod; removeDrawDefinitionExtension: EngineMethod; removeDrawEntries: EngineMethod; removeDrawPositionAssignment: EngineMethod; removeEvaluation: EngineMethod; removeEventEntries: EngineMethod; removeEventExtension: EngineMethod; removeEventMatchUpFormatTiming: EngineMethod; removeExtension: EngineMethod; removeIndividualParticipantIds: EngineMethod; removeMatchUpCourtAssignment: EngineMethod; removeMatchUpOutcome: EngineMethod; removeMatchUpSideParticipant: EngineMethod; removeMutationLock: EngineMethod; removeNotes: EngineMethod; removeOfficialAssignment: EngineMethod; removeOnlineResource: EngineMethod; removeOrphanedTieFormats: EngineMethod; removeParticipantExtension: EngineMethod; removeParticipantIdsFromAllTeams: EngineMethod; removePenalty: EngineMethod; removePersonRequests: EngineMethod; removePolicy: EngineMethod; removePracticeRegistration: EngineMethod; removeRatings: EngineMethod; removeRoundMatchUps: EngineMethod; removeScaleValues: EngineMethod; removeSeededParticipant: EngineMethod; removeSeeding: EngineMethod; removeStageEntries: EngineMethod; removeStructure: EngineMethod; removeSuspension: EngineMethod; removeTieMatchUpParticipantId: EngineMethod; removeTournamentExtension: EngineMethod; renameStructures: EngineMethod; reorderUpcomingMatchUps: EngineMethod; replaceTieMatchUpParticipantId: EngineMethod; resetAdHocMatchUps: EngineMethod; resetCompetitionState: EngineMethod; resetDrawDefinition: EngineMethod; resetMatchUpLineUps: EngineMethod; resetQualifyingStructure: EngineMethod; resetScorecard: EngineMethod; resetTieFormat: EngineMethod; resetVoluntaryConsolationStructure: EngineMethod; resolveDraftPositions: EngineMethod; resolvePointValue: EngineMethod; reverseScore: EngineMethod; scaledTeamAssignment: EngineMethod; scheduleMatchUps: EngineMethod; scheduleProfileGrid: EngineMethod; scheduleProfileRounds: EngineMethod; ScoringEngine: EngineMethod; seedWithdrawalCascade: EngineMethod; setDelegatedOutcome: EngineMethod; setDrawParticipantRepresentativeIds: EngineMethod; setDrawPositionPreferences: EngineMethod; setEntryPosition: EngineMethod; setEntryPositions: EngineMethod; setEventDates: EngineMethod; setEventDisplay: EngineMethod; setEventEndDate: EngineMethod; setEventStartDate: EngineMethod; setMatchUpCalledAt: EngineMethod; setMatchUpDailyLimits: EngineMethod; setMatchUpFormat: EngineMethod; setMatchUpHomeParticipantId: EngineMethod; setMatchUpState: EngineMethod; setMatchUpStatus: EngineMethod; setOrderOfFinish: EngineMethod; setParticipantScaleItem: EngineMethod; setParticipantScaleItems: EngineMethod; setPositionAssignments: EngineMethod; setPracticeDefaultCapacity: EngineMethod; setRegistrationProfile: EngineMethod; setSchedulingProfile: EngineMethod; setStructureOrder: EngineMethod; setSubOrder: EngineMethod; setTournamentCategories: EngineMethod; setTournamentDates: EngineMethod; setTournamentEndDate: EngineMethod; setTournamentLocalTimeZone: EngineMethod; setTournamentName: EngineMethod; setTournamentNotes: EngineMethod; setTournamentStartDate: EngineMethod; setTournamentStatus: EngineMethod; setTournamentTier: EngineMethod; shiftAdHocRounds: EngineMethod; shotParser: EngineMethod; shotSplitter: EngineMethod; stringify: EngineMethod; stringifyMatchUpFormat: EngineMethod; substituteParticipant: EngineMethod; suggestFormatPlans: EngineMethod; swapAdHocRounds: EngineMethod; swapDrawPositionAssignments: EngineMethod; tallyParticipantResults: EngineMethod; tieFormatGenderValidityCheck: EngineMethod; toggleParticipantCheckInState: EngineMethod; toStatObjects: EngineMethod; tournamentMatchUps: EngineMethod; transitionAssignmentStatus: EngineMethod; transitionCertificationStatus: EngineMethod; transitionEvaluationStatus: EngineMethod; unlinkTournament: EngineMethod; unlinkTournaments: EngineMethod; unPublishEvent: EngineMethod; unPublishEventSeeding: EngineMethod; unPublishOrderOfPlay: EngineMethod; unPublishParticipants: EngineMethod; updateDrawIdsOrder: EngineMethod; updatePracticeRegistration: EngineMethod; updateTeamLineUp: EngineMethod; updateTieMatchUpScore: EngineMethod; validateCategory: EngineMethod; validateCertification: EngineMethod; validateCollectionDefinition: EngineMethod; validateLineUp: EngineMethod; validateMatchUp: EngineMethod; validateMatchUpScore: EngineMethod; validateMCPMatch: EngineMethod; validateOfficiatingStatusTransition: EngineMethod; validatePlayoffGroups: EngineMethod; validateSchedulingProfile: EngineMethod; validateScore: EngineMethod; validateSet: EngineMethod; validateSetScore: EngineMethod; validateTieFormat: EngineMethod; validMatchUp: EngineMethod; validMatchUps: EngineMethod; version: EngineMethod; withdrawParticipantAtDrawPosition: EngineMethod; } type FactoryEngine = { [key: string]: any; }; type EngineHintKeys = { tournamentId?: string; eventId?: string; drawId?: string; matchUpId?: string; structureId?: string; }; type EngineMethod = F extends (firstParam: infer P, ...rest: infer R) => infer Ret ? [ NonNullable

] extends [object] ? (params?: Partial> & EngineHintKeys, ...rest: R) => Ret : F : F; type FacadeMethodNames = 'q' | 'on' | 'once' | 'off' | 'waitFor' | 'inspect' | 'build' | 'dryRun' | 'explain'; type FactoryEngineTyped = MethodSignatures & Record, (...args: any[]) => any> & { q: QueryFacade; on(topic: T, handler: (payload: TopicPayloadMap[T]) => void): Unsubscribe; once(topic: T, handler: (payload: TopicPayloadMap[T]) => void): Unsubscribe; off(topic: T, handler?: (payload: TopicPayloadMap[T]) => void): void; waitFor(topic: T, predicate?: (payload: TopicPayloadMap[T]) => boolean): Promise; inspect(): EngineInspection; build: BuildFacade; dryRun(directives: Directives): DryRunResult; explain(method: string, params?: Record): ExplainResult; }; type TournamentRecords = { [key: string]: Tournament; }; type Directives = { pipe?: { [key: string]: boolean; }; params?: { [key: string]: any; }; method: string; }[]; type CheckInOutParticipantArgs = { tournamentRecord: Tournament; drawDefinition: DrawDefinition; matchUp?: HydratedMatchUp; participantId: string; matchUpId: string; event?: Event$1; }; type ScheduleTimesResult = { scheduleTime: string; }; type SeedBlock = { drawPositions: number[]; seedNumbers: number[]; }; type SeedingProfile = { groupSeedingThreshold?: number; positioning?: string; nonRandom?: boolean; }; type ScaleAttributes = { eventType?: EventTypeUnion; scaleName?: string; scaleType: string; accessor?: string; }; type ScaleItem = { scaleDate?: string | Date; eventType?: EventTypeUnion; scaleName: string; scaleType: string; scaleValue: any; }; type Flight = { manuallyAdded?: boolean; drawEntries: Entry[]; flightNumber: number; drawName: string; drawId: string; }; type FlightProfile = { scaleAttributes?: ScaleAttributes; splitMethod?: string; flights: Flight[]; }; type PolicyDefinitions = { [key in ValidPolicyTypes]?: { [key: string]: any; }; }; type QueueMethod = { params: { [key: string]: any; }; method: string; }; type RoundProfile = { [key: number]: { finishingPositionRange: MatchUpFinishingPositionRange; pairedDrawPositions: number[][]; abbreviatedRoundName?: string; participantsCount?: number; drawPositions?: number[]; inactiveRound?: boolean; feedRoundIndex?: number; inactiveCount?: number; finishingRound?: number; preFeedRound?: boolean; matchUpsCount: number; roundFactor?: number; feedRound?: boolean; roundIndex?: number; roundNumber: number; roundName?: string; }; }; type ParticipantFilters = { accessorValues?: { accessor: string; value: any; }[]; participantRoleResponsibilities?: string[]; participantRoles?: ParticipantRoleUnion[]; participantTypes?: ParticipantTypeUnion[]; signInStatus?: SignedInStatusUnion; positionedParticipants?: boolean; eventEntryStatuses?: string[]; drawEntryStatuses?: string[]; enableOrFiltering?: boolean; participantIds?: string[]; genders?: GenderUnion; eventIds?: string[]; }; type StructureSortConfig = { deprioritizeCompleted?: boolean; mode?: { [key: string]: number; }; }; type PersonData = { participantExtensions?: Extension[]; participantTimeItems?: TimeItem[]; [key: string]: any; }; type AddressProps = { postalCodesCount?: number; citiesCount?: number; statesCount?: number; [key: string]: any; }; type TeamKey = { participantAttribute?: string; addParticipants?: boolean; personAttribute?: string; teamNames?: string[]; accessor?: string; uuids?: string[]; }; type ScheduleAnalysis = boolean | { scheduledMinutesDifference: number; }; type ParticipantsProfile = { participantType?: ParticipantTypeUnion; scaledParticipantsCount?: number; rankingRange?: [number, number]; nationalityCodesCount?: number; scaleAllParticipants?: boolean; personExtensions?: Extension[]; valuesInstanceLimit?: number; addressProps?: AddressProps; convertExtensions?: boolean; participantsCount?: number; addParticipants?: boolean; withScaleValues?: boolean; personAttribute?: string; consideredDate?: string; withGroupings?: boolean; personData?: PersonData; personIds?: string[]; inContext?: boolean; category?: Category; withISO2?: boolean; withIOC?: boolean; teamKey?: TeamKey; idPrefix?: string; uuids?: string[]; sex?: SexUnion; usePublishState?: boolean; withStatistics?: boolean; withOpponents?: boolean; withMatchUps?: boolean; withSeeding?: boolean; withEvents?: boolean; withDraws?: boolean; participantFilters?: ParticipantFilters; scheduleAnalysis?: ScheduleAnalysis; policyDefinitions?: PolicyDefinitions; }; type ScheduleVisibilityFilters = { visibilityThreshold: string; eventIds?: string[]; drawIds?: string[]; }; type ContextContent = { policies?: PolicyDefinitions; }; type ContextProfile = { withCompetitiveness?: boolean; withScaleValues?: boolean; inferGender?: boolean; exclude?: string[]; }; type Counters = { walkoverWins: number; defaultWins: number; walkovers: number; defaults: number; losses: number; wins: number; }; type ScheduleConflict = { priorScheduledMatchUpId: string; matchUpIdWithConflict: string; }; type LineParticipation = { collectionPosition: number; collectionId?: string; won: boolean; }; type StructureParticipation = { lineParticipation?: LineParticipation[]; rankingStage: StageTypeUnion; walkoverWinCount: number; defaultWinCount: number; stageSequence: number; structureId: string; winCount: number; drawId: string; }; type MappedParticipant = { structureParticipation: { [key: string]: StructureParticipation; } | StructureParticipation[]; potentialMatchUps: { tournamentId: string; matchUpId: string; eventId: string; drawId: string; }[]; scheduleConflicts: { [key: string]: ScheduleConflict; }; scheduleItems: any[]; participant: HydratedParticipant & { groupParticipantIds: string[]; pairParticipantIds: string[]; teamParticipantIds: string[]; groups: { participantRoleResponsibilities?: string[]; participantOtherName?: string; participantName: string; participantId: string; }[]; teams: { participantRoleResponsibilities?: string[]; participantOtherName?: string; participantName: string; participantId: string; teamId: string; }[]; }; statistics: { [key: string]: any; } | any[]; opponents: { [key: string]: any; } | any[]; pairIdMap: { [key: string]: any; } | any[]; matchUps: { [key: string]: any; } | any[]; events: { [key: string]: any; } | any[]; draws: { [key: string]: any; } | any[]; counters: Counters & { [DOUBLES_EVENT]: Counters; [SINGLES_EVENT]: Counters; [TEAM_EVENT]: Counters; }; }; type ParticipantMap = { [key: string]: MappedParticipant; }; type GetMatchUpsArgs = { scheduleVisibilityFilters?: ScheduleVisibilityFilters; tournamentAppliedPolicies?: PolicyDefinitions; participantsProfile?: ParticipantsProfile; participants?: HydratedParticipant[]; policyDefinitions?: PolicyDefinitions; context?: { [key: string]: any; }; contextFilters?: MatchUpFilters; matchUpFilters?: MatchUpFilters; contextContent?: ContextContent; participantMap?: ParticipantMap; hydrateParticipants?: boolean; tournamentRecord?: Tournament; contextProfile?: ContextProfile; drawDefinition?: DrawDefinition; afterRecoveryTimes?: boolean; useParticipantMap?: boolean; usePublishState?: boolean; nextMatchUps?: boolean; tournamentId?: string; publishStatus?: any; inContext?: boolean; event?: Event$1; }; type GroupInfo = { [key: string]: { participantName: string; participantId: string; }; }; type GroupsMatchUpsResult = { abandonedMatchUps?: HydratedMatchUp[]; completedMatchUps?: HydratedMatchUp[]; upcomingMatchUps?: HydratedMatchUp[]; participants?: HydratedParticipant[]; pendingMatchUps?: HydratedMatchUp[]; byeMatchUps?: HydratedMatchUp[]; matchUpsMap?: MatchUpsMap; matchUpsCount?: number; groupInfo?: GroupInfo; success?: boolean; error?: ErrorType; }; type ExitProfiles = { [key: string]: string[]; }; type MinutesMapping = { categoryNames: string[]; minutes: any; }; type ScheduleTiming = { matchUpRecoveryTimes: { [key: string]: { recoveryTiming: MinutesMapping[]; matchUpFormatCodes: string[]; }; }[]; matchUpAverageTimes: { [key: string]: { [key: string]: { averageTiming: MinutesMapping[]; matchUpFormatCodes: string[]; }; }; }[]; }; type Substitution = { previousParticipantId: string; substitutionOrder: number; participantId: string; }; type PlayoffAttributes = { [key: string | number]: { name: string; abbreviation: string; }; }; type WithPlayoffsArgs = { roundProfiles?: { [key: number]: number; }[]; playoffAttributes?: PlayoffAttributes; playoffStructureNameBase?: string; addNameBaseToAttributeName?: boolean; finishingPositionNaming?: any; finishingPositionLimit?: number; playoffPositions?: number[]; roundOffsetLimit?: number; exitProfileLimit?: boolean; roundNumbers?: number[]; roundPlayoffs?: { [roundNumber: number]: WithPlayoffsArgs; }; }; type LineUp = TeamCompetitor$1[]; type StructureProfile = { distanceFromMain?: number; drawSources: string[]; drawTargets: string[]; progeny?: string[]; sources: string[]; targets: string[]; rootStage?: string; stage?: string; }; type IdCollections = { groupParticipants: string[]; pairParticipants: string[]; teamParticipants: string[]; }; type Request$1 = { requestType: string; requestId: string; startTime: string; endTime: string; date: string; }; type PersonRequests = { [key: string]: Request$1[]; }; type AddScheduleAttributeArgs = { tournamentRecord?: Tournament; drawDefinition: DrawDefinition; removePriorValues?: boolean; disableNotice?: boolean; matchUpId: string; event?: Event$1; }; type MatchUpFilters = { matchUpStatuses?: MatchUpStatusUnion[]; excludeMatchUpStatuses?: string[]; hasParticipantsCount?: number; isCollectionMatchUp?: boolean; matchUpFormats?: string[]; roundPositions?: number[]; hasWinningSide?: boolean; collectionIds?: string[]; roundNumbers?: number[]; isMatchUpTie?: boolean; matchUpFormat?: string; matchUpIds?: string[]; roundNames?: string[]; processContext?: boolean; stageSequences?: string[]; scheduledDates?: string[]; participantIds?: string[]; stages?: StageTypeUnion[]; tournamentIds?: string[]; matchUpTypes?: string[]; structureIds?: string[]; scheduledDate?: string; readyToScore?: boolean; courtIds?: string[]; eventIds?: string[]; venueIds?: string[]; drawIds?: string[]; filterMatchUpTypes?: boolean; filterMatchUpIds?: boolean; }; type GenerateDrawDefinitionArgs = { automated?: boolean | { seedsOnly: boolean; }; playoffAttributes?: PlayoffAttributes; policyDefinitions?: PolicyDefinitions; appliedPolicies?: PolicyDefinitions; voluntaryConsolation?: { structureAbbreviation?: string; structureName?: string; structureId?: string; }; enforceMinimumDrawSize?: boolean; ignoreAllowedDrawTypes?: boolean; qualifyingPlaceholder?: boolean; considerEventEntries?: boolean; seedingProfile?: SeedingProfile; hydrateCollections?: boolean; tournamentRecord: Tournament; matchUpType?: EventTypeUnion; hydrateRoundNames?: boolean; drawTypeCoercion?: boolean; ignoreStageSpace?: boolean; qualifyingProfiles?: any[]; drawMatic?: DrawMaticArgs; qualifyingOnly?: boolean; drawType?: DrawTypeUnion; enforceGender?: boolean; processCodes?: string[]; matchUpFormat?: string; structureName?: string; tieFormatName?: string; tieFormat?: TieFormat; withPlayoffs?: WithPlayoffsArgs; drawEntries?: Entry[]; roundsCount?: number; seedsCount?: number; placeByes?: boolean; drawName?: string; drawSize?: number; idPrefix?: string; isMock?: boolean; random?: () => number; targetMatchUpIds?: TargetMatchUpId[]; uuids?: string[]; drawId?: string; event: Event$1; }; type TargetMatchUpId = { matchUpId: string; roundNumber: number; roundPosition: number; stage?: string; stageSequence?: number; exitProfile?: string; structureId?: string; }; type DrawMaticArgs = { adHocRatings?: { [key: string]: number; }; restrictRoundsCount?: boolean; restrictEntryStatus?: boolean; tournamentRecord: Tournament; drawDefinition: DrawDefinition; enableDoubleRobin?: boolean; generateMatchUps?: boolean; eventType?: EventTypeUnion; salted?: number | boolean; participantIds?: string[]; updateParticipantRatings?: boolean; dynamicRatings?: boolean; convertToELO?: boolean; refreshDynamic?: boolean; encounterValue?: number; sameTeamValue?: number; scaleAccessor?: string; maxIterations?: number; matchUpIds?: string[]; structure?: Structure; roundsCount?: number; structureId?: string; random?: () => number; scaleName?: string; idPrefix?: string; isMock?: boolean; event: Event$1; }; type ResultType = { context?: { [key: string]: any; }; stack?: string | string[]; errors?: string[]; error?: ErrorType; success?: boolean; valid?: boolean; info?: any; }; type MappedMatchUps = { [key: string]: { matchUps: HydratedMatchUp[] | MatchUp$1[] | undefined; itemStructureIds: string[]; structureName?: string; }; }; type MatchUpsMap = { mappedMatchUps: MappedMatchUps; drawMatchUps: MatchUp$1[]; }; type Tally = [number, number]; type ScheduledMatchUpArgs = { visibilityThreshold?: string; timeStamp?: string; schedule?: any; matchUp: any; }; declare function linkTournaments({ tournamentRecords }: { tournamentRecords: TournamentRecords; }): ResultType; type UnlinkTournamentsArgs = { tournamentRecords: TournamentRecords; }; declare function unlinkTournaments({ tournamentRecords }: UnlinkTournamentsArgs): ResultType; type UnlinkTournamentArgs = { tournamentRecords: TournamentRecords; tournamentId: string; }; declare function unlinkTournament({ tournamentRecords, tournamentId }: UnlinkTournamentArgs): ResultType; declare const mutate$g_initializeCompetitionState: typeof initializeCompetitionState; declare const mutate$g_linkTournaments: typeof linkTournaments; declare const mutate$g_processCompetitionMatchUp: typeof processCompetitionMatchUp; declare const mutate$g_processCompetitionRound: typeof processCompetitionRound; declare const mutate$g_resetCompetitionState: typeof resetCompetitionState; declare const mutate$g_unlinkTournament: typeof unlinkTournament; declare const mutate$g_unlinkTournaments: typeof unlinkTournaments; declare namespace mutate$g { export { mutate$g_initializeCompetitionState as initializeCompetitionState, mutate$g_linkTournaments as linkTournaments, mutate$g_processCompetitionMatchUp as processCompetitionMatchUp, mutate$g_processCompetitionRound as processCompetitionRound, mutate$g_resetCompetitionState as resetCompetitionState, mutate$g_unlinkTournament as unlinkTournament, mutate$g_unlinkTournaments as unlinkTournaments, }; } declare const query$f_getCompetitionLeaderboard: typeof getCompetitionLeaderboard; declare const query$f_getCompetitionParticipantState: typeof getCompetitionParticipantState; declare const query$f_getCompetitionPolicy: typeof getCompetitionPolicy; declare const query$f_getCompetitionState: typeof getCompetitionState; declare const query$f_getLinkedTournamentIds: typeof getLinkedTournamentIds; declare const query$f_getTournamentIds: typeof getTournamentIds; declare namespace query$f { export { query$f_getCompetitionLeaderboard as getCompetitionLeaderboard, query$f_getCompetitionParticipantState as getCompetitionParticipantState, query$f_getCompetitionPolicy as getCompetitionPolicy, query$f_getCompetitionState as getCompetitionState, query$f_getLinkedTournamentIds as getLinkedTournamentIds, query$f_getTournamentIds as getTournamentIds, }; } declare const index$q_getCompetitionLeaderboard: typeof getCompetitionLeaderboard; declare const index$q_getCompetitionParticipantState: typeof getCompetitionParticipantState; declare const index$q_getCompetitionPolicy: typeof getCompetitionPolicy; declare const index$q_getCompetitionState: typeof getCompetitionState; declare const index$q_getLinkedTournamentIds: typeof getLinkedTournamentIds; declare const index$q_getTournamentIds: typeof getTournamentIds; declare const index$q_initializeCompetitionState: typeof initializeCompetitionState; declare const index$q_linkTournaments: typeof linkTournaments; declare const index$q_processCompetitionMatchUp: typeof processCompetitionMatchUp; declare const index$q_processCompetitionRound: typeof processCompetitionRound; declare const index$q_resetCompetitionState: typeof resetCompetitionState; declare const index$q_unlinkTournament: typeof unlinkTournament; declare const index$q_unlinkTournaments: typeof unlinkTournaments; declare namespace index$q { export { index$q_getCompetitionLeaderboard as getCompetitionLeaderboard, index$q_getCompetitionParticipantState as getCompetitionParticipantState, index$q_getCompetitionPolicy as getCompetitionPolicy, index$q_getCompetitionState as getCompetitionState, index$q_getLinkedTournamentIds as getLinkedTournamentIds, index$q_getTournamentIds as getTournamentIds, index$q_initializeCompetitionState as initializeCompetitionState, index$q_linkTournaments as linkTournaments, mutate$g as mutate, index$q_processCompetitionMatchUp as processCompetitionMatchUp, index$q_processCompetitionRound as processCompetitionRound, query$f as query, index$q_resetCompetitionState as resetCompetitionState, index$q_unlinkTournament as unlinkTournament, index$q_unlinkTournaments as unlinkTournaments, }; } declare const mutate$f_adHocPositionSwap: typeof adHocPositionSwap; declare const mutate$f_addAdHocMatchUps: typeof addAdHocMatchUps; declare const mutate$f_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem; declare const mutate$f_addLinkedConsolationStructure: typeof addLinkedConsolationStructure; declare const mutate$f_addPlayoffStructures: typeof addPlayoffStructures; declare const mutate$f_addQualifyingStructure: typeof addQualifyingStructure; declare const mutate$f_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure; declare const mutate$f_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment; declare const mutate$f_assignDrawPosition: typeof assignDrawPosition; declare const mutate$f_assignDrawPositionBye: typeof assignDrawPositionBye; declare const mutate$f_attachConsolationStructures: typeof attachConsolationStructures; declare const mutate$f_attachPlayoffStructures: typeof attachPlayoffStructures; declare const mutate$f_attachQualifyingStructure: typeof attachQualifyingStructure; declare const mutate$f_attachStructures: typeof attachStructures; declare const mutate$f_automatedPlayoffPositioning: typeof automatedPlayoffPositioning; declare const mutate$f_automatedPositioning: typeof automatedPositioning; declare const mutate$f_deleteAdHocMatchUps: typeof deleteAdHocMatchUps; declare const mutate$f_initializeDraft: typeof initializeDraft; declare const mutate$f_luckyDrawAdvancement: typeof luckyDrawAdvancement; declare const mutate$f_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment; declare const mutate$f_modifyDrawDefinition: typeof modifyDrawDefinition; declare const mutate$f_modifyDrawName: typeof modifyDrawName; declare const mutate$f_modifySeedAssignment: typeof modifySeedAssignment; declare const mutate$f_pruneDrawDefinition: typeof pruneDrawDefinition; declare const mutate$f_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment; declare const mutate$f_qualifierProgression: typeof qualifierProgression; declare const mutate$f_remapDrawDefinitionMatchUpIds: typeof remapDrawDefinitionMatchUpIds; declare const mutate$f_removeDrawPositionAssignment: typeof removeDrawPositionAssignment; declare const mutate$f_removeRoundMatchUps: typeof removeRoundMatchUps; declare const mutate$f_removeSeededParticipant: typeof removeSeededParticipant; declare const mutate$f_removeStructure: typeof removeStructure; declare const mutate$f_renameStructures: typeof renameStructures; declare const mutate$f_resetDrawDefinition: typeof resetDrawDefinition; declare const mutate$f_resetQualifyingStructure: typeof resetQualifyingStructure; declare const mutate$f_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure; declare const mutate$f_resolveDraftPositions: typeof resolveDraftPositions; declare const mutate$f_seedWithdrawalCascade: typeof seedWithdrawalCascade; declare const mutate$f_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds; declare const mutate$f_setDrawPositionPreferences: typeof setDrawPositionPreferences; declare const mutate$f_setPositionAssignments: typeof setPositionAssignments; declare const mutate$f_setStructureOrder: typeof setStructureOrder; declare const mutate$f_setSubOrder: typeof setSubOrder; declare const mutate$f_shiftAdHocRounds: typeof shiftAdHocRounds; declare const mutate$f_swapAdHocRounds: typeof swapAdHocRounds; declare const mutate$f_swapDrawPositionAssignments: typeof swapDrawPositionAssignments; declare const mutate$f_updateTeamLineUp: typeof updateTeamLineUp; declare const mutate$f_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition; declare namespace mutate$f { export { mutate$f_adHocPositionSwap as adHocPositionSwap, mutate$f_addAdHocMatchUps as addAdHocMatchUps, mutate$f_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem, mutate$f_addLinkedConsolationStructure as addLinkedConsolationStructure, mutate$f_addPlayoffStructures as addPlayoffStructures, mutate$f_addQualifyingStructure as addQualifyingStructure, mutate$f_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure, mutate$f_alternateDrawPositionAssignment as alternateDrawPositionAssignment, mutate$f_assignDrawPosition as assignDrawPosition, mutate$f_assignDrawPositionBye as assignDrawPositionBye, mutate$f_attachConsolationStructures as attachConsolationStructures, mutate$f_attachPlayoffStructures as attachPlayoffStructures, mutate$f_attachQualifyingStructure as attachQualifyingStructure, mutate$f_attachStructures as attachStructures, mutate$f_automatedPlayoffPositioning as automatedPlayoffPositioning, mutate$f_automatedPositioning as automatedPositioning, mutate$f_deleteAdHocMatchUps as deleteAdHocMatchUps, mutate$f_initializeDraft as initializeDraft, mutate$f_luckyDrawAdvancement as luckyDrawAdvancement, mutate$f_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment, mutate$f_modifyDrawDefinition as modifyDrawDefinition, mutate$f_modifyDrawName as modifyDrawName, mutate$f_modifySeedAssignment as modifySeedAssignment, mutate$f_pruneDrawDefinition as pruneDrawDefinition, mutate$f_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment, mutate$f_qualifierProgression as qualifierProgression, mutate$f_remapDrawDefinitionMatchUpIds as remapDrawDefinitionMatchUpIds, mutate$f_removeDrawPositionAssignment as removeDrawPositionAssignment, mutate$f_removeRoundMatchUps as removeRoundMatchUps, mutate$f_removeSeededParticipant as removeSeededParticipant, mutate$f_removeStructure as removeStructure, mutate$f_renameStructures as renameStructures, mutate$f_resetDrawDefinition as resetDrawDefinition, mutate$f_resetQualifyingStructure as resetQualifyingStructure, mutate$f_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure, mutate$f_resolveDraftPositions as resolveDraftPositions, mutate$f_seedWithdrawalCascade as seedWithdrawalCascade, mutate$f_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds, mutate$f_setDrawPositionPreferences as setDrawPositionPreferences, mutate$f_setPositionAssignments as setPositionAssignments, mutate$f_setStructureOrder as setStructureOrder, mutate$f_setSubOrder as setSubOrder, mutate$f_shiftAdHocRounds as shiftAdHocRounds, mutate$f_swapAdHocRounds as swapAdHocRounds, mutate$f_swapDrawPositionAssignments as swapDrawPositionAssignments, mutate$f_updateTeamLineUp as updateTeamLineUp, mutate$f_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition, }; } declare const query$e_addGoesTo: typeof addGoesTo; declare const query$e_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled; declare const query$e_checkValidEntries: typeof checkValidEntries; declare const query$e_getAssignedParticipantIds: typeof getAssignedParticipantIds; declare const query$e_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount; declare const query$e_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles; declare const query$e_getDraftState: typeof getDraftState; declare const query$e_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem; declare const query$e_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds; declare const query$e_getDrawStructures: typeof getDrawStructures; declare const query$e_getDrawTypeCoercion: typeof getDrawTypeCoercion; declare const query$e_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants; declare const query$e_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus; declare const query$e_getMatchUpsMap: typeof getMatchUpsMap; declare const query$e_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions; declare const query$e_getPositionAssignments: typeof getPositionAssignments; declare const query$e_getPositionsPlayedOff: typeof getPositionsPlayedOff; declare const query$e_getRandomQualifierList: typeof getRandomQualifierList; declare const query$e_getSeedingThresholds: typeof getSeedingThresholds; declare const query$e_getSeedsCount: typeof getSeedsCount; declare const query$e_getStructureSeedAssignments: typeof getStructureSeedAssignments; declare const query$e_getSwissChart: typeof getSwissChart; declare const query$e_getSwissStandings: typeof getSwissStandings; declare const query$e_getTally: typeof getTally; declare const query$e_getTeamLineUp: typeof getTeamLineUp; declare const query$e_getValidGroupSizes: typeof getValidGroupSizes; declare const query$e_hasLuckyRounds: typeof hasLuckyRounds; declare const query$e_isAdHoc: typeof isAdHoc; declare const query$e_isCompletedStructure: typeof isCompletedStructure; declare const query$e_isValidForQualifying: typeof isValidForQualifying; declare const query$e_positionActions: typeof positionActions; declare const query$e_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands; declare const query$e_validatePlayoffGroups: typeof validatePlayoffGroups; declare namespace query$e { export { query$e_addGoesTo as addGoesTo, query$e_allPlayoffPositionsFilled as allPlayoffPositionsFilled, query$e_checkValidEntries as checkValidEntries, publicFindDrawDefinition as findDrawDefinition, query$e_getAssignedParticipantIds as getAssignedParticipantIds, query$e_getAvailableMatchUpsCount as getAvailableMatchUpsCount, query$e_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles, query$e_getDraftState as getDraftState, query$e_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem, query$e_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds, query$e_getDrawStructures as getDrawStructures, query$e_getDrawTypeCoercion as getDrawTypeCoercion, query$e_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants, query$e_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus, query$e_getMatchUpsMap as getMatchUpsMap, query$e_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions, query$e_getPositionAssignments as getPositionAssignments, query$e_getPositionsPlayedOff as getPositionsPlayedOff, query$e_getRandomQualifierList as getRandomQualifierList, query$e_getSeedingThresholds as getSeedingThresholds, query$e_getSeedsCount as getSeedsCount, query$e_getStructureSeedAssignments as getStructureSeedAssignments, query$e_getSwissChart as getSwissChart, query$e_getSwissStandings as getSwissStandings, query$e_getTally as getTally, query$e_getTeamLineUp as getTeamLineUp, query$e_getValidGroupSizes as getValidGroupSizes, query$e_hasLuckyRounds as hasLuckyRounds, query$e_isAdHoc as isAdHoc, query$e_isCompletedStructure as isCompletedStructure, query$e_isValidForQualifying as isValidForQualifying, query$e_positionActions as positionActions, query$e_predictDrawCompetitiveBands as predictDrawCompetitiveBands, query$e_validatePlayoffGroups as validatePlayoffGroups, }; } declare const index$p_adHocPositionSwap: typeof adHocPositionSwap; declare const index$p_addAdHocMatchUps: typeof addAdHocMatchUps; declare const index$p_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem; declare const index$p_addFinishingRounds: typeof addFinishingRounds; declare const index$p_addGoesTo: typeof addGoesTo; declare const index$p_addLinkedConsolationStructure: typeof addLinkedConsolationStructure; declare const index$p_addPlayoffStructures: typeof addPlayoffStructures; declare const index$p_addQualifyingStructure: typeof addQualifyingStructure; declare const index$p_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure; declare const index$p_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled; declare const index$p_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment; declare const index$p_assignDrawPosition: typeof assignDrawPosition; declare const index$p_assignDrawPositionBye: typeof assignDrawPositionBye; declare const index$p_attachConsolationStructures: typeof attachConsolationStructures; declare const index$p_attachPlayoffStructures: typeof attachPlayoffStructures; declare const index$p_attachQualifyingStructure: typeof attachQualifyingStructure; declare const index$p_attachStructures: typeof attachStructures; declare const index$p_autoSeeding: typeof autoSeeding; declare const index$p_automatedPlayoffPositioning: typeof automatedPlayoffPositioning; declare const index$p_automatedPositioning: typeof automatedPositioning; declare const index$p_buildDrawHierarchy: typeof buildDrawHierarchy; declare const index$p_checkValidEntries: typeof checkValidEntries; declare const index$p_deleteAdHocMatchUps: typeof deleteAdHocMatchUps; declare const index$p_drawMatic: typeof drawMatic; declare const index$p_generateAdHocMatchUps: typeof generateAdHocMatchUps; declare const index$p_generateAdHocRounds: typeof generateAdHocRounds; declare const index$p_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures; declare const index$p_generateConsolationStructure: typeof generateConsolationStructure; declare const index$p_generateDrawDefinition: typeof generateDrawDefinition; declare const index$p_generateDrawMaticRound: typeof generateDrawMaticRound; declare const index$p_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks; declare const index$p_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition; declare const index$p_generateQualifyingStructure: typeof generateQualifyingStructure; declare const index$p_generateSwissRound: typeof generateSwissRound; declare const index$p_generateVoluntaryConsolation: typeof generateVoluntaryConsolation; declare const index$p_getAssignedParticipantIds: typeof getAssignedParticipantIds; declare const index$p_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount; declare const index$p_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles; declare const index$p_getDraftState: typeof getDraftState; declare const index$p_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem; declare const index$p_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds; declare const index$p_getDrawStructures: typeof getDrawStructures; declare const index$p_getDrawTypeCoercion: typeof getDrawTypeCoercion; declare const index$p_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants; declare const index$p_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus; declare const index$p_getMatchUpsMap: typeof getMatchUpsMap; declare const index$p_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions; declare const index$p_getPositionAssignments: typeof getPositionAssignments; declare const index$p_getPositionsPlayedOff: typeof getPositionsPlayedOff; declare const index$p_getRandomQualifierList: typeof getRandomQualifierList; declare const index$p_getSeedingThresholds: typeof getSeedingThresholds; declare const index$p_getSeedsCount: typeof getSeedsCount; declare const index$p_getStructureSeedAssignments: typeof getStructureSeedAssignments; declare const index$p_getSwissChart: typeof getSwissChart; declare const index$p_getSwissStandings: typeof getSwissStandings; declare const index$p_getTally: typeof getTally; declare const index$p_getTeamLineUp: typeof getTeamLineUp; declare const index$p_getValidGroupSizes: typeof getValidGroupSizes; declare const index$p_hasLuckyRounds: typeof hasLuckyRounds; declare const index$p_initializeDraft: typeof initializeDraft; declare const index$p_isAdHoc: typeof isAdHoc; declare const index$p_isCompletedStructure: typeof isCompletedStructure; declare const index$p_isValidForQualifying: typeof isValidForQualifying; declare const index$p_luckyDrawAdvancement: typeof luckyDrawAdvancement; declare const index$p_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment; declare const index$p_modifyDrawDefinition: typeof modifyDrawDefinition; declare const index$p_modifyDrawName: typeof modifyDrawName; declare const index$p_modifySeedAssignment: typeof modifySeedAssignment; declare const index$p_positionActions: typeof positionActions; declare const index$p_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands; declare const index$p_pruneDrawDefinition: typeof pruneDrawDefinition; declare const index$p_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment; declare const index$p_qualifierProgression: typeof qualifierProgression; declare const index$p_remapDrawDefinitionMatchUpIds: typeof remapDrawDefinitionMatchUpIds; declare const index$p_removeDrawPositionAssignment: typeof removeDrawPositionAssignment; declare const index$p_removeRoundMatchUps: typeof removeRoundMatchUps; declare const index$p_removeSeededParticipant: typeof removeSeededParticipant; declare const index$p_removeStructure: typeof removeStructure; declare const index$p_renameStructures: typeof renameStructures; declare const index$p_resetDrawDefinition: typeof resetDrawDefinition; declare const index$p_resetQualifyingStructure: typeof resetQualifyingStructure; declare const index$p_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure; declare const index$p_resolveDraftPositions: typeof resolveDraftPositions; declare const index$p_seedWithdrawalCascade: typeof seedWithdrawalCascade; declare const index$p_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds; declare const index$p_setDrawPositionPreferences: typeof setDrawPositionPreferences; declare const index$p_setPositionAssignments: typeof setPositionAssignments; declare const index$p_setStructureOrder: typeof setStructureOrder; declare const index$p_setSubOrder: typeof setSubOrder; declare const index$p_shiftAdHocRounds: typeof shiftAdHocRounds; declare const index$p_swapAdHocRounds: typeof swapAdHocRounds; declare const index$p_swapDrawPositionAssignments: typeof swapDrawPositionAssignments; declare const index$p_updateTeamLineUp: typeof updateTeamLineUp; declare const index$p_validatePlayoffGroups: typeof validatePlayoffGroups; declare const index$p_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition; declare namespace index$p { export { index$p_adHocPositionSwap as adHocPositionSwap, index$p_addAdHocMatchUps as addAdHocMatchUps, index$p_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem, index$p_addFinishingRounds as addFinishingRounds, index$p_addGoesTo as addGoesTo, index$p_addLinkedConsolationStructure as addLinkedConsolationStructure, index$p_addPlayoffStructures as addPlayoffStructures, index$p_addQualifyingStructure as addQualifyingStructure, index$p_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure, index$p_allPlayoffPositionsFilled as allPlayoffPositionsFilled, index$p_alternateDrawPositionAssignment as alternateDrawPositionAssignment, index$p_assignDrawPosition as assignDrawPosition, index$p_assignDrawPositionBye as assignDrawPositionBye, index$p_attachConsolationStructures as attachConsolationStructures, index$p_attachPlayoffStructures as attachPlayoffStructures, index$p_attachQualifyingStructure as attachQualifyingStructure, index$p_attachStructures as attachStructures, index$p_autoSeeding as autoSeeding, index$p_automatedPlayoffPositioning as automatedPlayoffPositioning, index$p_automatedPositioning as automatedPositioning, index$p_buildDrawHierarchy as buildDrawHierarchy, index$p_checkValidEntries as checkValidEntries, index$p_deleteAdHocMatchUps as deleteAdHocMatchUps, index$p_drawMatic as drawMatic, publicFindDrawDefinition as findDrawDefinition, index$p_generateAdHocMatchUps as generateAdHocMatchUps, index$p_generateAdHocRounds as generateAdHocRounds, index$p_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$p_generateConsolationStructure as generateConsolationStructure, index$p_generateDrawDefinition as generateDrawDefinition, index$p_generateDrawMaticRound as generateDrawMaticRound, index$p_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$p_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$p_generateQualifyingStructure as generateQualifyingStructure, index$p_generateSwissRound as generateSwissRound, index$p_generateVoluntaryConsolation as generateVoluntaryConsolation, index$p_getAssignedParticipantIds as getAssignedParticipantIds, index$p_getAvailableMatchUpsCount as getAvailableMatchUpsCount, index$p_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles, index$p_getDraftState as getDraftState, index$p_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem, index$p_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds, index$p_getDrawStructures as getDrawStructures, index$p_getDrawTypeCoercion as getDrawTypeCoercion, index$p_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants, index$p_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus, index$p_getMatchUpsMap as getMatchUpsMap, index$p_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions, index$p_getPositionAssignments as getPositionAssignments, index$p_getPositionsPlayedOff as getPositionsPlayedOff, index$p_getRandomQualifierList as getRandomQualifierList, index$p_getSeedingThresholds as getSeedingThresholds, index$p_getSeedsCount as getSeedsCount, index$p_getStructureSeedAssignments as getStructureSeedAssignments, index$p_getSwissChart as getSwissChart, index$p_getSwissStandings as getSwissStandings, index$p_getTally as getTally, index$p_getTeamLineUp as getTeamLineUp, index$p_getValidGroupSizes as getValidGroupSizes, index$p_hasLuckyRounds as hasLuckyRounds, index$p_initializeDraft as initializeDraft, index$p_isAdHoc as isAdHoc, index$p_isCompletedStructure as isCompletedStructure, index$p_isValidForQualifying as isValidForQualifying, index$p_luckyDrawAdvancement as luckyDrawAdvancement, index$p_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment, index$p_modifyDrawDefinition as modifyDrawDefinition, index$p_modifyDrawName as modifyDrawName, index$p_modifySeedAssignment as modifySeedAssignment, mutate$f as mutate, index$p_positionActions as positionActions, index$p_predictDrawCompetitiveBands as predictDrawCompetitiveBands, index$p_pruneDrawDefinition as pruneDrawDefinition, index$p_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment, index$p_qualifierProgression as qualifierProgression, query$e as query, index$p_remapDrawDefinitionMatchUpIds as remapDrawDefinitionMatchUpIds, index$p_removeDrawPositionAssignment as removeDrawPositionAssignment, index$p_removeRoundMatchUps as removeRoundMatchUps, index$p_removeSeededParticipant as removeSeededParticipant, index$p_removeStructure as removeStructure, index$p_renameStructures as renameStructures, index$p_resetDrawDefinition as resetDrawDefinition, index$p_resetQualifyingStructure as resetQualifyingStructure, index$p_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure, index$p_resolveDraftPositions as resolveDraftPositions, index$p_seedWithdrawalCascade as seedWithdrawalCascade, index$p_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds, index$p_setDrawPositionPreferences as setDrawPositionPreferences, index$p_setPositionAssignments as setPositionAssignments, index$p_setStructureOrder as setStructureOrder, index$p_setSubOrder as setSubOrder, index$p_shiftAdHocRounds as shiftAdHocRounds, index$p_swapAdHocRounds as swapAdHocRounds, index$p_swapDrawPositionAssignments as swapDrawPositionAssignments, index$p_updateTeamLineUp as updateTeamLineUp, index$p_validatePlayoffGroups as validatePlayoffGroups, index$p_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition, }; } declare const mutate$e_addDrawEntries: typeof addDrawEntries; declare const mutate$e_addEventEntries: typeof addEventEntries; declare const mutate$e_addEventEntryPairs: typeof addEventEntryPairs; declare const mutate$e_destroyPairEntries: typeof destroyPairEntries; declare const mutate$e_destroyPairEntry: typeof destroyPairEntry; declare const mutate$e_modifyEntriesStatus: typeof modifyEntriesStatus; declare const mutate$e_modifyEventEntries: typeof modifyEventEntries; declare const mutate$e_promoteAlternate: typeof promoteAlternate; declare const mutate$e_promoteAlternates: typeof promoteAlternates; declare const mutate$e_removeDrawEntries: typeof removeDrawEntries; declare const mutate$e_removeEventEntries: typeof removeEventEntries; declare const mutate$e_removeStageEntries: typeof removeStageEntries; declare const mutate$e_setEntryPosition: typeof setEntryPosition; declare const mutate$e_setEntryPositions: typeof setEntryPositions; declare namespace mutate$e { export { mutate$e_addDrawEntries as addDrawEntries, mutate$e_addEventEntries as addEventEntries, mutate$e_addEventEntryPairs as addEventEntryPairs, mutate$e_destroyPairEntries as destroyPairEntries, mutate$e_destroyPairEntry as destroyPairEntry, mutate$e_modifyEntriesStatus as modifyEntriesStatus, mutate$e_modifyEventEntries as modifyEventEntries, mutate$e_promoteAlternate as promoteAlternate, mutate$e_promoteAlternates as promoteAlternates, mutate$e_removeDrawEntries as removeDrawEntries, mutate$e_removeEventEntries as removeEventEntries, mutate$e_removeStageEntries as removeStageEntries, mutate$e_setEntryPosition as setEntryPosition, mutate$e_setEntryPositions as setEntryPositions, }; } declare const query$d_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount; declare const query$d_getMaxEntryPosition: typeof getMaxEntryPosition; declare namespace query$d { export { query$d_getEntriesAndSeedsCount as getEntriesAndSeedsCount, query$d_getMaxEntryPosition as getMaxEntryPosition, }; } declare const index$o_addDrawEntries: typeof addDrawEntries; declare const index$o_addEventEntries: typeof addEventEntries; declare const index$o_addEventEntryPairs: typeof addEventEntryPairs; declare const index$o_destroyPairEntries: typeof destroyPairEntries; declare const index$o_destroyPairEntry: typeof destroyPairEntry; declare const index$o_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount; declare const index$o_getMaxEntryPosition: typeof getMaxEntryPosition; declare const index$o_modifyEntriesStatus: typeof modifyEntriesStatus; declare const index$o_modifyEventEntries: typeof modifyEventEntries; declare const index$o_promoteAlternate: typeof promoteAlternate; declare const index$o_promoteAlternates: typeof promoteAlternates; declare const index$o_removeDrawEntries: typeof removeDrawEntries; declare const index$o_removeEventEntries: typeof removeEventEntries; declare const index$o_removeStageEntries: typeof removeStageEntries; declare const index$o_setEntryPosition: typeof setEntryPosition; declare const index$o_setEntryPositions: typeof setEntryPositions; declare namespace index$o { export { index$o_addDrawEntries as addDrawEntries, index$o_addEventEntries as addEventEntries, index$o_addEventEntryPairs as addEventEntryPairs, index$o_destroyPairEntries as destroyPairEntries, index$o_destroyPairEntry as destroyPairEntry, index$o_getEntriesAndSeedsCount as getEntriesAndSeedsCount, index$o_getMaxEntryPosition as getMaxEntryPosition, index$o_modifyEntriesStatus as modifyEntriesStatus, index$o_modifyEventEntries as modifyEventEntries, mutate$e as mutate, index$o_promoteAlternate as promoteAlternate, index$o_promoteAlternates as promoteAlternates, query$d as query, index$o_removeDrawEntries as removeDrawEntries, index$o_removeEventEntries as removeEventEntries, index$o_removeStageEntries as removeStageEntries, index$o_setEntryPosition as setEntryPosition, index$o_setEntryPositions as setEntryPositions, }; } declare const generate$4_generateEventsFromTieFormat: typeof generateEventsFromTieFormat; declare namespace generate$4 { export { generate$4_generateEventsFromTieFormat as generateEventsFromTieFormat, }; } declare const mutate$d_addDrawDefinition: typeof addDrawDefinition; declare const mutate$d_addEvent: typeof addEvent; declare const mutate$d_addFlight: typeof addFlight; declare const mutate$d_assignSeedPositions: typeof assignSeedPositions; declare const mutate$d_attachFlightProfile: typeof attachFlightProfile; declare const mutate$d_deleteDrawDefinitions: typeof deleteDrawDefinitions; declare const mutate$d_deleteEvents: typeof deleteEvents; declare const mutate$d_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw; declare const mutate$d_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws; declare const mutate$d_modifyEvent: typeof modifyEvent; declare const mutate$d_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming; declare const mutate$d_modifyPairAssignment: typeof modifyPairAssignment; declare const mutate$d_refreshEventDrawOrder: typeof refreshEventDrawOrder; declare const mutate$d_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming; declare const mutate$d_removeScaleValues: typeof removeScaleValues; declare const mutate$d_removeSeeding: typeof removeSeeding; declare const mutate$d_setEventDates: typeof setEventDates; declare const mutate$d_setEventDisplay: typeof setEventDisplay; declare const mutate$d_setEventEndDate: typeof setEventEndDate; declare const mutate$d_setEventStartDate: typeof setEventStartDate; declare const mutate$d_updateDrawIdsOrder: typeof updateDrawIdsOrder; declare const mutate$d_validateCategory: typeof validateCategory; declare namespace mutate$d { export { mutate$d_addDrawDefinition as addDrawDefinition, mutate$d_addEvent as addEvent, mutate$d_addFlight as addFlight, mutate$d_assignSeedPositions as assignSeedPositions, mutate$d_attachFlightProfile as attachFlightProfile, mutate$d_deleteDrawDefinitions as deleteDrawDefinitions, mutate$d_deleteEvents as deleteEvents, mutate$d_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw, mutate$d_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws, mutate$d_modifyEvent as modifyEvent, mutate$d_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming, mutate$d_modifyPairAssignment as modifyPairAssignment, mutate$d_refreshEventDrawOrder as refreshEventDrawOrder, mutate$d_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming, mutate$d_removeScaleValues as removeScaleValues, mutate$d_removeSeeding as removeSeeding, mutate$d_setEventDates as setEventDates, mutate$d_setEventDisplay as setEventDisplay, mutate$d_setEventEndDate as setEventEndDate, mutate$d_setEventStartDate as setEventStartDate, mutate$d_updateDrawIdsOrder as updateDrawIdsOrder, mutate$d_validateCategory as validateCategory, }; } declare const query$c_categoryCanContain: typeof categoryCanContain; declare const query$c_getCategoryAgeDetails: typeof getCategoryAgeDetails; declare const query$c_getEvent: typeof getEvent; declare const query$c_getEventProperties: typeof getEventProperties; declare const query$c_getEventStructures: typeof getEventStructures; declare const query$c_getEventTimeItem: typeof getEventTimeItem; declare const query$c_getEvents: typeof getEvents; declare const query$c_getFlightProfile: typeof getFlightProfile; declare const query$c_getScaledEntries: typeof getScaledEntries; declare namespace query$c { export { query$c_categoryCanContain as categoryCanContain, query$c_getCategoryAgeDetails as getCategoryAgeDetails, query$c_getEvent as getEvent, query$c_getEventProperties as getEventProperties, query$c_getEventStructures as getEventStructures, query$c_getEventTimeItem as getEventTimeItem, query$c_getEvents as getEvents, query$c_getFlightProfile as getFlightProfile, query$c_getScaledEntries as getScaledEntries, }; } declare const index$n_addDrawDefinition: typeof addDrawDefinition; declare const index$n_addEvent: typeof addEvent; declare const index$n_addFlight: typeof addFlight; declare const index$n_assignSeedPositions: typeof assignSeedPositions; declare const index$n_attachFlightProfile: typeof attachFlightProfile; declare const index$n_categoryCanContain: typeof categoryCanContain; declare const index$n_deleteDrawDefinitions: typeof deleteDrawDefinitions; declare const index$n_deleteEvents: typeof deleteEvents; declare const index$n_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw; declare const index$n_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws; declare const index$n_generateEventsFromTieFormat: typeof generateEventsFromTieFormat; declare const index$n_getCategoryAgeDetails: typeof getCategoryAgeDetails; declare const index$n_getEvent: typeof getEvent; declare const index$n_getEventProperties: typeof getEventProperties; declare const index$n_getEventStructures: typeof getEventStructures; declare const index$n_getEventTimeItem: typeof getEventTimeItem; declare const index$n_getEvents: typeof getEvents; declare const index$n_getFlightProfile: typeof getFlightProfile; declare const index$n_getScaledEntries: typeof getScaledEntries; declare const index$n_modifyEvent: typeof modifyEvent; declare const index$n_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming; declare const index$n_modifyPairAssignment: typeof modifyPairAssignment; declare const index$n_refreshEventDrawOrder: typeof refreshEventDrawOrder; declare const index$n_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming; declare const index$n_removeScaleValues: typeof removeScaleValues; declare const index$n_removeSeeding: typeof removeSeeding; declare const index$n_setEventDates: typeof setEventDates; declare const index$n_setEventDisplay: typeof setEventDisplay; declare const index$n_setEventEndDate: typeof setEventEndDate; declare const index$n_setEventStartDate: typeof setEventStartDate; declare const index$n_updateDrawIdsOrder: typeof updateDrawIdsOrder; declare const index$n_validateCategory: typeof validateCategory; declare namespace index$n { export { index$n_addDrawDefinition as addDrawDefinition, index$n_addEvent as addEvent, index$n_addFlight as addFlight, index$n_assignSeedPositions as assignSeedPositions, index$n_attachFlightProfile as attachFlightProfile, index$n_categoryCanContain as categoryCanContain, index$n_deleteDrawDefinitions as deleteDrawDefinitions, index$n_deleteEvents as deleteEvents, index$n_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw, index$n_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws, generate$4 as generate, index$n_generateEventsFromTieFormat as generateEventsFromTieFormat, index$n_getCategoryAgeDetails as getCategoryAgeDetails, index$n_getEvent as getEvent, index$n_getEventProperties as getEventProperties, index$n_getEventStructures as getEventStructures, index$n_getEventTimeItem as getEventTimeItem, index$n_getEvents as getEvents, index$n_getFlightProfile as getFlightProfile, index$n_getScaledEntries as getScaledEntries, index$n_modifyEvent as modifyEvent, index$n_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming, index$n_modifyPairAssignment as modifyPairAssignment, mutate$d as mutate, query$c as query, index$n_refreshEventDrawOrder as refreshEventDrawOrder, index$n_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming, index$n_removeScaleValues as removeScaleValues, index$n_removeSeeding as removeSeeding, index$n_setEventDates as setEventDates, index$n_setEventDisplay as setEventDisplay, index$n_setEventEndDate as setEventEndDate, index$n_setEventStartDate as setEventStartDate, index$n_updateDrawIdsOrder as updateDrawIdsOrder, index$n_validateCategory as validateCategory, }; } declare function getRoundRobinGroupMatchUps({ drawPositions }: { drawPositions: any; }): { error: { message: string; code: string; }; groupMatchUps?: undefined; uniqueMatchUpGroupings?: undefined; } | { groupMatchUps: never[]; uniqueMatchUpGroupings: any[]; error?: undefined; }; declare function drawPositionsHash(drawPositions?: never[]): string; declare function groupRounds({ groupSize, drawPositionOffset }: { groupSize: any; drawPositionOffset: any; }): any[]; declare function determineRoundNumber({ rounds, hash }: { rounds: any; hash: any; }): any; declare const roundRobinGroups: { getRoundRobinGroupMatchUps: typeof getRoundRobinGroupMatchUps; determineRoundNumber: typeof determineRoundNumber; drawPositionsHash: typeof drawPositionsHash; groupRounds: typeof groupRounds; }; type GetCourtsAvailableAtPeriodStartArgs = { averageMatchUpMinutes: number; includeBookingTypes?: boolean; periodStart: string; courts: any[]; date: string; }; declare function getCourtsAvailableAtPeriodStart(params: GetCourtsAvailableAtPeriodStartArgs): ResultType & { availableToScheduleCount?: number; }; declare function getScheduleTimes(params: any): ResultType & { scheduleTimes?: ScheduleTimesResult[]; totalMatchUps?: number; timingProfile?: any; }; type GenerateTimeSlotsArgs = { includeBookingTypes?: string[]; courtDate: any; }; declare function generateTimeSlots(params: GenerateTimeSlotsArgs): ResultType & { timeSlots?: any[]; }; type CourtGeneratorArgs = { startTime?: string; endTime?: string; count?: number; date?: string; }; declare function courtGenerator(params?: CourtGeneratorArgs): { dateAvailability: { date: string | undefined; startTime: string; endTime: string; }[]; }[]; declare const garman: { getCourtsAvailableAtPeriodStart: typeof getCourtsAvailableAtPeriodStart; generateTimeSlots: typeof generateTimeSlots; getScheduleTimes: typeof getScheduleTimes; courtGenerator: typeof courtGenerator; }; declare const garman$1_garman: typeof garman; declare namespace garman$1 { export { garman as default, garman$1_garman as garman, }; } declare const index$m_drawMatic: typeof drawMatic; declare const index$m_generateAdHocMatchUps: typeof generateAdHocMatchUps; declare const index$m_generateAdHocRounds: typeof generateAdHocRounds; declare const index$m_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures; declare const index$m_generateCourts: typeof generateCourts; declare const index$m_generateDrawDefinition: typeof generateDrawDefinition; declare const index$m_generateDrawMaticRound: typeof generateDrawMaticRound; declare const index$m_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks; declare const index$m_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition; declare const index$m_generateFlightProfile: typeof generateFlightProfile; declare const index$m_generateLineUps: typeof generateLineUps; declare const index$m_generateQualifyingStructure: typeof generateQualifyingStructure; declare const index$m_generateSeedingScaleItems: typeof generateSeedingScaleItems; declare const index$m_generateStatCrew: typeof generateStatCrew; declare const index$m_generateVoluntaryConsolation: typeof generateVoluntaryConsolation; declare const index$m_roundRobinGroups: typeof roundRobinGroups; declare namespace index$m { export { index$m_drawMatic as drawMatic, garman$1 as garman, index$m_generateAdHocMatchUps as generateAdHocMatchUps, index$m_generateAdHocRounds as generateAdHocRounds, index$m_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$m_generateCourts as generateCourts, index$m_generateDrawDefinition as generateDrawDefinition, index$m_generateDrawMaticRound as generateDrawMaticRound, index$m_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$m_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$m_generateFlightProfile as generateFlightProfile, index$m_generateLineUps as generateLineUps, index$m_generateQualifyingStructure as generateQualifyingStructure, index$m_generateSeedingScaleItems as generateSeedingScaleItems, index$m_generateStatCrew as generateStatCrew, index$m_generateVoluntaryConsolation as generateVoluntaryConsolation, index$m_roundRobinGroups as roundRobinGroups, }; } declare const index$l_isAggregateFormat: typeof isAggregateFormat; declare const index$l_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const index$l_parse: typeof parse; declare const index$l_stringify: typeof stringify; declare namespace index$l { export { index$l_isAggregateFormat as isAggregateFormat, isValidMatchUpFormat as isValid, index$l_isValidMatchUpFormat as isValidMatchUpFormat, index$l_parse as parse, index$l_stringify as stringify, }; } declare const mutate$c_applyLineUps: typeof applyLineUps; declare const mutate$c_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant; declare const mutate$c_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId; declare const mutate$c_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate; declare const mutate$c_checkInParticipant: typeof checkInParticipant; declare const mutate$c_checkOutParticipant: typeof checkOutParticipant; declare const mutate$c_disableTieAutoCalc: typeof disableTieAutoCalc; declare const mutate$c_enableTieAutoCalc: typeof enableTieAutoCalc; declare const mutate$c_removeDelegatedOutcome: typeof removeDelegatedOutcome; declare const mutate$c_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant; declare const mutate$c_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId; declare const mutate$c_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId; declare const mutate$c_resetAdHocMatchUps: typeof resetAdHocMatchUps; declare const mutate$c_resetMatchUpLineUps: typeof resetMatchUpLineUps; declare const mutate$c_resetScorecard: typeof resetScorecard; declare const mutate$c_resetTieFormat: typeof resetTieFormat; declare const mutate$c_setDelegatedOutcome: typeof setDelegatedOutcome; declare const mutate$c_setMatchUpFormat: typeof setMatchUpFormat; declare const mutate$c_setMatchUpState: typeof setMatchUpState; declare const mutate$c_setMatchUpStatus: typeof setMatchUpStatus; declare const mutate$c_setOrderOfFinish: typeof setOrderOfFinish; declare const mutate$c_substituteParticipant: typeof substituteParticipant; declare const mutate$c_toggleParticipantCheckInState: typeof toggleParticipantCheckInState; declare const mutate$c_updateTieMatchUpScore: typeof updateTieMatchUpScore; declare namespace mutate$c { export { mutate$c_applyLineUps as applyLineUps, mutate$c_assignMatchUpSideParticipant as assignMatchUpSideParticipant, mutate$c_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId, mutate$c_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate, mutate$c_checkInParticipant as checkInParticipant, mutate$c_checkOutParticipant as checkOutParticipant, mutate$c_disableTieAutoCalc as disableTieAutoCalc, mutate$c_enableTieAutoCalc as enableTieAutoCalc, publicFindMatchUp as findMatchUp, mutate$c_removeDelegatedOutcome as removeDelegatedOutcome, mutate$c_removeMatchUpSideParticipant as removeMatchUpSideParticipant, mutate$c_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId, mutate$c_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId, mutate$c_resetAdHocMatchUps as resetAdHocMatchUps, mutate$c_resetMatchUpLineUps as resetMatchUpLineUps, mutate$c_resetScorecard as resetScorecard, mutate$c_resetTieFormat as resetTieFormat, mutate$c_setDelegatedOutcome as setDelegatedOutcome, mutate$c_setMatchUpFormat as setMatchUpFormat, mutate$c_setMatchUpState as setMatchUpState, mutate$c_setMatchUpStatus as setMatchUpStatus, mutate$c_setOrderOfFinish as setOrderOfFinish, mutate$c_substituteParticipant as substituteParticipant, mutate$c_toggleParticipantCheckInState as toggleParticipantCheckInState, mutate$c_updateTieMatchUpScore as updateTieMatchUpScore, }; } declare const query$b_allCompetitionMatchUps: typeof allCompetitionMatchUps; declare const query$b_allDrawMatchUps: typeof allDrawMatchUps; declare const query$b_allEventMatchUps: typeof allEventMatchUps; declare const query$b_allTournamentMatchUps: typeof allTournamentMatchUps; declare const query$b_analyzeMatchUp: typeof analyzeMatchUp; declare const query$b_calculateMatchUpMargin: typeof calculateMatchUpMargin; declare const query$b_calculateWinCriteria: typeof calculateWinCriteria; declare const query$b_checkMatchUpIsComplete: typeof checkMatchUpIsComplete; declare const query$b_competitionScheduleMatchUps: typeof competitionScheduleMatchUps; declare const query$b_drawMatchUps: typeof drawMatchUps; declare const query$b_eventMatchUps: typeof eventMatchUps; declare const query$b_filterMatchUps: typeof filterMatchUps; declare const query$b_getAllDrawMatchUps: typeof getAllDrawMatchUps; declare const query$b_getAllStructureMatchUps: typeof getAllStructureMatchUps; declare const query$b_getCheckedInParticipantIds: typeof getCheckedInParticipantIds; declare const query$b_getCompetitionFormat: typeof getCompetitionFormat; declare const query$b_getCompetitionMatchUps: typeof getCompetitionMatchUps; declare const query$b_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming; declare const query$b_getHomeParticipantId: typeof getHomeParticipantId; declare const query$b_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile; declare const query$b_getMatchUpContextIds: typeof getMatchUpContextIds; declare const query$b_getMatchUpDailyLimits: typeof getMatchUpDailyLimits; declare const query$b_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate; declare const query$b_getMatchUpDependencies: typeof getMatchUpDependencies; declare const query$b_getMatchUpFormat: typeof getMatchUpFormat; declare const query$b_getMatchUpFormatTiming: typeof getMatchUpFormatTiming; declare const query$b_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate; declare const query$b_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails; declare const query$b_getMatchUpType: typeof getMatchUpType; declare const query$b_getMatchUpsStats: typeof getMatchUpsStats; declare const query$b_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming; declare const query$b_getParticipantResults: typeof getParticipantResults; declare const query$b_getPredictiveAccuracy: typeof getPredictiveAccuracy; declare const query$b_getRoundMatchUps: typeof getRoundMatchUps; declare const query$b_getRounds: typeof getRounds; declare const query$b_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const query$b_matchUpActions: typeof matchUpActions; declare const query$b_participantScheduledMatchUps: typeof participantScheduledMatchUps; declare const query$b_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands; declare const query$b_tallyParticipantResults: typeof tallyParticipantResults; declare const query$b_tournamentMatchUps: typeof tournamentMatchUps; declare const query$b_validMatchUp: typeof validMatchUp; declare const query$b_validMatchUps: typeof validMatchUps; declare namespace query$b { export { query$b_allCompetitionMatchUps as allCompetitionMatchUps, query$b_allDrawMatchUps as allDrawMatchUps, query$b_allEventMatchUps as allEventMatchUps, query$b_allTournamentMatchUps as allTournamentMatchUps, query$b_analyzeMatchUp as analyzeMatchUp, query$b_calculateMatchUpMargin as calculateMatchUpMargin, query$b_calculateWinCriteria as calculateWinCriteria, query$b_checkMatchUpIsComplete as checkMatchUpIsComplete, query$b_competitionScheduleMatchUps as competitionScheduleMatchUps, query$b_drawMatchUps as drawMatchUps, query$b_eventMatchUps as eventMatchUps, query$b_filterMatchUps as filterMatchUps, query$b_getAllDrawMatchUps as getAllDrawMatchUps, query$b_getAllStructureMatchUps as getAllStructureMatchUps, query$b_getCheckedInParticipantIds as getCheckedInParticipantIds, query$b_getCompetitionFormat as getCompetitionFormat, query$b_getCompetitionMatchUps as getCompetitionMatchUps, query$b_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming, query$b_getHomeParticipantId as getHomeParticipantId, query$b_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile, query$b_getMatchUpContextIds as getMatchUpContextIds, query$b_getMatchUpDailyLimits as getMatchUpDailyLimits, query$b_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate, query$b_getMatchUpDependencies as getMatchUpDependencies, query$b_getMatchUpFormat as getMatchUpFormat, query$b_getMatchUpFormatTiming as getMatchUpFormatTiming, query$b_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate, query$b_getMatchUpScheduleDetails as getMatchUpScheduleDetails, query$b_getMatchUpType as getMatchUpType, query$b_getMatchUpsStats as getMatchUpsStats, query$b_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming, query$b_getParticipantResults as getParticipantResults, query$b_getPredictiveAccuracy as getPredictiveAccuracy, query$b_getRoundMatchUps as getRoundMatchUps, query$b_getRounds as getRounds, query$b_isValidMatchUpFormat as isValidMatchUpFormat, query$b_matchUpActions as matchUpActions, query$b_participantScheduledMatchUps as participantScheduledMatchUps, query$b_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands, query$b_tallyParticipantResults as tallyParticipantResults, query$b_tournamentMatchUps as tournamentMatchUps, query$b_validMatchUp as validMatchUp, query$b_validMatchUps as validMatchUps, }; } declare const index$k_allCompetitionMatchUps: typeof allCompetitionMatchUps; declare const index$k_allDrawMatchUps: typeof allDrawMatchUps; declare const index$k_allEventMatchUps: typeof allEventMatchUps; declare const index$k_allTournamentMatchUps: typeof allTournamentMatchUps; declare const index$k_analyzeMatchUp: typeof analyzeMatchUp; declare const index$k_applyLineUps: typeof applyLineUps; declare const index$k_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant; declare const index$k_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId; declare const index$k_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate; declare const index$k_calculateMatchUpMargin: typeof calculateMatchUpMargin; declare const index$k_calculateWinCriteria: typeof calculateWinCriteria; declare const index$k_checkInParticipant: typeof checkInParticipant; declare const index$k_checkMatchUpIsComplete: typeof checkMatchUpIsComplete; declare const index$k_checkOutParticipant: typeof checkOutParticipant; declare const index$k_competitionScheduleMatchUps: typeof competitionScheduleMatchUps; declare const index$k_disableTieAutoCalc: typeof disableTieAutoCalc; declare const index$k_drawMatchUps: typeof drawMatchUps; declare const index$k_enableTieAutoCalc: typeof enableTieAutoCalc; declare const index$k_eventMatchUps: typeof eventMatchUps; declare const index$k_filterMatchUps: typeof filterMatchUps; declare const index$k_getAllDrawMatchUps: typeof getAllDrawMatchUps; declare const index$k_getAllStructureMatchUps: typeof getAllStructureMatchUps; declare const index$k_getCheckedInParticipantIds: typeof getCheckedInParticipantIds; declare const index$k_getCompetitionFormat: typeof getCompetitionFormat; declare const index$k_getCompetitionMatchUps: typeof getCompetitionMatchUps; declare const index$k_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming; declare const index$k_getHomeParticipantId: typeof getHomeParticipantId; declare const index$k_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile; declare const index$k_getMatchUpContextIds: typeof getMatchUpContextIds; declare const index$k_getMatchUpDailyLimits: typeof getMatchUpDailyLimits; declare const index$k_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate; declare const index$k_getMatchUpDependencies: typeof getMatchUpDependencies; declare const index$k_getMatchUpFormat: typeof getMatchUpFormat; declare const index$k_getMatchUpFormatTiming: typeof getMatchUpFormatTiming; declare const index$k_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate; declare const index$k_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails; declare const index$k_getMatchUpType: typeof getMatchUpType; declare const index$k_getMatchUpsStats: typeof getMatchUpsStats; declare const index$k_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming; declare const index$k_getParticipantResults: typeof getParticipantResults; declare const index$k_getPredictiveAccuracy: typeof getPredictiveAccuracy; declare const index$k_getRoundMatchUps: typeof getRoundMatchUps; declare const index$k_getRounds: typeof getRounds; declare const index$k_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const index$k_matchUpActions: typeof matchUpActions; declare const index$k_participantScheduledMatchUps: typeof participantScheduledMatchUps; declare const index$k_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands; declare const index$k_removeDelegatedOutcome: typeof removeDelegatedOutcome; declare const index$k_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant; declare const index$k_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId; declare const index$k_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId; declare const index$k_resetAdHocMatchUps: typeof resetAdHocMatchUps; declare const index$k_resetMatchUpLineUps: typeof resetMatchUpLineUps; declare const index$k_resetScorecard: typeof resetScorecard; declare const index$k_resetTieFormat: typeof resetTieFormat; declare const index$k_setDelegatedOutcome: typeof setDelegatedOutcome; declare const index$k_setMatchUpFormat: typeof setMatchUpFormat; declare const index$k_setMatchUpState: typeof setMatchUpState; declare const index$k_setMatchUpStatus: typeof setMatchUpStatus; declare const index$k_setOrderOfFinish: typeof setOrderOfFinish; declare const index$k_substituteParticipant: typeof substituteParticipant; declare const index$k_tallyParticipantResults: typeof tallyParticipantResults; declare const index$k_toggleParticipantCheckInState: typeof toggleParticipantCheckInState; declare const index$k_tournamentMatchUps: typeof tournamentMatchUps; declare const index$k_updateTieMatchUpScore: typeof updateTieMatchUpScore; declare const index$k_validMatchUp: typeof validMatchUp; declare const index$k_validMatchUps: typeof validMatchUps; declare namespace index$k { export { index$k_allCompetitionMatchUps as allCompetitionMatchUps, index$k_allDrawMatchUps as allDrawMatchUps, index$k_allEventMatchUps as allEventMatchUps, index$k_allTournamentMatchUps as allTournamentMatchUps, index$k_analyzeMatchUp as analyzeMatchUp, index$k_applyLineUps as applyLineUps, index$k_assignMatchUpSideParticipant as assignMatchUpSideParticipant, index$k_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId, index$k_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate, index$k_calculateMatchUpMargin as calculateMatchUpMargin, index$k_calculateWinCriteria as calculateWinCriteria, index$k_checkInParticipant as checkInParticipant, index$k_checkMatchUpIsComplete as checkMatchUpIsComplete, index$k_checkOutParticipant as checkOutParticipant, index$k_competitionScheduleMatchUps as competitionScheduleMatchUps, index$k_disableTieAutoCalc as disableTieAutoCalc, index$k_drawMatchUps as drawMatchUps, index$k_enableTieAutoCalc as enableTieAutoCalc, index$k_eventMatchUps as eventMatchUps, index$k_filterMatchUps as filterMatchUps, publicFindMatchUp as findMatchUp, index$k_getAllDrawMatchUps as getAllDrawMatchUps, index$k_getAllStructureMatchUps as getAllStructureMatchUps, index$k_getCheckedInParticipantIds as getCheckedInParticipantIds, index$k_getCompetitionFormat as getCompetitionFormat, index$k_getCompetitionMatchUps as getCompetitionMatchUps, index$k_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming, index$k_getHomeParticipantId as getHomeParticipantId, index$k_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile, index$k_getMatchUpContextIds as getMatchUpContextIds, index$k_getMatchUpDailyLimits as getMatchUpDailyLimits, index$k_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate, index$k_getMatchUpDependencies as getMatchUpDependencies, index$k_getMatchUpFormat as getMatchUpFormat, index$k_getMatchUpFormatTiming as getMatchUpFormatTiming, index$k_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate, index$k_getMatchUpScheduleDetails as getMatchUpScheduleDetails, index$k_getMatchUpType as getMatchUpType, index$k_getMatchUpsStats as getMatchUpsStats, index$k_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming, index$k_getParticipantResults as getParticipantResults, index$k_getPredictiveAccuracy as getPredictiveAccuracy, index$k_getRoundMatchUps as getRoundMatchUps, index$k_getRounds as getRounds, index$k_isValidMatchUpFormat as isValidMatchUpFormat, index$k_matchUpActions as matchUpActions, mutate$c as mutate, index$k_participantScheduledMatchUps as participantScheduledMatchUps, index$k_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands, query$b as query, index$k_removeDelegatedOutcome as removeDelegatedOutcome, index$k_removeMatchUpSideParticipant as removeMatchUpSideParticipant, index$k_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId, index$k_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId, index$k_resetAdHocMatchUps as resetAdHocMatchUps, index$k_resetMatchUpLineUps as resetMatchUpLineUps, index$k_resetScorecard as resetScorecard, index$k_resetTieFormat as resetTieFormat, index$k_setDelegatedOutcome as setDelegatedOutcome, index$k_setMatchUpFormat as setMatchUpFormat, index$k_setMatchUpState as setMatchUpState, index$k_setMatchUpStatus as setMatchUpStatus, index$k_setOrderOfFinish as setOrderOfFinish, index$k_substituteParticipant as substituteParticipant, index$k_tallyParticipantResults as tallyParticipantResults, index$k_toggleParticipantCheckInState as toggleParticipantCheckInState, index$k_tournamentMatchUps as tournamentMatchUps, index$k_updateTieMatchUpScore as updateTieMatchUpScore, index$k_validMatchUp as validMatchUp, index$k_validMatchUps as validMatchUps, }; } declare const generate$3_generateEventWithDraw: typeof generateEventWithDraw; declare const generate$3_generateOutcome: typeof generateOutcome; declare const generate$3_generateOutcomeFromScoreString: typeof generateOutcomeFromScoreString; declare const generate$3_generateParticipants: typeof generateParticipants; declare const generate$3_generateTournamentRecord: typeof generateTournamentRecord; declare namespace generate$3 { export { generate$3_generateEventWithDraw as generateEventWithDraw, generate$3_generateOutcome as generateOutcome, generate$3_generateOutcomeFromScoreString as generateOutcomeFromScoreString, generate$3_generateParticipants as generateParticipants, generate$3_generateTournamentRecord as generateTournamentRecord, }; } declare const mutate$b_anonymizeTournamentRecord: typeof anonymizeTournamentRecord; declare const mutate$b_completeDrawMatchUps: typeof completeDrawMatchUps; declare const mutate$b_modifyTournamentRecord: typeof modifyTournamentRecord; declare const mutate$b_removeMatchUpOutcome: typeof removeMatchUpOutcome; declare namespace mutate$b { export { mutate$b_anonymizeTournamentRecord as anonymizeTournamentRecord, mutate$b_completeDrawMatchUps as completeDrawMatchUps, mutate$b_modifyTournamentRecord as modifyTournamentRecord, mutate$b_removeMatchUpOutcome as removeMatchUpOutcome, }; } declare const index$j_anonymizeTournamentRecord: typeof anonymizeTournamentRecord; declare const index$j_completeDrawMatchUps: typeof completeDrawMatchUps; declare const index$j_generateEventWithDraw: typeof generateEventWithDraw; declare const index$j_generateOutcome: typeof generateOutcome; declare const index$j_generateOutcomeFromScoreString: typeof generateOutcomeFromScoreString; declare const index$j_generateParticipants: typeof generateParticipants; declare const index$j_generateTournamentRecord: typeof generateTournamentRecord; declare const index$j_modifyTournamentRecord: typeof modifyTournamentRecord; declare const index$j_removeMatchUpOutcome: typeof removeMatchUpOutcome; declare namespace index$j { export { index$j_anonymizeTournamentRecord as anonymizeTournamentRecord, index$j_completeDrawMatchUps as completeDrawMatchUps, generate$3 as generate, index$j_generateEventWithDraw as generateEventWithDraw, index$j_generateOutcome as generateOutcome, index$j_generateOutcomeFromScoreString as generateOutcomeFromScoreString, index$j_generateParticipants as generateParticipants, index$j_generateTournamentRecord as generateTournamentRecord, index$j_modifyTournamentRecord as modifyTournamentRecord, mutate$b as mutate, index$j_removeMatchUpOutcome as removeMatchUpOutcome, }; } declare const mutate$a_addDynamicRatings: typeof addDynamicRatings; declare const mutate$a_addIndividualParticipantIds: typeof addIndividualParticipantIds; declare const mutate$a_addParticipant: typeof addParticipant; declare const mutate$a_addParticipants: typeof addParticipants; declare const mutate$a_addPenalty: typeof addPenalty; declare const mutate$a_addPersonOtherId: typeof addPersonOtherId; declare const mutate$a_addPersonRequests: typeof addPersonRequests; declare const mutate$a_addPersons: typeof addPersons; declare const mutate$a_createGroupParticipant: typeof createGroupParticipant; declare const mutate$a_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes; declare const mutate$a_deleteParticipants: typeof deleteParticipants; declare const mutate$a_mergeParticipants: typeof mergeParticipants; declare const mutate$a_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds; declare const mutate$a_modifyParticipant: typeof modifyParticipant; declare const mutate$a_modifyParticipantName: typeof modifyParticipantName; declare const mutate$a_modifyParticipantOtherName: typeof modifyParticipantOtherName; declare const mutate$a_modifyParticipantsPaymentStatus: typeof modifyParticipantsPaymentStatus; declare const mutate$a_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus; declare const mutate$a_modifyPenalty: typeof modifyPenalty; declare const mutate$a_modifyPersonRequests: typeof modifyPersonRequests; declare const mutate$a_regenerateParticipantNames: typeof regenerateParticipantNames; declare const mutate$a_removeIndividualParticipantIds: typeof removeIndividualParticipantIds; declare const mutate$a_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams; declare const mutate$a_removePenalty: typeof removePenalty; declare const mutate$a_removePersonRequests: typeof removePersonRequests; declare const mutate$a_removeRatings: typeof removeRatings; declare const mutate$a_scaledTeamAssignment: typeof scaledTeamAssignment; declare const mutate$a_setParticipantScaleItem: typeof setParticipantScaleItem; declare const mutate$a_setParticipantScaleItems: typeof setParticipantScaleItems; declare namespace mutate$a { export { mutate$a_addDynamicRatings as addDynamicRatings, mutate$a_addIndividualParticipantIds as addIndividualParticipantIds, mutate$a_addParticipant as addParticipant, mutate$a_addParticipants as addParticipants, mutate$a_addPenalty as addPenalty, mutate$a_addPersonOtherId as addPersonOtherId, mutate$a_addPersonRequests as addPersonRequests, mutate$a_addPersons as addPersons, mutate$a_createGroupParticipant as createGroupParticipant, mutate$a_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes, mutate$a_deleteParticipants as deleteParticipants, publicFindParticipant as findParticipant, mutate$a_mergeParticipants as mergeParticipants, mutate$a_modifyIndividualParticipantIds as modifyIndividualParticipantIds, mutate$a_modifyParticipant as modifyParticipant, mutate$a_modifyParticipantName as modifyParticipantName, mutate$a_modifyParticipantOtherName as modifyParticipantOtherName, mutate$a_modifyParticipantsPaymentStatus as modifyParticipantsPaymentStatus, mutate$a_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus, mutate$a_modifyPenalty as modifyPenalty, mutate$a_modifyPersonRequests as modifyPersonRequests, mutate$a_regenerateParticipantNames as regenerateParticipantNames, mutate$a_removeIndividualParticipantIds as removeIndividualParticipantIds, mutate$a_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams, mutate$a_removePenalty as removePenalty, mutate$a_removePersonRequests as removePersonRequests, mutate$a_removeRatings as removeRatings, mutate$a_scaledTeamAssignment as scaledTeamAssignment, mutate$a_setParticipantScaleItem as setParticipantScaleItem, mutate$a_setParticipantScaleItems as setParticipantScaleItems, }; } declare const query$a_filterParticipants: typeof filterParticipants; declare const query$a_getCompetitionParticipants: typeof getCompetitionParticipants; declare const query$a_getPairedParticipant: typeof getPairedParticipant; declare const query$a_getParticipantEventDetails: typeof getParticipantEventDetails; declare const query$a_getParticipantMembership: typeof getParticipantMembership; declare const query$a_getParticipantPaymentStatus: typeof getParticipantPaymentStatus; declare const query$a_getParticipantScaleItem: typeof getParticipantScaleItem; declare const query$a_getParticipantSchedules: typeof getParticipantSchedules; declare const query$a_getParticipantSignInStatus: typeof getParticipantSignInStatus; declare const query$a_getParticipantTimeItem: typeof getParticipantTimeItem; declare const query$a_getParticipants: typeof getParticipants; declare const query$a_getScaleValues: typeof getScaleValues; declare const query$a_participantScaleItem: typeof participantScaleItem; declare const query$a_validateLineUp: typeof validateLineUp; declare namespace query$a { export { query$a_filterParticipants as filterParticipants, query$a_getCompetitionParticipants as getCompetitionParticipants, query$a_getPairedParticipant as getPairedParticipant, query$a_getParticipantEventDetails as getParticipantEventDetails, query$a_getParticipantMembership as getParticipantMembership, query$a_getParticipantPaymentStatus as getParticipantPaymentStatus, query$a_getParticipantScaleItem as getParticipantScaleItem, query$a_getParticipantSchedules as getParticipantSchedules, query$a_getParticipantSignInStatus as getParticipantSignInStatus, query$a_getParticipantTimeItem as getParticipantTimeItem, query$a_getParticipants as getParticipants, query$a_getScaleValues as getScaleValues, query$a_participantScaleItem as participantScaleItem, query$a_validateLineUp as validateLineUp, }; } declare const index$i_addDynamicRatings: typeof addDynamicRatings; declare const index$i_addIndividualParticipantIds: typeof addIndividualParticipantIds; declare const index$i_addParticipant: typeof addParticipant; declare const index$i_addParticipants: typeof addParticipants; declare const index$i_addPenalty: typeof addPenalty; declare const index$i_addPersonOtherId: typeof addPersonOtherId; declare const index$i_addPersonRequests: typeof addPersonRequests; declare const index$i_addPersons: typeof addPersons; declare const index$i_createGroupParticipant: typeof createGroupParticipant; declare const index$i_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes; declare const index$i_deleteParticipants: typeof deleteParticipants; declare const index$i_filterParticipants: typeof filterParticipants; declare const index$i_getCompetitionParticipants: typeof getCompetitionParticipants; declare const index$i_getPairedParticipant: typeof getPairedParticipant; declare const index$i_getParticipantEventDetails: typeof getParticipantEventDetails; declare const index$i_getParticipantMembership: typeof getParticipantMembership; declare const index$i_getParticipantPaymentStatus: typeof getParticipantPaymentStatus; declare const index$i_getParticipantScaleItem: typeof getParticipantScaleItem; declare const index$i_getParticipantSchedules: typeof getParticipantSchedules; declare const index$i_getParticipantSignInStatus: typeof getParticipantSignInStatus; declare const index$i_getParticipantTimeItem: typeof getParticipantTimeItem; declare const index$i_getParticipants: typeof getParticipants; declare const index$i_getScaleValues: typeof getScaleValues; declare const index$i_mergeParticipants: typeof mergeParticipants; declare const index$i_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds; declare const index$i_modifyParticipant: typeof modifyParticipant; declare const index$i_modifyParticipantName: typeof modifyParticipantName; declare const index$i_modifyParticipantOtherName: typeof modifyParticipantOtherName; declare const index$i_modifyParticipantsPaymentStatus: typeof modifyParticipantsPaymentStatus; declare const index$i_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus; declare const index$i_modifyPenalty: typeof modifyPenalty; declare const index$i_modifyPersonRequests: typeof modifyPersonRequests; declare const index$i_participantScaleItem: typeof participantScaleItem; declare const index$i_regenerateParticipantNames: typeof regenerateParticipantNames; declare const index$i_removeIndividualParticipantIds: typeof removeIndividualParticipantIds; declare const index$i_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams; declare const index$i_removePenalty: typeof removePenalty; declare const index$i_removePersonRequests: typeof removePersonRequests; declare const index$i_removeRatings: typeof removeRatings; declare const index$i_scaledTeamAssignment: typeof scaledTeamAssignment; declare const index$i_setParticipantScaleItem: typeof setParticipantScaleItem; declare const index$i_setParticipantScaleItems: typeof setParticipantScaleItems; declare const index$i_validateLineUp: typeof validateLineUp; declare namespace index$i { export { index$i_addDynamicRatings as addDynamicRatings, index$i_addIndividualParticipantIds as addIndividualParticipantIds, index$i_addParticipant as addParticipant, index$i_addParticipants as addParticipants, index$i_addPenalty as addPenalty, index$i_addPersonOtherId as addPersonOtherId, index$i_addPersonRequests as addPersonRequests, index$i_addPersons as addPersons, index$i_createGroupParticipant as createGroupParticipant, index$i_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes, index$i_deleteParticipants as deleteParticipants, index$i_filterParticipants as filterParticipants, publicFindParticipant as findParticipant, index$i_getCompetitionParticipants as getCompetitionParticipants, index$i_getPairedParticipant as getPairedParticipant, index$i_getParticipantEventDetails as getParticipantEventDetails, index$i_getParticipantMembership as getParticipantMembership, index$i_getParticipantPaymentStatus as getParticipantPaymentStatus, index$i_getParticipantScaleItem as getParticipantScaleItem, index$i_getParticipantSchedules as getParticipantSchedules, index$i_getParticipantSignInStatus as getParticipantSignInStatus, index$i_getParticipantTimeItem as getParticipantTimeItem, index$i_getParticipants as getParticipants, index$i_getScaleValues as getScaleValues, index$i_mergeParticipants as mergeParticipants, index$i_modifyIndividualParticipantIds as modifyIndividualParticipantIds, index$i_modifyParticipant as modifyParticipant, index$i_modifyParticipantName as modifyParticipantName, index$i_modifyParticipantOtherName as modifyParticipantOtherName, index$i_modifyParticipantsPaymentStatus as modifyParticipantsPaymentStatus, index$i_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus, index$i_modifyPenalty as modifyPenalty, index$i_modifyPersonRequests as modifyPersonRequests, mutate$a as mutate, index$i_participantScaleItem as participantScaleItem, query$a as query, index$i_regenerateParticipantNames as regenerateParticipantNames, index$i_removeIndividualParticipantIds as removeIndividualParticipantIds, index$i_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams, index$i_removePenalty as removePenalty, index$i_removePersonRequests as removePersonRequests, index$i_removeRatings as removeRatings, index$i_scaledTeamAssignment as scaledTeamAssignment, index$i_setParticipantScaleItem as setParticipantScaleItem, index$i_setParticipantScaleItems as setParticipantScaleItems, index$i_validateLineUp as validateLineUp, }; } declare const mutate$9_attachPolicies: typeof attachPolicies; declare const mutate$9_removePolicy: typeof removePolicy; declare namespace mutate$9 { export { mutate$9_attachPolicies as attachPolicies, mutate$9_removePolicy as removePolicy, }; } declare const query$9_findPolicy: typeof findPolicy; declare const query$9_getAppliedPolicies: typeof getAppliedPolicies; declare const query$9_getPolicyDefinitions: typeof getPolicyDefinitions; declare namespace query$9 { export { query$9_findPolicy as findPolicy, query$9_getAppliedPolicies as getAppliedPolicies, query$9_getPolicyDefinitions as getPolicyDefinitions, }; } declare const index$h_attachPolicies: typeof attachPolicies; declare const index$h_findPolicy: typeof findPolicy; declare const index$h_getAppliedPolicies: typeof getAppliedPolicies; declare const index$h_getPolicyDefinitions: typeof getPolicyDefinitions; declare const index$h_removePolicy: typeof removePolicy; declare namespace index$h { export { index$h_attachPolicies as attachPolicies, index$h_findPolicy as findPolicy, index$h_getAppliedPolicies as getAppliedPolicies, index$h_getPolicyDefinitions as getPolicyDefinitions, mutate$9 as mutate, query$9 as query, index$h_removePolicy as removePolicy, }; } declare const mutate$8_publishEvent: typeof publishEvent; declare const mutate$8_publishEventSeeding: typeof publishEventSeeding; declare const mutate$8_publishOrderOfPlay: typeof publishOrderOfPlay; declare const mutate$8_publishParticipants: typeof publishParticipants; declare const mutate$8_setEventDisplay: typeof setEventDisplay; declare const mutate$8_unPublishEvent: typeof unPublishEvent; declare const mutate$8_unPublishEventSeeding: typeof unPublishEventSeeding; declare const mutate$8_unPublishOrderOfPlay: typeof unPublishOrderOfPlay; declare const mutate$8_unPublishParticipants: typeof unPublishParticipants; declare namespace mutate$8 { export { mutate$8_publishEvent as publishEvent, mutate$8_publishEventSeeding as publishEventSeeding, mutate$8_publishOrderOfPlay as publishOrderOfPlay, mutate$8_publishParticipants as publishParticipants, mutate$8_setEventDisplay as setEventDisplay, mutate$8_unPublishEvent as unPublishEvent, mutate$8_unPublishEventSeeding as unPublishEventSeeding, mutate$8_unPublishOrderOfPlay as unPublishOrderOfPlay, mutate$8_unPublishParticipants as unPublishParticipants, }; } declare const query$8_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds; declare const query$8_getAllEventData: typeof getAllEventData; declare const query$8_getCourtInfo: typeof getCourtInfo; declare const query$8_getDrawData: typeof getDrawData; declare const query$8_getEventData: typeof getEventData; declare const query$8_getEventPublishStatus: typeof getEventPublishStatus; declare const query$8_getPublishState: typeof getPublishState; declare const query$8_getRoundVisibilityState: typeof getRoundVisibilityState; declare const query$8_getTournamentPublishStatus: typeof getTournamentPublishStatus; declare const query$8_getVenueData: typeof getVenueData; declare const query$8_isEmbargoed: typeof isEmbargoed; declare const query$8_isVisiblyPublished: typeof isVisiblyPublished; declare namespace query$8 { export { query$8_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds, query$8_getAllEventData as getAllEventData, query$8_getCourtInfo as getCourtInfo, query$8_getDrawData as getDrawData, query$8_getEventData as getEventData, query$8_getEventPublishStatus as getEventPublishStatus, query$8_getPublishState as getPublishState, query$8_getRoundVisibilityState as getRoundVisibilityState, query$8_getTournamentPublishStatus as getTournamentPublishStatus, query$8_getVenueData as getVenueData, query$8_isEmbargoed as isEmbargoed, query$8_isVisiblyPublished as isVisiblyPublished, }; } declare const index$g_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds; declare const index$g_getAllEventData: typeof getAllEventData; declare const index$g_getCourtInfo: typeof getCourtInfo; declare const index$g_getDrawData: typeof getDrawData; declare const index$g_getEventData: typeof getEventData; declare const index$g_getEventPublishStatus: typeof getEventPublishStatus; declare const index$g_getPublishState: typeof getPublishState; declare const index$g_getRoundVisibilityState: typeof getRoundVisibilityState; declare const index$g_getTournamentPublishStatus: typeof getTournamentPublishStatus; declare const index$g_getVenueData: typeof getVenueData; declare const index$g_isEmbargoed: typeof isEmbargoed; declare const index$g_isVisiblyPublished: typeof isVisiblyPublished; declare const index$g_publishEvent: typeof publishEvent; declare const index$g_publishEventSeeding: typeof publishEventSeeding; declare const index$g_publishOrderOfPlay: typeof publishOrderOfPlay; declare const index$g_publishParticipants: typeof publishParticipants; declare const index$g_setEventDisplay: typeof setEventDisplay; declare const index$g_unPublishEvent: typeof unPublishEvent; declare const index$g_unPublishEventSeeding: typeof unPublishEventSeeding; declare const index$g_unPublishOrderOfPlay: typeof unPublishOrderOfPlay; declare const index$g_unPublishParticipants: typeof unPublishParticipants; declare namespace index$g { export { index$g_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds, index$g_getAllEventData as getAllEventData, index$g_getCourtInfo as getCourtInfo, index$g_getDrawData as getDrawData, index$g_getEventData as getEventData, index$g_getEventPublishStatus as getEventPublishStatus, index$g_getPublishState as getPublishState, index$g_getRoundVisibilityState as getRoundVisibilityState, index$g_getTournamentPublishStatus as getTournamentPublishStatus, index$g_getVenueData as getVenueData, index$g_isEmbargoed as isEmbargoed, index$g_isVisiblyPublished as isVisiblyPublished, mutate$8 as mutate, index$g_publishEvent as publishEvent, index$g_publishEventSeeding as publishEventSeeding, index$g_publishOrderOfPlay as publishOrderOfPlay, index$g_publishParticipants as publishParticipants, query$8 as query, index$g_setEventDisplay as setEventDisplay, index$g_unPublishEvent as unPublishEvent, index$g_unPublishEventSeeding as unPublishEventSeeding, index$g_unPublishOrderOfPlay as unPublishOrderOfPlay, index$g_unPublishParticipants as unPublishParticipants, }; } declare const query$7_analyzeDraws: typeof analyzeDraws; declare const query$7_analyzeTournament: typeof analyzeTournament; declare const query$7_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks; declare const query$7_getAggregateTeamResults: typeof getAggregateTeamResults; declare const query$7_getAllowedDrawTypes: typeof getAllowedDrawTypes; declare const query$7_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats; declare const query$7_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels; declare const query$7_getAppliedPolicies: typeof getAppliedPolicies; declare const query$7_getCompetitionDateRange: typeof getCompetitionDateRange; declare const query$7_getCompetitionPenalties: typeof getCompetitionPenalties; declare const query$7_getEventRankingPoints: typeof getEventRankingPoints; declare const query$7_getMutationLocks: typeof getMutationLocks; declare const query$7_getPolicyDefinitions: typeof getPolicyDefinitions; declare const query$7_getRegistrationProfile: typeof getRegistrationProfile; declare const query$7_getTournamentInfo: typeof getTournamentInfo; declare const query$7_getTournamentPenalties: typeof getTournamentPenalties; declare const query$7_getTournamentPersons: typeof getTournamentPersons; declare const query$7_getTournamentPoints: typeof getTournamentPoints; declare const query$7_getTournamentStructures: typeof getTournamentStructures; declare const query$7_getTournamentTimeItem: typeof getTournamentTimeItem; declare const query$7_suggestFormatPlans: typeof suggestFormatPlans; declare namespace query$7 { export { query$7_analyzeDraws as analyzeDraws, query$7_analyzeTournament as analyzeTournament, query$7_cleanExpiredMutationLocks as cleanExpiredMutationLocks, query$7_getAggregateTeamResults as getAggregateTeamResults, query$7_getAllowedDrawTypes as getAllowedDrawTypes, query$7_getAllowedMatchUpFormats as getAllowedMatchUpFormats, query$7_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels, query$7_getAppliedPolicies as getAppliedPolicies, query$7_getCompetitionDateRange as getCompetitionDateRange, query$7_getCompetitionPenalties as getCompetitionPenalties, query$7_getEventRankingPoints as getEventRankingPoints, query$7_getMutationLocks as getMutationLocks, query$7_getPolicyDefinitions as getPolicyDefinitions, query$7_getRegistrationProfile as getRegistrationProfile, query$7_getTournamentInfo as getTournamentInfo, query$7_getTournamentPenalties as getTournamentPenalties, query$7_getTournamentPersons as getTournamentPersons, query$7_getTournamentPoints as getTournamentPoints, query$7_getTournamentStructures as getTournamentStructures, query$7_getTournamentTimeItem as getTournamentTimeItem, query$7_suggestFormatPlans as suggestFormatPlans, }; } declare const query$6_compareTieFormats: typeof compareTieFormats; declare const query$6_getTieFormat: typeof getTieFormat; declare const query$6_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck; declare const query$6_validateCollectionDefinition: typeof validateCollectionDefinition; declare namespace query$6 { export { query$6_compareTieFormats as compareTieFormats, query$6_getTieFormat as getTieFormat, query$6_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck, query$6_validateCollectionDefinition as validateCollectionDefinition, }; } declare const query$5_courtGridRows: typeof courtGridRows; declare const query$5_findVenue: typeof findVenue; declare const query$5_getMatchUpsToSchedule: typeof getMatchUpsToSchedule; declare const query$5_getPersonRequests: typeof getPersonRequests; declare const query$5_getProfileRounds: typeof getProfileRounds; declare const query$5_getScheduledRoundsDetails: typeof getScheduledRoundsDetails; declare const query$5_getSchedulingProfile: typeof getSchedulingProfile; declare const query$5_getSchedulingProfileIssues: typeof getSchedulingProfileIssues; declare const query$5_publicFindCourt: typeof publicFindCourt; declare namespace query$5 { export { query$5_courtGridRows as courtGridRows, query$5_findVenue as findVenue, query$5_getMatchUpsToSchedule as getMatchUpsToSchedule, query$5_getPersonRequests as getPersonRequests, query$5_getProfileRounds as getProfileRounds, query$5_getScheduledRoundsDetails as getScheduledRoundsDetails, query$5_getSchedulingProfile as getSchedulingProfile, query$5_getSchedulingProfileIssues as getSchedulingProfileIssues, query$5_publicFindCourt as publicFindCourt, }; } declare const query$4_getCompetitionVenues: typeof getCompetitionVenues; declare const query$4_getCourts: typeof getCourts; declare const query$4_getVenuesAndCourts: typeof getVenuesAndCourts; declare const query$4_publicFindVenue: typeof publicFindVenue; declare namespace query$4 { export { query$4_getCompetitionVenues as getCompetitionVenues, query$4_getCourts as getCourts, query$4_getVenuesAndCourts as getVenuesAndCourts, query$4_publicFindVenue as publicFindVenue, }; } declare const index$f_addGoesTo: typeof addGoesTo; declare const index$f_allCompetitionMatchUps: typeof allCompetitionMatchUps; declare const index$f_allDrawMatchUps: typeof allDrawMatchUps; declare const index$f_allEventMatchUps: typeof allEventMatchUps; declare const index$f_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled; declare const index$f_allTournamentMatchUps: typeof allTournamentMatchUps; declare const index$f_analyzeDraws: typeof analyzeDraws; declare const index$f_analyzeMatchUp: typeof analyzeMatchUp; declare const index$f_analyzeTournament: typeof analyzeTournament; declare const index$f_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds; declare const index$f_calculateMatchUpMargin: typeof calculateMatchUpMargin; declare const index$f_calculateWinCriteria: typeof calculateWinCriteria; declare const index$f_categoryCanContain: typeof categoryCanContain; declare const index$f_checkMatchUpIsComplete: typeof checkMatchUpIsComplete; declare const index$f_checkValidEntries: typeof checkValidEntries; declare const index$f_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks; declare const index$f_compareTieFormats: typeof compareTieFormats; declare const index$f_competitionScheduleMatchUps: typeof competitionScheduleMatchUps; declare const index$f_courtGridRows: typeof courtGridRows; declare const index$f_credits: typeof credits; declare const index$f_drawMatchUps: typeof drawMatchUps; declare const index$f_eventMatchUps: typeof eventMatchUps; declare const index$f_filterMatchUps: typeof filterMatchUps; declare const index$f_filterParticipants: typeof filterParticipants; declare const index$f_findExtension: typeof findExtension; declare const index$f_findVenue: typeof findVenue; declare const index$f_getAggregateTeamResults: typeof getAggregateTeamResults; declare const index$f_getAllDrawMatchUps: typeof getAllDrawMatchUps; declare const index$f_getAllEventData: typeof getAllEventData; declare const index$f_getAllStructureMatchUps: typeof getAllStructureMatchUps; declare const index$f_getAllowedDrawTypes: typeof getAllowedDrawTypes; declare const index$f_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats; declare const index$f_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels; declare const index$f_getAppliedPolicies: typeof getAppliedPolicies; declare const index$f_getAssignedParticipantIds: typeof getAssignedParticipantIds; declare const index$f_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount; declare const index$f_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles; declare const index$f_getCategoryAgeDetails: typeof getCategoryAgeDetails; declare const index$f_getCheckedInParticipantIds: typeof getCheckedInParticipantIds; declare const index$f_getCompetitionDateRange: typeof getCompetitionDateRange; declare const index$f_getCompetitionFormat: typeof getCompetitionFormat; declare const index$f_getCompetitionLeaderboard: typeof getCompetitionLeaderboard; declare const index$f_getCompetitionMatchUps: typeof getCompetitionMatchUps; declare const index$f_getCompetitionParticipantState: typeof getCompetitionParticipantState; declare const index$f_getCompetitionParticipants: typeof getCompetitionParticipants; declare const index$f_getCompetitionPenalties: typeof getCompetitionPenalties; declare const index$f_getCompetitionPolicy: typeof getCompetitionPolicy; declare const index$f_getCompetitionState: typeof getCompetitionState; declare const index$f_getCompetitionVenues: typeof getCompetitionVenues; declare const index$f_getCourtInfo: typeof getCourtInfo; declare const index$f_getCourts: typeof getCourts; declare const index$f_getDraftState: typeof getDraftState; declare const index$f_getDrawData: typeof getDrawData; declare const index$f_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem; declare const index$f_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds; declare const index$f_getDrawStructures: typeof getDrawStructures; declare const index$f_getDrawTypeCoercion: typeof getDrawTypeCoercion; declare const index$f_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants; declare const index$f_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount; declare const index$f_getEvent: typeof getEvent; declare const index$f_getEventData: typeof getEventData; declare const index$f_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming; declare const index$f_getEventProperties: typeof getEventProperties; declare const index$f_getEventPublishStatus: typeof getEventPublishStatus; declare const index$f_getEventRankingPoints: typeof getEventRankingPoints; declare const index$f_getEventStructures: typeof getEventStructures; declare const index$f_getEventTimeItem: typeof getEventTimeItem; declare const index$f_getEvents: typeof getEvents; declare const index$f_getFlightProfile: typeof getFlightProfile; declare const index$f_getHomeParticipantId: typeof getHomeParticipantId; declare const index$f_getLinkedTournamentIds: typeof getLinkedTournamentIds; declare const index$f_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus; declare const index$f_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile; declare const index$f_getMatchUpContextIds: typeof getMatchUpContextIds; declare const index$f_getMatchUpDailyLimits: typeof getMatchUpDailyLimits; declare const index$f_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate; declare const index$f_getMatchUpDependencies: typeof getMatchUpDependencies; declare const index$f_getMatchUpFormat: typeof getMatchUpFormat; declare const index$f_getMatchUpFormatTiming: typeof getMatchUpFormatTiming; declare const index$f_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate; declare const index$f_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails; declare const index$f_getMatchUpType: typeof getMatchUpType; declare const index$f_getMatchUpsMap: typeof getMatchUpsMap; declare const index$f_getMatchUpsStats: typeof getMatchUpsStats; declare const index$f_getMatchUpsToSchedule: typeof getMatchUpsToSchedule; declare const index$f_getMaxEntryPosition: typeof getMaxEntryPosition; declare const index$f_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming; declare const index$f_getMutationLocks: typeof getMutationLocks; declare const index$f_getPairedParticipant: typeof getPairedParticipant; declare const index$f_getParticipantEventDetails: typeof getParticipantEventDetails; declare const index$f_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions; declare const index$f_getParticipantMembership: typeof getParticipantMembership; declare const index$f_getParticipantPaymentStatus: typeof getParticipantPaymentStatus; declare const index$f_getParticipantResults: typeof getParticipantResults; declare const index$f_getParticipantScaleItem: typeof getParticipantScaleItem; declare const index$f_getParticipantSchedules: typeof getParticipantSchedules; declare const index$f_getParticipantSignInStatus: typeof getParticipantSignInStatus; declare const index$f_getParticipantTimeItem: typeof getParticipantTimeItem; declare const index$f_getParticipants: typeof getParticipants; declare const index$f_getPersonRequests: typeof getPersonRequests; declare const index$f_getPolicyDefinitions: typeof getPolicyDefinitions; declare const index$f_getPositionAssignments: typeof getPositionAssignments; declare const index$f_getPositionsPlayedOff: typeof getPositionsPlayedOff; declare const index$f_getPredictiveAccuracy: typeof getPredictiveAccuracy; declare const index$f_getProfileRounds: typeof getProfileRounds; declare const index$f_getPublishState: typeof getPublishState; declare const index$f_getRandomQualifierList: typeof getRandomQualifierList; declare const index$f_getRegistrationProfile: typeof getRegistrationProfile; declare const index$f_getRoundMatchUps: typeof getRoundMatchUps; declare const index$f_getRoundVisibilityState: typeof getRoundVisibilityState; declare const index$f_getRounds: typeof getRounds; declare const index$f_getScaleValues: typeof getScaleValues; declare const index$f_getScaledEntries: typeof getScaledEntries; declare const index$f_getScheduledRoundsDetails: typeof getScheduledRoundsDetails; declare const index$f_getSchedulingProfile: typeof getSchedulingProfile; declare const index$f_getSchedulingProfileIssues: typeof getSchedulingProfileIssues; declare const index$f_getSeedingThresholds: typeof getSeedingThresholds; declare const index$f_getSeedsCount: typeof getSeedsCount; declare const index$f_getStructureSeedAssignments: typeof getStructureSeedAssignments; declare const index$f_getSwissChart: typeof getSwissChart; declare const index$f_getSwissStandings: typeof getSwissStandings; declare const index$f_getTally: typeof getTally; declare const index$f_getTeamLineUp: typeof getTeamLineUp; declare const index$f_getTieFormat: typeof getTieFormat; declare const index$f_getTimeItem: typeof getTimeItem; declare const index$f_getTournamentIds: typeof getTournamentIds; declare const index$f_getTournamentInfo: typeof getTournamentInfo; declare const index$f_getTournamentPenalties: typeof getTournamentPenalties; declare const index$f_getTournamentPersons: typeof getTournamentPersons; declare const index$f_getTournamentPoints: typeof getTournamentPoints; declare const index$f_getTournamentPublishStatus: typeof getTournamentPublishStatus; declare const index$f_getTournamentStructures: typeof getTournamentStructures; declare const index$f_getTournamentTimeItem: typeof getTournamentTimeItem; declare const index$f_getValidGroupSizes: typeof getValidGroupSizes; declare const index$f_getVenueData: typeof getVenueData; declare const index$f_getVenuesAndCourts: typeof getVenuesAndCourts; declare const index$f_hasLuckyRounds: typeof hasLuckyRounds; declare const index$f_isAdHoc: typeof isAdHoc; declare const index$f_isCompletedStructure: typeof isCompletedStructure; declare const index$f_isEmbargoed: typeof isEmbargoed; declare const index$f_isValidForQualifying: typeof isValidForQualifying; declare const index$f_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const index$f_isVisiblyPublished: typeof isVisiblyPublished; declare const index$f_matchUpActions: typeof matchUpActions; declare const index$f_participantScaleItem: typeof participantScaleItem; declare const index$f_participantScheduledMatchUps: typeof participantScheduledMatchUps; declare const index$f_positionActions: typeof positionActions; declare const index$f_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands; declare const index$f_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands; declare const index$f_publicFindCourt: typeof publicFindCourt; declare const index$f_publicFindVenue: typeof publicFindVenue; declare const index$f_suggestFormatPlans: typeof suggestFormatPlans; declare const index$f_tallyParticipantResults: typeof tallyParticipantResults; declare const index$f_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck; declare const index$f_tournamentMatchUps: typeof tournamentMatchUps; declare const index$f_validMatchUp: typeof validMatchUp; declare const index$f_validMatchUps: typeof validMatchUps; declare const index$f_validateCollectionDefinition: typeof validateCollectionDefinition; declare const index$f_validateLineUp: typeof validateLineUp; declare const index$f_validatePlayoffGroups: typeof validatePlayoffGroups; declare namespace index$f { export { index$f_addGoesTo as addGoesTo, index$f_allCompetitionMatchUps as allCompetitionMatchUps, index$f_allDrawMatchUps as allDrawMatchUps, index$f_allEventMatchUps as allEventMatchUps, index$f_allPlayoffPositionsFilled as allPlayoffPositionsFilled, index$f_allTournamentMatchUps as allTournamentMatchUps, index$f_analyzeDraws as analyzeDraws, index$f_analyzeMatchUp as analyzeMatchUp, index$f_analyzeTournament as analyzeTournament, index$f_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds, index$f_calculateMatchUpMargin as calculateMatchUpMargin, index$f_calculateWinCriteria as calculateWinCriteria, index$f_categoryCanContain as categoryCanContain, index$f_checkMatchUpIsComplete as checkMatchUpIsComplete, index$f_checkValidEntries as checkValidEntries, index$f_cleanExpiredMutationLocks as cleanExpiredMutationLocks, index$f_compareTieFormats as compareTieFormats, index$f_competitionScheduleMatchUps as competitionScheduleMatchUps, index$f_courtGridRows as courtGridRows, index$f_credits as credits, index$f_drawMatchUps as drawMatchUps, index$f_eventMatchUps as eventMatchUps, index$f_filterMatchUps as filterMatchUps, index$f_filterParticipants as filterParticipants, publicFindDrawDefinition as findDrawDefinition, index$f_findExtension as findExtension, index$f_findVenue as findVenue, index$f_getAggregateTeamResults as getAggregateTeamResults, index$f_getAllDrawMatchUps as getAllDrawMatchUps, index$f_getAllEventData as getAllEventData, index$f_getAllStructureMatchUps as getAllStructureMatchUps, index$f_getAllowedDrawTypes as getAllowedDrawTypes, index$f_getAllowedMatchUpFormats as getAllowedMatchUpFormats, index$f_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels, index$f_getAppliedPolicies as getAppliedPolicies, index$f_getAssignedParticipantIds as getAssignedParticipantIds, index$f_getAvailableMatchUpsCount as getAvailableMatchUpsCount, index$f_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles, index$f_getCategoryAgeDetails as getCategoryAgeDetails, index$f_getCheckedInParticipantIds as getCheckedInParticipantIds, index$f_getCompetitionDateRange as getCompetitionDateRange, index$f_getCompetitionFormat as getCompetitionFormat, index$f_getCompetitionLeaderboard as getCompetitionLeaderboard, index$f_getCompetitionMatchUps as getCompetitionMatchUps, index$f_getCompetitionParticipantState as getCompetitionParticipantState, index$f_getCompetitionParticipants as getCompetitionParticipants, index$f_getCompetitionPenalties as getCompetitionPenalties, index$f_getCompetitionPolicy as getCompetitionPolicy, index$f_getCompetitionState as getCompetitionState, index$f_getCompetitionVenues as getCompetitionVenues, index$f_getCourtInfo as getCourtInfo, index$f_getCourts as getCourts, index$f_getDraftState as getDraftState, index$f_getDrawData as getDrawData, index$f_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem, index$f_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds, index$f_getDrawStructures as getDrawStructures, index$f_getDrawTypeCoercion as getDrawTypeCoercion, index$f_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants, index$f_getEntriesAndSeedsCount as getEntriesAndSeedsCount, index$f_getEvent as getEvent, index$f_getEventData as getEventData, index$f_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming, index$f_getEventProperties as getEventProperties, index$f_getEventPublishStatus as getEventPublishStatus, index$f_getEventRankingPoints as getEventRankingPoints, index$f_getEventStructures as getEventStructures, index$f_getEventTimeItem as getEventTimeItem, index$f_getEvents as getEvents, index$f_getFlightProfile as getFlightProfile, index$f_getHomeParticipantId as getHomeParticipantId, index$f_getLinkedTournamentIds as getLinkedTournamentIds, index$f_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus, index$f_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile, index$f_getMatchUpContextIds as getMatchUpContextIds, index$f_getMatchUpDailyLimits as getMatchUpDailyLimits, index$f_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate, index$f_getMatchUpDependencies as getMatchUpDependencies, index$f_getMatchUpFormat as getMatchUpFormat, index$f_getMatchUpFormatTiming as getMatchUpFormatTiming, index$f_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate, index$f_getMatchUpScheduleDetails as getMatchUpScheduleDetails, index$f_getMatchUpType as getMatchUpType, index$f_getMatchUpsMap as getMatchUpsMap, index$f_getMatchUpsStats as getMatchUpsStats, index$f_getMatchUpsToSchedule as getMatchUpsToSchedule, index$f_getMaxEntryPosition as getMaxEntryPosition, index$f_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming, index$f_getMutationLocks as getMutationLocks, index$f_getPairedParticipant as getPairedParticipant, index$f_getParticipantEventDetails as getParticipantEventDetails, index$f_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions, index$f_getParticipantMembership as getParticipantMembership, index$f_getParticipantPaymentStatus as getParticipantPaymentStatus, index$f_getParticipantResults as getParticipantResults, index$f_getParticipantScaleItem as getParticipantScaleItem, index$f_getParticipantSchedules as getParticipantSchedules, index$f_getParticipantSignInStatus as getParticipantSignInStatus, index$f_getParticipantTimeItem as getParticipantTimeItem, index$f_getParticipants as getParticipants, index$f_getPersonRequests as getPersonRequests, index$f_getPolicyDefinitions as getPolicyDefinitions, index$f_getPositionAssignments as getPositionAssignments, index$f_getPositionsPlayedOff as getPositionsPlayedOff, index$f_getPredictiveAccuracy as getPredictiveAccuracy, index$f_getProfileRounds as getProfileRounds, index$f_getPublishState as getPublishState, index$f_getRandomQualifierList as getRandomQualifierList, index$f_getRegistrationProfile as getRegistrationProfile, index$f_getRoundMatchUps as getRoundMatchUps, index$f_getRoundVisibilityState as getRoundVisibilityState, index$f_getRounds as getRounds, index$f_getScaleValues as getScaleValues, index$f_getScaledEntries as getScaledEntries, index$f_getScheduledRoundsDetails as getScheduledRoundsDetails, index$f_getSchedulingProfile as getSchedulingProfile, index$f_getSchedulingProfileIssues as getSchedulingProfileIssues, index$f_getSeedingThresholds as getSeedingThresholds, index$f_getSeedsCount as getSeedsCount, index$f_getStructureSeedAssignments as getStructureSeedAssignments, index$f_getSwissChart as getSwissChart, index$f_getSwissStandings as getSwissStandings, index$f_getTally as getTally, index$f_getTeamLineUp as getTeamLineUp, index$f_getTieFormat as getTieFormat, index$f_getTimeItem as getTimeItem, index$f_getTournamentIds as getTournamentIds, index$f_getTournamentInfo as getTournamentInfo, index$f_getTournamentPenalties as getTournamentPenalties, index$f_getTournamentPersons as getTournamentPersons, index$f_getTournamentPoints as getTournamentPoints, index$f_getTournamentPublishStatus as getTournamentPublishStatus, index$f_getTournamentStructures as getTournamentStructures, index$f_getTournamentTimeItem as getTournamentTimeItem, index$f_getValidGroupSizes as getValidGroupSizes, index$f_getVenueData as getVenueData, index$f_getVenuesAndCourts as getVenuesAndCourts, index$f_hasLuckyRounds as hasLuckyRounds, index$f_isAdHoc as isAdHoc, index$f_isCompletedStructure as isCompletedStructure, index$f_isEmbargoed as isEmbargoed, index$f_isValidForQualifying as isValidForQualifying, index$f_isValidMatchUpFormat as isValidMatchUpFormat, index$f_isVisiblyPublished as isVisiblyPublished, index$f_matchUpActions as matchUpActions, index$f_participantScaleItem as participantScaleItem, index$f_participantScheduledMatchUps as participantScheduledMatchUps, index$f_positionActions as positionActions, index$f_predictDrawCompetitiveBands as predictDrawCompetitiveBands, index$f_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands, index$f_publicFindCourt as publicFindCourt, index$f_publicFindVenue as publicFindVenue, index$f_suggestFormatPlans as suggestFormatPlans, index$f_tallyParticipantResults as tallyParticipantResults, index$f_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck, index$f_tournamentMatchUps as tournamentMatchUps, index$f_validMatchUp as validMatchUp, index$f_validMatchUps as validMatchUps, index$f_validateCollectionDefinition as validateCollectionDefinition, index$f_validateLineUp as validateLineUp, index$f_validatePlayoffGroups as validatePlayoffGroups, }; } declare const query$3_applyDerivedRankings: typeof applyDerivedRankings; declare const query$3_generateRankingList: typeof generateRankingList; declare const query$3_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels; declare const query$3_getAwardPoints: typeof getAwardPoints; declare const query$3_getAwardProfile: typeof getAwardProfile; declare const query$3_getEventRankingPoints: typeof getEventRankingPoints; declare const query$3_getParticipantPoints: typeof getParticipantPoints; declare const query$3_getQualityWinPoints: typeof getQualityWinPoints; declare const query$3_getTournamentPointAwards: typeof getTournamentPointAwards; declare const query$3_getTournamentPoints: typeof getTournamentPoints; declare namespace query$3 { export { query$3_applyDerivedRankings as applyDerivedRankings, query$3_generateRankingList as generateRankingList, query$3_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels, query$3_getAwardPoints as getAwardPoints, query$3_getAwardProfile as getAwardProfile, query$3_getEventRankingPoints as getEventRankingPoints, query$3_getParticipantPoints as getParticipantPoints, query$3_getQualityWinPoints as getQualityWinPoints, query$3_getTournamentPointAwards as getTournamentPointAwards, query$3_getTournamentPoints as getTournamentPoints, }; } declare const mutate$7_applyTournamentRankingPoints: typeof applyTournamentRankingPoints; declare namespace mutate$7 { export { mutate$7_applyTournamentRankingPoints as applyTournamentRankingPoints, }; } declare const index$e_applyDerivedRankings: typeof applyDerivedRankings; declare const index$e_applyTournamentRankingPoints: typeof applyTournamentRankingPoints; declare const index$e_generateRankingList: typeof generateRankingList; declare const index$e_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels; declare const index$e_getAwardPoints: typeof getAwardPoints; declare const index$e_getAwardProfile: typeof getAwardProfile; declare const index$e_getEventRankingPoints: typeof getEventRankingPoints; declare const index$e_getParticipantPoints: typeof getParticipantPoints; declare const index$e_getQualityWinPoints: typeof getQualityWinPoints; declare const index$e_getTournamentPointAwards: typeof getTournamentPointAwards; declare const index$e_getTournamentPoints: typeof getTournamentPoints; declare namespace index$e { export { index$e_applyDerivedRankings as applyDerivedRankings, index$e_applyTournamentRankingPoints as applyTournamentRankingPoints, index$e_generateRankingList as generateRankingList, index$e_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels, index$e_getAwardPoints as getAwardPoints, index$e_getAwardProfile as getAwardProfile, index$e_getEventRankingPoints as getEventRankingPoints, index$e_getParticipantPoints as getParticipantPoints, index$e_getQualityWinPoints as getQualityWinPoints, index$e_getTournamentPointAwards as getTournamentPointAwards, index$e_getTournamentPoints as getTournamentPoints, mutate$7 as mutate, query$3 as query, }; } declare const index$d_buildReportContext: typeof buildReportContext; declare const index$d_generateReport: typeof generateReport; declare const index$d_getAvailableReports: typeof getAvailableReports; declare const index$d_getEntryStatusReports: typeof getEntryStatusReports; declare const index$d_getParticipantStats: typeof getParticipantStats; declare const index$d_getStructureReports: typeof getStructureReports; declare const index$d_getVenuesReport: typeof getVenuesReport; declare namespace index$d { export { index$d_buildReportContext as buildReportContext, index$d_generateReport as generateReport, index$d_getAvailableReports as getAvailableReports, index$d_getEntryStatusReports as getEntryStatusReports, index$d_getParticipantStats as getParticipantStats, index$d_getStructureReports as getStructureReports, index$d_getVenuesReport as getVenuesReport, }; } declare const mutate$6_addCourtGridBooking: typeof addCourtGridBooking; declare const mutate$6_addMatchUpCourtOrder: typeof addMatchUpCourtOrder; declare const mutate$6_addMatchUpEndTime: typeof addMatchUpEndTime; declare const mutate$6_addMatchUpOfficial: typeof addMatchUpOfficial; declare const mutate$6_addMatchUpResumeTime: typeof addMatchUpResumeTime; declare const mutate$6_addMatchUpScheduleItems: typeof addMatchUpScheduleItems; declare const mutate$6_addMatchUpScheduledDate: typeof addMatchUpScheduledDate; declare const mutate$6_addMatchUpScheduledTime: typeof addMatchUpScheduledTime; declare const mutate$6_addMatchUpStartTime: typeof addMatchUpStartTime; declare const mutate$6_addMatchUpStopTime: typeof addMatchUpStopTime; declare const mutate$6_addSchedulingProfileRound: typeof addSchedulingProfileRound; declare const mutate$6_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts; declare const mutate$6_assignMatchUpCourt: typeof assignMatchUpCourt; declare const mutate$6_assignMatchUpVenue: typeof assignMatchUpVenue; declare const mutate$6_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps; declare const mutate$6_bulkScheduleMatchUps: typeof bulkScheduleMatchUps; declare const mutate$6_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps; declare const mutate$6_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments; declare const mutate$6_calculateScheduleTimes: typeof calculateScheduleTimes; declare const mutate$6_clearMatchUpSchedule: typeof clearMatchUpSchedule; declare const mutate$6_clearScheduledMatchUps: typeof clearScheduledMatchUps; declare const mutate$6_findMatchUpFormatTiming: typeof findMatchUpFormatTiming; declare const mutate$6_generateBookings: typeof generateBookings; declare const mutate$6_generateVirtualCourts: typeof generateVirtualCourts; declare const mutate$6_matchUpScheduleChange: typeof matchUpScheduleChange; declare const mutate$6_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming; declare const mutate$6_proAutoSchedule: typeof proAutoSchedule; declare const mutate$6_proConflicts: typeof proConflicts; declare const mutate$6_removeCourtGridBooking: typeof removeCourtGridBooking; declare const mutate$6_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming; declare const mutate$6_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment; declare const mutate$6_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps; declare const mutate$6_scheduleMatchUps: typeof scheduleMatchUps; declare const mutate$6_scheduleProfileGrid: typeof scheduleProfileGrid; declare const mutate$6_scheduleProfileRounds: typeof scheduleProfileRounds; declare const mutate$6_setMatchUpCalledAt: typeof setMatchUpCalledAt; declare const mutate$6_setMatchUpDailyLimits: typeof setMatchUpDailyLimits; declare const mutate$6_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId; declare const mutate$6_setSchedulingProfile: typeof setSchedulingProfile; declare const mutate$6_toggleParticipantCheckInState: typeof toggleParticipantCheckInState; declare const mutate$6_validateSchedulingProfile: typeof validateSchedulingProfile; declare namespace mutate$6 { export { mutate$6_addCourtGridBooking as addCourtGridBooking, mutate$6_addMatchUpCourtOrder as addMatchUpCourtOrder, mutate$6_addMatchUpEndTime as addMatchUpEndTime, mutate$6_addMatchUpOfficial as addMatchUpOfficial, mutate$6_addMatchUpResumeTime as addMatchUpResumeTime, mutate$6_addMatchUpScheduleItems as addMatchUpScheduleItems, mutate$6_addMatchUpScheduledDate as addMatchUpScheduledDate, mutate$6_addMatchUpScheduledTime as addMatchUpScheduledTime, mutate$6_addMatchUpStartTime as addMatchUpStartTime, mutate$6_addMatchUpStopTime as addMatchUpStopTime, mutate$6_addSchedulingProfileRound as addSchedulingProfileRound, mutate$6_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts, mutate$6_assignMatchUpCourt as assignMatchUpCourt, mutate$6_assignMatchUpVenue as assignMatchUpVenue, mutate$6_bulkRescheduleMatchUps as bulkRescheduleMatchUps, mutate$6_bulkScheduleMatchUps as bulkScheduleMatchUps, mutate$6_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps, mutate$6_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments, mutate$6_calculateScheduleTimes as calculateScheduleTimes, mutate$6_clearMatchUpSchedule as clearMatchUpSchedule, mutate$6_clearScheduledMatchUps as clearScheduledMatchUps, mutate$6_findMatchUpFormatTiming as findMatchUpFormatTiming, mutate$6_generateBookings as generateBookings, mutate$6_generateVirtualCourts as generateVirtualCourts, mutate$6_matchUpScheduleChange as matchUpScheduleChange, mutate$6_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming, mutate$6_proAutoSchedule as proAutoSchedule, mutate$6_proConflicts as proConflicts, mutate$6_removeCourtGridBooking as removeCourtGridBooking, mutate$6_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming, mutate$6_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment, mutate$6_reorderUpcomingMatchUps as reorderUpcomingMatchUps, mutate$6_scheduleMatchUps as scheduleMatchUps, mutate$6_scheduleProfileGrid as scheduleProfileGrid, mutate$6_scheduleProfileRounds as scheduleProfileRounds, mutate$6_setMatchUpCalledAt as setMatchUpCalledAt, mutate$6_setMatchUpDailyLimits as setMatchUpDailyLimits, mutate$6_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId, mutate$6_setSchedulingProfile as setSchedulingProfile, mutate$6_toggleParticipantCheckInState as toggleParticipantCheckInState, mutate$6_validateSchedulingProfile as validateSchedulingProfile, }; } declare const index$c_addCourtGridBooking: typeof addCourtGridBooking; declare const index$c_addMatchUpCourtOrder: typeof addMatchUpCourtOrder; declare const index$c_addMatchUpEndTime: typeof addMatchUpEndTime; declare const index$c_addMatchUpOfficial: typeof addMatchUpOfficial; declare const index$c_addMatchUpResumeTime: typeof addMatchUpResumeTime; declare const index$c_addMatchUpScheduleItems: typeof addMatchUpScheduleItems; declare const index$c_addMatchUpScheduledDate: typeof addMatchUpScheduledDate; declare const index$c_addMatchUpScheduledTime: typeof addMatchUpScheduledTime; declare const index$c_addMatchUpStartTime: typeof addMatchUpStartTime; declare const index$c_addMatchUpStopTime: typeof addMatchUpStopTime; declare const index$c_addSchedulingProfileRound: typeof addSchedulingProfileRound; declare const index$c_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts; declare const index$c_assignMatchUpCourt: typeof assignMatchUpCourt; declare const index$c_assignMatchUpVenue: typeof assignMatchUpVenue; declare const index$c_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps; declare const index$c_bulkScheduleMatchUps: typeof bulkScheduleMatchUps; declare const index$c_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps; declare const index$c_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments; declare const index$c_calculateScheduleTimes: typeof calculateScheduleTimes; declare const index$c_clearMatchUpSchedule: typeof clearMatchUpSchedule; declare const index$c_clearScheduledMatchUps: typeof clearScheduledMatchUps; declare const index$c_courtGridRows: typeof courtGridRows; declare const index$c_findMatchUpFormatTiming: typeof findMatchUpFormatTiming; declare const index$c_findVenue: typeof findVenue; declare const index$c_generateBookings: typeof generateBookings; declare const index$c_generateVirtualCourts: typeof generateVirtualCourts; declare const index$c_getMatchUpsToSchedule: typeof getMatchUpsToSchedule; declare const index$c_getPersonRequests: typeof getPersonRequests; declare const index$c_getProfileRounds: typeof getProfileRounds; declare const index$c_getScheduledRoundsDetails: typeof getScheduledRoundsDetails; declare const index$c_getSchedulingProfile: typeof getSchedulingProfile; declare const index$c_getSchedulingProfileIssues: typeof getSchedulingProfileIssues; declare const index$c_matchUpScheduleChange: typeof matchUpScheduleChange; declare const index$c_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming; declare const index$c_proAutoSchedule: typeof proAutoSchedule; declare const index$c_proConflicts: typeof proConflicts; declare const index$c_publicFindCourt: typeof publicFindCourt; declare const index$c_removeCourtGridBooking: typeof removeCourtGridBooking; declare const index$c_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming; declare const index$c_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment; declare const index$c_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps; declare const index$c_scheduleMatchUps: typeof scheduleMatchUps; declare const index$c_scheduleProfileGrid: typeof scheduleProfileGrid; declare const index$c_scheduleProfileRounds: typeof scheduleProfileRounds; declare const index$c_setMatchUpCalledAt: typeof setMatchUpCalledAt; declare const index$c_setMatchUpDailyLimits: typeof setMatchUpDailyLimits; declare const index$c_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId; declare const index$c_setSchedulingProfile: typeof setSchedulingProfile; declare const index$c_toggleParticipantCheckInState: typeof toggleParticipantCheckInState; declare const index$c_validateSchedulingProfile: typeof validateSchedulingProfile; declare namespace index$c { export { index$c_addCourtGridBooking as addCourtGridBooking, index$c_addMatchUpCourtOrder as addMatchUpCourtOrder, index$c_addMatchUpEndTime as addMatchUpEndTime, index$c_addMatchUpOfficial as addMatchUpOfficial, index$c_addMatchUpResumeTime as addMatchUpResumeTime, index$c_addMatchUpScheduleItems as addMatchUpScheduleItems, index$c_addMatchUpScheduledDate as addMatchUpScheduledDate, index$c_addMatchUpScheduledTime as addMatchUpScheduledTime, index$c_addMatchUpStartTime as addMatchUpStartTime, index$c_addMatchUpStopTime as addMatchUpStopTime, index$c_addSchedulingProfileRound as addSchedulingProfileRound, index$c_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts, index$c_assignMatchUpCourt as assignMatchUpCourt, index$c_assignMatchUpVenue as assignMatchUpVenue, index$c_bulkRescheduleMatchUps as bulkRescheduleMatchUps, index$c_bulkScheduleMatchUps as bulkScheduleMatchUps, index$c_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps, index$c_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments, index$c_calculateScheduleTimes as calculateScheduleTimes, index$c_clearMatchUpSchedule as clearMatchUpSchedule, index$c_clearScheduledMatchUps as clearScheduledMatchUps, index$c_courtGridRows as courtGridRows, index$c_findMatchUpFormatTiming as findMatchUpFormatTiming, index$c_findVenue as findVenue, index$c_generateBookings as generateBookings, index$c_generateVirtualCourts as generateVirtualCourts, index$c_getMatchUpsToSchedule as getMatchUpsToSchedule, index$c_getPersonRequests as getPersonRequests, index$c_getProfileRounds as getProfileRounds, index$c_getScheduledRoundsDetails as getScheduledRoundsDetails, index$c_getSchedulingProfile as getSchedulingProfile, index$c_getSchedulingProfileIssues as getSchedulingProfileIssues, index$c_matchUpScheduleChange as matchUpScheduleChange, index$c_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming, mutate$6 as mutate, index$c_proAutoSchedule as proAutoSchedule, index$c_proConflicts as proConflicts, index$c_publicFindCourt as publicFindCourt, query$5 as query, index$c_removeCourtGridBooking as removeCourtGridBooking, index$c_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming, index$c_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment, index$c_reorderUpcomingMatchUps as reorderUpcomingMatchUps, index$c_scheduleMatchUps as scheduleMatchUps, index$c_scheduleProfileGrid as scheduleProfileGrid, index$c_scheduleProfileRounds as scheduleProfileRounds, index$c_setMatchUpCalledAt as setMatchUpCalledAt, index$c_setMatchUpDailyLimits as setMatchUpDailyLimits, index$c_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId, index$c_setSchedulingProfile as setSchedulingProfile, index$c_toggleParticipantCheckInState as toggleParticipantCheckInState, index$c_validateSchedulingProfile as validateSchedulingProfile, }; } type generate$2_CompetitionFormat = CompetitionFormat; type generate$2_PenaltyProfile = PenaltyProfile; type generate$2_PlayerRules = PlayerRules; type generate$2_PointProfile = PointProfile; type generate$2_ScoringEngine = ScoringEngine; declare const generate$2_ScoringEngine: typeof ScoringEngine; type generate$2_ScoringEngineOptions = ScoringEngineOptions; type generate$2_ScoringEngineSupplementaryState = ScoringEngineSupplementaryState; type generate$2_ServerRule = ServerRule; type generate$2_SubstitutionRules = SubstitutionRules; type generate$2_TimeoutRules = TimeoutRules; type generate$2_TimerProfile = TimerProfile; declare const generate$2_generateScoreString: typeof generateScoreString; declare const generate$2_generateTieMatchUpScore: typeof generateTieMatchUpScore; declare const generate$2_reverseScore: typeof reverseScore; declare namespace generate$2 { export { generate$2_ScoringEngine as ScoringEngine, generate$2_generateScoreString as generateScoreString, generate$2_generateTieMatchUpScore as generateTieMatchUpScore, generate$2_reverseScore as reverseScore }; export type { generate$2_CompetitionFormat as CompetitionFormat, generate$2_PenaltyProfile as PenaltyProfile, generate$2_PlayerRules as PlayerRules, generate$2_PointProfile as PointProfile, generate$2_ScoringEngineOptions as ScoringEngineOptions, generate$2_ScoringEngineSupplementaryState as ScoringEngineSupplementaryState, generate$2_ServerRule as ServerRule, generate$2_SubstitutionRules as SubstitutionRules, generate$2_TimeoutRules as TimeoutRules, generate$2_TimerProfile as TimerProfile }; } type mutate$5_AddPointConfig = AddPointConfig; type mutate$5_PointMultiplier = PointMultiplier; type mutate$5_PointsToDecoration = PointsToDecoration; declare const mutate$5_addPoint: typeof addPoint; declare const mutate$5_calculatePointsTo: typeof calculatePointsTo; declare const mutate$5_createMatchUp: typeof createMatchUp; declare const mutate$5_inferServeSide: typeof inferServeSide; declare const mutate$5_resolvePointValue: typeof resolvePointValue; declare namespace mutate$5 { export { mutate$5_addPoint as addPoint, mutate$5_calculatePointsTo as calculatePointsTo, mutate$5_createMatchUp as createMatchUp, mutate$5_inferServeSide as inferServeSide, mutate$5_resolvePointValue as resolvePointValue }; export type { mutate$5_AddPointConfig as AddPointConfig, mutate$5_PointMultiplier as PointMultiplier, mutate$5_PointsToDecoration as PointsToDecoration }; } declare const help_keyValueScore: typeof keyValueScore; declare namespace help { export { help_keyValueScore as keyValueScore, parse as parseMatchUpFormat, stringify as stringifyMatchUpFormat, }; } type query$2_CalculatedStat = CalculatedStat; type query$2_GetScoreOptions = GetScoreOptions; type query$2_MatchStatistics = MatchStatistics; type query$2_StatObject = StatObject; type query$2_StatisticsOptions = StatisticsOptions; declare const query$2_analyzeScore: typeof analyzeScore; declare const query$2_analyzeSet: typeof analyzeSet; declare const query$2_calculateMatchStatistics: typeof calculateMatchStatistics; declare const query$2_checkScoreHasValue: typeof checkScoreHasValue; declare const query$2_checkSetIsComplete: typeof checkSetIsComplete; declare const query$2_deduceMatchUpFormat: typeof deduceMatchUpFormat; declare const query$2_enrichPointHistory: typeof enrichPointHistory; declare const query$2_getEpisodes: typeof getEpisodes; declare const query$2_getQuickStats: typeof getQuickStats; declare const query$2_getScore: typeof getScore; declare const query$2_getScoreboard: typeof getScoreboard; declare const query$2_getSetComplement: typeof getSetComplement; declare const query$2_getTiebreakComplement: typeof getTiebreakComplement; declare const query$2_getWinner: typeof getWinner; declare const query$2_isComplete: typeof isComplete; declare const query$2_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const query$2_parseScoreString: typeof parseScoreString; declare const query$2_toStatObjects: typeof toStatObjects; declare const query$2_validateMatchUpScore: typeof validateMatchUpScore; declare const query$2_validateScore: typeof validateScore; declare const query$2_validateSetScore: typeof validateSetScore; declare const query$2_validateTieFormat: typeof validateTieFormat; declare namespace query$2 { export { query$2_analyzeScore as analyzeScore, query$2_analyzeSet as analyzeSet, query$2_calculateMatchStatistics as calculateMatchStatistics, query$2_checkScoreHasValue as checkScoreHasValue, query$2_checkSetIsComplete as checkSetIsComplete, query$2_deduceMatchUpFormat as deduceMatchUpFormat, query$2_enrichPointHistory as enrichPointHistory, query$2_getEpisodes as getEpisodes, query$2_getQuickStats as getQuickStats, query$2_getScore as getScore, query$2_getScoreboard as getScoreboard, query$2_getSetComplement as getSetComplement, query$2_getTiebreakComplement as getTiebreakComplement, query$2_getWinner as getWinner, query$2_isComplete as isComplete, query$2_isValidMatchUpFormat as isValidMatchUpFormat, query$2_parseScoreString as parseScoreString, query$2_toStatObjects as toStatObjects, query$2_validateMatchUpScore as validateMatchUpScore, query$2_validateScore as validateScore, query$2_validateSetScore as validateSetScore, query$2_validateTieFormat as validateTieFormat }; export type { query$2_CalculatedStat as CalculatedStat, query$2_GetScoreOptions as GetScoreOptions, query$2_MatchStatistics as MatchStatistics, StatCounters$1 as StatCounters, query$2_StatObject as StatObject, query$2_StatisticsOptions as StatisticsOptions }; } type index$b_AddGameOptions = AddGameOptions; type index$b_AddPointConfig = AddPointConfig; type index$b_AddPointOptions = AddPointOptions; type index$b_AddSetOptions = AddSetOptions; type index$b_CalculatedStat = CalculatedStat; type index$b_CompetitionFormat = CompetitionFormat; type index$b_CreateMatchUpOptions = CreateMatchUpOptions; type index$b_EndSegmentOptions = EndSegmentOptions; type index$b_Episode = Episode; type index$b_EpisodeGame = EpisodeGame; type index$b_EpisodeNeeded = EpisodeNeeded; type index$b_EpisodePoint = EpisodePoint; type index$b_EpisodeSet = EpisodeSet; type index$b_FormatStructure = FormatStructure; type index$b_GameFormatStructure = GameFormatStructure; type index$b_GetScoreOptions = GetScoreOptions; type index$b_GetScoreboardOptions = GetScoreboardOptions; type index$b_InitialScoreOptions = InitialScoreOptions; type index$b_MCPMatch = MCPMatch; type index$b_MCPMatchResult = MCPMatchResult; type index$b_MCPPoint = MCPPoint; type index$b_MCPValidationOptions = MCPValidationOptions; type index$b_MCPValidationResult = MCPValidationResult; type index$b_MatchStatistics = MatchStatistics; type index$b_MatchUpHistory = MatchUpHistory; type index$b_MatchUpState = MatchUpState; type index$b_PBPValidationOptions = PBPValidationOptions; type index$b_PBPValidationResult = PBPValidationResult; type index$b_ParsedMCPPoint = ParsedMCPPoint; type index$b_PenaltyProfile = PenaltyProfile; type index$b_PlayerRules = PlayerRules; type index$b_PointMultiplier = PointMultiplier; type index$b_PointProfile = PointProfile; type index$b_PointResult = PointResult; type index$b_PointSituation = PointSituation; type index$b_PointsToDecoration = PointsToDecoration; type index$b_RallyShot = RallyShot; type index$b_ScoreEntry = ScoreEntry; type index$b_ScoreResult = ScoreResult; type index$b_ScoringEngine = ScoringEngine; declare const index$b_ScoringEngine: typeof ScoringEngine; type index$b_ScoringEngineOptions = ScoringEngineOptions; type index$b_ScoringEngineSupplementaryState = ScoringEngineSupplementaryState; type index$b_ServeLocation = ServeLocation; type index$b_ServerRule = ServerRule; type index$b_SetFormatStructure = SetFormatStructure; type index$b_SetScore = SetScore; type index$b_StatObject = StatObject; type index$b_Statistics = Statistics; type index$b_StatisticsOptions = StatisticsOptions; type index$b_StrokeType = StrokeType; type index$b_SubstitutionEvent = SubstitutionEvent; type index$b_SubstitutionRules = SubstitutionRules; type index$b_TiebreakFormatStructure = TiebreakFormatStructure; type index$b_TimeoutRules = TimeoutRules; type index$b_TimerProfile = TimerProfile; type index$b_ValidateMatchUpOptions = ValidateMatchUpOptions; type index$b_ValidationDetails = ValidationDetails; type index$b_ValidationResult = ValidationResult; declare const index$b_addPoint: typeof addPoint; declare const index$b_analyzeScore: typeof analyzeScore; declare const index$b_analyzeSequence: typeof analyzeSequence; declare const index$b_analyzeSet: typeof analyzeSet; declare const index$b_calculateMatchStatistics: typeof calculateMatchStatistics; declare const index$b_calculatePointsTo: typeof calculatePointsTo; declare const index$b_checkScoreHasValue: typeof checkScoreHasValue; declare const index$b_checkSetIsComplete: typeof checkSetIsComplete; declare const index$b_createMatchUp: typeof createMatchUp; declare const index$b_deduceMatchUpFormat: typeof deduceMatchUpFormat; declare const index$b_enrichPointHistory: typeof enrichPointHistory; declare const index$b_exportMatchUpJSON: typeof exportMatchUpJSON; declare const index$b_generateScoreString: typeof generateScoreString; declare const index$b_generateTieMatchUpScore: typeof generateTieMatchUpScore; declare const index$b_getEpisodes: typeof getEpisodes; declare const index$b_getQuickStats: typeof getQuickStats; declare const index$b_getScore: typeof getScore; declare const index$b_getScoreboard: typeof getScoreboard; declare const index$b_getSetComplement: typeof getSetComplement; declare const index$b_getSetScoreString: typeof getSetScoreString; declare const index$b_getTiebreakComplement: typeof getTiebreakComplement; declare const index$b_getWinner: typeof getWinner; declare const index$b_groupByMatch: typeof groupByMatch; declare const index$b_inferServeSide: typeof inferServeSide; declare const index$b_isComplete: typeof isComplete; declare const index$b_isValidMatchUpFormat: typeof isValidMatchUpFormat; declare const index$b_keyValueScore: typeof keyValueScore; declare const index$b_mcpValidator: typeof mcpValidator; declare const index$b_parseCSV: typeof parseCSV; declare const index$b_parseMCPPoint: typeof parseMCPPoint; declare const index$b_parseScoreString: typeof parseScoreString; declare const index$b_pbpValidator: typeof pbpValidator; declare const index$b_pointParser: typeof pointParser; declare const index$b_resolvePointValue: typeof resolvePointValue; declare const index$b_reverseScore: typeof reverseScore; declare const index$b_shotParser: typeof shotParser; declare const index$b_shotSplitter: typeof shotSplitter; declare const index$b_toStatObjects: typeof toStatObjects; declare const index$b_validateMCPMatch: typeof validateMCPMatch; declare const index$b_validateMatchUp: typeof validateMatchUp; declare const index$b_validateMatchUpScore: typeof validateMatchUpScore; declare const index$b_validateScore: typeof validateScore; declare const index$b_validateSet: typeof validateSet; declare const index$b_validateSetScore: typeof validateSetScore; declare const index$b_validateTieFormat: typeof validateTieFormat; declare namespace index$b { export { index$b_ScoringEngine as ScoringEngine, index$b_addPoint as addPoint, index$b_analyzeScore as analyzeScore, index$b_analyzeSequence as analyzeSequence, index$b_analyzeSet as analyzeSet, index$b_calculateMatchStatistics as calculateMatchStatistics, index$b_calculatePointsTo as calculatePointsTo, index$b_checkScoreHasValue as checkScoreHasValue, index$b_checkSetIsComplete as checkSetIsComplete, index$b_createMatchUp as createMatchUp, index$b_deduceMatchUpFormat as deduceMatchUpFormat, index$b_enrichPointHistory as enrichPointHistory, index$b_exportMatchUpJSON as exportMatchUpJSON, generate$2 as generate, index$b_generateScoreString as generateScoreString, index$b_generateTieMatchUpScore as generateTieMatchUpScore, index$b_getEpisodes as getEpisodes, index$b_getQuickStats as getQuickStats, index$b_getScore as getScore, index$b_getScoreboard as getScoreboard, index$b_getSetComplement as getSetComplement, index$b_getSetScoreString as getSetScoreString, index$b_getTiebreakComplement as getTiebreakComplement, index$b_getWinner as getWinner, index$b_groupByMatch as groupByMatch, help as helpers, index$b_inferServeSide as inferServeSide, index$b_isComplete as isComplete, index$b_isValidMatchUpFormat as isValidMatchUpFormat, index$b_keyValueScore as keyValueScore, index$b_mcpValidator as mcpValidator, mutate$5 as mutate, index$b_parseCSV as parseCSV, index$b_parseMCPPoint as parseMCPPoint, parse as parseMatchUpFormat, index$b_parseScoreString as parseScoreString, index$b_pbpValidator as pbpValidator, index$b_pointParser as pointParser, query$2 as query, index$b_resolvePointValue as resolvePointValue, index$b_reverseScore as reverseScore, index$b_shotParser as shotParser, index$b_shotSplitter as shotSplitter, stringify as stringifyMatchUpFormat, index$b_toStatObjects as toStatObjects, index$b_validateMCPMatch as validateMCPMatch, index$b_validateMatchUp as validateMatchUp, index$b_validateMatchUpScore as validateMatchUpScore, index$b_validateScore as validateScore, index$b_validateSet as validateSet, index$b_validateSetScore as validateSetScore, index$b_validateTieFormat as validateTieFormat }; export type { index$b_AddGameOptions as AddGameOptions, index$b_AddPointConfig as AddPointConfig, index$b_AddPointOptions as AddPointOptions, index$b_AddSetOptions as AddSetOptions, index$b_CalculatedStat as CalculatedStat, index$b_CompetitionFormat as CompetitionFormat, index$b_CreateMatchUpOptions as CreateMatchUpOptions, index$b_EndSegmentOptions as EndSegmentOptions, index$b_Episode as Episode, index$b_EpisodeGame as EpisodeGame, index$b_EpisodeNeeded as EpisodeNeeded, index$b_EpisodePoint as EpisodePoint, index$b_EpisodeSet as EpisodeSet, index$b_FormatStructure as FormatStructure, index$b_GameFormatStructure as GameFormatStructure, index$b_GetScoreOptions as GetScoreOptions, index$b_GetScoreboardOptions as GetScoreboardOptions, index$b_InitialScoreOptions as InitialScoreOptions, index$b_MCPMatch as MCPMatch, index$b_MCPMatchResult as MCPMatchResult, index$b_MCPPoint as MCPPoint, index$b_MCPValidationOptions as MCPValidationOptions, index$b_MCPValidationResult as MCPValidationResult, index$b_MatchStatistics as MatchStatistics, index$b_MatchUpHistory as MatchUpHistory, index$b_MatchUpState as MatchUpState, index$b_PBPValidationOptions as PBPValidationOptions, index$b_PBPValidationResult as PBPValidationResult, index$b_ParsedMCPPoint as ParsedMCPPoint, index$b_PenaltyProfile as PenaltyProfile, index$b_PlayerRules as PlayerRules, index$b_PointMultiplier as PointMultiplier, index$b_PointProfile as PointProfile, index$b_PointResult as PointResult, index$b_PointSituation as PointSituation, index$b_PointsToDecoration as PointsToDecoration, index$b_RallyShot as RallyShot, index$b_ScoreEntry as ScoreEntry, index$b_ScoreResult as ScoreResult, index$b_ScoringEngineOptions as ScoringEngineOptions, index$b_ScoringEngineSupplementaryState as ScoringEngineSupplementaryState, MatchUp as ScoringMatchUp, Point as ScoringPoint, Score as ScoringScore, index$b_ServeLocation as ServeLocation, index$b_ServerRule as ServerRule, index$b_SetFormatStructure as SetFormatStructure, index$b_SetScore as SetScore, StatCounters$1 as StatCounters, index$b_StatObject as StatObject, index$b_Statistics as Statistics, index$b_StatisticsOptions as StatisticsOptions, index$b_StrokeType as StrokeType, index$b_SubstitutionEvent as SubstitutionEvent, index$b_SubstitutionRules as SubstitutionRules, index$b_TiebreakFormatStructure as TiebreakFormatStructure, index$b_TimeoutRules as TimeoutRules, index$b_TimerProfile as TimerProfile, index$b_ValidateMatchUpOptions as ValidateMatchUpOptions, index$b_ValidationDetails as ValidationDetails, index$b_ValidationResult as ValidationResult }; } declare const mutate$4_addCollectionDefinition: typeof addCollectionDefinition; declare const mutate$4_addCollectionGroup: typeof addCollectionGroup; declare const mutate$4_aggregateTieFormats: typeof aggregateTieFormats; declare const mutate$4_modifyCollectionDefinition: typeof modifyCollectionDefinition; declare const mutate$4_modifyTieFormat: typeof modifyTieFormat; declare const mutate$4_orderCollectionDefinitions: typeof orderCollectionDefinitions; declare const mutate$4_removeCollectionDefinition: typeof removeCollectionDefinition; declare const mutate$4_removeCollectionGroup: typeof removeCollectionGroup; declare const mutate$4_removeOrphanedTieFormats: typeof removeOrphanedTieFormats; declare namespace mutate$4 { export { mutate$4_addCollectionDefinition as addCollectionDefinition, mutate$4_addCollectionGroup as addCollectionGroup, mutate$4_aggregateTieFormats as aggregateTieFormats, mutate$4_modifyCollectionDefinition as modifyCollectionDefinition, mutate$4_modifyTieFormat as modifyTieFormat, mutate$4_orderCollectionDefinitions as orderCollectionDefinitions, mutate$4_removeCollectionDefinition as removeCollectionDefinition, mutate$4_removeCollectionGroup as removeCollectionGroup, mutate$4_removeOrphanedTieFormats as removeOrphanedTieFormats, }; } declare const index$a_addCollectionDefinition: typeof addCollectionDefinition; declare const index$a_addCollectionGroup: typeof addCollectionGroup; declare const index$a_aggregateTieFormats: typeof aggregateTieFormats; declare const index$a_compareTieFormats: typeof compareTieFormats; declare const index$a_getTieFormat: typeof getTieFormat; declare const index$a_modifyCollectionDefinition: typeof modifyCollectionDefinition; declare const index$a_modifyTieFormat: typeof modifyTieFormat; declare const index$a_orderCollectionDefinitions: typeof orderCollectionDefinitions; declare const index$a_removeCollectionDefinition: typeof removeCollectionDefinition; declare const index$a_removeCollectionGroup: typeof removeCollectionGroup; declare const index$a_removeOrphanedTieFormats: typeof removeOrphanedTieFormats; declare const index$a_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck; declare const index$a_validateCollectionDefinition: typeof validateCollectionDefinition; declare namespace index$a { export { index$a_addCollectionDefinition as addCollectionDefinition, index$a_addCollectionGroup as addCollectionGroup, index$a_aggregateTieFormats as aggregateTieFormats, index$a_compareTieFormats as compareTieFormats, index$a_getTieFormat as getTieFormat, index$a_modifyCollectionDefinition as modifyCollectionDefinition, index$a_modifyTieFormat as modifyTieFormat, mutate$4 as mutate, index$a_orderCollectionDefinitions as orderCollectionDefinitions, query$6 as query, index$a_removeCollectionDefinition as removeCollectionDefinition, index$a_removeCollectionGroup as removeCollectionGroup, index$a_removeOrphanedTieFormats as removeOrphanedTieFormats, index$a_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck, index$a_validateCollectionDefinition as validateCollectionDefinition, }; } declare const generate$1_copyTournamentRecord: typeof copyTournamentRecord; declare const generate$1_createTournamentRecord: typeof createTournamentRecord; declare namespace generate$1 { export { generate$1_copyTournamentRecord as copyTournamentRecord, generate$1_createTournamentRecord as createTournamentRecord, }; } declare const mutate$3_addDrawDefinitionExtension: typeof addDrawDefinitionExtension; declare const mutate$3_addEventExtension: typeof addEventExtension; declare const mutate$3_addEventTimeItem: typeof addEventTimeItem; declare const mutate$3_addExtension: typeof addExtension; declare const mutate$3_addMutationLock: typeof addMutationLock; declare const mutate$3_addNotes: typeof addNotes; declare const mutate$3_addOnlineResource: typeof addOnlineResource; declare const mutate$3_addParticipantExtension: typeof addParticipantExtension; declare const mutate$3_addParticipantTimeItem: typeof addParticipantTimeItem; declare const mutate$3_addTimeItem: typeof addTimeItem; declare const mutate$3_addTournamentExtension: typeof addTournamentExtension; declare const mutate$3_addTournamentTimeItem: typeof addTournamentTimeItem; declare const mutate$3_hydrateTournamentRecord: typeof hydrateTournamentRecord; declare const mutate$3_migrateTournamentRecord: typeof migrateTournamentRecord; declare const mutate$3_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension; declare const mutate$3_removeEventExtension: typeof removeEventExtension; declare const mutate$3_removeExtension: typeof removeExtension; declare const mutate$3_removeMutationLock: typeof removeMutationLock; declare const mutate$3_removeNotes: typeof removeNotes; declare const mutate$3_removeOnlineResource: typeof removeOnlineResource; declare const mutate$3_removeParticipantExtension: typeof removeParticipantExtension; declare const mutate$3_removeTournamentExtension: typeof removeTournamentExtension; declare const mutate$3_setRegistrationProfile: typeof setRegistrationProfile; declare const mutate$3_setTournamentCategories: typeof setTournamentCategories; declare const mutate$3_setTournamentDates: typeof setTournamentDates; declare const mutate$3_setTournamentEndDate: typeof setTournamentEndDate; declare const mutate$3_setTournamentLocalTimeZone: typeof setTournamentLocalTimeZone; declare const mutate$3_setTournamentName: typeof setTournamentName; declare const mutate$3_setTournamentNotes: typeof setTournamentNotes; declare const mutate$3_setTournamentStartDate: typeof setTournamentStartDate; declare const mutate$3_setTournamentStatus: typeof setTournamentStatus; declare const mutate$3_setTournamentTier: typeof setTournamentTier; declare namespace mutate$3 { export { mutate$3_addDrawDefinitionExtension as addDrawDefinitionExtension, mutate$3_addEventExtension as addEventExtension, mutate$3_addEventTimeItem as addEventTimeItem, mutate$3_addExtension as addExtension, mutate$3_addMutationLock as addMutationLock, mutate$3_addNotes as addNotes, mutate$3_addOnlineResource as addOnlineResource, mutate$3_addParticipantExtension as addParticipantExtension, mutate$3_addParticipantTimeItem as addParticipantTimeItem, mutate$3_addTimeItem as addTimeItem, mutate$3_addTournamentExtension as addTournamentExtension, mutate$3_addTournamentTimeItem as addTournamentTimeItem, mutate$3_hydrateTournamentRecord as hydrateTournamentRecord, mutate$3_migrateTournamentRecord as migrateTournamentRecord, mutate$3_removeDrawDefinitionExtension as removeDrawDefinitionExtension, mutate$3_removeEventExtension as removeEventExtension, mutate$3_removeExtension as removeExtension, mutate$3_removeMutationLock as removeMutationLock, mutate$3_removeNotes as removeNotes, mutate$3_removeOnlineResource as removeOnlineResource, mutate$3_removeParticipantExtension as removeParticipantExtension, mutate$3_removeTournamentExtension as removeTournamentExtension, mutate$3_setRegistrationProfile as setRegistrationProfile, mutate$3_setTournamentCategories as setTournamentCategories, mutate$3_setTournamentDates as setTournamentDates, mutate$3_setTournamentEndDate as setTournamentEndDate, mutate$3_setTournamentLocalTimeZone as setTournamentLocalTimeZone, mutate$3_setTournamentName as setTournamentName, mutate$3_setTournamentNotes as setTournamentNotes, mutate$3_setTournamentStartDate as setTournamentStartDate, mutate$3_setTournamentStatus as setTournamentStatus, mutate$3_setTournamentTier as setTournamentTier, }; } declare const index$9_addDrawDefinitionExtension: typeof addDrawDefinitionExtension; declare const index$9_addEventExtension: typeof addEventExtension; declare const index$9_addEventTimeItem: typeof addEventTimeItem; declare const index$9_addExtension: typeof addExtension; declare const index$9_addMutationLock: typeof addMutationLock; declare const index$9_addNotes: typeof addNotes; declare const index$9_addOnlineResource: typeof addOnlineResource; declare const index$9_addParticipantExtension: typeof addParticipantExtension; declare const index$9_addParticipantTimeItem: typeof addParticipantTimeItem; declare const index$9_addTimeItem: typeof addTimeItem; declare const index$9_addTournamentExtension: typeof addTournamentExtension; declare const index$9_addTournamentTimeItem: typeof addTournamentTimeItem; declare const index$9_analyzeDraws: typeof analyzeDraws; declare const index$9_analyzeTournament: typeof analyzeTournament; declare const index$9_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks; declare const index$9_copyTournamentRecord: typeof copyTournamentRecord; declare const index$9_createTournamentRecord: typeof createTournamentRecord; declare const index$9_getAggregateTeamResults: typeof getAggregateTeamResults; declare const index$9_getAllowedDrawTypes: typeof getAllowedDrawTypes; declare const index$9_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats; declare const index$9_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels; declare const index$9_getAppliedPolicies: typeof getAppliedPolicies; declare const index$9_getCompetitionDateRange: typeof getCompetitionDateRange; declare const index$9_getCompetitionPenalties: typeof getCompetitionPenalties; declare const index$9_getEventRankingPoints: typeof getEventRankingPoints; declare const index$9_getMutationLocks: typeof getMutationLocks; declare const index$9_getPolicyDefinitions: typeof getPolicyDefinitions; declare const index$9_getRegistrationProfile: typeof getRegistrationProfile; declare const index$9_getTournamentInfo: typeof getTournamentInfo; declare const index$9_getTournamentPenalties: typeof getTournamentPenalties; declare const index$9_getTournamentPersons: typeof getTournamentPersons; declare const index$9_getTournamentPoints: typeof getTournamentPoints; declare const index$9_getTournamentStructures: typeof getTournamentStructures; declare const index$9_getTournamentTimeItem: typeof getTournamentTimeItem; declare const index$9_hydrateTournamentRecord: typeof hydrateTournamentRecord; declare const index$9_migrateTournamentRecord: typeof migrateTournamentRecord; declare const index$9_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension; declare const index$9_removeEventExtension: typeof removeEventExtension; declare const index$9_removeExtension: typeof removeExtension; declare const index$9_removeMutationLock: typeof removeMutationLock; declare const index$9_removeNotes: typeof removeNotes; declare const index$9_removeOnlineResource: typeof removeOnlineResource; declare const index$9_removeParticipantExtension: typeof removeParticipantExtension; declare const index$9_removeTournamentExtension: typeof removeTournamentExtension; declare const index$9_setRegistrationProfile: typeof setRegistrationProfile; declare const index$9_setTournamentCategories: typeof setTournamentCategories; declare const index$9_setTournamentDates: typeof setTournamentDates; declare const index$9_setTournamentEndDate: typeof setTournamentEndDate; declare const index$9_setTournamentLocalTimeZone: typeof setTournamentLocalTimeZone; declare const index$9_setTournamentName: typeof setTournamentName; declare const index$9_setTournamentNotes: typeof setTournamentNotes; declare const index$9_setTournamentStartDate: typeof setTournamentStartDate; declare const index$9_setTournamentStatus: typeof setTournamentStatus; declare const index$9_setTournamentTier: typeof setTournamentTier; declare const index$9_suggestFormatPlans: typeof suggestFormatPlans; declare namespace index$9 { export { index$9_addDrawDefinitionExtension as addDrawDefinitionExtension, index$9_addEventExtension as addEventExtension, index$9_addEventTimeItem as addEventTimeItem, index$9_addExtension as addExtension, index$9_addMutationLock as addMutationLock, index$9_addNotes as addNotes, index$9_addOnlineResource as addOnlineResource, index$9_addParticipantExtension as addParticipantExtension, index$9_addParticipantTimeItem as addParticipantTimeItem, index$9_addTimeItem as addTimeItem, index$9_addTournamentExtension as addTournamentExtension, index$9_addTournamentTimeItem as addTournamentTimeItem, index$9_analyzeDraws as analyzeDraws, index$9_analyzeTournament as analyzeTournament, index$9_cleanExpiredMutationLocks as cleanExpiredMutationLocks, index$9_copyTournamentRecord as copyTournamentRecord, index$9_createTournamentRecord as createTournamentRecord, generate$1 as generate, index$9_getAggregateTeamResults as getAggregateTeamResults, index$9_getAllowedDrawTypes as getAllowedDrawTypes, index$9_getAllowedMatchUpFormats as getAllowedMatchUpFormats, index$9_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels, index$9_getAppliedPolicies as getAppliedPolicies, index$9_getCompetitionDateRange as getCompetitionDateRange, index$9_getCompetitionPenalties as getCompetitionPenalties, index$9_getEventRankingPoints as getEventRankingPoints, index$9_getMutationLocks as getMutationLocks, index$9_getPolicyDefinitions as getPolicyDefinitions, index$9_getRegistrationProfile as getRegistrationProfile, index$9_getTournamentInfo as getTournamentInfo, index$9_getTournamentPenalties as getTournamentPenalties, index$9_getTournamentPersons as getTournamentPersons, index$9_getTournamentPoints as getTournamentPoints, index$9_getTournamentStructures as getTournamentStructures, index$9_getTournamentTimeItem as getTournamentTimeItem, index$9_hydrateTournamentRecord as hydrateTournamentRecord, index$9_migrateTournamentRecord as migrateTournamentRecord, mutate$3 as mutate, query$7 as query, index$9_removeDrawDefinitionExtension as removeDrawDefinitionExtension, index$9_removeEventExtension as removeEventExtension, index$9_removeExtension as removeExtension, index$9_removeMutationLock as removeMutationLock, index$9_removeNotes as removeNotes, index$9_removeOnlineResource as removeOnlineResource, index$9_removeParticipantExtension as removeParticipantExtension, index$9_removeTournamentExtension as removeTournamentExtension, index$9_setRegistrationProfile as setRegistrationProfile, index$9_setTournamentCategories as setTournamentCategories, index$9_setTournamentDates as setTournamentDates, index$9_setTournamentEndDate as setTournamentEndDate, index$9_setTournamentLocalTimeZone as setTournamentLocalTimeZone, index$9_setTournamentName as setTournamentName, index$9_setTournamentNotes as setTournamentNotes, index$9_setTournamentStartDate as setTournamentStartDate, index$9_setTournamentStatus as setTournamentStatus, index$9_setTournamentTier as setTournamentTier, index$9_suggestFormatPlans as suggestFormatPlans, }; } type DayId = string; type BlockId = string; type VenueId = string; type CourtId = string; type TournamentId = string; type TemplateId = string; type RuleId = string; declare const BLOCK_TYPES: { readonly MAINTENANCE: "MAINTENANCE"; readonly PRACTICE: "PRACTICE"; readonly RESERVED: "RESERVED"; readonly BLOCKED: "BLOCKED"; readonly CLOSED: "CLOSED"; readonly SCHEDULED: "SCHEDULED"; readonly SOFT_BLOCK: "SOFT_BLOCK"; readonly HARD_BLOCK: "HARD_BLOCK"; readonly LOCKED: "LOCKED"; readonly AVAILABLE: "AVAILABLE"; readonly UNSPECIFIED: "UNSPECIFIED"; }; type BlockType = 'MAINTENANCE' | 'PRACTICE' | 'RESERVED' | 'BLOCKED' | 'CLOSED' | 'SCHEDULED' | 'SOFT_BLOCK' | 'HARD_BLOCK' | 'LOCKED' | 'AVAILABLE' | 'UNSPECIFIED'; type BlockSource = 'USER' | 'TEMPLATE' | 'RULE' | 'SYSTEM'; type BlockHardness = 'HARD' | 'SOFT'; interface TimeRange { start: string; end: string; } interface CourtRef { tournamentId: TournamentId; venueId: VenueId; courtId: CourtId; } interface Block extends TimeRange { id: BlockId; court: CourtRef; type: BlockType; reason?: string; priority?: number; hardSoft?: BlockHardness; recurrenceKey?: string; source?: BlockSource; matchUpId?: string; } interface RailSegment extends TimeRange { status: BlockType; contributingBlocks: BlockId[]; } interface CourtRail { court: CourtRef; segments: RailSegment[]; } interface VenueDayTimeline { day: DayId; venueId: VenueId; rails: CourtRail[]; } interface CourtSchedulingSummary { scheduledMinutes: number; availableMinutes: number; blockedMinutes: number; } interface CapacityPoint { time: string; courtsAvailable: number; courtsSoftBlocked: number; courtsHardBlocked: number; } interface CapacityCurve { day: DayId; points: CapacityPoint[]; } interface Template { id: TemplateId; name: string; description?: string; operations: TemplateOperation[]; } interface TemplateOperation { target: 'TOURNAMENT' | 'VENUE' | 'COURT_GROUP' | 'COURT'; venueIds?: VenueId[]; courtIds?: CourtId[]; days?: DayId[]; relativeTime?: { startOffsetMinutes: number; endOffsetMinutes: number; }; absoluteTime?: TimeRange; blockType: BlockType; reason?: string; hardSoft?: BlockHardness; } interface Rule { id: RuleId; name: string; description?: string; evaluate: (ctx: EngineContext) => BlockMutation[]; } type MutationKind = 'ADD_BLOCK' | 'UPDATE_BLOCK' | 'REMOVE_BLOCK'; interface BlockMutation { kind: MutationKind; block: Block; previousBlock?: Block; } interface MutationResult { applied: BlockMutation[]; rejected: BlockMutation[]; warnings: EngineWarning[]; conflicts: EngineConflict[]; } interface SimulationResult { previewRails: VenueDayTimeline[]; capacityImpact?: CapacityCurve; conflicts: EngineConflict[]; } type ConflictSeverity = 'INFO' | 'WARN' | 'ERROR'; interface EngineWarning { code: string; message: string; relatedBlocks?: BlockId[]; relatedCourts?: CourtRef[]; } interface EngineConflict { code: string; message: string; severity: ConflictSeverity; timeRange: TimeRange; courts: CourtRef[]; relatedMatches?: string[]; } interface EngineConfig { tournamentId: TournamentId; dayStartTime: string; dayEndTime: string; slotMinutes: number; granularityMinutes?: number; typePrecedence: BlockType[]; conflictEvaluators?: ConflictEvaluator[]; } interface ConflictEvaluator { id: string; description: string; evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; } interface EngineContext { config: EngineConfig; tournamentRecord: any; blocksById: Map; blocksByCourtDay: Map; templates: Map; rules: Map; } type EngineEventType = 'STATE_CHANGED' | 'BLOCKS_CHANGED' | 'CONFLICTS_CHANGED' | 'AVAILABILITY_CHANGED' | 'PLAN_CHANGED'; interface EngineEvent { type: EngineEventType; payload: any; } interface StateChangedEvent extends EngineEvent { type: 'STATE_CHANGED'; payload: { reason: string; }; } interface BlocksChangedEvent extends EngineEvent { type: 'BLOCKS_CHANGED'; payload: { mutations: BlockMutation[]; }; } interface ConflictsChangedEvent extends EngineEvent { type: 'CONFLICTS_CHANGED'; payload: { conflicts: EngineConflict[]; }; } interface ApplyBlockOptions { courts: CourtRef[]; timeRange: TimeRange; type: BlockType; reason?: string; hardSoft?: BlockHardness; source?: BlockSource; } interface MoveBlockOptions { blockId: BlockId; newTimeRange: TimeRange; newCourt?: CourtRef; } interface ResizeBlockOptions { blockId: BlockId; newTimeRange: TimeRange; } interface ApplyTemplateOptions { templateId: TemplateId; scope?: { venues?: VenueId[]; courts?: CourtRef[]; days?: DayId[]; }; } interface CourtDayAvailability { startTime: string; endTime: string; } interface CourtMeta { ref: CourtRef; name: string; surface: string; indoor: boolean; hasLights: boolean; tags: string[]; openTime?: string; closeTime?: string; closedDays?: string[]; extendedProps?: Record; } interface Edge { time: string; type: 'START' | 'END'; blockId: BlockId; } declare function courtDayKey(court: CourtRef, day: string): string; declare function courtKey(court: CourtRef): string; declare function venueKey(tournamentId: string, venueId: string): string; declare function venueDayKey(tournamentId: string, venueId: string, day: string): string; declare function resolveVenueId(venue: { venueId?: string; venueName?: string; }): string; declare function resolveCourtId(court: { courtId?: string; courtName?: string; }): string; declare function clampToDayRange(block: Block, dayRange: TimeRange): Block | null; declare function rangesOverlap(a: TimeRange, b: TimeRange): boolean; declare function overlappingRange(a: TimeRange, b: TimeRange): TimeRange; declare function diffMinutes(start: string, end: string): number; declare function resolveStatus(contributingIds: BlockId[], blocksById: Map, precedence: BlockType[]): BlockType; declare function buildEdges(blocks: Block[]): Edge[]; declare function sortEdges(edges: Edge[]): Edge[]; declare function deriveRailSegments(blocks: Block[], dayRange: TimeRange, config: EngineConfig): RailSegment[]; declare function mergeAdjacentSegments(segments: RailSegment[]): RailSegment[]; declare function extractDay(isoDateTime: string): string; declare function buildDayRange(day: string, config: EngineConfig): TimeRange; declare function validateSegments(segments: RailSegment[]): boolean; declare function generateCapacityCurve(day: DayId, timelines: VenueDayTimeline[]): CapacityCurve; interface CapacityStats { peakAvailable: number; peakTime: string; minAvailable: number; minTime: string; avgAvailable: number; totalCourtHours: number; utilizationPercent: number; peakUnavailable?: number; peakUnavailableTime?: string; totalCourts?: number; totalAvailableHours?: number; totalUnavailableHours?: number; availablePercent?: number; avgBlockedHoursPerCourt?: number; } declare function calculateCapacityStats(curve: CapacityCurve): CapacityStats; declare function filterCapacityCurve(curve: CapacityCurve, timeRange: { start: string; end: string; }): CapacityCurve; declare function sampleCapacityCurve(curve: CapacityCurve, intervalMinutes: number): CapacityCurve; interface CapacityDiff { time: string; availableDelta: number; softBlockedDelta: number; hardBlockedDelta: number; } declare function compareCapacityCurves(baseline: CapacityCurve, modified: CapacityCurve): CapacityDiff[]; declare function intervalsOverlap(a: TimeRange, b: TimeRange): boolean; declare function timeInsideBlock(time: number, block: Block): boolean; declare function findBlocksContainingTime(time: number, blocks: Block[]): Block[]; declare function clampDragToCollisions(anchorTime: number, cursorTime: number, blocks: Block[]): { start: number; end: number; clamped: boolean; clampedBy?: Block; direction: 'forward' | 'backward'; }; declare function sortBlocksByStart(blocks: Block[]): void; declare const courtOverlapEvaluator: { id: string; description: string; evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const matchWindowEvaluator: { id: string; description: string; evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const adjacentBlockEvaluator: { id: string; description: string; evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const lightingEvaluator: { id: string; description: string; evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const blockDurationEvaluator: { id: string; description: string; evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const dayBoundaryEvaluator: { id: string; description: string; evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const maintenanceWindowEvaluator: { id: string; description: string; evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }; declare const defaultEvaluators: { id: string; description: string; evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[]; }[]; declare class EvaluatorRegistry { private readonly evaluators; register(evaluator: any): void; unregister(evaluatorId: string): void; get(evaluatorId: string): any; getAll(): any[]; clear(): void; } declare const createFollowByEvaluator: (_factoryAPI: any) => { id: string; description: string; evaluate: (_ctx: EngineContext, _mutations: BlockMutation[]) => EngineConflict[]; }; declare function groupConflictsBySeverity(conflicts: EngineConflict[]): { errors: EngineConflict[]; warnings: EngineConflict[]; info: EngineConflict[]; }; declare function getHighestSeverity(conflicts: EngineConflict[]): 'ERROR' | 'WARN' | 'INFO' | null; declare function formatConflicts(conflicts: EngineConflict[]): string[]; declare function hhmmToMinutes(hhmm: string): number; declare function minutesToHhmm(minutes: number): string; declare function snapToGranularity(minutes: number, granularity: number, mode?: 'floor' | 'ceil' | 'round'): number; declare function snapIsoToGranularity(iso: string, granularity: number, mode?: 'floor' | 'ceil' | 'round'): string; declare function iterateDayTicks(startHhmm: string, endHhmm: string, granularity: number): Generator; interface PlanItem { planItemId: string; day: DayId; venueId: VenueId; eventId: string; drawId?: string; structureId?: string; roundNumber: number; roundSegment?: { segmentNumber: number; segmentsCount: number; }; matchUpType?: string; notBeforeTime?: string; estimatedDurationMinutes?: number; } interface DayPlan { day: DayId; items: PlanItem[]; } declare function computePlanItemId(item: Pick): string; declare class AvailabilityEngine { private config; private tournamentRecord; private blocksById; private blocksByCourtDay; private courtDayAvailability; private venueDayAvailability; private templates; private rules; private plans; private readonly subscribers; private resolvedGranularity; private nextBlockId; init(tournamentRecord: any, config?: Partial): void; updateTournamentRecord(tournamentRecord: any): void; getConfig(): EngineConfig; getResolvedGranularityMinutes(): number; getCourtAvailability(court: CourtRef, day: DayId): CourtDayAvailability; setCourtAvailability(court: CourtRef, day: DayId, avail: CourtDayAvailability): void; setCourtAvailabilityAllDays(court: CourtRef, avail: CourtDayAvailability): void; setAllCourtsDefaultAvailability(avail: CourtDayAvailability): void; clearCourtAvailabilityForVenue(tournamentId: TournamentId, venueId: VenueId): void; getCourtAvailabilityKeys(court: CourtRef): string[]; getVenueAvailability(tournamentId: TournamentId, venueId: VenueId, day?: DayId): CourtDayAvailability | null; setVenueDefaultAvailability(tournamentId: TournamentId, venueId: VenueId, avail: CourtDayAvailability): void; setVenueDayAvailability(tournamentId: TournamentId, venueId: VenueId, day: DayId, avail: CourtDayAvailability): void; getVisibleTimeRange(day: DayId, courtRefs?: CourtRef[]): { startTime: string; endTime: string; }; getTournamentDays(): DayId[]; getActiveDays(): DayId[]; getDayTimeline(day: DayId): VenueDayTimeline[]; getVenueTimeline(day: DayId, venueId: VenueId): VenueDayTimeline | null; getCourtRail(day: DayId, court: CourtRef): CourtRail | null; getCourtSchedulingSummary(court: CourtRef): CourtSchedulingSummary; getCapacityCurve(day: DayId): CapacityCurve; getDayBlocks(day: DayId): Block[]; getAllBlocks(): Block[]; getTemplates(): Template[]; getTemplate(templateId: TemplateId): Template | null; getRules(): Rule[]; getRule(ruleId: RuleId): Rule | null; addPlanItem(item: Omit): PlanItem; removePlanItem(planItemId: string): boolean; updatePlanItem(planItemId: string, updates: Partial>): PlanItem | null; movePlanItem(planItemId: string, newDay: DayId): PlanItem | null; getDayPlan(day: DayId): DayPlan | null; getAllPlans(): DayPlan[]; applyBlock(opts: ApplyBlockOptions): MutationResult; moveBlock(opts: MoveBlockOptions): MutationResult; resizeBlock(opts: ResizeBlockOptions): MutationResult; removeBlock(blockId: BlockId): MutationResult; applyTemplate(opts: ApplyTemplateOptions): MutationResult; importScheduledMatchUps(matchUps: Array<{ matchUpId: string; courtId: string; venueId: string; date: string; startTime: string; durationMinutes: number; }>): MutationResult; private timeToMinutes; simulateBlocks(mutations: BlockMutation[], day?: DayId): SimulationResult; subscribe(listener: (event: EngineEvent) => void): () => void; private emit; private applyMutations; private applyMutation; private indexBlock; private unindexBlock; private evaluateConflicts; private createContext; private createSnapshot; private static readonly BOOKING_TYPE_MAP; private loadBlocksFromTournamentRecord; private loadVenueAvailability; private loadCourtAvailability; private createBlockFromBooking; private getAllCourtsFromTournamentRecord; private getFirstAvailableDay; private generateBlockId; private clampToAvailability; listCourtMeta(): CourtMeta[]; private getCourtMeta; } type ValidationPhase = 'PRECHECK' | 'INTEGRITY' | 'ORDERING' | 'CAPACITY'; type ValidationSeverity = 'ERROR' | 'WARN' | 'INFO'; interface FixAction { type: string; description: string; payload?: any; } interface RuleResult { ruleId: string; phase: ValidationPhase; severity: ValidationSeverity; message: string; context?: { day?: string; venueId?: string; planItemId?: string; }; fixAction?: FixAction; } type IssueIndex = Map; interface ValidationPipelineResult { results: RuleResult[]; issueIndex: IssueIndex; } interface ValidationPipelineParams { engine: AvailabilityEngine; day?: DayId; phases?: ValidationPhase[]; } declare function runValidationPipeline(params: ValidationPipelineParams): ValidationPipelineResult; interface TodsDateAvailability { date: string; startTime: string; endTime: string; venueId: string; courtIds?: string[]; } interface TodsVenue { venueId?: string; venueName?: string; defaultStartTime?: string; defaultEndTime?: string; courts?: TodsCourt[]; dateAvailability?: TodsDateAvailability[]; } interface TodsCourt { courtId?: string; courtName?: string; surfaceType?: string; surfaceCategory?: string; courtDimensions?: string; indoor?: boolean; onlineResources?: any[]; } interface SchedulingProfileRound { eventId: string; drawId?: string; roundNumber?: number; roundSegment?: string; matchUpType?: string; } interface SchedulingProfileItem { scheduleDate: string; venueIds: string[]; rounds?: SchedulingProfileRound[]; } type SchedulingProfile = SchedulingProfileItem[]; interface SchedulingSelection { scheduleDate: string; venueIds: string[]; rounds: SchedulingProfileRound[]; } interface BridgeConfig { courtToCourtId?: (courtRef: CourtRef) => string; isSchedulableStatus?: (status: BlockType) => boolean; aggregateByVenue?: boolean; } declare function railsToDateAvailability(timelines: VenueDayTimeline[], config?: BridgeConfig): TodsDateAvailability[]; declare function applyAvailabilityToTournamentRecord(params: { tournamentRecord: any; timelines: VenueDayTimeline[]; config?: BridgeConfig; engine?: AvailabilityEngine; }): any; declare function buildSchedulingProfileFromUISelections(selections: SchedulingSelection[]): SchedulingProfile; declare function todsAvailabilityToBlocks(params: { venue: TodsVenue; tournamentId: string; blockType?: BlockType; }): Array<{ court: CourtRef; start: string; end: string; type: BlockType; }>; declare function validateSchedulingProfileFormat(profile: SchedulingProfile): { valid: boolean; errors: string[]; }; declare function validateDateAvailability(entries: TodsDateAvailability[]): { valid: boolean; errors: string[]; }; declare function mergeOverlappingAvailability(entries: TodsDateAvailability[]): TodsDateAvailability[]; declare function calculateCourtHours(entries: TodsDateAvailability[]): number; type index$8_ApplyBlockOptions = ApplyBlockOptions; type index$8_ApplyTemplateOptions = ApplyTemplateOptions; declare const index$8_BLOCK_TYPES: typeof BLOCK_TYPES; type index$8_Block = Block; type index$8_BlockHardness = BlockHardness; type index$8_BlockId = BlockId; type index$8_BlockMutation = BlockMutation; type index$8_BlockSource = BlockSource; type index$8_BlockType = BlockType; type index$8_BlocksChangedEvent = BlocksChangedEvent; type index$8_BridgeConfig = BridgeConfig; type index$8_CapacityCurve = CapacityCurve; type index$8_CapacityDiff = CapacityDiff; type index$8_CapacityPoint = CapacityPoint; type index$8_CapacityStats = CapacityStats; type index$8_ConflictEvaluator = ConflictEvaluator; type index$8_ConflictSeverity = ConflictSeverity; type index$8_ConflictsChangedEvent = ConflictsChangedEvent; type index$8_CourtDayAvailability = CourtDayAvailability; type index$8_CourtId = CourtId; type index$8_CourtMeta = CourtMeta; type index$8_CourtRail = CourtRail; type index$8_CourtRef = CourtRef; type index$8_CourtSchedulingSummary = CourtSchedulingSummary; type index$8_DayId = DayId; type index$8_DayPlan = DayPlan; type index$8_Edge = Edge; type index$8_EngineConfig = EngineConfig; type index$8_EngineConflict = EngineConflict; type index$8_EngineContext = EngineContext; type index$8_EngineEvent = EngineEvent; type index$8_EngineEventType = EngineEventType; type index$8_EngineWarning = EngineWarning; type index$8_EvaluatorRegistry = EvaluatorRegistry; declare const index$8_EvaluatorRegistry: typeof EvaluatorRegistry; type index$8_FixAction = FixAction; type index$8_IssueIndex = IssueIndex; type index$8_MoveBlockOptions = MoveBlockOptions; type index$8_MutationKind = MutationKind; type index$8_MutationResult = MutationResult; type index$8_PlanItem = PlanItem; type index$8_RailSegment = RailSegment; type index$8_ResizeBlockOptions = ResizeBlockOptions; type index$8_Rule = Rule; type index$8_RuleId = RuleId; type index$8_RuleResult = RuleResult; type index$8_SchedulingProfile = SchedulingProfile; type index$8_SchedulingProfileItem = SchedulingProfileItem; type index$8_SchedulingProfileRound = SchedulingProfileRound; type index$8_SchedulingSelection = SchedulingSelection; type index$8_SimulationResult = SimulationResult; type index$8_StateChangedEvent = StateChangedEvent; type index$8_Template = Template; type index$8_TemplateId = TemplateId; type index$8_TemplateOperation = TemplateOperation; type index$8_TimeRange = TimeRange; type index$8_TodsCourt = TodsCourt; type index$8_TodsDateAvailability = TodsDateAvailability; type index$8_TodsVenue = TodsVenue; type index$8_TournamentId = TournamentId; type index$8_ValidationPhase = ValidationPhase; type index$8_ValidationPipelineParams = ValidationPipelineParams; type index$8_ValidationPipelineResult = ValidationPipelineResult; type index$8_ValidationSeverity = ValidationSeverity; type index$8_VenueDayTimeline = VenueDayTimeline; type index$8_VenueId = VenueId; declare const index$8_adjacentBlockEvaluator: typeof adjacentBlockEvaluator; declare const index$8_applyAvailabilityToTournamentRecord: typeof applyAvailabilityToTournamentRecord; declare const index$8_blockDurationEvaluator: typeof blockDurationEvaluator; declare const index$8_buildDayRange: typeof buildDayRange; declare const index$8_buildEdges: typeof buildEdges; declare const index$8_buildSchedulingProfileFromUISelections: typeof buildSchedulingProfileFromUISelections; declare const index$8_calculateCapacityStats: typeof calculateCapacityStats; declare const index$8_calculateCourtHours: typeof calculateCourtHours; declare const index$8_clampDragToCollisions: typeof clampDragToCollisions; declare const index$8_clampToDayRange: typeof clampToDayRange; declare const index$8_compareCapacityCurves: typeof compareCapacityCurves; declare const index$8_computePlanItemId: typeof computePlanItemId; declare const index$8_courtDayKey: typeof courtDayKey; declare const index$8_courtKey: typeof courtKey; declare const index$8_courtOverlapEvaluator: typeof courtOverlapEvaluator; declare const index$8_createFollowByEvaluator: typeof createFollowByEvaluator; declare const index$8_dayBoundaryEvaluator: typeof dayBoundaryEvaluator; declare const index$8_defaultEvaluators: typeof defaultEvaluators; declare const index$8_deriveRailSegments: typeof deriveRailSegments; declare const index$8_diffMinutes: typeof diffMinutes; declare const index$8_extractDay: typeof extractDay; declare const index$8_filterCapacityCurve: typeof filterCapacityCurve; declare const index$8_findBlocksContainingTime: typeof findBlocksContainingTime; declare const index$8_formatConflicts: typeof formatConflicts; declare const index$8_generateCapacityCurve: typeof generateCapacityCurve; declare const index$8_getHighestSeverity: typeof getHighestSeverity; declare const index$8_groupConflictsBySeverity: typeof groupConflictsBySeverity; declare const index$8_hhmmToMinutes: typeof hhmmToMinutes; declare const index$8_intervalsOverlap: typeof intervalsOverlap; declare const index$8_iterateDayTicks: typeof iterateDayTicks; declare const index$8_lightingEvaluator: typeof lightingEvaluator; declare const index$8_maintenanceWindowEvaluator: typeof maintenanceWindowEvaluator; declare const index$8_matchWindowEvaluator: typeof matchWindowEvaluator; declare const index$8_mergeAdjacentSegments: typeof mergeAdjacentSegments; declare const index$8_mergeOverlappingAvailability: typeof mergeOverlappingAvailability; declare const index$8_minutesToHhmm: typeof minutesToHhmm; declare const index$8_overlappingRange: typeof overlappingRange; declare const index$8_railsToDateAvailability: typeof railsToDateAvailability; declare const index$8_rangesOverlap: typeof rangesOverlap; declare const index$8_resolveCourtId: typeof resolveCourtId; declare const index$8_resolveStatus: typeof resolveStatus; declare const index$8_resolveVenueId: typeof resolveVenueId; declare const index$8_runValidationPipeline: typeof runValidationPipeline; declare const index$8_sampleCapacityCurve: typeof sampleCapacityCurve; declare const index$8_snapIsoToGranularity: typeof snapIsoToGranularity; declare const index$8_snapToGranularity: typeof snapToGranularity; declare const index$8_sortBlocksByStart: typeof sortBlocksByStart; declare const index$8_sortEdges: typeof sortEdges; declare const index$8_timeInsideBlock: typeof timeInsideBlock; declare const index$8_todsAvailabilityToBlocks: typeof todsAvailabilityToBlocks; declare const index$8_validateDateAvailability: typeof validateDateAvailability; declare const index$8_validateSchedulingProfileFormat: typeof validateSchedulingProfileFormat; declare const index$8_validateSegments: typeof validateSegments; declare const index$8_venueDayKey: typeof venueDayKey; declare const index$8_venueKey: typeof venueKey; declare namespace index$8 { export { index$8_BLOCK_TYPES as BLOCK_TYPES, index$8_EvaluatorRegistry as EvaluatorRegistry, index$8_adjacentBlockEvaluator as adjacentBlockEvaluator, index$8_applyAvailabilityToTournamentRecord as applyAvailabilityToTournamentRecord, index$8_blockDurationEvaluator as blockDurationEvaluator, index$8_buildDayRange as buildDayRange, index$8_buildEdges as buildEdges, index$8_buildSchedulingProfileFromUISelections as buildSchedulingProfileFromUISelections, index$8_calculateCapacityStats as calculateCapacityStats, index$8_calculateCourtHours as calculateCourtHours, index$8_clampDragToCollisions as clampDragToCollisions, index$8_clampToDayRange as clampToDayRange, index$8_compareCapacityCurves as compareCapacityCurves, index$8_computePlanItemId as computePlanItemId, index$8_courtDayKey as courtDayKey, index$8_courtKey as courtKey, index$8_courtOverlapEvaluator as courtOverlapEvaluator, index$8_createFollowByEvaluator as createFollowByEvaluator, index$8_dayBoundaryEvaluator as dayBoundaryEvaluator, index$8_defaultEvaluators as defaultEvaluators, index$8_deriveRailSegments as deriveRailSegments, index$8_diffMinutes as diffMinutes, index$8_extractDay as extractDay, index$8_filterCapacityCurve as filterCapacityCurve, index$8_findBlocksContainingTime as findBlocksContainingTime, index$8_formatConflicts as formatConflicts, index$8_generateCapacityCurve as generateCapacityCurve, index$8_getHighestSeverity as getHighestSeverity, index$8_groupConflictsBySeverity as groupConflictsBySeverity, index$8_hhmmToMinutes as hhmmToMinutes, index$8_intervalsOverlap as intervalsOverlap, index$8_iterateDayTicks as iterateDayTicks, index$8_lightingEvaluator as lightingEvaluator, index$8_maintenanceWindowEvaluator as maintenanceWindowEvaluator, index$8_matchWindowEvaluator as matchWindowEvaluator, index$8_mergeAdjacentSegments as mergeAdjacentSegments, index$8_mergeOverlappingAvailability as mergeOverlappingAvailability, index$8_minutesToHhmm as minutesToHhmm, index$8_overlappingRange as overlappingRange, index$8_railsToDateAvailability as railsToDateAvailability, index$8_rangesOverlap as rangesOverlap, index$8_resolveCourtId as resolveCourtId, index$8_resolveStatus as resolveStatus, index$8_resolveVenueId as resolveVenueId, index$8_runValidationPipeline as runValidationPipeline, index$8_sampleCapacityCurve as sampleCapacityCurve, index$8_snapIsoToGranularity as snapIsoToGranularity, index$8_snapToGranularity as snapToGranularity, index$8_sortBlocksByStart as sortBlocksByStart, index$8_sortEdges as sortEdges, index$8_timeInsideBlock as timeInsideBlock, index$8_todsAvailabilityToBlocks as todsAvailabilityToBlocks, index$8_validateDateAvailability as validateDateAvailability, index$8_validateSchedulingProfileFormat as validateSchedulingProfileFormat, index$8_validateSegments as validateSegments, index$8_venueDayKey as venueDayKey, index$8_venueKey as venueKey }; export type { index$8_ApplyBlockOptions as ApplyBlockOptions, index$8_ApplyTemplateOptions as ApplyTemplateOptions, index$8_Block as Block, index$8_BlockHardness as BlockHardness, index$8_BlockId as BlockId, index$8_BlockMutation as BlockMutation, index$8_BlockSource as BlockSource, index$8_BlockType as BlockType, index$8_BlocksChangedEvent as BlocksChangedEvent, index$8_BridgeConfig as BridgeConfig, index$8_CapacityCurve as CapacityCurve, index$8_CapacityDiff as CapacityDiff, index$8_CapacityPoint as CapacityPoint, index$8_CapacityStats as CapacityStats, index$8_ConflictEvaluator as ConflictEvaluator, index$8_ConflictSeverity as ConflictSeverity, index$8_ConflictsChangedEvent as ConflictsChangedEvent, index$8_CourtDayAvailability as CourtDayAvailability, index$8_CourtId as CourtId, index$8_CourtMeta as CourtMeta, index$8_CourtRail as CourtRail, index$8_CourtRef as CourtRef, index$8_CourtSchedulingSummary as CourtSchedulingSummary, index$8_DayId as DayId, index$8_DayPlan as DayPlan, index$8_Edge as Edge, index$8_EngineConfig as EngineConfig, index$8_EngineConflict as EngineConflict, index$8_EngineContext as EngineContext, index$8_EngineEvent as EngineEvent, index$8_EngineEventType as EngineEventType, index$8_EngineWarning as EngineWarning, index$8_FixAction as FixAction, index$8_IssueIndex as IssueIndex, index$8_MoveBlockOptions as MoveBlockOptions, index$8_MutationKind as MutationKind, index$8_MutationResult as MutationResult, index$8_PlanItem as PlanItem, index$8_RailSegment as RailSegment, index$8_ResizeBlockOptions as ResizeBlockOptions, index$8_Rule as Rule, index$8_RuleId as RuleId, index$8_RuleResult as RuleResult, index$8_SchedulingProfile as SchedulingProfile, index$8_SchedulingProfileItem as SchedulingProfileItem, index$8_SchedulingProfileRound as SchedulingProfileRound, index$8_SchedulingSelection as SchedulingSelection, index$8_SimulationResult as SimulationResult, index$8_StateChangedEvent as StateChangedEvent, index$8_Template as Template, index$8_TemplateId as TemplateId, index$8_TemplateOperation as TemplateOperation, index$8_TimeRange as TimeRange, index$8_TodsCourt as TodsCourt, index$8_TodsDateAvailability as TodsDateAvailability, index$8_TodsVenue as TodsVenue, index$8_TournamentId as TournamentId, index$8_ValidationPhase as ValidationPhase, index$8_ValidationPipelineParams as ValidationPipelineParams, index$8_ValidationPipelineResult as ValidationPipelineResult, index$8_ValidationSeverity as ValidationSeverity, index$8_VenueDayTimeline as VenueDayTimeline, index$8_VenueId as VenueId }; } declare const mutate$2_addCertification: typeof addCertification; declare const mutate$2_addCertificationRequirement: typeof addCertificationRequirement; declare const mutate$2_addEvaluation: typeof addEvaluation; declare const mutate$2_addEvaluationPolicy: typeof addEvaluationPolicy; declare const mutate$2_addSuspension: typeof addSuspension; declare const mutate$2_assignOfficial: typeof assignOfficial; declare const mutate$2_createOfficialRecord: typeof createOfficialRecord; declare const mutate$2_modifyCertification: typeof modifyCertification; declare const mutate$2_modifyEvaluation: typeof modifyEvaluation; declare const mutate$2_removeCertification: typeof removeCertification; declare const mutate$2_removeEvaluation: typeof removeEvaluation; declare const mutate$2_removeOfficialAssignment: typeof removeOfficialAssignment; declare const mutate$2_removeSuspension: typeof removeSuspension; declare const mutate$2_transitionAssignmentStatus: typeof transitionAssignmentStatus; declare const mutate$2_transitionCertificationStatus: typeof transitionCertificationStatus; declare const mutate$2_transitionEvaluationStatus: typeof transitionEvaluationStatus; declare namespace mutate$2 { export { mutate$2_addCertification as addCertification, mutate$2_addCertificationRequirement as addCertificationRequirement, mutate$2_addEvaluation as addEvaluation, mutate$2_addEvaluationPolicy as addEvaluationPolicy, mutate$2_addSuspension as addSuspension, mutate$2_assignOfficial as assignOfficial, mutate$2_createOfficialRecord as createOfficialRecord, mutate$2_modifyCertification as modifyCertification, mutate$2_modifyEvaluation as modifyEvaluation, mutate$2_removeCertification as removeCertification, mutate$2_removeEvaluation as removeEvaluation, mutate$2_removeOfficialAssignment as removeOfficialAssignment, mutate$2_removeSuspension as removeSuspension, mutate$2_transitionAssignmentStatus as transitionAssignmentStatus, mutate$2_transitionCertificationStatus as transitionCertificationStatus, mutate$2_transitionEvaluationStatus as transitionEvaluationStatus, }; } declare const query$1_getEvaluationSummary: typeof getEvaluationSummary; declare const query$1_getEvaluationTemplate: typeof getEvaluationTemplate; declare const query$1_getEvaluations: typeof getEvaluations; declare const query$1_getOfficialAssignments: typeof getOfficialAssignments; declare const query$1_getOfficialCertifications: typeof getOfficialCertifications; declare const query$1_getOfficialEligibility: typeof getOfficialEligibility; declare const query$1_queryOfficialRecord: typeof queryOfficialRecord; declare const query$1_validateCertification: typeof validateCertification; declare const query$1_validateOfficiatingStatusTransition: typeof validateOfficiatingStatusTransition; declare namespace query$1 { export { query$1_getEvaluationSummary as getEvaluationSummary, query$1_getEvaluationTemplate as getEvaluationTemplate, query$1_getEvaluations as getEvaluations, query$1_getOfficialAssignments as getOfficialAssignments, query$1_getOfficialCertifications as getOfficialCertifications, query$1_getOfficialEligibility as getOfficialEligibility, query$1_queryOfficialRecord as queryOfficialRecord, query$1_validateCertification as validateCertification, query$1_validateOfficiatingStatusTransition as validateOfficiatingStatusTransition, }; } declare const index$7_addCertification: typeof addCertification; declare const index$7_addCertificationRequirement: typeof addCertificationRequirement; declare const index$7_addEvaluation: typeof addEvaluation; declare const index$7_addEvaluationPolicy: typeof addEvaluationPolicy; declare const index$7_addSuspension: typeof addSuspension; declare const index$7_assignOfficial: typeof assignOfficial; declare const index$7_createOfficialRecord: typeof createOfficialRecord; declare const index$7_getEvaluationSummary: typeof getEvaluationSummary; declare const index$7_getEvaluationTemplate: typeof getEvaluationTemplate; declare const index$7_getEvaluations: typeof getEvaluations; declare const index$7_getOfficialAssignments: typeof getOfficialAssignments; declare const index$7_getOfficialCertifications: typeof getOfficialCertifications; declare const index$7_getOfficialEligibility: typeof getOfficialEligibility; declare const index$7_modifyCertification: typeof modifyCertification; declare const index$7_modifyEvaluation: typeof modifyEvaluation; declare const index$7_queryOfficialRecord: typeof queryOfficialRecord; declare const index$7_removeCertification: typeof removeCertification; declare const index$7_removeEvaluation: typeof removeEvaluation; declare const index$7_removeOfficialAssignment: typeof removeOfficialAssignment; declare const index$7_removeSuspension: typeof removeSuspension; declare const index$7_transitionAssignmentStatus: typeof transitionAssignmentStatus; declare const index$7_transitionCertificationStatus: typeof transitionCertificationStatus; declare const index$7_transitionEvaluationStatus: typeof transitionEvaluationStatus; declare const index$7_validateCertification: typeof validateCertification; declare const index$7_validateOfficiatingStatusTransition: typeof validateOfficiatingStatusTransition; declare namespace index$7 { export { index$7_addCertification as addCertification, index$7_addCertificationRequirement as addCertificationRequirement, index$7_addEvaluation as addEvaluation, index$7_addEvaluationPolicy as addEvaluationPolicy, index$7_addSuspension as addSuspension, index$7_assignOfficial as assignOfficial, index$7_createOfficialRecord as createOfficialRecord, index$7_getEvaluationSummary as getEvaluationSummary, index$7_getEvaluationTemplate as getEvaluationTemplate, index$7_getEvaluations as getEvaluations, index$7_getOfficialAssignments as getOfficialAssignments, index$7_getOfficialCertifications as getOfficialCertifications, index$7_getOfficialEligibility as getOfficialEligibility, index$7_modifyCertification as modifyCertification, index$7_modifyEvaluation as modifyEvaluation, mutate$2 as mutate, query$1 as query, index$7_queryOfficialRecord as queryOfficialRecord, index$7_removeCertification as removeCertification, index$7_removeEvaluation as removeEvaluation, index$7_removeOfficialAssignment as removeOfficialAssignment, index$7_removeSuspension as removeSuspension, index$7_transitionAssignmentStatus as transitionAssignmentStatus, index$7_transitionCertificationStatus as transitionCertificationStatus, index$7_transitionEvaluationStatus as transitionEvaluationStatus, index$7_validateCertification as validateCertification, index$7_validateOfficiatingStatusTransition as validateOfficiatingStatusTransition, }; } declare const mutate$1_addPracticeRegistration: typeof addPracticeRegistration; declare const mutate$1_removePracticeRegistration: typeof removePracticeRegistration; declare const mutate$1_setPracticeDefaultCapacity: typeof setPracticeDefaultCapacity; declare const mutate$1_updatePracticeRegistration: typeof updatePracticeRegistration; declare namespace mutate$1 { export { mutate$1_addPracticeRegistration as addPracticeRegistration, mutate$1_removePracticeRegistration as removePracticeRegistration, mutate$1_setPracticeDefaultCapacity as setPracticeDefaultCapacity, mutate$1_updatePracticeRegistration as updatePracticeRegistration, }; } declare const query_getPracticeRegistrations: typeof getPracticeRegistrations; declare namespace query { export { query_getPracticeRegistrations as getPracticeRegistrations, }; } declare const index$6_addPracticeRegistration: typeof addPracticeRegistration; declare const index$6_getPracticeRegistrations: typeof getPracticeRegistrations; declare const index$6_query: typeof query; declare const index$6_removePracticeRegistration: typeof removePracticeRegistration; declare const index$6_setPracticeDefaultCapacity: typeof setPracticeDefaultCapacity; declare const index$6_updatePracticeRegistration: typeof updatePracticeRegistration; declare namespace index$6 { export { index$6_addPracticeRegistration as addPracticeRegistration, index$6_getPracticeRegistrations as getPracticeRegistrations, mutate$1 as mutate, index$6_query as query, index$6_removePracticeRegistration as removePracticeRegistration, index$6_setPracticeDefaultCapacity as setPracticeDefaultCapacity, index$6_updatePracticeRegistration as updatePracticeRegistration, }; } declare const generate_generateCourts: typeof generateCourts; declare namespace generate { export { generate_generateCourts as generateCourts, }; } declare const mutate_addCourt: typeof addCourt; declare const mutate_addCourts: typeof addCourts; declare const mutate_addVenue: typeof addVenue; declare const mutate_deleteCourt: typeof deleteCourt; declare const mutate_deleteCourts: typeof deleteCourts; declare const mutate_deleteVenue: typeof deleteVenue; declare const mutate_deleteVenues: typeof deleteVenues; declare const mutate_disableCourts: typeof disableCourts; declare const mutate_disableVenues: typeof disableVenues; declare const mutate_enableCourts: typeof enableCourts; declare const mutate_enableVenues: typeof enableVenues; declare const mutate_modifyCourt: typeof modifyCourt; declare const mutate_modifyCourtAvailability: typeof modifyCourtAvailability; declare const mutate_modifyVenue: typeof modifyVenue; declare namespace mutate { export { mutate_addCourt as addCourt, mutate_addCourts as addCourts, mutate_addVenue as addVenue, mutate_deleteCourt as deleteCourt, mutate_deleteCourts as deleteCourts, mutate_deleteVenue as deleteVenue, mutate_deleteVenues as deleteVenues, mutate_disableCourts as disableCourts, mutate_disableVenues as disableVenues, mutate_enableCourts as enableCourts, mutate_enableVenues as enableVenues, mutate_modifyCourt as modifyCourt, mutate_modifyCourtAvailability as modifyCourtAvailability, mutate_modifyVenue as modifyVenue, }; } declare const index$5_addCourt: typeof addCourt; declare const index$5_addCourts: typeof addCourts; declare const index$5_addVenue: typeof addVenue; declare const index$5_deleteCourt: typeof deleteCourt; declare const index$5_deleteCourts: typeof deleteCourts; declare const index$5_deleteVenue: typeof deleteVenue; declare const index$5_deleteVenues: typeof deleteVenues; declare const index$5_disableCourts: typeof disableCourts; declare const index$5_disableVenues: typeof disableVenues; declare const index$5_enableCourts: typeof enableCourts; declare const index$5_enableVenues: typeof enableVenues; declare const index$5_generate: typeof generate; declare const index$5_generateCourts: typeof generateCourts; declare const index$5_getCompetitionVenues: typeof getCompetitionVenues; declare const index$5_getCourts: typeof getCourts; declare const index$5_getVenuesAndCourts: typeof getVenuesAndCourts; declare const index$5_modifyCourt: typeof modifyCourt; declare const index$5_modifyCourtAvailability: typeof modifyCourtAvailability; declare const index$5_modifyVenue: typeof modifyVenue; declare const index$5_mutate: typeof mutate; declare const index$5_publicFindVenue: typeof publicFindVenue; declare namespace index$5 { export { index$5_addCourt as addCourt, index$5_addCourts as addCourts, index$5_addVenue as addVenue, index$5_deleteCourt as deleteCourt, index$5_deleteCourts as deleteCourts, index$5_deleteVenue as deleteVenue, index$5_deleteVenues as deleteVenues, index$5_disableCourts as disableCourts, index$5_disableVenues as disableVenues, index$5_enableCourts as enableCourts, index$5_enableVenues as enableVenues, index$5_generate as generate, index$5_generateCourts as generateCourts, index$5_getCompetitionVenues as getCompetitionVenues, index$5_getCourts as getCourts, index$5_getVenuesAndCourts as getVenuesAndCourts, index$5_modifyCourt as modifyCourt, index$5_modifyCourtAvailability as modifyCourtAvailability, index$5_modifyVenue as modifyVenue, index$5_mutate as mutate, index$5_publicFindVenue as publicFindVenue, query$4 as query, }; } declare namespace index$4 { export { index$8 as availabilityGovernor, index$q as competitionGovernor, index$p as drawsGovernor, index$o as entriesGovernor, index$n as eventGovernor, index$m as generationGovernor, index$l as matchUpFormatGovernor, index$k as matchUpGovernor, index$j as mocksGovernor, index$7 as officiatingGovernor, index$i as participantGovernor, index$h as policyGovernor, index$6 as practiceGovernor, index$g as publishingGovernor, index$f as queryGovernor, index$e as rankingGovernor, index$d as reportGovernor, index$c as scheduleGovernor, index$b as scoreGovernor, index$a as tieFormatGovernor, index$9 as tournamentGovernor, index$5 as venueGovernor, }; } declare function isPowerOf2(n?: any): boolean; declare function nearestPowerOf2(val: any): number; declare function isNumeric(value: any): boolean; declare function isOdd(num: any): boolean | undefined; declare function nextPowerOf2(n?: any): any; declare function isConvertableInteger(n: any): boolean; declare function visualizeScheduledMatchUps({ scheduledMatchUps, showGlobalLog }: { scheduledMatchUps: any; showGlobalLog: any; }): void; declare function createMap(objectArray: any, attribute: any): any; declare const hasAttributeValues: (a: any) => (o: any) => boolean; declare function undefinedToNull(obj: object, shallow?: boolean): any; declare function generateHashCode(o: any): string | undefined; declare function getIsoDateString(schedule: any): string | undefined; declare function validTimeValue(value: any): boolean; declare function DateHHMM(date: any): string; declare function timeUTC(date?: any): number; declare function formatDate(date?: any, separator?: string, format?: string): string; declare function offsetDate(date: any): Date; declare function offsetTime(date?: any): number; declare function isDate(dateArg: any): boolean; declare function generateDateRange(startDt?: any, endDt?: any): string[]; declare function isISODateString(dateString: any): boolean; declare function isValidEmbargoDate(value: unknown): boolean; declare function isTimeString(timeString: any): boolean; declare function timeStringMinutes(timeString?: any): number; declare function extractTime(dateString: any): string | undefined; declare function extractDate(dateString: any): string; declare function convertTime(value: any, time24?: any, keepDate?: any): string | undefined; declare function addDays(date: any, days?: number): string; declare function addWeek(date: any): string; declare function getDateByWeek(week: any, year: any, dateFormat: any, sunday?: boolean): string; declare function timeToDate(timeString: any, date?: string | undefined): Date; declare function addMinutesToTimeString(timeString?: any, minutes?: any): string; declare function sameDay(date1: any, date2: any): boolean; declare const dateTime: { addDays: typeof addDays; addWeek: typeof addWeek; addMinutesToTimeString: typeof addMinutesToTimeString; convertTime: typeof convertTime; getIsoDateString: typeof getIsoDateString; getUTCdateString: (date?: any) => string; DateHHMM: typeof DateHHMM; extractDate: typeof extractDate; extractTime: typeof extractTime; formatDate: typeof formatDate; getDateByWeek: typeof getDateByWeek; isISODateString: typeof isISODateString; isValidEmbargoDate: typeof isValidEmbargoDate; isDate: typeof isDate; isTimeString: typeof isTimeString; offsetDate: typeof offsetDate; offsetTime: typeof offsetTime; sameDay: typeof sameDay; timeStringMinutes: typeof timeStringMinutes; timeToDate: typeof timeToDate; timeUTC: typeof timeUTC; validTimeValue: typeof validTimeValue; validDateString: RegExp; timeValidation: RegExp; dateValidation: RegExp; }; declare function matchUpChronologicalSort(a: HydratedMatchUp, b: HydratedMatchUp): number; declare function matchUpScheduleSort(a: any, b: any): number; declare function structureSort(a: Structure | undefined, b: Structure | undefined, config?: any): number; declare function matchUpSort(a: HydratedMatchUp, b: HydratedMatchUp): number; declare function dehydrateMatchUps({ tournamentRecord }: { tournamentRecord: any; }): { success?: boolean; error?: ErrorType; }; declare const extractAttributes: (accessor: any) => (element: any) => any; declare function definedAttributes(obj: object, ignoreFalse?: boolean, ignoreEmptyArrays?: boolean, shallow?: boolean): any; declare function attributeFilter(params?: any): any; declare function JSON2CSV(arrayOfJSON?: any, config?: any): any; declare function flattenJSON(obj: any, keyJoiner?: string, path?: string[]): any; declare function generateTimeCode(index?: number): string; declare function makeDeepCopy(sourceObject: any, convertExtensions?: any, internalUse?: any, removeExtensions?: any, iteration?: number): any; declare function constantToString(str: any): any; declare function numericSort(a: any, b: any): number; declare function UUIDS(count?: number, pre?: any, random?: () => number): string[]; declare function UUID(pre?: any, random?: () => number): string; declare function isValidIANATimeZone(timeZone: string): boolean; declare function getTimeZoneOffsetMinutes(timeZone: string, date?: Date): number; declare function wallClockToUTC(date: string, time: string, timeZone: string): string | { error: typeof INVALID_TIME_ZONE; }; declare function utcToWallClock(utcIso: string, timeZone: string): { date: string; time: string; } | { error: typeof INVALID_TIME_ZONE; }; declare function toEmbargoUTC(date: string, time: string, timeZone: string): string | { error: typeof INVALID_TIME_ZONE; }; declare const timeZone: { isValidIANATimeZone: typeof isValidIANATimeZone; getTimeZoneOffsetMinutes: typeof getTimeZoneOffsetMinutes; wallClockToUTC: typeof wallClockToUTC; utcToWallClock: typeof utcToWallClock; toEmbargoUTC: typeof toEmbargoUTC; }; declare function unique(arr: any): any[]; declare function noNulls(arr: any): any; declare function shuffleArray(arr: any, random?: () => number): any[]; declare function instanceCount(values: any): { [key: number | string]: number; }; declare function countValues(values: any): { [key: number]: string[]; }; declare function groupValues(obj: any): {}; declare function randomPop(array: any, random?: () => number): any; declare function randomMember(arr: any, random?: () => number): any; declare function generateRange(start: any, end: any): any[]; declare function intersection(a: any, b: any): any[]; declare function overlap(a: any, b: any): boolean; declare function occurrences(val: any, arr: any): any; declare function subSort(arr: any, i: any, n: any, sortFx: any): never[]; declare function chunkArray(arr: any, chunksize: any): any; declare function chunkSizeProfile(arr: number[], [size, ...otherSizes]: number[]): any; declare function allNumeric(arr: any): any; declare function noNumeric(arr: any): any; declare function chunkByNth(arr: any[], chunksCount: number, shuttle?: boolean): any; declare const index$3_JSON2CSV: typeof JSON2CSV; declare const index$3_UUID: typeof UUID; declare const index$3_UUIDS: typeof UUIDS; declare const index$3_allNumeric: typeof allNumeric; declare const index$3_attributeFilter: typeof attributeFilter; declare const index$3_chunkArray: typeof chunkArray; declare const index$3_chunkByNth: typeof chunkByNth; declare const index$3_chunkSizeProfile: typeof chunkSizeProfile; declare const index$3_constantToString: typeof constantToString; declare const index$3_countValues: typeof countValues; declare const index$3_createMap: typeof createMap; declare const index$3_dateTime: typeof dateTime; declare const index$3_definedAttributes: typeof definedAttributes; declare const index$3_dehydrateMatchUps: typeof dehydrateMatchUps; declare const index$3_extractAttributes: typeof extractAttributes; declare const index$3_flattenJSON: typeof flattenJSON; declare const index$3_generateDateRange: typeof generateDateRange; declare const index$3_generateHashCode: typeof generateHashCode; declare const index$3_generateRange: typeof generateRange; declare const index$3_generateTimeCode: typeof generateTimeCode; declare const index$3_groupValues: typeof groupValues; declare const index$3_hasAttributeValues: typeof hasAttributeValues; declare const index$3_instanceCount: typeof instanceCount; declare const index$3_intersection: typeof intersection; declare const index$3_isConvertableInteger: typeof isConvertableInteger; declare const index$3_isNumeric: typeof isNumeric; declare const index$3_isOdd: typeof isOdd; declare const index$3_isPowerOf2: typeof isPowerOf2; declare const index$3_isValidEmbargoDate: typeof isValidEmbargoDate; declare const index$3_makeDeepCopy: typeof makeDeepCopy; declare const index$3_matchUpChronologicalSort: typeof matchUpChronologicalSort; declare const index$3_matchUpScheduleSort: typeof matchUpScheduleSort; declare const index$3_matchUpSort: typeof matchUpSort; declare const index$3_nearestPowerOf2: typeof nearestPowerOf2; declare const index$3_nextPowerOf2: typeof nextPowerOf2; declare const index$3_noNulls: typeof noNulls; declare const index$3_noNumeric: typeof noNumeric; declare const index$3_numericSort: typeof numericSort; declare const index$3_occurrences: typeof occurrences; declare const index$3_overlap: typeof overlap; declare const index$3_randomMember: typeof randomMember; declare const index$3_randomPop: typeof randomPop; declare const index$3_shuffleArray: typeof shuffleArray; declare const index$3_structureSort: typeof structureSort; declare const index$3_subSort: typeof subSort; declare const index$3_timeZone: typeof timeZone; declare const index$3_undefinedToNull: typeof undefinedToNull; declare const index$3_unique: typeof unique; declare const index$3_visualizeScheduledMatchUps: typeof visualizeScheduledMatchUps; declare namespace index$3 { export { index$3_JSON2CSV as JSON2CSV, index$3_UUID as UUID, index$3_UUIDS as UUIDS, index$3_allNumeric as allNumeric, index$3_attributeFilter as attributeFilter, index$3_chunkArray as chunkArray, index$3_chunkByNth as chunkByNth, index$3_chunkSizeProfile as chunkSizeProfile, index$3_constantToString as constantToString, index$3_countValues as countValues, index$3_createMap as createMap, index$3_dateTime as dateTime, index$3_definedAttributes as definedAttributes, index$3_dehydrateMatchUps as dehydrateMatchUps, index$3_extractAttributes as extractAttributes, index$3_flattenJSON as flattenJSON, index$3_generateDateRange as generateDateRange, index$3_generateHashCode as generateHashCode, index$3_generateRange as generateRange, index$3_generateTimeCode as generateTimeCode, index$3_groupValues as groupValues, index$3_hasAttributeValues as hasAttributeValues, index$3_instanceCount as instanceCount, index$3_intersection as intersection, index$3_isConvertableInteger as isConvertableInteger, index$3_isNumeric as isNumeric, index$3_isOdd as isOdd, index$3_isPowerOf2 as isPowerOf2, index$3_isValidEmbargoDate as isValidEmbargoDate, index$3_makeDeepCopy as makeDeepCopy, index$3_matchUpChronologicalSort as matchUpChronologicalSort, index$3_matchUpScheduleSort as matchUpScheduleSort, index$3_matchUpSort as matchUpSort, index$3_nearestPowerOf2 as nearestPowerOf2, index$3_nextPowerOf2 as nextPowerOf2, index$3_noNulls as noNulls, index$3_noNumeric as noNumeric, index$3_numericSort as numericSort, index$3_occurrences as occurrences, index$3_overlap as overlap, index$3_randomMember as randomMember, index$3_randomPop as randomPop, index$3_shuffleArray as shuffleArray, index$3_structureSort as structureSort, index$3_subSort as subSort, index$3_timeZone as timeZone, index$3_undefinedToNull as undefinedToNull, index$3_unique as unique, index$3_visualizeScheduledMatchUps as visualizeScheduledMatchUps, }; } declare const NATIVE = "native"; declare const LEGACY = "legacy"; declare const DUAL = "dual"; type SchemaWriteMode = typeof NATIVE | typeof DUAL | typeof LEGACY; type Notice = { topic: string; payload: any; key?: string; }; type DevContextType = { errors?: boolean | string[]; params?: boolean | string[]; result?: boolean | string[]; exclude?: string[]; [key: string]: any; } | boolean; type ImplemtationGlobalStateTypes = { tournamentRecords: TournamentRecords; subscriptions: { [key: string]: any; }; methods: { [key: string]: any; }; disableNotifications: boolean; tournamentId?: string; notices: Notice[]; modified: boolean; }; declare function setStateProvider(globalStateProvider?: { [key: string]: any; }): { success: boolean; }; declare function createInstanceState(): { error: unknown; success?: undefined; } | { success: boolean; error?: undefined; }; declare function getDevContext(contextCriteria?: { [key: string]: any; }): DevContextType; declare function timeKeeper(action?: string, timer?: string): any; declare function setGlobalLog(loggingFx?: any): void; declare function setDevContext(value?: DevContextType): void; declare function setSchemaWriteMode(mode?: SchemaWriteMode): { success?: boolean; error?: ErrorType; }; declare function getSchemaWriteMode(): SchemaWriteMode; declare function writeNativeEnabled(): boolean; declare function writeLegacyEnabled(): boolean; declare function setSaveDrawDeletions(flag?: boolean): { success?: boolean; error?: ErrorType; }; declare function getSaveDrawDeletions(): boolean; declare function setAuditAuthorityServer(flag?: boolean): { success?: boolean; error?: ErrorType; }; declare function getAuditAuthorityServer(): boolean; declare function disableNotifications(): void; declare function enableNotifications(): void; type DeepCopyAttributes = { threshold?: number; stringify?: string[]; ignore?: string[]; toJSON?: string[]; }; declare function setDeepCopy(value: boolean, attributes: DeepCopyAttributes): void; declare function deepCopyEnabled(): { threshold?: number; modulate?: any; stringify: string[]; ignore: any; toJSON: string[]; enabled: boolean; }; declare function setGlobalSubscriptions(params: any): { error: { message: string; code: string; }; info: string; } | { success: boolean; error?: undefined; info?: undefined; }; declare function setSubscriptions(params: any): any; declare function setGlobalMethods(params?: { [key: string]: any; }): { error: { message: string; code: string; }; info: string; } | { error: { message: string; code: string; }; info?: undefined; } | { success: boolean; error?: undefined; info?: undefined; }; declare function setMethods(params?: { [key: string]: any; }): any; declare function cycleMutationStatus(): any; declare function addNotice(notice: Notice): any; type GetNoticesArgs = { topic: string; }; declare function getMethods(): { [key: string]: any; }; declare function getNotices(params: GetNoticesArgs): any[]; declare function getPayloads(params: GetNoticesArgs): any[]; type DeleteNoticeArgs = { topic?: string; key: string; }; declare function deleteNotice({ key, topic }: DeleteNoticeArgs): any; declare function deleteNotices(): any; declare function getTopics(): any; declare function hasTopic(topic: any): any; type CallListenerArgs = { payloads: any[]; notices?: any[]; topic: string; }; declare function callListener(payload: any): Promise; declare function getTournamentId(): any; declare function getTournamentRecord(tournamentId: string): any; declare function getTournamentRecords(): any; declare function setTournamentRecord(tournamentRecord: ResultType): any; declare function setTournamentRecords(tournamentRecords: any): any; declare function setTournamentId(tournamentId?: string): { success?: boolean; error?: ErrorType; }; declare function removeTournamentRecord(tournamentId: string): any; declare function getProvider(): any; type HandleCaughtErrorArgs = { engineName?: string; methodName: string; params: any; err: any; }; declare function handleCaughtError({ engineName, methodName, params, err }: HandleCaughtErrorArgs): any; declare function globalLog(log: any, engine?: string): void; declare function setStateMethods(submittedMethods: any, traverse: any, maxDepth: any, global: any): { error: { message: string; code: string; }; methods?: undefined; } | { methods: {}; error?: undefined; }; type globalState_CallListenerArgs = CallListenerArgs; type globalState_DeepCopyAttributes = DeepCopyAttributes; type globalState_DeleteNoticeArgs = DeleteNoticeArgs; type globalState_DevContextType = DevContextType; type globalState_GetNoticesArgs = GetNoticesArgs; type globalState_HandleCaughtErrorArgs = HandleCaughtErrorArgs; type globalState_ImplemtationGlobalStateTypes = ImplemtationGlobalStateTypes; type globalState_Notice = Notice; declare const globalState_addNotice: typeof addNotice; declare const globalState_callListener: typeof callListener; declare const globalState_createInstanceState: typeof createInstanceState; declare const globalState_cycleMutationStatus: typeof cycleMutationStatus; declare const globalState_deepCopyEnabled: typeof deepCopyEnabled; declare const globalState_deleteNotice: typeof deleteNotice; declare const globalState_deleteNotices: typeof deleteNotices; declare const globalState_disableNotifications: typeof disableNotifications; declare const globalState_enableNotifications: typeof enableNotifications; declare const globalState_getAuditAuthorityServer: typeof getAuditAuthorityServer; declare const globalState_getDevContext: typeof getDevContext; declare const globalState_getMethods: typeof getMethods; declare const globalState_getNotices: typeof getNotices; declare const globalState_getPayloads: typeof getPayloads; declare const globalState_getProvider: typeof getProvider; declare const globalState_getSaveDrawDeletions: typeof getSaveDrawDeletions; declare const globalState_getSchemaWriteMode: typeof getSchemaWriteMode; declare const globalState_getTopics: typeof getTopics; declare const globalState_getTournamentId: typeof getTournamentId; declare const globalState_getTournamentRecord: typeof getTournamentRecord; declare const globalState_getTournamentRecords: typeof getTournamentRecords; declare const globalState_globalLog: typeof globalLog; declare const globalState_handleCaughtError: typeof handleCaughtError; declare const globalState_hasTopic: typeof hasTopic; declare const globalState_removeTournamentRecord: typeof removeTournamentRecord; declare const globalState_setAuditAuthorityServer: typeof setAuditAuthorityServer; declare const globalState_setDeepCopy: typeof setDeepCopy; declare const globalState_setDevContext: typeof setDevContext; declare const globalState_setGlobalLog: typeof setGlobalLog; declare const globalState_setGlobalMethods: typeof setGlobalMethods; declare const globalState_setGlobalSubscriptions: typeof setGlobalSubscriptions; declare const globalState_setMethods: typeof setMethods; declare const globalState_setSaveDrawDeletions: typeof setSaveDrawDeletions; declare const globalState_setSchemaWriteMode: typeof setSchemaWriteMode; declare const globalState_setStateMethods: typeof setStateMethods; declare const globalState_setStateProvider: typeof setStateProvider; declare const globalState_setSubscriptions: typeof setSubscriptions; declare const globalState_setTournamentId: typeof setTournamentId; declare const globalState_setTournamentRecord: typeof setTournamentRecord; declare const globalState_setTournamentRecords: typeof setTournamentRecords; declare const globalState_timeKeeper: typeof timeKeeper; declare const globalState_writeLegacyEnabled: typeof writeLegacyEnabled; declare const globalState_writeNativeEnabled: typeof writeNativeEnabled; declare namespace globalState { export { globalState_addNotice as addNotice, globalState_callListener as callListener, globalState_createInstanceState as createInstanceState, globalState_cycleMutationStatus as cycleMutationStatus, globalState_deepCopyEnabled as deepCopyEnabled, globalState_deleteNotice as deleteNotice, globalState_deleteNotices as deleteNotices, globalState_disableNotifications as disableNotifications, globalState_enableNotifications as enableNotifications, globalState_getAuditAuthorityServer as getAuditAuthorityServer, globalState_getDevContext as getDevContext, globalState_getMethods as getMethods, globalState_getNotices as getNotices, globalState_getPayloads as getPayloads, globalState_getProvider as getProvider, globalState_getSaveDrawDeletions as getSaveDrawDeletions, globalState_getSchemaWriteMode as getSchemaWriteMode, globalState_getTopics as getTopics, globalState_getTournamentId as getTournamentId, globalState_getTournamentRecord as getTournamentRecord, globalState_getTournamentRecords as getTournamentRecords, globalState_globalLog as globalLog, globalState_handleCaughtError as handleCaughtError, globalState_hasTopic as hasTopic, globalState_removeTournamentRecord as removeTournamentRecord, globalState_setAuditAuthorityServer as setAuditAuthorityServer, globalState_setDeepCopy as setDeepCopy, globalState_setDevContext as setDevContext, globalState_setGlobalLog as setGlobalLog, globalState_setGlobalMethods as setGlobalMethods, globalState_setGlobalSubscriptions as setGlobalSubscriptions, globalState_setMethods as setMethods, globalState_setSaveDrawDeletions as setSaveDrawDeletions, globalState_setSchemaWriteMode as setSchemaWriteMode, globalState_setStateMethods as setStateMethods, globalState_setStateProvider as setStateProvider, globalState_setSubscriptions as setSubscriptions, globalState_setTournamentId as setTournamentId, globalState_setTournamentRecord as setTournamentRecord, globalState_setTournamentRecords as setTournamentRecords, globalState_timeKeeper as timeKeeper, globalState_writeLegacyEnabled as writeLegacyEnabled, globalState_writeNativeEnabled as writeNativeEnabled }; export type { globalState_CallListenerArgs as CallListenerArgs, globalState_DeepCopyAttributes as DeepCopyAttributes, globalState_DeleteNoticeArgs as DeleteNoticeArgs, globalState_DevContextType as DevContextType, globalState_GetNoticesArgs as GetNoticesArgs, globalState_HandleCaughtErrorArgs as HandleCaughtErrorArgs, globalState_ImplemtationGlobalStateTypes as ImplemtationGlobalStateTypes, globalState_Notice as Notice }; } type PolicyDefinition = Record; type PolicyEntry = { policyType: string; definition: PolicyDefinition; version?: string; name: string; }; type RegisterArgs = { definition: PolicyDefinition; policyType: string; version?: string; name: string; }; declare function register({ policyType, name, version, definition }: RegisterArgs): void; type LookupArgs = { policyType: string; version?: string; name: string; }; declare function lookup({ policyType, name, version }: LookupArgs): PolicyDefinition | undefined; type ListArgs = { policyType?: string; }; declare function list({ policyType }?: ListArgs): PolicyEntry[]; type ClearArgs = { policyType?: string; name?: string; }; declare function clear({ policyType, name }?: ClearArgs): void; declare const policyRegistry: { register: typeof register; lookup: typeof lookup; list: typeof list; clear: typeof clear; }; interface PolicyComposer { get(path: string): unknown; extend(other: Record): PolicyComposer; set(path: string, value: unknown): PolicyComposer; merge(path: string, fragment: Record): PolicyComposer; unset(path: string): PolicyComposer; from(args: { name: string; version?: string; }): PolicyComposer; build(): Record; register(args: { name: string; version?: string; }): Record; } declare function policyComposer(policyType?: string): PolicyComposer; type FactoryErrorOptions = { cause?: unknown; methodName?: string; path?: string; context?: Record; info?: string; }; declare class FactoryError extends Error { readonly code: string; readonly methodName?: string; readonly path?: string; readonly context?: Record; readonly info?: string; constructor(code: string, message: string, opts?: FactoryErrorOptions); get suggestions(): string[]; toJSON(): { message: string; code: string; info?: string; }; } declare class MissingTournamentRecordError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingTournamentRecordsError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingDrawDefinitionError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingEventError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingValueError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingSanctioningRecordError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MissingOfficialRecordError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class InvalidValuesError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class InvalidDateError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class ParticipantNotFoundError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class StructureNotFoundError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class MatchUpNotFoundError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare class EventNotFoundError extends FactoryError { constructor(opts?: FactoryErrorOptions); } declare function constructFactoryError(code: string, message: string, opts?: FactoryErrorOptions): FactoryError; type SuggestionFactory = (context?: Record) => string[]; declare function registerSuggestions(code: string, factory: SuggestionFactory): void; declare function getSuggestions(code: string, context?: Record): string[]; type index$2_EventNotFoundError = EventNotFoundError; declare const index$2_EventNotFoundError: typeof EventNotFoundError; type index$2_FactoryError = FactoryError; declare const index$2_FactoryError: typeof FactoryError; type index$2_FactoryErrorOptions = FactoryErrorOptions; type index$2_InvalidDateError = InvalidDateError; declare const index$2_InvalidDateError: typeof InvalidDateError; type index$2_InvalidValuesError = InvalidValuesError; declare const index$2_InvalidValuesError: typeof InvalidValuesError; type index$2_MatchUpNotFoundError = MatchUpNotFoundError; declare const index$2_MatchUpNotFoundError: typeof MatchUpNotFoundError; type index$2_MissingDrawDefinitionError = MissingDrawDefinitionError; declare const index$2_MissingDrawDefinitionError: typeof MissingDrawDefinitionError; type index$2_MissingEventError = MissingEventError; declare const index$2_MissingEventError: typeof MissingEventError; type index$2_MissingOfficialRecordError = MissingOfficialRecordError; declare const index$2_MissingOfficialRecordError: typeof MissingOfficialRecordError; type index$2_MissingSanctioningRecordError = MissingSanctioningRecordError; declare const index$2_MissingSanctioningRecordError: typeof MissingSanctioningRecordError; type index$2_MissingTournamentRecordError = MissingTournamentRecordError; declare const index$2_MissingTournamentRecordError: typeof MissingTournamentRecordError; type index$2_MissingTournamentRecordsError = MissingTournamentRecordsError; declare const index$2_MissingTournamentRecordsError: typeof MissingTournamentRecordsError; type index$2_MissingValueError = MissingValueError; declare const index$2_MissingValueError: typeof MissingValueError; type index$2_ParticipantNotFoundError = ParticipantNotFoundError; declare const index$2_ParticipantNotFoundError: typeof ParticipantNotFoundError; type index$2_StructureNotFoundError = StructureNotFoundError; declare const index$2_StructureNotFoundError: typeof StructureNotFoundError; declare const index$2_constructFactoryError: typeof constructFactoryError; declare const index$2_getSuggestions: typeof getSuggestions; declare const index$2_registerSuggestions: typeof registerSuggestions; declare namespace index$2 { export { index$2_EventNotFoundError as EventNotFoundError, index$2_FactoryError as FactoryError, index$2_InvalidDateError as InvalidDateError, index$2_InvalidValuesError as InvalidValuesError, index$2_MatchUpNotFoundError as MatchUpNotFoundError, index$2_MissingDrawDefinitionError as MissingDrawDefinitionError, index$2_MissingEventError as MissingEventError, index$2_MissingOfficialRecordError as MissingOfficialRecordError, index$2_MissingSanctioningRecordError as MissingSanctioningRecordError, index$2_MissingTournamentRecordError as MissingTournamentRecordError, index$2_MissingTournamentRecordsError as MissingTournamentRecordsError, index$2_MissingValueError as MissingValueError, index$2_ParticipantNotFoundError as ParticipantNotFoundError, index$2_StructureNotFoundError as StructureNotFoundError, index$2_constructFactoryError as constructFactoryError, index$2_getSuggestions as getSuggestions, index$2_registerSuggestions as registerSuggestions }; export type { index$2_FactoryErrorOptions as FactoryErrorOptions }; } declare function asyncEngine(test?: boolean): FactoryEngine & { error?: any; }; declare const syncEngine: FactoryEngine; declare const askEngine: FactoryEngine; declare const matchUpEngine: FactoryEngine; declare const mocksEngine: FactoryEngine; type index$1_ApplyBlockOptions = ApplyBlockOptions; type index$1_ApplyTemplateOptions = ApplyTemplateOptions; type index$1_AvailabilityEngine = AvailabilityEngine; declare const index$1_AvailabilityEngine: typeof AvailabilityEngine; declare const index$1_BLOCK_TYPES: typeof BLOCK_TYPES; type index$1_Block = Block; type index$1_BlockHardness = BlockHardness; type index$1_BlockId = BlockId; type index$1_BlockMutation = BlockMutation; type index$1_BlockSource = BlockSource; type index$1_BlockType = BlockType; type index$1_BlocksChangedEvent = BlocksChangedEvent; type index$1_BridgeConfig = BridgeConfig; type index$1_CapacityCurve = CapacityCurve; type index$1_CapacityDiff = CapacityDiff; type index$1_CapacityPoint = CapacityPoint; type index$1_CapacityStats = CapacityStats; type index$1_ConflictEvaluator = ConflictEvaluator; type index$1_ConflictSeverity = ConflictSeverity; type index$1_ConflictsChangedEvent = ConflictsChangedEvent; type index$1_CourtDayAvailability = CourtDayAvailability; type index$1_CourtId = CourtId; type index$1_CourtMeta = CourtMeta; type index$1_CourtRail = CourtRail; type index$1_CourtRef = CourtRef; type index$1_CourtSchedulingSummary = CourtSchedulingSummary; type index$1_DayId = DayId; type index$1_DayPlan = DayPlan; type index$1_Edge = Edge; type index$1_EngineConfig = EngineConfig; type index$1_EngineConflict = EngineConflict; type index$1_EngineContext = EngineContext; type index$1_EngineEvent = EngineEvent; type index$1_EngineEventType = EngineEventType; type index$1_EngineWarning = EngineWarning; type index$1_EvaluatorRegistry = EvaluatorRegistry; declare const index$1_EvaluatorRegistry: typeof EvaluatorRegistry; type index$1_FixAction = FixAction; type index$1_IssueIndex = IssueIndex; type index$1_MoveBlockOptions = MoveBlockOptions; type index$1_MutationKind = MutationKind; type index$1_MutationResult = MutationResult; type index$1_PlanItem = PlanItem; type index$1_RailSegment = RailSegment; type index$1_ResizeBlockOptions = ResizeBlockOptions; type index$1_Rule = Rule; type index$1_RuleId = RuleId; type index$1_RuleResult = RuleResult; type index$1_SchedulingProfile = SchedulingProfile; type index$1_SchedulingProfileItem = SchedulingProfileItem; type index$1_SchedulingProfileRound = SchedulingProfileRound; type index$1_SchedulingSelection = SchedulingSelection; type index$1_SimulationResult = SimulationResult; type index$1_StateChangedEvent = StateChangedEvent; type index$1_Template = Template; type index$1_TemplateId = TemplateId; type index$1_TemplateOperation = TemplateOperation; type index$1_TimeRange = TimeRange; type index$1_TodsCourt = TodsCourt; type index$1_TodsDateAvailability = TodsDateAvailability; type index$1_TodsVenue = TodsVenue; type index$1_TournamentId = TournamentId; type index$1_ValidationPhase = ValidationPhase; type index$1_ValidationPipelineParams = ValidationPipelineParams; type index$1_ValidationPipelineResult = ValidationPipelineResult; type index$1_ValidationSeverity = ValidationSeverity; type index$1_VenueDayTimeline = VenueDayTimeline; type index$1_VenueId = VenueId; declare const index$1_adjacentBlockEvaluator: typeof adjacentBlockEvaluator; declare const index$1_applyAvailabilityToTournamentRecord: typeof applyAvailabilityToTournamentRecord; declare const index$1_blockDurationEvaluator: typeof blockDurationEvaluator; declare const index$1_buildDayRange: typeof buildDayRange; declare const index$1_buildEdges: typeof buildEdges; declare const index$1_buildSchedulingProfileFromUISelections: typeof buildSchedulingProfileFromUISelections; declare const index$1_calculateCapacityStats: typeof calculateCapacityStats; declare const index$1_calculateCourtHours: typeof calculateCourtHours; declare const index$1_clampDragToCollisions: typeof clampDragToCollisions; declare const index$1_clampToDayRange: typeof clampToDayRange; declare const index$1_compareCapacityCurves: typeof compareCapacityCurves; declare const index$1_computePlanItemId: typeof computePlanItemId; declare const index$1_courtDayKey: typeof courtDayKey; declare const index$1_courtKey: typeof courtKey; declare const index$1_courtOverlapEvaluator: typeof courtOverlapEvaluator; declare const index$1_createFollowByEvaluator: typeof createFollowByEvaluator; declare const index$1_dayBoundaryEvaluator: typeof dayBoundaryEvaluator; declare const index$1_defaultEvaluators: typeof defaultEvaluators; declare const index$1_deriveRailSegments: typeof deriveRailSegments; declare const index$1_diffMinutes: typeof diffMinutes; declare const index$1_extractDay: typeof extractDay; declare const index$1_filterCapacityCurve: typeof filterCapacityCurve; declare const index$1_findBlocksContainingTime: typeof findBlocksContainingTime; declare const index$1_formatConflicts: typeof formatConflicts; declare const index$1_generateCapacityCurve: typeof generateCapacityCurve; declare const index$1_getHighestSeverity: typeof getHighestSeverity; declare const index$1_groupConflictsBySeverity: typeof groupConflictsBySeverity; declare const index$1_hhmmToMinutes: typeof hhmmToMinutes; declare const index$1_intervalsOverlap: typeof intervalsOverlap; declare const index$1_iterateDayTicks: typeof iterateDayTicks; declare const index$1_lightingEvaluator: typeof lightingEvaluator; declare const index$1_maintenanceWindowEvaluator: typeof maintenanceWindowEvaluator; declare const index$1_matchWindowEvaluator: typeof matchWindowEvaluator; declare const index$1_mergeAdjacentSegments: typeof mergeAdjacentSegments; declare const index$1_mergeOverlappingAvailability: typeof mergeOverlappingAvailability; declare const index$1_minutesToHhmm: typeof minutesToHhmm; declare const index$1_overlappingRange: typeof overlappingRange; declare const index$1_railsToDateAvailability: typeof railsToDateAvailability; declare const index$1_rangesOverlap: typeof rangesOverlap; declare const index$1_resolveCourtId: typeof resolveCourtId; declare const index$1_resolveStatus: typeof resolveStatus; declare const index$1_resolveVenueId: typeof resolveVenueId; declare const index$1_runValidationPipeline: typeof runValidationPipeline; declare const index$1_sampleCapacityCurve: typeof sampleCapacityCurve; declare const index$1_snapIsoToGranularity: typeof snapIsoToGranularity; declare const index$1_snapToGranularity: typeof snapToGranularity; declare const index$1_sortBlocksByStart: typeof sortBlocksByStart; declare const index$1_sortEdges: typeof sortEdges; declare const index$1_timeInsideBlock: typeof timeInsideBlock; declare const index$1_todsAvailabilityToBlocks: typeof todsAvailabilityToBlocks; declare const index$1_validateDateAvailability: typeof validateDateAvailability; declare const index$1_validateSchedulingProfileFormat: typeof validateSchedulingProfileFormat; declare const index$1_validateSegments: typeof validateSegments; declare const index$1_venueDayKey: typeof venueDayKey; declare const index$1_venueKey: typeof venueKey; declare namespace index$1 { export { index$1_AvailabilityEngine as AvailabilityEngine, index$1_BLOCK_TYPES as BLOCK_TYPES, index$1_EvaluatorRegistry as EvaluatorRegistry, index$1_adjacentBlockEvaluator as adjacentBlockEvaluator, index$1_applyAvailabilityToTournamentRecord as applyAvailabilityToTournamentRecord, index$1_blockDurationEvaluator as blockDurationEvaluator, index$1_buildDayRange as buildDayRange, index$1_buildEdges as buildEdges, index$1_buildSchedulingProfileFromUISelections as buildSchedulingProfileFromUISelections, index$1_calculateCapacityStats as calculateCapacityStats, index$1_calculateCourtHours as calculateCourtHours, index$1_clampDragToCollisions as clampDragToCollisions, index$1_clampToDayRange as clampToDayRange, index$1_compareCapacityCurves as compareCapacityCurves, index$1_computePlanItemId as computePlanItemId, index$1_courtDayKey as courtDayKey, index$1_courtKey as courtKey, index$1_courtOverlapEvaluator as courtOverlapEvaluator, index$1_createFollowByEvaluator as createFollowByEvaluator, index$1_dayBoundaryEvaluator as dayBoundaryEvaluator, index$1_defaultEvaluators as defaultEvaluators, index$1_deriveRailSegments as deriveRailSegments, index$1_diffMinutes as diffMinutes, index$1_extractDay as extractDay, index$1_filterCapacityCurve as filterCapacityCurve, index$1_findBlocksContainingTime as findBlocksContainingTime, index$1_formatConflicts as formatConflicts, index$1_generateCapacityCurve as generateCapacityCurve, index$1_getHighestSeverity as getHighestSeverity, index$1_groupConflictsBySeverity as groupConflictsBySeverity, index$1_hhmmToMinutes as hhmmToMinutes, index$1_intervalsOverlap as intervalsOverlap, index$1_iterateDayTicks as iterateDayTicks, index$1_lightingEvaluator as lightingEvaluator, index$1_maintenanceWindowEvaluator as maintenanceWindowEvaluator, index$1_matchWindowEvaluator as matchWindowEvaluator, index$1_mergeAdjacentSegments as mergeAdjacentSegments, index$1_mergeOverlappingAvailability as mergeOverlappingAvailability, index$1_minutesToHhmm as minutesToHhmm, index$1_overlappingRange as overlappingRange, index$1_railsToDateAvailability as railsToDateAvailability, index$1_rangesOverlap as rangesOverlap, index$1_resolveCourtId as resolveCourtId, index$1_resolveStatus as resolveStatus, index$1_resolveVenueId as resolveVenueId, index$1_runValidationPipeline as runValidationPipeline, index$1_sampleCapacityCurve as sampleCapacityCurve, index$1_snapIsoToGranularity as snapIsoToGranularity, index$1_snapToGranularity as snapToGranularity, index$1_sortBlocksByStart as sortBlocksByStart, index$1_sortEdges as sortEdges, index$1_timeInsideBlock as timeInsideBlock, index$1_todsAvailabilityToBlocks as todsAvailabilityToBlocks, index$1_validateDateAvailability as validateDateAvailability, index$1_validateSchedulingProfileFormat as validateSchedulingProfileFormat, index$1_validateSegments as validateSegments, index$1_venueDayKey as venueDayKey, index$1_venueKey as venueKey }; export type { index$1_ApplyBlockOptions as ApplyBlockOptions, index$1_ApplyTemplateOptions as ApplyTemplateOptions, index$1_Block as Block, index$1_BlockHardness as BlockHardness, index$1_BlockId as BlockId, index$1_BlockMutation as BlockMutation, index$1_BlockSource as BlockSource, index$1_BlockType as BlockType, index$1_BlocksChangedEvent as BlocksChangedEvent, index$1_BridgeConfig as BridgeConfig, index$1_CapacityCurve as CapacityCurve, index$1_CapacityDiff as CapacityDiff, index$1_CapacityPoint as CapacityPoint, index$1_CapacityStats as CapacityStats, index$1_ConflictEvaluator as ConflictEvaluator, index$1_ConflictSeverity as ConflictSeverity, index$1_ConflictsChangedEvent as ConflictsChangedEvent, index$1_CourtDayAvailability as CourtDayAvailability, index$1_CourtId as CourtId, index$1_CourtMeta as CourtMeta, index$1_CourtRail as CourtRail, index$1_CourtRef as CourtRef, index$1_CourtSchedulingSummary as CourtSchedulingSummary, index$1_DayId as DayId, index$1_DayPlan as DayPlan, index$1_Edge as Edge, index$1_EngineConfig as EngineConfig, index$1_EngineConflict as EngineConflict, index$1_EngineContext as EngineContext, index$1_EngineEvent as EngineEvent, index$1_EngineEventType as EngineEventType, index$1_EngineWarning as EngineWarning, index$1_FixAction as FixAction, index$1_IssueIndex as IssueIndex, index$1_MoveBlockOptions as MoveBlockOptions, index$1_MutationKind as MutationKind, index$1_MutationResult as MutationResult, index$1_PlanItem as PlanItem, index$1_RailSegment as RailSegment, index$1_ResizeBlockOptions as ResizeBlockOptions, index$1_Rule as Rule, index$1_RuleId as RuleId, index$1_RuleResult as RuleResult, index$1_SchedulingProfile as SchedulingProfile, index$1_SchedulingProfileItem as SchedulingProfileItem, index$1_SchedulingProfileRound as SchedulingProfileRound, index$1_SchedulingSelection as SchedulingSelection, index$1_SimulationResult as SimulationResult, index$1_StateChangedEvent as StateChangedEvent, index$1_Template as Template, index$1_TemplateId as TemplateId, index$1_TemplateOperation as TemplateOperation, index$1_TimeRange as TimeRange, index$1_TodsCourt as TodsCourt, index$1_TodsDateAvailability as TodsDateAvailability, index$1_TodsVenue as TodsVenue, index$1_TournamentId as TournamentId, index$1_ValidationPhase as ValidationPhase, index$1_ValidationPipelineParams as ValidationPipelineParams, index$1_ValidationPipelineResult as ValidationPipelineResult, index$1_ValidationSeverity as ValidationSeverity, index$1_VenueDayTimeline as VenueDayTimeline, index$1_VenueId as VenueId }; } type CalendarConflict = { type: 'PROXIMITY' | 'SAME_WEEK' | 'BLACKOUT' | 'MAX_EVENTS_PER_WEEK'; severity: 'error' | 'warning'; message: string; conflictingEvent?: CalendarEvent; }; type ValidationIssue = { field: string; message: string; severity: 'error' | 'warning'; }; declare const sanctioningEngine: { version: () => string; reset: () => { success: boolean; }; getState: () => { sanctioningRecords: any; success: boolean; }; setState: (records: SanctioningRecords) => { success: boolean; }; setSanctioningRecord: (record: SanctioningRecord) => { error: { message: string; code: string; }; context: { message: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; removeSanctioningRecord: (sanctioningId: string) => { error: ErrorType; context: { sanctioningId: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; setActiveSanctioningId: (sanctioningId?: string) => { error: ErrorType; context: { sanctioningId: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; getActiveSanctioningId: () => string | undefined; createSanctioningRecord: (params: any) => { error?: any; sanctioningRecord?: SanctioningRecord; success?: boolean; }; updateProposal: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; status?: undefined; }; } | { error: ErrorType; context: { status: SanctioningStatus; message?: undefined; }; } | { success: boolean; error?: undefined; context?: undefined; }; addEventProposal: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; status?: undefined; }; } | { error: ErrorType; context: { status: SanctioningStatus; message?: undefined; }; } | { eventProposalId: string | undefined; success: boolean; error?: undefined; context?: undefined; }; removeEventProposal: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; status?: undefined; eventProposalId?: undefined; }; } | { error: ErrorType; context: { status: SanctioningStatus; message?: undefined; eventProposalId?: undefined; }; } | { error: ErrorType; context: { eventProposalId: string; message?: undefined; status?: undefined; }; } | { success: boolean; error?: undefined; context?: undefined; }; updateEventProposal: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; status?: undefined; eventProposalId?: undefined; }; } | { error: ErrorType; context: { status: SanctioningStatus; message?: undefined; eventProposalId?: undefined; }; } | { error: ErrorType; context: { eventProposalId: string; message?: undefined; status?: undefined; }; } | { success: boolean; error?: undefined; context?: undefined; }; submitApplication: (params: any) => { error: ErrorType; context: { fromStatus: SanctioningStatus; message: string; toStatus?: undefined; validTargets?: undefined; }; } | { error: ErrorType; context: { fromStatus: SanctioningStatus; toStatus: SanctioningStatus; validTargets: SanctioningStatus[]; message?: undefined; }; } | { error: ErrorType; context: { guard: TransitionGuardType; message: string; }; } | { success: boolean; error?: undefined; } | { error: ErrorType; }; reviewApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; approveApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; conditionallyApprove: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; }; meetCondition: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; conditionId?: undefined; }; } | { error: ErrorType; context: { conditionId: string; message?: undefined; }; } | { allConditionsMet: boolean; success: boolean; error?: undefined; context?: undefined; }; rejectApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; withdrawApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; requestModification: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; requestEndorsement: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; endorseApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; declineEndorsement: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; addReviewNote: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { noteId: string; success: boolean; error?: undefined; context?: undefined; }; activateFromSanctioning: (params: any) => { error: ErrorType; } | { error: { message: string; code: string; }; context: { message: string; }; } | { tournamentRecord: Tournament; success: boolean; error?: undefined; context?: undefined; }; proposeAmendment: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; status?: undefined; }; } | { error: ErrorType; context: { status: SanctioningStatus; message?: undefined; }; } | { error: ErrorType; context: { message: string | undefined; status?: undefined; }; } | { amendmentId: string; severity: AmendmentSeverity; autoApproved: boolean; success: boolean; error?: undefined; context?: undefined; }; reviewAmendment: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; amendmentId?: undefined; }; } | { error: ErrorType; context: { amendmentId: string; message?: undefined; }; } | { approved: boolean; success: boolean; error?: undefined; context?: undefined; }; transitionToPostEvent: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; submitComplianceItem: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; verifyComplianceItem: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { allCompliant: boolean; success: boolean; error?: undefined; context?: undefined; }; waiveComplianceItem: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; flagComplianceIssues: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; closeApplication: (params: any) => { error: ErrorType; } | { success: boolean; error?: undefined; }; checkComplianceDeadlines: (params: any) => { error: ErrorType; } | { overdueCount: number; success: boolean; error?: undefined; }; getSanctioningRecord: (params?: any) => { error: ErrorType; } | { sanctioningRecord: any; success: boolean; error?: undefined; }; getAvailableTransitions: (params?: any) => { error?: any; success?: boolean; availableTransitions?: SanctioningStatus[]; }; getStatusHistory: (params?: any) => { error?: any; success?: boolean; statusHistory?: StatusTransition[]; }; getCompleteness: (params?: any) => { error: ErrorType; } | { completeness: { score: number; totalFields: number; completedFields: number; missingFields: string[]; }; success: boolean; error?: undefined; }; getEligibleTiers: (params: any) => { error: ErrorType; } | { tierEligibilities: { tierName: string; tierLevel: number; eligible: boolean; reasons: string[]; }[]; eligibleTiers: { tierName: string; tierLevel: number; eligible: boolean; reasons: string[]; }[]; success: boolean; error?: undefined; }; validateProposal: (params: any) => { error: ErrorType; } | { valid: boolean; issues: ValidationIssue[]; errors: ValidationIssue[]; warnings: ValidationIssue[]; success: boolean; error?: undefined; }; getCalendarConflicts: (params: any) => { error: ErrorType; context?: undefined; } | { error: { message: string; code: string; }; context: { message: string; }; } | { conflicts: CalendarConflict[]; errors: CalendarConflict[]; warnings: CalendarConflict[]; hasConflicts: boolean; success: boolean; error?: undefined; context?: undefined; }; executionQueue: (directives: SanctioningDirectives, rollbackOnError?: boolean) => any; }; declare const officiatingEngine: { version: () => string; reset: () => { success: boolean; }; getState: () => { officialRecords: any; success: boolean; }; setState: (records: OfficialRecords) => { success: boolean; }; setOfficialRecord: (record: OfficialRecord) => { error: { message: string; code: string; }; context: { message: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; removeOfficialRecord: (officialRecordId: string) => { error: ErrorType; context: { officialRecordId: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; setActiveOfficialRecordId: (officialRecordId?: string) => { error: ErrorType; context: { officialRecordId: string; }; } | { success: boolean; error?: undefined; context?: undefined; }; getActiveOfficialRecordId: () => string | undefined; createOfficialRecord: (params: any) => { error?: any; officialRecord?: OfficialRecord; success?: boolean; }; addCertification: (params: any) => { error?: any; certification?: OfficialCertification; success?: boolean; }; modifyCertification: (params: any) => { error?: any; certification?: OfficialCertification; success?: boolean; }; removeCertification: (params: any) => any; transitionCertificationStatus: (params: any) => { error?: any; certification?: OfficialCertification; success?: boolean; }; addEvaluation: (params: any) => { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; modifyEvaluation: (params: any) => { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; removeEvaluation: (params: any) => any; transitionEvaluationStatus: (params: any) => { error?: any; evaluation?: OfficialEvaluation; success?: boolean; }; assignOfficial: (params: any) => { error?: any; assignment?: OfficialAssignment; success?: boolean; }; removeOfficialAssignment: (params: any) => any; transitionAssignmentStatus: (params: any) => { error?: any; assignment?: OfficialAssignment; success?: boolean; }; addCertificationRequirement: (params: any) => { error?: any; certificationRequirement?: CertificationRequirement; success?: boolean; }; addSuspension: (params: any) => { error?: any; suspension?: OfficialSuspension; success?: boolean; }; removeSuspension: (params: any) => any; addEvaluationPolicy: (params: any) => { error?: any; evaluationPolicy?: EvaluationPolicy; success?: boolean; }; getOfficialRecord: (params?: any) => { error?: any; success?: boolean; officialRecord?: OfficialRecord; }; getOfficialCertifications: (params?: any) => { error?: any; success?: boolean; certifications?: OfficialCertification[]; }; validateCertification: (params: any) => { error?: any; success?: boolean; valid?: boolean; certification?: OfficialCertification; reasons?: string[]; }; getEvaluations: (params?: any) => { error?: any; success?: boolean; evaluations?: OfficialEvaluation[]; }; getEvaluationSummary: (params?: any) => { error?: any; success?: boolean; summary?: EvaluationSummary; }; getOfficialEligibility: (params: any) => { error?: any; success?: boolean; eligible?: boolean; reasons?: string[]; }; getOfficialAssignments: (params?: any) => { error?: any; success?: boolean; assignments?: OfficialAssignment[]; }; getEvaluationTemplate: (params: any) => { error?: any; success?: boolean; fields?: EvaluationFormField[]; evaluationPolicy?: EvaluationPolicy; }; executionQueue: (directives: OfficiatingDirectives, rollbackOnError?: boolean) => any; }; declare const competitionEngine: FactoryEngineTyped; declare const tournamentEngine: FactoryEngineTyped; declare const competitionEngineUntyped: FactoryEngine; declare const tournamentEngineUntyped: FactoryEngine; declare const competitionEngineAsync: FactoryEngine & { error?: any; }; declare const tournamentEngineAsync: FactoryEngine & { error?: any; }; declare function countryToFlag(isoCode: string): string; declare function flagIOC(ioc: string): string; declare const fixtures: { competitionFormats: { INTENNSE_STANDARD: { competitionFormatName: string; matchUpFormat: string; sport: string; timerProfile: { shotClockSeconds: number; segmentTimers: { segmentType: string; direction: string; minutes: number; }[]; changeoverSeconds: number; setBreakSeconds: number; }; timeoutRules: { count: number; per: string; durationSeconds: number; maxPerSide: number; }; substitutionRules: { allowed: boolean; allowedMatchUpTypes: string[]; timing: string; }; playerRules: { maxMinutesPerSegment: number; matchUpTypes: string[]; }; penaltyBoxProfile: { durationSeconds: number; }; penaltyProfile: { sport: string; penaltyTypes: { penaltyType: string; label: string; category: string; }[]; escalation: { step: number; consequence: string; }[]; }; pointProfile: { sport: string; pointResults: ({ result: string; label: string; isServe: boolean; isError?: undefined; } | { result: string; label: string; isServe?: undefined; isError?: undefined; } | { result: string; label: string; isError: boolean; isServe?: undefined; } | { result: string; label: string; isServe: boolean; isError: boolean; })[]; }; pointMultipliers: { condition: { results: string[]; }; value: number; }[]; }; TENNIS_STANDARD: { competitionFormatName: string; matchUpFormat: string; sport: string; timerProfile: { changeoverSeconds: number; setBreakSeconds: number; }; timeoutRules: { count: number; per: string; }; substitutionRules: { allowed: boolean; }; penaltyProfile: { sport: string; penaltyTypes: { penaltyType: string; label: string; category: string; }[]; escalation: { step: number; consequence: string; }[]; }; pointProfile: { sport: string; pointResults: ({ result: string; label: string; isServe: boolean; isError?: undefined; } | { result: string; label: string; isServe?: undefined; isError?: undefined; } | { result: string; label: string; isError: boolean; isServe?: undefined; } | { result: string; label: string; isServe: boolean; isError: boolean; })[]; }; pointMultipliers: never[]; }; }; ratingsParameters: { ELO: { defaultInitialization: number; decimalsCount: number; range: number[]; ascending: boolean; }; NTRP: { accessors: string[]; attributes: { ustaRatingType: string; }; accessor: string; defaultInitialization: number; decimalsCount: number; ascending: boolean; range: number[]; }; UTR: { defaultInitialization: number; accessors: string[]; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; WTN: { attributes: { confidence: { generator: boolean; range: number[]; }; }; accessors: string[]; defaultInitialization: number; accessor: string; ascending: boolean; decimalsCount: number; range: number[]; }; DUPR: { defaultInitialization: number; accessors: string[]; accessor: string; attributes: { reliabilityScore: { generator: boolean; range: number[]; }; }; decimalsCount: number; ascending: boolean; range: number[]; }; UTR_P: { defaultInitialization: number; accessors: string[]; accessor: string; attributes: { verified: { type: string; }; provisional: { type: string; }; }; decimalsCount: number; ascending: boolean; range: number[]; }; UTPR: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; deprecated: boolean; }; PSA: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; attributes: { tournaments: { generator: boolean; range: number[]; }; divisor: { generator: boolean; range: number[]; }; }; }; SQUASH_LEVELS: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; US_SQUASH: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; USATT: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; ITTF: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; USAR: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; }; BWF: { defaultInitialization: number; accessor: string; decimalsCount: number; ascending: boolean; range: number[]; attributes: { tournaments: { generator: boolean; range: number[]; }; }; }; }; matchUpFormats: { FORMAT_STANDARD: string; FORMAT_STANDARD_NOAD: string; FORMAT_ATP_DOUBLES: string; FORMAT_SHORT_SETS: string; FORMAT_FAST4: string; FORMAT_GRAND_SLAM: string; FORMAT_ONE_SET: string; FORMAT_MATCH_TIEBREAK: string; FORMAT_SET3_TB7: string; FORMAT_PRO_SET: string; FORMAT_COLLEGE_PRO_SET: string; TIMED20: string; }; countryToFlag: typeof countryToFlag; tieFormats: { COLLEGE_D3: { collectionDefinitions: { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; COLLEGE_DEFAULT: { collectionDefinitions: ({ collectionName: string; collectionValue: number; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue?: undefined; } | { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; collectionValue?: undefined; })[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; COLLEGE_JUCO: { collectionDefinitions: { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; DOMINANT_DUO: { collectionDefinitions: { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; DOMINANT_DUO_MIXED: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; LAVER_CUP: { collectionDefinitions: { collectionGroupNumber: number; matchUpType: string; matchUpCount: number; matchUpFormat: string; matchUpValue: number; }[]; collectionGroups: { groupNumber: number; groupName: string; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; TEAM_DOUBLES_3_AGGREGATION: { collectionDefinitions: { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; scoreValue: number; }[]; tieFormatName: string; unrestrictedSelections: boolean; winCriteria: { aggregateValue: boolean; }; }; USTA_BREWER_CUP: { collectionDefinitions: ({ category: { ageCategoryCode: string; }; collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; collectionGroupNumber?: undefined; } | { category: { ageCategoryCode: string; }; collectionName: string; collectionGroupNumber: number; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; })[]; collectionGroups: { groupNumber: number; groupName: string; groupValue: number; winCriteria: { valueGoal: number; }; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_OZAKI_CUP: { winCriteria: { valueGoal: number; }; tieFormatName: string; collectionDefinitions: { category: { ageCategoryCode: string; }; matchUpFormat: string; collectionName: string; matchUpType: string; matchUpCount: number; matchUpValue: number; gender: string; }[]; }; USTA_COLLEGE: { collectionDefinitions: ({ collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; collectionValue: number; matchUpValue?: undefined; } | { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; collectionValue?: undefined; })[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_GOLD_TEAM_CHALLENGE: { collectionDefinitions: { collectionName: string; matchUpFormat: string; matchUpType: string; matchUpCount: number; matchUpValue: number; gender: string; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_INTERSECTIONAL: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_LEVEL_1: { collectionDefinitions: { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_SECTION_BATTLE: { collectionDefinitions: ({ category: { ageCategoryCode: string; }; collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; processCodes?: undefined; } | { collectionName: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; processCodes: string[]; category?: undefined; })[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_SOUTHERN_LEVEL_5: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; USTA_TOC: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; scoreValue: number; }[]; tieFormatName: string; winCriteria: { aggregateValue: boolean; }; }; USTA_WTT_ITT: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; scoreValue: number; }[]; tieFormatName: string; winCriteria: { aggregateValue: boolean; }; }; USTA_ZONAL: { collectionDefinitions: { collectionName: string; gender: string; matchUpCount: number; matchUpFormat: string; matchUpType: string; matchUpValue: number; }[]; tieFormatName: string; winCriteria: { valueGoal: number; }; }; }; countries: ({ ioc: string; iso2: string; iso: string; label: string; phone: string; suggested?: undefined; } | { ioc: string; iso2: string; iso: string; label: string; phone: string; suggested: boolean; })[]; policies: { POLICY_AVOIDANCE_COUNTRY: { avoidance: { roundsToSeparate: undefined; policyName: string; policyAttributes: { key: string; }[]; }; }; POLICY_COMPETITION_STANDARD: { competition: { policyName: string; ratingPolicy: { baselineRating: { source: "SCALE"; frozenDuringEvent: true; }; dynamicFormRating: { enabled: true; initializeFrom: "BASELINE"; kFactor: number; logisticScale: number; }; }; pairingPolicy: { method: "DRAW_MATIC"; ratingSource: "DYNAMIC_FORM"; avoidRepeatOpponents: true; sameTeamValue: number; }; victoryPolicy: { primaryRanking: "WINS"; tiebreakOrder: ("DYNAMIC_FORM_RATING" | "HEAD_TO_HEAD" | "POINT_DIFFERENTIAL")[]; }; processingGranularity: "PER_ROUND"; }; }; POLICY_COMPETITION_PRESSURE: { competition: { policyName: string; ratingPolicy: { baselineRating: { source: "SCALE"; frozenDuringEvent: true; }; dynamicFormRating: { enabled: true; initializeFrom: "BASELINE"; kFactor: number; logisticScale: number; }; pressureRating: { enabled: true; expectationSource: "BASELINE_ONLY"; actualOutputMethod: "POINT_SHARE"; weights: { pointShare: number; pointDifferential: number; contextFactor: number; }; }; }; pairingPolicy: { method: "DRAW_MATIC"; ratingSource: "DYNAMIC_FORM"; avoidRepeatOpponents: true; sameTeamValue: number; }; victoryPolicy: { primaryRanking: "PRESSURE_RATING"; tiebreakOrder: ("HEAD_TO_HEAD_PRESSURE" | "POINT_DIFFERENTIAL" | "STRENGTH_OF_OPPOSITION")[]; }; processingGranularity: "PER_MATCHUP"; }; }; POLICY_COMPETITION_SWISS: { competition: { policyName: string; ratingPolicy: { baselineRating: { source: "SCALE"; frozenDuringEvent: true; }; dynamicFormRating: { enabled: true; initializeFrom: "BASELINE"; kFactor: number; logisticScale: number; }; pressureRating: { enabled: true; expectationSource: "BASELINE_ONLY"; actualOutputMethod: "POINT_SHARE"; weights: { pointShare: number; }; }; }; pairingPolicy: { method: "SWISS"; ratingSource: "DYNAMIC_FORM"; avoidRepeatOpponents: true; }; victoryPolicy: { primaryRanking: "WINS"; tiebreakOrder: ("PRESSURE_RATING" | "HEAD_TO_HEAD" | "BUCHHOLZ" | "SONNEBORN_BERGER")[]; }; processingGranularity: "PER_ROUND"; }; }; POLICY_POSITION_ACTIONS_DEFAULT: { positionActions: { policyName: string; enabledStructures: ({ stages: string[]; stageSequences: number[]; enabledActions: never[]; disabledActions: never[]; } | { stages: never[]; stageSequences: never[]; enabledActions: string[]; disabledActions: never[]; })[]; disbledStructures: never[]; otherFlightEntries: boolean; activePositionOverrides: never[]; }; }; POLICY_POSITION_ACTIONS_DISABLED: { positionActions: { policyName: string; enabledStructures: boolean; }; }; POLICY_POSITION_ACTIONS_NO_MOVEMENT: { positionActions: { policyName: string; enabledStructures: { stages: never[]; stageSequences: never[]; enabledActions: string[]; disabledActions: never[]; }[]; }; }; POLICY_POSITION_ACTIONS_UNRESTRICTED: { positionActions: { policyName: string; enabledStructures: never[]; otherFlightEntries: boolean; disableRoundRestrictions: boolean; activePositionOverrides: string[]; }; }; POLICY_PRIVACY_DEFAULT: { participant: { policyName: string; participant: { contacts: boolean; individualParticipants: { onlineResources: boolean; participantName: boolean; participantOtherName: boolean; participantId: boolean; participantRole: boolean; participantStatus: boolean; penalties: boolean; rankings: boolean; ratings: boolean; representing: boolean; participantRoleResponsibilities: boolean; participantType: boolean; person: { addresses: boolean; biographicalInformation: boolean; birthDate: boolean; contacts: boolean; nationalityCode: boolean; nativeFamilyName: boolean; nativeGivenName: boolean; onlineResources: boolean; otherNames: boolean; parentOrganisationId: boolean; passportFamilyName: boolean; passportGivenName: boolean; personId: boolean; personOtherIds: boolean; previousNames: boolean; sex: boolean; standardFamilyName: boolean; standardGivenName: boolean; status: boolean; tennisId: boolean; wheelchair: boolean; }; }; individualParticipantIds: boolean; onlineResources: boolean; participantName: boolean; participantOtherName: boolean; participantId: boolean; participantRole: boolean; participantStatus: boolean; penalties: boolean; rankings: boolean; ratings: boolean; representing: boolean; participantRoleResponsibilities: boolean; participantType: boolean; person: { addresses: boolean; biographicalInformation: boolean; birthDate: boolean; contacts: boolean; nationalityCode: boolean; nativeFamilyName: boolean; nativeGivenName: boolean; onlineResources: boolean; otherNames: boolean; parentOrganisationId: boolean; passportFamilyName: boolean; passportGivenName: boolean; personId: boolean; personOtherIds: boolean; previousNames: boolean; sex: boolean; standardFamilyName: boolean; standardGivenName: boolean; status: boolean; tennisId: boolean; wheelchair: boolean; }; }; }; }; POLICY_RANKING_POINTS_ITF_JUNIOR: { rankingPoints: { policyName: string; policyVersion: string; pointsAuthority: string; validDateRange: { startDate: string; }; awardProfiles: ({ profileName: string; levels: number[]; drawTypes: string[]; eventTypes: string[]; finishingPositionRanges: { 1: number; 2: number; 3: number; 4: number; 5: number; 6: number; 7: number; 8: number; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: number; 2: number; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; }; }; 2: { level: { 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; }; }; }; })[]; aggregationRules: { rollingPeriodDays: number; separateByGender: boolean; perCategory: boolean; countingBuckets: ({ bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints"]; weight?: undefined; } | { bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints"]; weight: number; })[]; }; doublesAttribution: "fullToEach"; }; }; POLICY_RANKING_POINTS_ITF_WTT: { rankingPoints: { policyName: string; policyVersion: string; pointsAuthority: string; validDateRange: { startDate: string; }; awardProfiles: { profileName: string; levels: number[]; drawTypes: string[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 1: number; 2: number; 3: number; 4: number; }; }; 2: number; }; }[]; aggregationRules: { rollingPeriodDays: number; separateByGender: boolean; perCategory: boolean; bestOfCount: number; }; doublesAttribution: "fullToEach"; }; }; POLICY_RANKING_POINTS_BASIC: { rankingPoints: { policyName: string; policyVersion: string; awardProfiles: { profileName: string; finishingPositionRanges: { 1: number; 2: number; 4: number; 8: number; 16: number; 32: number; 64: number; 128: number; }; }[]; requireWinForPoints: boolean; doublesAttribution: "fullToEach"; }; }; POLICY_RANKING_POINTS_ATP: { rankingPoints: { policyName: string; policyVersion: string; pointsAuthority: string; validDateRange: { startDate: string; }; awardProfiles: ({ profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 3: number; 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; 11: number; 12: number; 13: number; }; }; 2: { level: { 3: number; 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; 11: number; 12: number; 13: number; }; }; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 9: number; 10: number; 11: number; 12: number; 13: number; 14: number; 15: number; }; }; 2: { level: { 9: number; 10: number; 11: number; 12: number; 13: number; 14: number; 15: number; }; }; 4: { level: { 9: number; 10: number; 11: number; 12: number; 13: number; 14: number; 15: number; }; }; 8: { level: { 9: number; 10: number; 11: number; 12: number; 13: number; 14: number; 15: number; }; }; }; } | { profileName: string; eventTypes: string[]; finishingPositionRanges: { 1: number; }; })[]; aggregationRules: { rollingPeriodDays: number; separateByGender: boolean; perCategory: boolean; countingBuckets: ({ bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"]; mandatoryRules: { ruleName: string; levels: number[]; }[]; } | { bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"]; mandatoryRules?: undefined; })[]; }; doublesAttribution: "fullToEach"; }; }; POLICY_RANKING_POINTS_WTA: { rankingPoints: { policyName: string; policyVersion: string; pointsAuthority: string; validDateRange: { startDate: string; }; awardProfiles: ({ profileName: string; levels: number[]; eventTypes: string[]; finishingPositionRanges: { 1: number; 2: number; 4: number; 8: number; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: number; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 1: number; 3: number; 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; }; }; 2: { level: { 1: number; 3: number; 4: number; 5: number; 6: number; 7: number; 8: number; 9: number; }; }; 4: { level: { 1: number; 3: number; 4: number; 5: number; 6: number; }; }; 8: { level: { 1: number; }; }; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; }; 2: { level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; }; 4: { level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; }; 8: { level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; }; 16: ({ drawSize: number; threshold: boolean; level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; } | { level: { 7: number; 8: number; 9: number; 10: number; 11: number; }; drawSize?: undefined; threshold?: undefined; })[]; 32: ({ drawSize: number; threshold: boolean; level: { 7: number; 8: number; 9: number; 10: number; }; } | { level: { 7: number; 8: number; 9: number; 10?: undefined; }; drawSize?: undefined; threshold?: undefined; })[]; 64: { level: { 9: number; 10: number; }; }; }; } | { profileName: string; levels: number[]; eventTypes: string[]; stages: string[]; finishingPositionRanges: { 1: { level: { 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; }; }; 2: { level: { 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; }; }; 4: { level: { 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; }; }; 8: { level: { 5: number; 6: number; 7: number; 8: number; 9: number; 10: number; }; }; 16: number; }; })[]; aggregationRules: { rollingPeriodDays: number; separateByGender: boolean; perCategory: boolean; minCountableResults: number; countingBuckets: ({ bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"]; mandatoryRules: ({ ruleName: string; levels: number[]; bestOfCount?: undefined; } | { ruleName: string; levels: number[]; bestOfCount: number; })[]; } | { bucketName: string; eventTypes: string[]; bestOfCount: number; pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"]; mandatoryRules?: undefined; })[]; tiebreakCriteria: readonly ["highestSingleResult", "mostCountingResults"]; }; doublesAttribution: "fullToEach"; }; }; POLICY_ROUND_NAMING_DEFAULT: { roundNaming: { policyName: string; namingConventions: { round: string; pre: string; }; qualifyingFinishMap: { 1: string; }; abbreviatedRoundNamingMap: { 1: string; 2: string; 4: string; }; roundNamingMap: { 1: string; 2: string; 4: string; }; affixes: { roundNumber: string; preFeedRound: string; preQualifying: string; }; stageConstants: { MAIN: string; PLAY_OFF: string; QUALIFYING: string; CONSOLATION: string; }; }; }; POLICY_SCHEDULING_DEFAULT: { scheduling: { allowModificationWhenMatchUpsScheduled: { courts: boolean; venues: boolean; }; defaultTimes: { averageTimes: { categoryNames: never[]; minutes: { default: number; }; }[]; recoveryTimes: { minutes: { DOUBLES: number; default: number; }; }[]; }; defaultDailyLimits: { SINGLES: number; DOUBLES: number; total: number; }; matchUpAverageTimes: { matchUpFormatCodes: string[]; averageTimes: ({ categoryNames: never[]; minutes: { default: number; }; categoryTypes?: undefined; } | { categoryTypes: string[]; minutes: { default: number; }; categoryNames?: undefined; })[]; }[]; matchUpRecoveryTimes: ({ matchUpFormatCodes: string[]; recoveryTimes: { categoryTypes: string[]; minutes: { default: number; DOUBLES: number; }; }[]; } | { matchUpFormatCodes: string[]; recoveryTimes: { categoryTypes: string[]; minutes: { default: number; }; }[]; } | { matchUpFormatCodes: string[]; recoveryTimes: { categoryNames: never[]; minutes: { default: number; }; }[]; })[]; matchUpDailyLimits: never[]; }; }; POLICY_SCORING_DEFAULT: { scoring: { processCodes: { incompleteAssignmentsOnDefault: string[]; }; defaultMatchUpFormat: string; allowDeletionWithScoresPresent: { drawDefinitions: boolean; structures: boolean; }; requireParticipantsForScoring: boolean; requireAllPositionsAssigned: undefined; allowChangePropagation: boolean; stage: { MAIN: { stageSequence: { 1: { requireAllPositionsAssigned: boolean; }; }; }; }; matchUpFormats: never[]; matchUpStatusCodes: { [x: number]: never[]; }; }; }; POLICY_SCORING_USTA: { scoring: { requireAllPositionsAssigned: boolean; stage: { MAIN: { stageSequence: { 1: { requireAllPositionsAssigned: boolean; }; }; }; }; defaultMatchUpFormat: string; matchUpFormats: ({ description: string; matchUpFormat: string; categoryNames: never[]; categoryTypes: never[]; } | { description: string; matchUpFormat: string; categoryNames?: undefined; categoryTypes?: undefined; })[]; matchUpStatusCodes: { [x: number]: ({ description: string; label: string; matchUpStatusCodeDisplay: string; matchUpStatusCode: string; } | { label: string; matchUpStatusCodeDisplay: string; matchUpStatusCode: string; description?: undefined; })[]; WITHDRAWN: { matchUpStatusCodeDisplay: string; matchUpStatusCode: string; label: string; }[]; }; }; }; POLICY_SEEDING_ITF: { seeding: { seedingProfile: { positioning: string; }; validSeedPositions: { ignore: boolean; }; duplicateSeedNumbers: boolean; drawSizeProgression: boolean; policyName: string; seedsCountThresholds: { drawSize: number; minimumParticipantCount: number; seedsCount: number; }[]; }; }; POLICY_SEEDING_DEFAULT: { seeding: { validSeedPositions: { ignore: boolean; }; duplicateSeedNumbers: boolean; drawSizeProgression: boolean; seedingProfile: { drawTypes: { ROUND_ROBIN_WITH_PLAYOFF: { positioning: string; }; ROUND_ROBIN: { positioning: string; }; }; positioning: string; }; policyName: string; seedsCountThresholds: { drawSize: number; minimumParticipantCount: number; seedsCount: number; }[]; }; }; POLICY_OFFICIATING_EVALUATION_CHAIR_UMPIRE: EvaluationPolicy; POLICY_OFFICIATING_EVALUATION_REFEREE: EvaluationPolicy; POLICY_PRINT_DEFAULT: { print: { policyName: string; }; }; }; flagIOC: typeof flagIOC; }; declare function computeRatingDistributionStats({ binWidth, gapThreshold, ratings, }: { ratings: number[]; binWidth?: number; gapThreshold?: number; }): RatingDistributionStats; declare const auditConstants: { AUTO_SCHEDULING_AUDIT: string; DELETE_EVENTS: string; DELETE_DRAW_DEFINITIONS: string; }; declare const competitionFormatConstants: { INTENNSE_STANDARD: string; TENNIS_STANDARD: string; MATCHUP: string; SET: string; HALF: string; SEGMENT: string; BETWEEN_GAMES: string; BETWEEN_POINTS: string; ANY: string; }; declare const drawDefinitionConstants: { MAIN: string; QUALIFYING: string; CONSOLATION: string; ITEM: string; CONTAINER: string; FIRST_MATCHUP: string; WINNER: any; LOSER: any; AD_HOC: string; FEED_IN: string; FLEX_ROUNDS: string; COMPASS: string; PLAY_OFF: string; PAGE_PLAYOFF: string; PAGE_PLAYOFF_ATTRIBUTES: { 0: { name: string; abbreviation: string; }; '0-1': { name: string; abbreviation: string; }; '0-2': { name: string; abbreviation: string; }; }; PLAYOFF: string; SWISS: string; OLYMPIC: string; KNOCKOUT: string; SINGLE_ELIMINATION: string; DOUBLE_ELIMINATION: string; CURTIS: string; FICSF: string; FICQF: string; FICR16: string; MFIC: string; VOLUNTARY_CONSOLATION: string; FIRST_MATCH_LOSER_CONSOLATION: string; FIRST_ROUND_LOSER_CONSOLATION: string; MODIFIED_FEED_IN_CHAMPIONSHIP: string; FEED_IN_CHAMPIONSHIP_TO_R16: string; FEED_IN_CHAMPIONSHIP_TO_QF: string; FEED_IN_CHAMPIONSHIP_TO_SF: string; FEED_IN_CHAMPIONSHIP: string; LUCKY_DRAW: string; ADAPTIVE: string; ROUND_ROBIN_WITH_PLAYOFF: string; ROUND_ROBIN: string; DECIDER: string; BACKDRAW: string; COMPASS_ATTRIBUTES: { 0: { name: string; abbreviation: string; }; '0-1': { name: string; abbreviation: string; }; '0-2': { name: string; abbreviation: string; }; '0-3': { name: string; abbreviation: string; }; '0-1-1': { name: string; abbreviation: string; }; '0-1-2': { name: string; abbreviation: string; }; '0-2-1': { name: string; abbreviation: string; }; '0-1-1-1': { name: string; abbreviation: string; }; }; OLYMPIC_ATTRIBUTES: { 0: { name: string; abbreviation: string; }; '0-1': { name: string; abbreviation: string; }; '0-2': { name: string; abbreviation: string; }; '0-1-1': { name: string; abbreviation: string; }; }; ADAPTIVE_ATTRIBUTES: { 0: { name: string; abbreviation: string; }; '0-1': { name: string; abbreviation: string; }; '0-2': { name: string; abbreviation: string; }; '0-3': { name: string; abbreviation: string; }; '0-1-1': { name: string; abbreviation: string; }; '0-1-2': { name: string; abbreviation: string; }; '0-2-1': { name: string; abbreviation: string; }; '0-1-1-1': { name: string; abbreviation: string; }; }; DRAW: any; RANDOM: any; TOP_DOWN: any; BOTTOM_UP: any; CLUSTER: string; ADJACENT: string; SEPARATE: string; WATERFALL: string; WIN_RATIO: string; ROUND_OUTCOME: string; MULTI_STRUCTURE_DRAWS: string[]; generatedDrawTypes: string[]; stageOrder: { QUALIFYING: number; MAIN: number; PLAY_OFF: number; CONSOLATION: number; VOLUNTARY_CONSOLATION: number; }; finishOrder: { MAIN: number; PLAY_OFF: number; CONSOLATION: number; QUALIFYING: number; VOLUNTARY_CONSOLATION: number; }; AGGREGATE_EVENT_STRUCTURES: string; FINISHING_POSITIONS: string; }; declare const displayConstants: { PUBLIC_DISPLAY: string; ADMIN_DISPLAY: string; }; declare const entryStatusConstants: any; declare const extensionConstants: { ACTIVE_SUSPENSION: string; APPLIED_POLICIES: string; COMPETITION_STATE: string; CONTEXT: string; DELEGATED_OUTCOME: string; DISABLED: string; DISABLE_LINKS: string; DISABLE_AUTO_CALC: string; DISPLAY: string; DRAFT_STATE: string; DRAW_DELETIONS: string; DRAW_PROFILE: string; EVENT_PROFILE: string; EVENT_WITHDRAWAL_REQUESTS: string; FLIGHT_PROFILE: string; GROUPING_ATTRIBUTE: string; LINEUPS: string; LINKED_TOURNAMENTS: string; MUTATION_LOCKS: string; PARTICIPANT_REPRESENTATIVES: string; PERSON_REQUESTS: string; POSITION_ACTIONS: string; RANKING_POINTS: string; REGISTRATION: string; ROUND_TARGET: string; SANCTIONING_CONSTRAINTS: string; SCHEDULE_LIMITS: string; SCHEDULE_TIMING: string; SCHEDULING_PROFILE: string; STATUS_DETAIL: string; SUB_ORDER: string; TALLY: string; TIE_FORMAT_MODIFICATIONS: string; FACTORY: string; }; declare const flightConstants: { SPLIT_LEVEL_BASED: string; SPLIT_WATERFALL: string; SPLIT_SHUTTLE: string; }; declare const genderConstants: { FEMALE_ABBR: string; OTHER_ABBR: string; MIXED_ABBR: string; MALE_ABBR: string; ANY_ABBR: string; FEMALE: string; MIXED: string; OTHER: string; MALE: string; ANY: string; }; declare const keyValueConstants: { OUTCOMEKEYS: string[]; SIDE1KEYS: string[]; SIDE2KEYS: string[]; MODIFIERS: string[]; PROMPT: string; MOVEUP: string[]; MOVEDOWN: string[]; HOTKEYS: string; }; declare const matchUpActionConstants: { REPLACE_TEAM_POSITION_METHOD: string; ASSIGN_TEAM_POSITION_METHOD: string; REMOVE_TEAM_POSITION_METHOD: string; REPLACE_PARTICIPANT: string; SUBSTITUTION_METHOD: string; REMOVE_SUBSTITUTION: string; REMOVE_PARTICIPANT: string; SCHEDULE_METHOD: string; SUBSTITUTION: string; SCHEDULE: string; PENALTY: string; REFEREE: string; STATUS: string; SCORE: string; START: string; END: string; }; declare const matchUpTypes: { SINGLES_MATCHUP: string; SINGLES: string; DOUBLES_MATCHUP: string; DOUBLES: string; TEAM_MATCHUP: string; TEAM: string; HYBRID_MATCHUP: string; HYBRID: string; }; declare const participantRoles: { ADMINISTRATION: any; CAPTAIN: any; COACH: any; COMPETITOR: any; DIRECTOR: any; HOSPITALITY: any; MEDIA: any; MEDICAL: any; OFFICIAL: any; OTHER: any; PHYSIO: any; SECURITY: any; STRINGER: any; SUPERVISOR: any; TRAINER: any; TRANSPORT: any; VOLUNTEER: any; }; declare const penaltyConstants: { COACHING: string; BALL_ABUSE: string; RACKET_ABUSE: string; VERBAL_ABUSE: string; PHYSICAL_ABUSE: string; INELIGIBILITY: string; UNSPORTSMANLIKE_CONDUCT: string; PROHIBITED_SUBSTANCE: string; DRESS_CODE_VIOLATION: string; EQUIMENT_VIOLATION: string; LEAVING_THE_COURT: string; REFUSAL_TO_PLAY: string; FAILURE_TO_COMPLETE: string; NO_SHOW: string; OTHER: string; PUNCTUALITY: string; FAILUIRE_TO_SIGN_IN: string; }; declare const positionActionConstants: { MODIFY_PAIR_ASSIGNMENT: string; QUALIFYING_PARTICIPANT: string; ALTERNATE_PARTICIPANT: string; WITHDRAW_PARTICIPANT: string; ASSIGN_PARTICIPANT: string; LUCKY_PARTICIPANT: string; REMOVE_ASSIGNMENT: string; SWAP_PARTICIPANTS: string; ADD_NICKNAME: string; REMOVE_SEED: string; ADD_PENALTY: string; ASSIGN_BYE: string; SEED_CASCADE: string; SEED_VALUE: string; }; declare const rankingConstants: { RANKING_POINTS: string; QUALITY_WIN: string; FULL_TO_EACH: string; SPLIT_EVEN: string; TEAM_ONLY: string; CATEGORY_SCOPE_FIELDS: readonly ["ageCategoryCodes", "genders", "categoryNames", "categoryTypes", "ratingTypes", "ballTypes", "wheelchairClasses", "subTypes"]; PROFILE_SCOPE_FIELDS: readonly ["eventTypes", "drawTypes", "drawSizes", "maxDrawSize", "stages", "stageSequences", "levels", "maxLevel", "flights", "maxFlightNumber", "participationOrder", "dateRanges"]; }; declare const ratingConstants: { ELO: string; NTRP: string; TRN: string; UTR: string; WTN: string; DUPR: string; UTR_P: string; UTPR: string; PSA: string; SQUASH_LEVELS: string; US_SQUASH: string; USATT: string; ITTF: string; USAR: string; BWF: string; }; declare const requestConstants: { DO_NOT_SCHEDULE: string; }; declare const resourceContants: { RESOURCE_SUB_TYPE: string; RESOURCE_TYPE: string; IDENTIFIER: string; NAME: string; }; declare const resultConstants: { SUCCESS: { success: boolean; }; ERROR: string; }; declare const scaleConstants: { RANKING: string; RATING: string; SCALE: string; SEEDING: string; }; declare const scheduleConstants: { SINGLES_DOUBLES: string; DOUBLES_SINGLES: string; TOTAL: string; CONFLICT_MATCHUP_ORDER: string; CONFLICT_PARTICIPANTS: string; CONFLICT_POTENTIAL_PARTICIPANTS: string; CONFLICT_COURT_DOUBLE_BOOKING: string; CONFLICT_POSITION_LINK: string; SCHEDULE_ISSUE_IDS: string; SCHEDULE_CONFLICT: string; SCHEDULE_WARNING: string; SCHEDULE_ERROR: string; SCHEDULE_ISSUE: string; SCHEDULE_STATE: string; BLOCKED: string; PRACTICE: string; MAINTENANCE: string; }; declare const sortingConstants: { ASC: string; ASCENDING: string; DESC: string; DESCENDING: string; }; declare const surfaceConstants: { CLAY: string; HARD: string; GRASS: string; CARPET: string; ARTIFICIAL: string; }; declare const swissConstants: { BUCHHOLZ: string; MEDIAN_BUCHHOLZ: string; PROGRESSIVE_SCORE: string; RATING_BASED: string; SCORE_GROUP: string; SONNEBORN_BERGER: string; }; declare const tallyConstants: { GEM_SCORE: string; }; declare const tieFormatConstants: { COLLEGE_D3: string; COLLEGE_DEFAULT: string; COLLEGE_JUCO: string; DOMINANT_DUO: string; DOMINANT_DUO_MIXED: string; INTENNSE_2026: string; LAVER_CUP: string; TEAM_DOUBLES_3_AGGREGATION: string; USTA_BREWER_CUP: string; USTA_OZAKI_CUP: string; USTA_COLLEGE: string; USTA_GOLD_TEAM_CHALLENGE: string; USTA_INTERSECTIONAL: string; USTA_LEVEL_1: string; USTA_SECTION_BATTLE: string; USTA_SOUTHERN_LEVEL_5: string; USTA_TOC: string; USTA_WTT_ITT: string; USTA_ZONAL: string; }; declare const timeItemConstants: { MUTUALLY_EXCLUSIVE_TIME_MODIFIERS: string[]; AFTER_REST: string; ALLOCATE_COURTS: string; ASSIGN_COURT: string; ASSIGN_OFFICIAL: string; ASSIGN_VENUE: string; CHECK_IN: string; CHECK_OUT: string; COMPLETED_DATE: string; COURT_ANNOTATION: string; COURT_ORDER: string; ELIGIBILITY: string; END_TIME: string; FOLLOWED_BY: string; MEDICAL: string; MODIFICATION: string; NEXT_AVAILABLE: string; NOT_BEFORE: string; OTHER: string; PENALTY: string; PUBLIC: string; PUBLISH: string; RANKING: string; RATING: string; RAIN_DELAY: string; REGISTRATION: string; RESUME_TIME: string; RETRIEVAL: string; SCALE: string; SCHEDULE: string; SCHEDULED_DATE: string; SCHEDULED_TIME: string; SEEDING: string; START_TIME: string; STATUS: string; STOP_TIME: string; SUSPENSION: string; TIME_MODIFIERS: string; TO_BE_ANNOUNCED: string; }; declare const topicConstants: { ADD_DRAW_DEFINITION: string; ADD_MATCHUPS: string; ADD_PARTICIPANTS: string; ADD_SCALE_ITEMS: string; ADD_EVENT: string; ADD_VENUE: string; AUDIT: string; DATA_ISSUE: string; DELETE_PARTICIPANTS: string; DELETE_VENUE: string; DELETED_DRAW_IDS: string; DELETED_MATCHUP_IDS: string; MODIFY_DRAW_DEFINITION: string; MODIFY_DRAW_ENTRIES: string; MODIFY_EVENT_ENTRIES: string; MODIFY_MATCHUP: string; MODIFY_PARTICIPANTS: string; MODIFY_POSITION_ASSIGNMENTS: string; MODIFY_SEED_ASSIGNMENTS: string; MODIFY_TOURNAMENT_DETAIL: string; MODIFY_VENUE: string; MUTATIONS: string; PUBLISH_EVENT_SEEDING: string; PUBLISH_EVENT: string; PUBLISH_ORDER_OF_PLAY: string; PUBLISH_PARTICIPANTS: string; UNPUBLISH_EVENT_SEEDING: string; UNPUBLISH_EVENT: string; UNPUBLISH_ORDER_OF_PLAY: string; UNPUBLISH_PARTICIPANTS: string; UNPUBLISH_TOURNAMENT: string; UPDATE_INCONTEXT_MATCHUP: string; }; declare const tournamentConstants: { TOURNAMENT_IMAGE_RESOURCE_NAME: string; IN_PROGRESS: string; ABANDONED: string; CANCELLED: string; COMPLETED: string; ACTIVE: string; }; declare const officiatingConstants: { readonly CERT_ACTIVE: "ACTIVE"; readonly CERT_EXPIRED: "EXPIRED"; readonly CERT_SUSPENDED: "SUSPENDED"; readonly CERT_REVOKED: "REVOKED"; readonly CERT_PENDING_RENEWAL: "PENDING_RENEWAL"; readonly EVAL_DRAFT: "DRAFT"; readonly EVAL_SUBMITTED: "SUBMITTED"; readonly EVAL_REVIEWED: "REVIEWED"; readonly EVAL_APPROVED: "APPROVED"; readonly EVAL_REJECTED: "REJECTED"; readonly ASSIGN_PROPOSED: "PROPOSED"; readonly ASSIGN_CONFIRMED: "CONFIRMED"; readonly ASSIGN_DECLINED: "DECLINED"; readonly ASSIGN_CANCELLED: "CANCELLED"; readonly ASSIGN_COMPLETED: "COMPLETED"; readonly VALID_CERTIFICATION_TRANSITIONS: Record; readonly VALID_EVALUATION_TRANSITIONS: Record; readonly VALID_ASSIGNMENT_TRANSITIONS: Record; readonly CERTIFICATION_TERMINAL: CertificationStatus[]; readonly EVALUATION_TERMINAL: EvaluationStatus[]; readonly ASSIGNMENT_TERMINAL: AssignmentStatus[]; readonly EVALUATION_EDITABLE: EvaluationStatus[]; readonly EVALUATION_SCALE_OPTIONS: readonly [{ readonly value: 1; readonly label: "Unsatisfactory"; }, { readonly value: 2; readonly label: "Below Average"; }, { readonly value: 3; readonly label: "Average"; }, { readonly value: 4; readonly label: "Good"; }, { readonly value: 5; readonly label: "Excellent"; }]; }; declare const sanctioningConstants: { readonly DRAFT: "DRAFT"; readonly SUBMITTED: "SUBMITTED"; readonly UNDER_REVIEW: "UNDER_REVIEW"; readonly APPROVED: "APPROVED"; readonly CONDITIONALLY_APPROVED: "CONDITIONALLY_APPROVED"; readonly REJECTED: "REJECTED"; readonly WITHDRAWN: "WITHDRAWN"; readonly MODIFICATION_REQUESTED: "MODIFICATION_REQUESTED"; readonly ACTIVE: "ACTIVE"; readonly POST_EVENT: "POST_EVENT"; readonly CLOSED: "CLOSED"; readonly ISSUES_FLAGGED: "ISSUES_FLAGGED"; readonly VALID_STATUS_TRANSITIONS: Record; readonly TERMINAL_STATUSES: SanctioningStatus[]; readonly EDITABLE_STATUSES: SanctioningStatus[]; readonly AMENDABLE_STATUSES: SanctioningStatus[]; }; declare const venueConstants: { INDOOR: string; OUTDOOR: string; }; declare const weekdayConstants: { MON: string; TUE: string; WED: string; THU: string; FRI: string; SAT: string; SUN: string; }; declare const ENTRY_STATUS_REPORT = "entries.entryStatus"; declare const STRUCTURE_REPORT = "structure.drawReport"; declare const PARTICIPANT_STATS_REPORT = "participant.teamStats"; declare const PARTICIPANT_RESULTS_REPORT = "participant.results"; declare const VENUE_UTILIZATION_REPORT = "venue.utilization"; declare const MATCH_RESULTS_REPORT = "matchUp.results"; declare const MATCHUP_STATUS_REPORT = "matchUp.statusSummary"; declare const SEEDING_PERFORMANCE_REPORT = "participant.seedingPerformance"; declare const COMPETITIVENESS_REPORT = "matchUp.competitiveness"; declare const DRAW_REVISIONS_REPORT = "audit.drawRevisions"; declare const SCHEDULING_CHURN_REPORT = "audit.schedulingChurn"; declare const MUTATION_LOG_REPORT = "audit.mutationLog"; declare const POSITION_CHANGES_REPORT = "audit.positionChanges"; declare const REPORT_CATEGORIES: { readonly ENTRIES: "Entries"; readonly DRAWS: "Draws"; readonly MATCHUPS: "MatchUps"; readonly PARTICIPANTS: "Participants"; readonly SCHEDULING: "Scheduling"; readonly AUDIT: "Audit"; }; declare const REPORT_SOURCE: { readonly FACTORY: "factory"; readonly SERVER: "server"; }; declare const reportConstants_COMPETITIVENESS_REPORT: typeof COMPETITIVENESS_REPORT; declare const reportConstants_DRAW_REVISIONS_REPORT: typeof DRAW_REVISIONS_REPORT; declare const reportConstants_ENTRY_STATUS_REPORT: typeof ENTRY_STATUS_REPORT; declare const reportConstants_MATCHUP_STATUS_REPORT: typeof MATCHUP_STATUS_REPORT; declare const reportConstants_MATCH_RESULTS_REPORT: typeof MATCH_RESULTS_REPORT; declare const reportConstants_MUTATION_LOG_REPORT: typeof MUTATION_LOG_REPORT; declare const reportConstants_PARTICIPANT_RESULTS_REPORT: typeof PARTICIPANT_RESULTS_REPORT; declare const reportConstants_PARTICIPANT_STATS_REPORT: typeof PARTICIPANT_STATS_REPORT; declare const reportConstants_POSITION_CHANGES_REPORT: typeof POSITION_CHANGES_REPORT; declare const reportConstants_REPORT_CATEGORIES: typeof REPORT_CATEGORIES; declare const reportConstants_REPORT_SOURCE: typeof REPORT_SOURCE; declare const reportConstants_SCHEDULING_CHURN_REPORT: typeof SCHEDULING_CHURN_REPORT; declare const reportConstants_SEEDING_PERFORMANCE_REPORT: typeof SEEDING_PERFORMANCE_REPORT; declare const reportConstants_STRUCTURE_REPORT: typeof STRUCTURE_REPORT; declare const reportConstants_VENUE_UTILIZATION_REPORT: typeof VENUE_UTILIZATION_REPORT; declare namespace reportConstants { export { reportConstants_COMPETITIVENESS_REPORT as COMPETITIVENESS_REPORT, reportConstants_DRAW_REVISIONS_REPORT as DRAW_REVISIONS_REPORT, reportConstants_ENTRY_STATUS_REPORT as ENTRY_STATUS_REPORT, reportConstants_MATCHUP_STATUS_REPORT as MATCHUP_STATUS_REPORT, reportConstants_MATCH_RESULTS_REPORT as MATCH_RESULTS_REPORT, reportConstants_MUTATION_LOG_REPORT as MUTATION_LOG_REPORT, reportConstants_PARTICIPANT_RESULTS_REPORT as PARTICIPANT_RESULTS_REPORT, reportConstants_PARTICIPANT_STATS_REPORT as PARTICIPANT_STATS_REPORT, reportConstants_POSITION_CHANGES_REPORT as POSITION_CHANGES_REPORT, reportConstants_REPORT_CATEGORIES as REPORT_CATEGORIES, reportConstants_REPORT_SOURCE as REPORT_SOURCE, reportConstants_SCHEDULING_CHURN_REPORT as SCHEDULING_CHURN_REPORT, reportConstants_SEEDING_PERFORMANCE_REPORT as SEEDING_PERFORMANCE_REPORT, reportConstants_STRUCTURE_REPORT as STRUCTURE_REPORT, reportConstants_VENUE_UTILIZATION_REPORT as VENUE_UTILIZATION_REPORT, }; } declare const recoveryTimeRequiredMatchUpStatuses: any[]; declare const particicipantsRequiredMatchUpStatuses: any[]; declare const validMatchUpStatuses: any[]; declare const directingMatchUpStatuses: any[]; declare const nonDirectingMatchUpStatuses: any[]; declare const completedMatchUpStatuses: any[]; declare const activeMatchUpStatuses: any[]; declare const upcomingMatchUpStatuses: any[]; declare const matchUpStatusConstants: { ABANDONED: any; AWAITING_RESULT: any; BYE: any; CANCELLED: any; COMPLETED: any; DEAD_RUBBER: any; DEFAULTED: any; DOUBLE_WALKOVER: any; DOUBLE_DEFAULT: any; IN_PROGRESS: any; INCOMPLETE: any; NOT_PLAYED: any; RETIRED: any; SUSPENDED: any; TO_BE_PLAYED: any; WALKOVER: any; }; type index_PointsAuthority = PointsAuthority; declare const index_activeMatchUpStatuses: typeof activeMatchUpStatuses; declare const index_auditConstants: typeof auditConstants; declare const index_competitionFormatConstants: typeof competitionFormatConstants; declare const index_completedMatchUpStatuses: typeof completedMatchUpStatuses; declare const index_directingMatchUpStatuses: typeof directingMatchUpStatuses; declare const index_displayConstants: typeof displayConstants; declare const index_drawDefinitionConstants: typeof drawDefinitionConstants; declare const index_entryStatusConstants: typeof entryStatusConstants; declare const index_errorConditionConstants: typeof errorConditionConstants; declare const index_eventConstants: typeof eventConstants; declare const index_extensionConstants: typeof extensionConstants; declare const index_flightConstants: typeof flightConstants; declare const index_genderConstants: typeof genderConstants; declare const index_keyValueConstants: typeof keyValueConstants; declare const index_matchUpActionConstants: typeof matchUpActionConstants; declare const index_matchUpStatusConstants: typeof matchUpStatusConstants; declare const index_matchUpTypes: typeof matchUpTypes; declare const index_nonDirectingMatchUpStatuses: typeof nonDirectingMatchUpStatuses; declare const index_officiatingConstants: typeof officiatingConstants; declare const index_particicipantsRequiredMatchUpStatuses: typeof particicipantsRequiredMatchUpStatuses; declare const index_participantConstants: typeof participantConstants; declare const index_participantRoles: typeof participantRoles; declare const index_participantTypes: typeof participantTypes; declare const index_penaltyConstants: typeof penaltyConstants; declare const index_pointsAuthorityConstants: typeof pointsAuthorityConstants; declare const index_policyConstants: typeof policyConstants; declare const index_positionActionConstants: typeof positionActionConstants; declare const index_rankingConstants: typeof rankingConstants; declare const index_ratingConstants: typeof ratingConstants; declare const index_recoveryTimeRequiredMatchUpStatuses: typeof recoveryTimeRequiredMatchUpStatuses; declare const index_reportConstants: typeof reportConstants; declare const index_requestConstants: typeof requestConstants; declare const index_resourceContants: typeof resourceContants; declare const index_resultConstants: typeof resultConstants; declare const index_sanctioningConstants: typeof sanctioningConstants; declare const index_scaleConstants: typeof scaleConstants; declare const index_scheduleConstants: typeof scheduleConstants; declare const index_sortingConstants: typeof sortingConstants; declare const index_surfaceConstants: typeof surfaceConstants; declare const index_swissConstants: typeof swissConstants; declare const index_tallyConstants: typeof tallyConstants; declare const index_tieFormatConstants: typeof tieFormatConstants; declare const index_timeItemConstants: typeof timeItemConstants; declare const index_topicConstants: typeof topicConstants; declare const index_tournamentConstants: typeof tournamentConstants; declare const index_upcomingMatchUpStatuses: typeof upcomingMatchUpStatuses; declare const index_validMatchUpStatuses: typeof validMatchUpStatuses; declare const index_venueConstants: typeof venueConstants; declare const index_weekdayConstants: typeof weekdayConstants; declare namespace index { export { index_activeMatchUpStatuses as activeMatchUpStatuses, index_auditConstants as auditConstants, index_competitionFormatConstants as competitionFormatConstants, index_completedMatchUpStatuses as completedMatchUpStatuses, index_directingMatchUpStatuses as directingMatchUpStatuses, index_displayConstants as displayConstants, index_drawDefinitionConstants as drawDefinitionConstants, index_entryStatusConstants as entryStatusConstants, index_errorConditionConstants as errorConditionConstants, index_eventConstants as eventConstants, index_extensionConstants as extensionConstants, index_flightConstants as flightConstants, index_genderConstants as genderConstants, index_keyValueConstants as keyValueConstants, index_matchUpActionConstants as matchUpActionConstants, index_matchUpStatusConstants as matchUpStatusConstants, index_matchUpTypes as matchUpTypes, index_nonDirectingMatchUpStatuses as nonDirectingMatchUpStatuses, index_officiatingConstants as officiatingConstants, index_particicipantsRequiredMatchUpStatuses as particicipantsRequiredMatchUpStatuses, index_participantConstants as participantConstants, index_participantRoles as participantRoles, index_participantTypes as participantTypes, index_penaltyConstants as penaltyConstants, index_pointsAuthorityConstants as pointsAuthorityConstants, index_policyConstants as policyConstants, index_positionActionConstants as positionActionConstants, index_rankingConstants as rankingConstants, index_ratingConstants as ratingConstants, index_recoveryTimeRequiredMatchUpStatuses as recoveryTimeRequiredMatchUpStatuses, index_reportConstants as reportConstants, index_requestConstants as requestConstants, index_resourceContants as resourceContants, index_resultConstants as resultConstants, index_sanctioningConstants as sanctioningConstants, index_scaleConstants as scaleConstants, index_scheduleConstants as scheduleConstants, index_sortingConstants as sortingConstants, index_surfaceConstants as surfaceConstants, index_swissConstants as swissConstants, index_tallyConstants as tallyConstants, index_tieFormatConstants as tieFormatConstants, index_timeItemConstants as timeItemConstants, index_topicConstants as topicConstants, index_tournamentConstants as tournamentConstants, index_upcomingMatchUpStatuses as upcomingMatchUpStatuses, index_validMatchUpStatuses as validMatchUpStatuses, index_venueConstants as venueConstants, index_weekdayConstants as weekdayConstants }; export type { index_PointsAuthority as PointsAuthority }; } export { AddressTypeEnum, AmendmentSeverityEnum, AmendmentStatusEnum, AssignmentStatusEnum, AvailabilityEngine, BallTypeEnum, CertificationFamilyEnum, CertificationLevelEnum, CertificationStatusEnum, ComplianceItemStatusEnum, ComplianceItemTypeEnum, ComplianceStatusEnum, CountryCodeEnum, CourtPositionEnum, DrawTypeEnum, EndorsementStatusEnum, EntryStatusEnum, EvaluationStatusEnum, EventNotFoundError, FactoryError, FinishingPositionEnum, InvalidDateError, InvalidValuesError, LengthUnitEnum, LinkTypeEnum, MatchUpNotFoundError, MatchUpStatusEnum, MissingDrawDefinitionError, MissingEventError, MissingOfficialRecordError, MissingSanctioningRecordError, MissingTournamentRecordError, MissingTournamentRecordsError, MissingValueError, OfficialRoleSubtypeEnum, OnlineResourceTypeEnum, ParticipantNotFoundError, ParticipantRoleEnum, ParticipantStatusEnum, ParticipantTypeEnum, PenaltyTypeEnum, PlayingDoubleHandCodeEnum, PlayingHandCodeEnum, PositioningProfileEnum, SanctioningRelationshipEnum, SanctioningStatusEnum, ScoringMethodEnum, ScoringTypeEnum, SeedingProfileEnum, SexEnum, ShotDetailEnum, ShotOutcomeEnum, ShotTypeEnum, StageTypeEnum, StructureNotFoundError, StructureTypeEnum, SurfaceCategoryEnum, TournamentLevelEnum, WeekdayEnum, WheelchairClassEnum, WinReasonEnum, activeMatchUpStatuses, askEngine, asyncEngine, auditConstants, index$1 as availability, index$8 as availabilityGovernor, calculateMatchStatistics, competitionEngine, competitionEngineAsync, competitionEngineUntyped, competitionFormatConstants, index$q as competitionGovernor, completedMatchUpStatuses, computeRatingDistributionStats, constructFactoryError, directingMatchUpStatuses, displayConstants, drawDefinitionConstants, index$p as drawsGovernor, dryRun, index$o as entriesGovernor, entryStatusConstants, errorConditionConstants, index$2 as errors, eventConstants, index$n as eventGovernor, explain, extensionConstants, index as factoryConstants, fixtures, flightConstants, forge, genderConstants, generatePatch, index$m as generationGovernor, globalState, index$4 as governors, keyValueConstants, matchUpActionConstants, matchUpEngine, index$l as matchUpFormatCode, index$l as matchUpFormatGovernor, index$k as matchUpGovernor, matchUpStatusConstants, matchUpTypes, mocksEngine, index$j as mocksGovernor, nonDirectingMatchUpStatuses, officiatingConstants, officiatingEngine, index$7 as officiatingGovernor, particicipantsRequiredMatchUpStatuses, participantConstants, index$i as participantGovernor, participantRoles, participantTypes, penaltyConstants, pointsAuthorityConstants, policyComposer, policyConstants, index$h as policyGovernor, policyRegistry, positionActionConstants, index$6 as practiceGovernor, index$g as publishingGovernor, index$f as queryGovernor, rankingConstants, index$e as rankingGovernor, ratingConstants, recoveryTimeRequiredMatchUpStatuses, registerSuggestions, reportConstants, index$d as reportGovernor, requestConstants, resourceContants, resultConstants, sanctioningConstants, sanctioningEngine, scaleConstants, syncEngine as scaleEngine, scheduleConstants, index$c as scheduleGovernor, index$b as scoreGovernor, sortingConstants, surfaceConstants, swissConstants, syncEngine, tallyConstants, tieFormatConstants, index$a as tieFormatGovernor, timeItemConstants, toStatObjects, index$3 as tools, topicConstants, tournamentConstants, tournamentEngine, tournamentEngineAsync, tournamentEngineUntyped, index$9 as tournamentGovernor, unwrap, unwrapOr, upcomingMatchUpStatuses, index$3 as utilities, validMatchUpStatuses, venueConstants, index$5 as venueGovernor, factoryVersion as version, weekdayConstants }; export type { AddScheduleAttributeArgs, Address, AddressProps, AddressTypeUnion, AggregationRules$2 as AggregationRules, Amendment, AmendmentRules, AmendmentSeverity, AmendmentStatus, Applicant, AssignmentStatus, Availability, AwardProfile, AwardProfileScope, BallTypeUnion, BiographicalInformation, BonusPointDef, Booking, BuildFacade, BuildResult, CalendarContext, CalendarEvent, CalendarRules, CalendarSection, Category, CategoryAggregationRule, CategoryScope, CategoryUnion, CertificationFamily, CertificationLevel, CertificationRequirement, CertificationRequirementResult, CertificationStatus, CheckInOutParticipantArgs, CollectionAssignment$1 as CollectionAssignment, CollectionDefinition, CollectionGroup, CollectionValueProfile, ComplianceItem, ComplianceItemStatus, ComplianceItemType, ComplianceRecord, ComplianceStatus, Condition, ConsolationAppetite, Contact, ContextContent, ContextProfile, Coordinates, CountingBucket$2 as CountingBucket, CountryCodeUnion, Court, CourtPosition, CourtPositionUnion, Credential, DateRange, DerivedFilter, DerivedRanking, Directives, DisciplineUnion, DistributionBin, DistributionGap, DocumentLink, DocumentReference, DoublesAttribution, DrawDefinition, DrawLink, DrawLinkSource, DrawLinkTarget, DrawMaticArgs, DrawOpts, DrawStatusUnion, DrawTypeUnion, DryRunResult, EmittedNotice, Endorsement, EndorsementStatus, EngineInspection, EngineInspectionCounts, EngineMethod, EntriesOpts, Entry, EntryFee, EntryStatusUnion, EvaluationCriterion, EvaluationFormField, EvaluationPolicy, EvaluationScore, EvaluationSection, EvaluationStatus, Event$1 as Event, EventBus, EventHandler, EventPredicate, EventProposal, EventSeed, EventTypeUnion, ExitProfiles, ExplainResult, Extension, FactoryEngine, FactoryEngineMethod, FactoryEngineTyped, FactoryErrorOptions, FinishingPositionUnion, Flight, FlightConfig, FlightProfile, FlightStructure, FlightValues, FlightingStrategy, FlightingStrategyType, Game, GenderInput, GenderUnion, GenerateDrawDefinitionArgs, GetMatchUpsArgs, GroupInfo, GroupsMatchUpsResult, HydratedCourt, HydratedMatchUp, HydratedParticipant, HydratedSide, HydratedVenue, IdCollections, IndoorOutdoorUnion, Interleave, JsonPatch, JsonPatchOp, LengthUnitUnion, LevelKeyed, LineParticipation, LineUp, LineValues, LinkTypeUnion, LogisticsOption, LogisticsSection, MandatoryRule, MappedMatchUps, MappedParticipant, MatchStatistics, MatchUp$1 as MatchUp, MatchUpFilters, MatchUpFinishingPositionRange, MatchUpSchedule, MatchUpStatusUnion, MatchUpsMap, MethodSignatures, OfficialAssignment, OfficialCertification, OfficialEvaluation, OfficialProposal, OfficialRecord, OfficialRecords, OfficialRoleSubtype, OfficialSuspension, OfficiatingDirective, OfficiatingDirectives, OfficiatingStatusTransition, OnlineResource, OnlineResourceTypeUnion, OpponentOutcome, Organisation, Participant$1 as Participant, ParticipantBuildResult, ParticipantFilters, ParticipantMap, ParticipantRoleUnion, ParticipantStatusUnion, ParticipantTypeUnion, ParticipantsProfile, Penalty, PenaltyBoxProfile$1 as PenaltyBoxProfile, PenaltyEscalation, PenaltyProfile$1 as PenaltyProfile, PenaltyTypeDefinition, PenaltyTypeUnion, PerWinPointsDef, Person$1 as Person, PersonData, PersonInput, PersonReference, PersonRequests, PersonnelRole, PersonnelRules, PlanWarning, PlayerRules$1 as PlayerRules, PlayingDoubleHandCodeUnion, PlayingHandCodeUnion, PlayoffAttributes, Point$1 as Point, PointAward$2 as PointAward, PointComponent, PointMultiplier$1 as PointMultiplier, PointPoolModel, PointProfile$1 as PointProfile, PointResultDefinition, PointsAuthority, PolicyComposer, PolicyDefinitions, PositionAssignment, PositionValue, PositionValueObject, PositioningProfileUnion, PostEventRequirement, PracticeRegistration, PracticeRegistrationStatus, PrizeMoney, ProposalChange, QualityWinProfile, QualityWinRange, QueryFacade, QueueMethod, RankedPlan, RankedPlanAggregate, RankingListEntry$1 as RankingListEntry, RankingPolicy, RatingDistributionStats, RegistrationEntryFee, RegistrationProfile, RejectedStrategy, ReportAvailability, ReportColumn, ReportContext, ReportDefinition, ReportResult, RequirementItem, ResultType, ReviewNote, Reviewer, RoundProfile, SanctioningDirective, SanctioningDirectives, SanctioningPolicy, SanctioningRecord, SanctioningRecords, SanctioningRelationship, SanctioningStatus, SanctioningTier, ScaleAttributes, ScaleItem, ScaleOption, ScheduleAnalysis, ScheduleConflict, ScheduleTimesResult, ScheduleTiming, ScheduleVisibilityFilters, ScheduledMatchUpArgs, Score$1 as Score, ScoreGroup, ScoringMethod, ScoringType, SeedAssignment, SeedBlock, SeedingProfile, SeedingProfileUnion, SegmentTimer, ServerRule$1 as ServerRule, Set, SexUnion, Shot, ShotDetailUnion, ShotOutcomeUnion, ShotTypeUnion, Side$1 as Side, SocialEvent, SourceFilter, Sponsor, SportUnion, StageTypeUnion, StatCounters$1 as StatCounters, StatObject, StatisticsOptions, StatusTransition, Structure, StructureKind, StructureParticipation, StructureProfile, StructureRecommendation, StructureSortConfig, StructureTypeUnion, Substitution, SubstitutionRules$1 as SubstitutionRules, SubstitutionTiming, SurfaceCategoryUnion, SwissParticipantRecord, SwissPolicy, SwissStanding, SwissState, Tally, TallyResult, TargetMatchUpId, Team, TeamAttribute, TeamCompetitor$1 as TeamCompetitor, TeamKey, TieFormat, TiebreakCriterion, TierClassification, TimeItem, TimeoutRules$1 as TimeoutRules, TimeoutScope, TimerProfile$1 as TimerProfile, Topic, TopicPayloadMap, Tournament, TournamentLevelUnion, TournamentProposal, TournamentRecords, TournamentStatusUnion, TransitionGuard, TransitionGuardType, UnifiedPersonID, UnifiedTournamentID, UnifiedVenueID, Unsubscribe, Unwrap, Venue, VenueProposal, WeekdayUnion, WeightUnitUnion, WheelchairClassUnion, WinCriteria, WinReasonUnion, WithPlayoffsArgs, WizardConstraints, WizardFlight, WizardGovernance, WizardParticipant, competitionFormat };