tods-competition-factory
Version:
Create and mutate TODS compliant tournament objects
12,797 lines • 424 kB
TypeScript
declare function factoryVersion(): string;
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;
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";
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;
};
interface Tournament {
activeDates?: Date[] | string[];
createdAt?: Date | string;
endDate?: string;
events?: Event$1[];
extensions?: Extension[];
formalName?: string;
hostCountryCode?: CountryCodeUnion;
indoorOutdoor?: IndoorOutdoorUnion;
isMock?: boolean;
localTimeZone?: string;
matchUps?: MatchUp[];
notes?: string;
onlineResources?: OnlineResource[];
parentOrganisationId?: string;
parentOrganisation?: Organisation;
participants?: Participant[];
processCodes?: string[];
promotionalName?: string;
registrationProfile?: RegistrationProfile;
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;
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;
createdAt?: Date | string;
discipline?: DisciplineUnion;
drawDefinitions?: DrawDefinition[];
endDate?: string;
entries?: Entry[];
eventAbbreviation?: string;
eventId: string;
eventLevel?: TournamentLevelUnion;
eventName?: string;
eventOrder?: number;
eventRank?: string;
eventType?: EventTypeUnion;
extensions?: Extension[];
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 enum DrawTypeEnum {
AD_HOC = "AD_HOC",
COMPASS = "COMPASS",
CURTIS_cONSOLATION = "CURTIS_CONSOLATION",
DOUBLE_eLIMINATION = "DOUBLE_ELIMINATION",
FEED_IN = "FEED_IN",
FEED_IN_CHAMPIONSHIP = "FEED_IN_CHAMPIONSHIP",
FEED_IN_CHAMPIONSHIP_TO_QF = "FEED_IN_CHAMPIONSHIP_TO_QF",
FEED_IN_CHAMPIONSHIP_TO_R16 = "FEED_IN_CHAMPIONSHIP_TO_R16",
FEED_In_CHAMPIONSHIP_TO_SF = "FEED_IN_CHAMPIONSHIP_TO_SF",
FIRST_MATCH_LOSER_CONSOLATION = "FIRST_MATCH_LOSER_CONSOLATION",
FIRST_ROUND_LOSER_CONSOLATION = "FIRST_ROUND_LOSER_CONSOLATION",
MODIFIED_FEED_IN_CHAMPIONSHIP = "MODIFIED_FEED_IN_CHAMPIONSHIP",
LUCKY_DRAW = "LUCKY_DRAW",
OLYMPIC = "OLYMPIC",
OTHER = "OTHER",
PLAYOFF = "PLAYOFF",
ROUND_ROBIN = "ROUND_ROBIN",
ROUND_ROBIN_WITH_PLAYOFF = "ROUND_ROBIN_WITH_PLAYOFF",
SINGLE_ELIMINATION = "SINGLE_ELIMINATION"
}
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;
createdAt?: Date | string;
drawId: string;
drawName?: string;
drawOrder?: number;
drawRepresentativeIds?: string[];
drawStatus?: DrawStatusUnion;
drawType?: DrawTypeUnion;
endDate?: string;
entries?: Entry[];
extensions?: Extension[];
isMock?: boolean;
links?: DrawLink[];
matchUpFormat?: string;
matchUps?: MatchUp[];
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;
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 {
createdAt?: Date | string;
drawId?: string;
extensions?: Extension[];
finishingPositions?: number[];
isMock?: boolean;
notes?: string;
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';
interface MatchUp {
collectionId?: string;
collectionPosition?: number;
createdAt?: Date | string;
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;
score?: Score;
sides?: Side[];
startDate?: string;
surfaceCategory?: SurfaceCategoryUnion;
tieFormat?: TieFormat;
tieFormatId?: string;
tieMatchUps?: MatchUp[];
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 {
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;
side1Score?: number;
side1TiebreakScore?: number;
side2PointScore?: number;
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[];
timeItems?: TimeItem[];
updatedAt?: Date | string;
winningSide?: number;
winReason?: WinReasonUnion;
}
interface Point {
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 {
createdAt?: Date | string;
extensions?: Extension[];
isMock?: boolean;
lineUp?: TeamCompetitor[];
notes?: string;
participantId?: string;
participant?: Participant;
sideNumber?: number;
timeItems?: TimeItem[];
updatedAt?: Date | string;
}
interface TeamCompetitor {
collectionAssignments?: CollectionAssignment[];
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 {
collectionId: string;
collectionPosition: 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 {
ANY = "ANY",
FEMALE = "FEMALE",
MALE = "MALE",
MIXED = "MIXED"
}
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 {
createdAt?: Date | string;
extensions?: Extension[];
finishingPosition?: FinishingPositionUnion;
isMock?: boolean;
matchUpFormat?: string;
matchUps?: MatchUp[];
matchUpType?: EventTypeUnion;
notes?: string;
positionAssignments?: PositionAssignment[];
processCodes?: string[];
qualifyingRoundNumber?: number;
roundLimit?: number;
roundOffset?: 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 PositionAssignment {
bye?: boolean;
createdAt?: Date | string;
drawPosition: number;
extensions?: Extension[];
isMock?: boolean;
notes?: string;
participantId?: string;
qualifier?: boolean;
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;
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 = keyof typeof 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 {
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;
personId?: string;
representing?: CountryCodeUnion;
teamId?: string;
timeItems?: TimeItem[];
updatedAt?: Date | string;
}
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",
MEDIA = "MEDIA",
MEDICAL = "MEDICAL",
OFFICIAL = "OFFICIAL",
OTHER = "OTHER",
SECURITY = "SECURITY"
}
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 {
addresses?: Address[];
biographicalInformation?: BiographicalInformation;
birthDate?: string;
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 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;
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;
extensions?: Extension[];
isMock?: boolean;
notes?: string;
timeItems?: TimeItem[];
updatedAt?: Date | string;
withdrawalDeadline?: Date | string;
}
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;
extensions?: Extension[];
isMock?: 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[];
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 {
bookingType?: string;
createdAt?: Date | string;
endTime?: string;
extensions?: Extension[];
isMock?: boolean;
notes?: string;
startTime?: string;
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 {
[key: string | number]: any;
sides?: HydratedSide[];
}
type HydratedParticipant = {
individualParticipants?: HydratedParticipant[];
[key: string | number]: any;
} & Participant;
type HydratedSide = Side & {
participant?: HydratedParticipant;
[key: string | number]: any;
};
type ErrorType = {
message: string;
info?: string;
code: string;
};
declare const errorConditionConstants: {
ANACHRONISM: {
message: string;
code: string;
};
CANNOT_CHANGE_WINNING_SIDE: {
message: string;
code: string;
};
CANNOT_MODIFY_TIEFORMAT: {
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;
};
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;
};
MATCHUP_NOT_FOUND: {
message: string;
code: string;
};
METHOD_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;
};
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;
};
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;
};
};
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_AUDIT = "audit";
declare const POLICY_TYPE_DRAWS = "draws";
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_FEED_IN | typeof POLICY_TYPE_SCORING | typeof POLICY_TYPE_SEEDING | typeof POLICY_TYPE_AUDIT | typeof POLICY_TYPE_DRAWS;
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_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_AUDIT: "audit";
readonly POLICY_TYPE_DRAWS: "draws";
};
type FactoryEngine = {
[key: string]: any;
};
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;
scaleType: string;
scaleName: 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 StructureParticipation = {
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 LineUp = TeamCompetitor[];
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;
drawTypeCoercion?: boolean;
ignoreStageSpace?: boolean;
qualifyingProfiles?: any[];
drawMatic?: DrawMaticArgs;
qualifyingOnly?: boolean;
drawType?: DrawTypeUnion;
enforceGender?: boolean;
processCodes?: string[];
matchUpFormat?: string;
structureName?: string;
tieFormatName?: string;
tieFormat?: TieFormat;
drawEntries?: Entry[];
roundsCount?: number;
seedsCount?: number;
placeByes?: boolean;
drawName?: string;
drawSize?: number;
idPrefix?: string;
isMock?: boolean;
uuids?: string[];
drawId?: string;
event: Event$1;
};
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[];
dynamicRatings?: boolean;
refreshDynamic?: boolean;
encounterValue?: number;
sameTeamValue?: number;
scaleAccessor?: string;
maxIterations?: number;
matchUpIds?: string[];
structure?: Structure;
roundsCount?: number;
structureId?: string;
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[] | undefined;
itemStructureIds: string[];
structureName?: string;
};
};
type MatchUpsMap = {
mappedMatchUps: MappedMatchUps;
drawMatchUps: MatchUp[];
};
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$d_linkTournaments: typeof linkTournaments;
declare const mutate$d_unlinkTournament: typeof unlinkTournament;
declare const mutate$d_unlinkTournaments: typeof unlinkTournaments;
declare namespace mutate$d {
export {
mutate$d_linkTournaments as linkTournaments,
mutate$d_unlinkTournament as unlinkTournament,
mutate$d_unlinkTournaments as unlinkTournaments,
};
}
declare function getLinkedTournamentIds({ tournamentRecords, }: {
tournamentRecords: TournamentRecords;
}): ResultType & {
linkedTournamentIds?: string[];
};
declare function getTournamentIds({ tournamentRecords }: {
tournamentRecords: any;
}): {
success: boolean;
tournamentIds: string[];
};
declare const query$c_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const query$c_getTournamentIds: typeof getTournamentIds;
declare namespace query$c {
export {
query$c_getLinkedTournamentIds as getLinkedTournamentIds,
query$c_getTournamentIds as getTournamentIds,
};
}
declare const index$k_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const index$k_getTournamentIds: typeof getTournamentIds;
declare const index$k_linkTournaments: typeof linkTournaments;
declare const index$k_unlinkTournament: typeof unlinkTournament;
declare const index$k_unlinkTournaments: typeof unlinkTournaments;
declare namespace index$k {
export {
index$k_getLinkedTournamentIds as getLinkedTournamentIds,
index$k_getTournamentIds as getTournamentIds,
index$k_linkTournaments as linkTournaments,
mutate$d as mutate,
query$c as query,
index$k_unlinkTournament as unlinkTournament,
index$k_unlinkTournaments as unlinkTournaments,
};
}
declare function setDrawParticipantRepresentativeIds({ representativeParticipantIds, drawDefinition }: {
representativeParticipantIds: any;
drawDefinition: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
};
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 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;
};
declare function luckyLoserDrawPositionAssignment(params: any): ResultType | {
error: {
message: string;
code: string;
};
};
type ShiftRoundsArgs = {
drawDefinition: DrawDefinition;
targetRoundNumber: number;
roundNumber: number;
structureId: string;
};
declare function shiftAdHocRounds(params: ShiftRoundsArgs): ResultType;
declare function setPositionAssignments({ structurePositionAssignments, provisionalPositioning, tournamentRecord, drawDefinition, event, }: {
structurePositionAssignments: any;
provisionalPositioning: any;
tournamentRecord: any;
drawDefinition: any;
event: any;
}): any;
type SwapRoundsArgs = {
roundNumbers: [number, number];
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
structureId: string;
event?: Event$1;
};
declare function swapAdHocRounds(params: SwapRoundsArgs): 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;
};
};
declare function removeDrawPositionAssignment(params: any): ResultType & {
participantId?: string;
};
type StructurePositionAssignmentType = {
positionAssignments: PositionAssignment[];
structureId: string;
};
type AutomatedPlayoffPositioningArgs = {
provisionalPositioning?: boolean;
seedingProfile?: SeedingProfile;
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
applyPositioning?: boolean;
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 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;
};
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 QualifierProgressionArgs {
drawDefinition: DrawDefinition;
tournamentRecord: Tournament;
targetRoundNumber?: number;
event: Event$1;
randomList?: number[];
}
declare function qualifierProgression({ targetRoundNumber, tournamentRecord, drawDefinition, event, randomList, }: QualifierProgressionArgs): ResultType;
declare function setStructureOrder({ drawDefinition, orderMap }: {
drawDefinition: any;
orderMap: any;
}): ResultType;
declare function attachQualifyingStructure(params: any): ResultType;
type RenameStructuresArgs = {
drawDefinition: DrawDefinition;
structureDetails: {
structureId: string;
structureName: string;
}[];
};
declare function renameStructures({ drawDefinition, structureDetails }: RenameStructuresArgs): ResultType;
type AssignDrawPositionByeArgs = {
provisionalPositioning?: boolean;
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
isPositionAction?: boolean;
matchUpsMap?: MatchUpsMap;
structure?: Structure;
drawPosition: number;
structureId?: string;
event?: Event$1;
};
declare function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, structureId, structure, event, }: AssignDrawPositionByeArgs): any;
declare function addDrawDefinitionTimeItem({ drawDefinition, timeItem }: {
drawDefinition: any;
timeItem: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
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;
};
declare function addVoluntaryConsolationStage(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
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;
};
declare function swapDrawPositionAssignments({ tournamentRecord, drawDefinition, drawPositions, structureId, event }: {
tournamentRecord: any;
drawDefinition: any;
drawPositions: any;
structureId: any;
event: any;
}): any;
type RemoveSeededParticipantArgs = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
participantId: string;
structureId: string;
};
declare function removeSeededParticipant({ tournamentRecord, drawDefinition, participantId, structureId, }: RemoveSeededParticipantArgs): ResultType;
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 AdHocPositionSwapArgs = {
drawDefinition: DrawDefinition;
tournamentRecord: Tournament;
participantIds: string[];
structureId: string;
roundNumber: number;
event: Event$1;
};
declare function adHocPositionSwap(params: AdHocPositionSwapArgs): ResultType;
declare function addPlayoffStructures(params: any): ResultType & {
addedStructureIds?: 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;
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 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 resetDrawDefinition({ tournamentRecord, removeScheduling, drawDefinition }: {
tournamentRecord: any;
removeScheduling: any;
drawDefinition: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function pruneDrawDefinition({ matchPlayDrawPositions, tournamentRecord, drawDefinition, drawId, }: {
matchPlayDrawPositions?: boolean | undefined;
tournamentRecord: any;
drawDefinition: any;
drawId: any;
}): {
error: {
message: string;
code: string;
};
} | {
matchUps: MatchUp[];
success: boolean;
error?: undefined;
};
declare function assignDrawPosition({ tournamentRecord, drawDefinition, participantId, drawPosition, structureId, qualifier, event, bye, }: {
tournamentRecord: any;
drawDefinition: any;
participantId: any;
drawPosition: any;
structureId: any;
qualifier: any;
event: any;
bye: any;
}): any;
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 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 UpdateTeamLineUpArgs = {
drawDefinition: DrawDefinition;
participantId: string;
tieFormat: TieFormat;
drawId?: string;
lineUp: LineUp;
};
declare function updateTeamLineUp({ drawDefinition, participantId, tieFormat, lineUp }: UpdateTeamLineUpArgs): {
success?: boolean;
error?: ErrorType;
};
type AddAdHocMatchUpsParams = {
suppressNotifications?: boolean;
tournamentRecord: any;
structureId?: string;
drawDefinition: any;
matchUps: any[];
event: any;
};
declare function addAdHocMatchUps(params: AddAdHocMatchUpsParams): ResultType;
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;
};
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;
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 const mutate$c_adHocPositionSwap: typeof adHocPositionSwap;
declare const mutate$c_addAdHocMatchUps: typeof addAdHocMatchUps;
declare const mutate$c_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem;
declare const mutate$c_addPlayoffStructures: typeof addPlayoffStructures;
declare const mutate$c_addQualifyingStructure: typeof addQualifyingStructure;
declare const mutate$c_addVoluntaryConsolationStage: typeof addVoluntaryConsolationStage;
declare const mutate$c_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure;
declare const mutate$c_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment;
declare const mutate$c_assignDrawPosition: typeof assignDrawPosition;
declare const mutate$c_assignDrawPositionBye: typeof assignDrawPositionBye;
declare const mutate$c_attachConsolationStructures: typeof attachConsolationStructures;
declare const mutate$c_attachPlayoffStructures: typeof attachPlayoffStructures;
declare const mutate$c_attachQualifyingStructure: typeof attachQualifyingStructure;
declare const mutate$c_attachStructures: typeof attachStructures;
declare const mutate$c_automatedPlayoffPositioning: typeof automatedPlayoffPositioning;
declare const mutate$c_automatedPositioning: typeof automatedPositioning;
declare const mutate$c_deleteAdHocMatchUps: typeof deleteAdHocMatchUps;
declare const mutate$c_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment;
declare const mutate$c_modifyDrawDefinition: typeof modifyDrawDefinition;
declare const mutate$c_modifyDrawName: typeof modifyDrawName;
declare const mutate$c_modifySeedAssignment: typeof modifySeedAssignment;
declare const mutate$c_pruneDrawDefinition: typeof pruneDrawDefinition;
declare const mutate$c_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment;
declare const mutate$c_qualifierProgression: typeof qualifierProgression;
declare const mutate$c_removeDrawPositionAssignment: typeof removeDrawPositionAssignment;
declare const mutate$c_removeRoundMatchUps: typeof removeRoundMatchUps;
declare const mutate$c_removeSeededParticipant: typeof removeSeededParticipant;
declare const mutate$c_removeStructure: typeof removeStructure;
declare const mutate$c_renameStructures: typeof renameStructures;
declare const mutate$c_resetDrawDefinition: typeof resetDrawDefinition;
declare const mutate$c_resetQualifyingStructure: typeof resetQualifyingStructure;
declare const mutate$c_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure;
declare const mutate$c_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds;
declare const mutate$c_setPositionAssignments: typeof setPositionAssignments;
declare const mutate$c_setStructureOrder: typeof setStructureOrder;
declare const mutate$c_setSubOrder: typeof setSubOrder;
declare const mutate$c_shiftAdHocRounds: typeof shiftAdHocRounds;
declare const mutate$c_swapAdHocRounds: typeof swapAdHocRounds;
declare const mutate$c_swapDrawPositionAssignments: typeof swapDrawPositionAssignments;
declare const mutate$c_updateTeamLineUp: typeof updateTeamLineUp;
declare const mutate$c_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition;
declare namespace mutate$c {
export {
mutate$c_adHocPositionSwap as adHocPositionSwap,
mutate$c_addAdHocMatchUps as addAdHocMatchUps,
mutate$c_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem,
mutate$c_addPlayoffStructures as addPlayoffStructures,
mutate$c_addQualifyingStructure as addQualifyingStructure,
mutate$c_addVoluntaryConsolationStage as addVoluntaryConsolationStage,
mutate$c_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure,
mutate$c_alternateDrawPositionAssignment as alternateDrawPositionAssignment,
mutate$c_assignDrawPosition as assignDrawPosition,
mutate$c_assignDrawPositionBye as assignDrawPositionBye,
mutate$c_attachConsolationStructures as attachConsolationStructures,
mutate$c_attachPlayoffStructures as attachPlayoffStructures,
mutate$c_attachQualifyingStructure as attachQualifyingStructure,
mutate$c_attachStructures as attachStructures,
mutate$c_automatedPlayoffPositioning as automatedPlayoffPositioning,
mutate$c_automatedPositioning as automatedPositioning,
mutate$c_deleteAdHocMatchUps as deleteAdHocMatchUps,
mutate$c_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment,
mutate$c_modifyDrawDefinition as modifyDrawDefinition,
mutate$c_modifyDrawName as modifyDrawName,
mutate$c_modifySeedAssignment as modifySeedAssignment,
mutate$c_pruneDrawDefinition as pruneDrawDefinition,
mutate$c_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment,
mutate$c_qualifierProgression as qualifierProgression,
mutate$c_removeDrawPositionAssignment as removeDrawPositionAssignment,
mutate$c_removeRoundMatchUps as removeRoundMatchUps,
mutate$c_removeSeededParticipant as removeSeededParticipant,
mutate$c_removeStructure as removeStructure,
mutate$c_renameStructures as renameStructures,
mutate$c_resetDrawDefinition as resetDrawDefinition,
mutate$c_resetQualifyingStructure as resetQualifyingStructure,
mutate$c_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure,
mutate$c_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds,
mutate$c_setPositionAssignments as setPositionAssignments,
mutate$c_setStructureOrder as setStructureOrder,
mutate$c_setSubOrder as setSubOrder,
mutate$c_shiftAdHocRounds as shiftAdHocRounds,
mutate$c_swapAdHocRounds as swapAdHocRounds,
mutate$c_swapDrawPositionAssignments as swapDrawPositionAssignments,
mutate$c_updateTeamLineUp as updateTeamLineUp,
mutate$c_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition,
};
}
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[];
losingParticipantIds?: string[];
error?: ErrorType;
};
type GetAvailableMatchUpsCountArgs = {
drawDefinition: DrawDefinition;
structureId?: string;
roundNumber?: number;
};
declare function getAvailableMatchUpsCount(params: GetAvailableMatchUpsCountArgs): ResultType & {
availableMatchUpsCount?: number;
roundMatchUpsCount?: number;
lastRoundNumber?: number;
};
declare function getDrawParticipantRepresentativeIds({ drawDefinition }: {
drawDefinition: any;
}): (ResultType & {
extension?: Extension;
}) | {
representativeParticipantIds: any;
};
type GetValidGroupSizesArgs = {
groupSizeLimit?: number;
drawSize: number;
};
declare function getValidGroupSizes(params: GetValidGroupSizesArgs): ResultType & {
validGroupSizes?: number[];
};
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;
};
};
type GetAvailablePlayoffProfileArgs = {
drawDefinition: DrawDefinition;
structureId?: string;
};
declare function getAvailablePlayoffProfiles({ drawDefinition, structureId }: GetAvailablePlayoffProfileArgs): any;
type GetParticipantIdFinishingPositionsArgs = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
byeAdvancements?: boolean;
};
declare function getParticipantIdFinishingPositions({ byeAdvancements, tournamentRecord, drawDefinition, }: GetParticipantIdFinishingPositionsArgs): any;
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 GetAssignedParticipantIdsArgs = {
drawDefinition: DrawDefinition;
stages?: StageTypeUnion[];
};
declare function getAssignedParticipantIds({ drawDefinition, stages }: GetAssignedParticipantIdsArgs): ResultType & {
assignedParticipantIds?: string[];
};
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;
};
type PositionActionsArgs = {
inContextDrawMatchUps?: HydratedMatchUp[];
restrictAdHocRoundParticipants?: boolean;
tournamentParticipants?: Participant[];
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 getDrawTypeCoercionArgs = {
policyDefinitions?: PolicyDefinitions;
appliedPolicies?: PolicyDefinitions;
drawType?: string;
};
declare function getDrawTypeCoercion({ policyDefinitions, appliedPolicies, drawType }: getDrawTypeCoercionArgs): any;
interface GetRandomQualifierListParams {
drawDefinition: DrawDefinition;
}
declare const getRandomQualifierList: ({ drawDefinition }: GetRandomQualifierListParams) => any[] | ResultType;
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;
};
declare function isValidForQualifying({ structureId, drawDefinition }: {
structureId: any;
drawDefinition: any;
}): {
error: {
message: string;
code: string;
};
links?: undefined;
} | {
valid: boolean;
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;
};
type GetSeedingThresholdsArgs = {
roundRobinGroupsCount?: number;
participantsCount: number;
};
declare function getSeedingThresholds({ roundRobinGroupsCount, participantsCount, }: GetSeedingThresholdsArgs): ResultType & {
seedingThresholds?: any;
success?: boolean;
};
declare function getTeamLineUp({ drawDefinition, participantId }: {
drawDefinition: any;
participantId: any;
}): {
error: {
message: string;
code: string;
};
lineUp?: undefined;
} | {
lineUp: any;
error?: undefined;
};
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;
};
type CheckValidEntriesArgs = {
policyDefinitions?: PolicyDefinitions;
appliedPolicies?: PolicyDefinitions;
participantMap?: ParticipantMap;
tournamentRecord?: Tournament;
participants?: Participant[];
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;
};
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;
}): {
participant?: Participant;
tournamentId?: string;
error?: ErrorType;
} | {
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 GetMatchUpsMapArgs = {
drawDefinition?: DrawDefinition;
structure?: Structure;
};
declare function getMatchUpsMap({ drawDefinition, structure }: GetMatchUpsMapArgs): MatchUpsMap;
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 IsAdHocArgs = {
structure?: any;
};
declare function isAdHoc({ structure }: IsAdHocArgs): boolean;
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 const query$b_addGoesTo: typeof addGoesTo;
declare const query$b_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const query$b_checkValidEntries: typeof checkValidEntries;
declare const query$b_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const query$b_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const query$b_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const query$b_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const query$b_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const query$b_getDrawStructures: typeof getDrawStructures;
declare const query$b_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const query$b_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const query$b_getMatchUpsMap: typeof getMatchUpsMap;
declare const query$b_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const query$b_getPositionAssignments: typeof getPositionAssignments;
declare const query$b_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const query$b_getRandomQualifierList: typeof getRandomQualifierList;
declare const query$b_getSeedingThresholds: typeof getSeedingThresholds;
declare const query$b_getSeedsCount: typeof getSeedsCount;
declare const query$b_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const query$b_getTeamLineUp: typeof getTeamLineUp;
declare const query$b_getValidGroupSizes: typeof getValidGroupSizes;
declare const query$b_isAdHoc: typeof isAdHoc;
declare const query$b_isCompletedStructure: typeof isCompletedStructure;
declare const query$b_isValidForQualifying: typeof isValidForQualifying;
declare const query$b_positionActions: typeof positionActions;
declare namespace query$b {
export {
query$b_addGoesTo as addGoesTo,
query$b_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
query$b_checkValidEntries as checkValidEntries,
publicFindDrawDefinition as findDrawDefinition,
query$b_getAssignedParticipantIds as getAssignedParticipantIds,
query$b_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
query$b_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
query$b_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
query$b_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
query$b_getDrawStructures as getDrawStructures,
query$b_getDrawTypeCoercion as getDrawTypeCoercion,
query$b_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
query$b_getMatchUpsMap as getMatchUpsMap,
query$b_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
query$b_getPositionAssignments as getPositionAssignments,
query$b_getPositionsPlayedOff as getPositionsPlayedOff,
query$b_getRandomQualifierList as getRandomQualifierList,
query$b_getSeedingThresholds as getSeedingThresholds,
query$b_getSeedsCount as getSeedsCount,
query$b_getStructureSeedAssignments as getStructureSeedAssignments,
query$b_getTeamLineUp as getTeamLineUp,
query$b_getValidGroupSizes as getValidGroupSizes,
query$b_isAdHoc as isAdHoc,
query$b_isCompletedStructure as isCompletedStructure,
query$b_isValidForQualifying as isValidForQualifying,
query$b_positionActions as positionActions,
};
}
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[];
links?: DrawLink[];
success?: boolean;
};
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;
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 GenerateDrawMaticRoundArgs = {
adHocRatings?: {
[key: string]: number;
};
updateParticipantRatings?: boolean;
ignoreLastRoundNumber?: boolean;
restrictEntryStatus?: boolean;
iterationMatchUps?: MatchUp[];
drawDefinition: DrawDefinition;
tournamentRecord: Tournament;
generateMatchUps?: boolean;
eventType?: EventTypeUnion;
salted?: number | boolean;
participantIds?: string[];
dynamicRatings?: boolean;
refreshDynamic?: boolean;
minimizeDelta?: boolean;
encounterValue?: number;
sameTeamValue?: number;
maxIterations?: number;
matchUpIds?: string[];
structure?: Structure;
roundNumber?: number;
structureId?: string;
scaleName?: string;
idPrefix?: string;
isMock?: boolean;
drawId?: string;
event: Event$1;
};
type DrawMaticRoundResult = {
modifiedScaleValues?: {
[key: string]: number;
};
participantIdPairings?: string[][];
candidatesCount?: number;
outputScaleName?: string;
deltaCandidate?: any;
roundNumber?: number;
matchUps?: MatchUp[];
iterations?: number;
success?: boolean;
maxDelta?: number;
maxDiff?: number;
};
declare function generateDrawMaticRound(params: GenerateDrawMaticRoundArgs): ResultType & DrawMaticRoundResult;
type GenerateVoluntaryConsolationArgs = {
playoffAttributes?: PlayoffAttributes;
tournamentRecord: Tournament;
seedingProfile?: SeedingProfile;
drawDefinition: DrawDefinition;
matchUpType?: EventTypeUnion;
attachConsolation?: boolean;
applyPositioning?: boolean;
staggeredEntry?: boolean;
structureName?: 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 generateDrawDefinition(params: GenerateDrawDefinitionArgs): ResultType & {
existingDrawDefinition?: boolean;
drawDefinition?: DrawDefinition;
qualifyingConflicts?: any[];
positioningReports?: any[];
structureId?: string;
success?: boolean;
error?: ErrorType;
conflicts?: 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 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 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[];
error?: ErrorType;
info?: any;
};
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[];
};
declare function drawMatic(params: DrawMaticArgs): ResultType & {
matchUps?: MatchUp[];
roundResults?: DrawMaticRoundResult[];
};
type AddFinishingRoundsArgs = {
finishingPositionOffset?: number;
finishingPositionLimit?: number;
positionsFed?: number;
roundsCount?: number;
roundLimit?: number;
matchUps: MatchUp[];
lucky?: boolean;
fmlc?: boolean;
};
declare function addFinishingRounds({ finishingPositionOffset, finishingPositionLimit, positionsFed, roundsCount, roundLimit, matchUps, lucky, fmlc, }: AddFinishingRoundsArgs): MatchUp[];
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;
};
declare const index$j_adHocPositionSwap: typeof adHocPositionSwap;
declare const index$j_addAdHocMatchUps: typeof addAdHocMatchUps;
declare const index$j_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem;
declare const index$j_addFinishingRounds: typeof addFinishingRounds;
declare const index$j_addGoesTo: typeof addGoesTo;
declare const index$j_addPlayoffStructures: typeof addPlayoffStructures;
declare const index$j_addQualifyingStructure: typeof addQualifyingStructure;
declare const index$j_addVoluntaryConsolationStage: typeof addVoluntaryConsolationStage;
declare const index$j_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure;
declare const index$j_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const index$j_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment;
declare const index$j_assignDrawPosition: typeof assignDrawPosition;
declare const index$j_assignDrawPositionBye: typeof assignDrawPositionBye;
declare const index$j_attachConsolationStructures: typeof attachConsolationStructures;
declare const index$j_attachPlayoffStructures: typeof attachPlayoffStructures;
declare const index$j_attachQualifyingStructure: typeof attachQualifyingStructure;
declare const index$j_attachStructures: typeof attachStructures;
declare const index$j_autoSeeding: typeof autoSeeding;
declare const index$j_automatedPlayoffPositioning: typeof automatedPlayoffPositioning;
declare const index$j_automatedPositioning: typeof automatedPositioning;
declare const index$j_checkValidEntries: typeof checkValidEntries;
declare const index$j_deleteAdHocMatchUps: typeof deleteAdHocMatchUps;
declare const index$j_drawMatic: typeof drawMatic;
declare const index$j_generateAdHocMatchUps: typeof generateAdHocMatchUps;
declare const index$j_generateAdHocRounds: typeof generateAdHocRounds;
declare const index$j_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures;
declare const index$j_generateDrawDefinition: typeof generateDrawDefinition;
declare const index$j_generateDrawMaticRound: typeof generateDrawMaticRound;
declare const index$j_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks;
declare const index$j_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition;
declare const index$j_generateQualifyingStructure: typeof generateQualifyingStructure;
declare const index$j_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
declare const index$j_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const index$j_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const index$j_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const index$j_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const index$j_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const index$j_getDrawStructures: typeof getDrawStructures;
declare const index$j_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const index$j_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const index$j_getMatchUpsMap: typeof getMatchUpsMap;
declare const index$j_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const index$j_getPositionAssignments: typeof getPositionAssignments;
declare const index$j_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const index$j_getRandomQualifierList: typeof getRandomQualifierList;
declare const index$j_getSeedingThresholds: typeof getSeedingThresholds;
declare const index$j_getSeedsCount: typeof getSeedsCount;
declare const index$j_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const index$j_getTeamLineUp: typeof getTeamLineUp;
declare const index$j_getValidGroupSizes: typeof getValidGroupSizes;
declare const index$j_isAdHoc: typeof isAdHoc;
declare const index$j_isCompletedStructure: typeof isCompletedStructure;
declare const index$j_isValidForQualifying: typeof isValidForQualifying;
declare const index$j_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment;
declare const index$j_modifyDrawDefinition: typeof modifyDrawDefinition;
declare const index$j_modifyDrawName: typeof modifyDrawName;
declare const index$j_modifySeedAssignment: typeof modifySeedAssignment;
declare const index$j_positionActions: typeof positionActions;
declare const index$j_pruneDrawDefinition: typeof pruneDrawDefinition;
declare const index$j_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment;
declare const index$j_qualifierProgression: typeof qualifierProgression;
declare const index$j_removeDrawPositionAssignment: typeof removeDrawPositionAssignment;
declare const index$j_removeRoundMatchUps: typeof removeRoundMatchUps;
declare const index$j_removeSeededParticipant: typeof removeSeededParticipant;
declare const index$j_removeStructure: typeof removeStructure;
declare const index$j_renameStructures: typeof renameStructures;
declare const index$j_resetDrawDefinition: typeof resetDrawDefinition;
declare const index$j_resetQualifyingStructure: typeof resetQualifyingStructure;
declare const index$j_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure;
declare const index$j_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds;
declare const index$j_setPositionAssignments: typeof setPositionAssignments;
declare const index$j_setStructureOrder: typeof setStructureOrder;
declare const index$j_setSubOrder: typeof setSubOrder;
declare const index$j_shiftAdHocRounds: typeof shiftAdHocRounds;
declare const index$j_swapAdHocRounds: typeof swapAdHocRounds;
declare const index$j_swapDrawPositionAssignments: typeof swapDrawPositionAssignments;
declare const index$j_updateTeamLineUp: typeof updateTeamLineUp;
declare const index$j_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition;
declare namespace index$j {
export {
index$j_adHocPositionSwap as adHocPositionSwap,
index$j_addAdHocMatchUps as addAdHocMatchUps,
index$j_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem,
index$j_addFinishingRounds as addFinishingRounds,
index$j_addGoesTo as addGoesTo,
index$j_addPlayoffStructures as addPlayoffStructures,
index$j_addQualifyingStructure as addQualifyingStructure,
index$j_addVoluntaryConsolationStage as addVoluntaryConsolationStage,
index$j_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure,
index$j_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
index$j_alternateDrawPositionAssignment as alternateDrawPositionAssignment,
index$j_assignDrawPosition as assignDrawPosition,
index$j_assignDrawPositionBye as assignDrawPositionBye,
index$j_attachConsolationStructures as attachConsolationStructures,
index$j_attachPlayoffStructures as attachPlayoffStructures,
index$j_attachQualifyingStructure as attachQualifyingStructure,
index$j_attachStructures as attachStructures,
index$j_autoSeeding as autoSeeding,
index$j_automatedPlayoffPositioning as automatedPlayoffPositioning,
index$j_automatedPositioning as automatedPositioning,
index$j_checkValidEntries as checkValidEntries,
index$j_deleteAdHocMatchUps as deleteAdHocMatchUps,
index$j_drawMatic as drawMatic,
publicFindDrawDefinition as findDrawDefinition,
index$j_generateAdHocMatchUps as generateAdHocMatchUps,
index$j_generateAdHocRounds as generateAdHocRounds,
index$j_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures,
index$j_generateDrawDefinition as generateDrawDefinition,
index$j_generateDrawMaticRound as generateDrawMaticRound,
index$j_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks,
index$j_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition,
index$j_generateQualifyingStructure as generateQualifyingStructure,
index$j_generateVoluntaryConsolation as generateVoluntaryConsolation,
index$j_getAssignedParticipantIds as getAssignedParticipantIds,
index$j_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
index$j_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
index$j_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
index$j_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
index$j_getDrawStructures as getDrawStructures,
index$j_getDrawTypeCoercion as getDrawTypeCoercion,
index$j_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
index$j_getMatchUpsMap as getMatchUpsMap,
index$j_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
index$j_getPositionAssignments as getPositionAssignments,
index$j_getPositionsPlayedOff as getPositionsPlayedOff,
index$j_getRandomQualifierList as getRandomQualifierList,
index$j_getSeedingThresholds as getSeedingThresholds,
index$j_getSeedsCount as getSeedsCount,
index$j_getStructureSeedAssignments as getStructureSeedAssignments,
index$j_getTeamLineUp as getTeamLineUp,
index$j_getValidGroupSizes as getValidGroupSizes,
index$j_isAdHoc as isAdHoc,
index$j_isCompletedStructure as isCompletedStructure,
index$j_isValidForQualifying as isValidForQualifying,
index$j_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment,
index$j_modifyDrawDefinition as modifyDrawDefinition,
index$j_modifyDrawName as modifyDrawName,
index$j_modifySeedAssignment as modifySeedAssignment,
mutate$c as mutate,
index$j_positionActions as positionActions,
index$j_pruneDrawDefinition as pruneDrawDefinition,
index$j_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment,
index$j_qualifierProgression as qualifierProgression,
query$b as query,
index$j_removeDrawPositionAssignment as removeDrawPositionAssignment,
index$j_removeRoundMatchUps as removeRoundMatchUps,
index$j_removeSeededParticipant as removeSeededParticipant,
index$j_removeStructure as removeStructure,
index$j_renameStructures as renameStructures,
index$j_resetDrawDefinition as resetDrawDefinition,
index$j_resetQualifyingStructure as resetQualifyingStructure,
index$j_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure,
index$j_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds,
index$j_setPositionAssignments as setPositionAssignments,
index$j_setStructureOrder as setStructureOrder,
index$j_setSubOrder as setSubOrder,
index$j_shiftAdHocRounds as shiftAdHocRounds,
index$j_swapAdHocRounds as swapAdHocRounds,
index$j_swapDrawPositionAssignments as swapDrawPositionAssignments,
index$j_updateTeamLineUp as updateTeamLineUp,
index$j_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition,
};
}
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 setEntryPosition({ tournamentRecord, drawDefinition, participantId, entryPosition, skipRefresh, event, }: {
tournamentRecord: any;
drawDefinition: any;
participantId: any;
entryPosition: any;
skipRefresh: any;
event: any;
}): ResultType | {
error: {
message: string;
code: string;
};
entryPosition?: undefined;
} | {
error: {
message: string;
code: string;
};
entryPosition: any;
};
declare function setEntryPositions({ tournamentRecord, entryPositions, drawDefinition, event }: {
tournamentRecord: any;
entryPositions: any;
drawDefinition: any;
event: any;
}): ResultType | {
error: {
message: string;
code: string;
};
entryPosition?: undefined;
} | {
error: {
message: string;
code: string;
};
entryPosition: any;
};
declare function promoteAlternate(params: any): ResultType | {
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?: 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: 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?: undefined;
} | {
error: {
message: string;
code: string;
};
participantIds: any;
};
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;
};
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: never;
} | {
error: {
message: string;
code: string;
};
method?: undefined;
participantIds?: undefined;
};
type AddEventEntryPairsArgs = {
allowDuplicateParticipantIdPairs?: boolean;
participantIdPairs?: string[][];
entryStatus?: EntryStatusUnion;
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
entryStage?: StageTypeUnion;
uuids?: string[];
event: Event$1;
};
declare function addEventEntryPairs(params: AddEventEntryPairsArgs): 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 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;
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 AddEventEntriesArgs = {
policyDefinitions?: PolicyDefinitions;
suppressDuplicateEntries?: boolean;
entryStatus?: EntryStatusUnion;
drawDefinition?: DrawDefinition;
autoEntryPositions?: boolean;
tournamentRecord?: Tournament;
entryStageSequence?: number;
ignoreStageSpace?: boolean;
entryStage?: StageTypeUnion;
participantIds?: string[];
extensions?: Extension[];
enforceGender?: boolean;
extension?: Extension;
roundTarget?: number;
drawId?: string;
event: Event$1;
};
declare function addEventEntries(params: AddEventEntriesArgs): ResultType;
declare const mutate$b_addDrawEntries: typeof addDrawEntries;
declare const mutate$b_addEventEntries: typeof addEventEntries;
declare const mutate$b_addEventEntryPairs: typeof addEventEntryPairs;
declare const mutate$b_destroyPairEntries: typeof destroyPairEntries;
declare const mutate$b_destroyPairEntry: typeof destroyPairEntry;
declare const mutate$b_modifyEntriesStatus: typeof modifyEntriesStatus;
declare const mutate$b_modifyEventEntries: typeof modifyEventEntries;
declare const mutate$b_promoteAlternate: typeof promoteAlternate;
declare const mutate$b_promoteAlternates: typeof promoteAlternates;
declare const mutate$b_removeDrawEntries: typeof removeDrawEntries;
declare const mutate$b_removeEventEntries: typeof removeEventEntries;
declare const mutate$b_setEntryPosition: typeof setEntryPosition;
declare const mutate$b_setEntryPositions: typeof setEntryPositions;
declare namespace mutate$b {
export {
mutate$b_addDrawEntries as addDrawEntries,
mutate$b_addEventEntries as addEventEntries,
mutate$b_addEventEntryPairs as addEventEntryPairs,
mutate$b_destroyPairEntries as destroyPairEntries,
mutate$b_destroyPairEntry as destroyPairEntry,
mutate$b_modifyEntriesStatus as modifyEntriesStatus,
mutate$b_modifyEventEntries as modifyEventEntries,
mutate$b_promoteAlternate as promoteAlternate,
mutate$b_promoteAlternates as promoteAlternates,
mutate$b_removeDrawEntries as removeDrawEntries,
mutate$b_removeEventEntries as removeEventEntries,
mutate$b_setEntryPosition as setEntryPosition,
mutate$b_setEntryPositions as setEntryPositions,
};
}
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;
};
declare function getMaxEntryPosition(params: any): number;
declare const query$a_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const query$a_getMaxEntryPosition: typeof getMaxEntryPosition;
declare namespace query$a {
export {
query$a_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
query$a_getMaxEntryPosition as getMaxEntryPosition,
};
}
declare const index$i_addDrawEntries: typeof addDrawEntries;
declare const index$i_addEventEntries: typeof addEventEntries;
declare const index$i_addEventEntryPairs: typeof addEventEntryPairs;
declare const index$i_destroyPairEntries: typeof destroyPairEntries;
declare const index$i_destroyPairEntry: typeof destroyPairEntry;
declare const index$i_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const index$i_getMaxEntryPosition: typeof getMaxEntryPosition;
declare const index$i_modifyEntriesStatus: typeof modifyEntriesStatus;
declare const index$i_modifyEventEntries: typeof modifyEventEntries;
declare const index$i_promoteAlternate: typeof promoteAlternate;
declare const index$i_promoteAlternates: typeof promoteAlternates;
declare const index$i_removeDrawEntries: typeof removeDrawEntries;
declare const index$i_removeEventEntries: typeof removeEventEntries;
declare const index$i_setEntryPosition: typeof setEntryPosition;
declare const index$i_setEntryPositions: typeof setEntryPositions;
declare namespace index$i {
export {
index$i_addDrawEntries as addDrawEntries,
index$i_addEventEntries as addEventEntries,
index$i_addEventEntryPairs as addEventEntryPairs,
index$i_destroyPairEntries as destroyPairEntries,
index$i_destroyPairEntry as destroyPairEntry,
index$i_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
index$i_getMaxEntryPosition as getMaxEntryPosition,
index$i_modifyEntriesStatus as modifyEntriesStatus,
index$i_modifyEventEntries as modifyEventEntries,
mutate$b as mutate,
index$i_promoteAlternate as promoteAlternate,
index$i_promoteAlternates as promoteAlternates,
query$a as query,
index$i_removeDrawEntries as removeDrawEntries,
index$i_removeEventEntries as removeEventEntries,
index$i_setEntryPosition as setEntryPosition,
index$i_setEntryPositions as setEntryPositions,
};
}
type GenerateEventsFromTieFormatArgs = {
entryStatus?: EntryStatusUnion;
addEntriesFromTeams?: boolean;
tournamentRecord: Tournament;
tieFormatName?: string;
tieFormat?: TieFormat;
addEvents?: boolean;
uuids?: string[];
};
declare function generateEventsFromTieFormat(params: GenerateEventsFromTieFormatArgs): ResultType | {
context?: {
[key: string]: any;
};
error?: ErrorType;
event?: Event$1;
info?: any;
} | {
events: Event$1[];
success: boolean;
};
declare const generate$4_generateEventsFromTieFormat: typeof generateEventsFromTieFormat;
declare namespace generate$4 {
export {
generate$4_generateEventsFromTieFormat as generateEventsFromTieFormat,
};
}
declare function deleteFlightProfileAndFlightDraws({ autoPublish, tournamentRecord, auditData, event, force }: {
autoPublish?: boolean | undefined;
tournamentRecord: any;
auditData: any;
event: any;
force: any;
}): {
success?: boolean;
error?: ErrorType;
info?: any;
} | {
error: any;
};
type ModifyEventMatchUpFormatTimingArgs = {
tournamentRecord: Tournament;
recoveryMinutes?: number;
averageMinutes?: number;
matchUpFormat: string;
categoryType?: string;
tournamentId?: string;
eventId: string;
event?: Event$1;
};
declare function modifyEventMatchUpFormatTiming(params: ModifyEventMatchUpFormatTimingArgs): {
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;
};
};
declare function setEventStartDate({ tournamentRecord, event, startDate }: {
tournamentRecord: any;
event: any;
startDate: any;
}): (ResultType & {
tournamentStartDate?: number;
tournamentEndDate?: number;
}) | {
error: {
message: string;
code: string;
};
};
declare function setEventEndDate(params: any): (ResultType & {
tournamentStartDate?: number;
tournamentEndDate?: number;
}) | {
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 & {
valid?: boolean;
}) | {
error: {
message: string;
code: string;
};
};
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;
};
declare function refreshEventDrawOrder({ tournamentRecord, event }: {
tournamentRecord: any;
event: any;
}): {
error: {
message: string;
code: string;
};
info: string;
} | {
success: boolean;
error?: undefined;
info?: undefined;
} | {
error: {
message: string;
code: string;
};
};
declare function modifyPairAssignment(params: any): 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 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 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 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;
};
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: string;
} | {
success: boolean;
error?: undefined;
info?: undefined;
} | {
error: {
message: string;
code: string;
};
};
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;
declare function validateCategory({ category }: {
category: any;
}): any;
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 | {
success: boolean;
error?: undefined;
info?: undefined;
} | {
error: {
message: string;
code: string;
};
};
declare function deleteEvents(params: any): ResultType & {
valid?: boolean;
};
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 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;
} | {
error: {
message: string;
code: 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 const mutate$a_addDrawDefinition: typeof addDrawDefinition;
declare const mutate$a_addEvent: typeof addEvent;
declare const mutate$a_addFlight: typeof addFlight;
declare const mutate$a_assignSeedPositions: typeof assignSeedPositions;
declare const mutate$a_attachFlightProfile: typeof attachFlightProfile;
declare const mutate$a_deleteDrawDefinitions: typeof deleteDrawDefinitions;
declare const mutate$a_deleteEvents: typeof deleteEvents;
declare const mutate$a_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw;
declare const mutate$a_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws;
declare const mutate$a_modifyEvent: typeof modifyEvent;
declare const mutate$a_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming;
declare const mutate$a_modifyPairAssignment: typeof modifyPairAssignment;
declare const mutate$a_refreshEventDrawOrder: typeof refreshEventDrawOrder;
declare const mutate$a_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const mutate$a_removeScaleValues: typeof removeScaleValues;
declare const mutate$a_removeSeeding: typeof removeSeeding;
declare const mutate$a_setEventDates: typeof setEventDates;
declare const mutate$a_setEventDisplay: typeof setEventDisplay;
declare const mutate$a_setEventEndDate: typeof setEventEndDate;
declare const mutate$a_setEventStartDate: typeof setEventStartDate;
declare const mutate$a_updateDrawIdsOrder: typeof updateDrawIdsOrder;
declare const mutate$a_validateCategory: typeof validateCategory;
declare namespace mutate$a {
export {
mutate$a_addDrawDefinition as addDrawDefinition,
mutate$a_addEvent as addEvent,
mutate$a_addFlight as addFlight,
mutate$a_assignSeedPositions as assignSeedPositions,
mutate$a_attachFlightProfile as attachFlightProfile,
mutate$a_deleteDrawDefinitions as deleteDrawDefinitions,
mutate$a_deleteEvents as deleteEvents,
mutate$a_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw,
mutate$a_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws,
mutate$a_modifyEvent as modifyEvent,
mutate$a_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming,
mutate$a_modifyPairAssignment as modifyPairAssignment,
mutate$a_refreshEventDrawOrder as refreshEventDrawOrder,
mutate$a_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
mutate$a_removeScaleValues as removeScaleValues,
mutate$a_removeSeeding as removeSeeding,
mutate$a_setEventDates as setEventDates,
mutate$a_setEventDisplay as setEventDisplay,
mutate$a_setEventEndDate as setEventEndDate,
mutate$a_setEventStartDate as setEventStartDate,
mutate$a_updateDrawIdsOrder as updateDrawIdsOrder,
mutate$a_validateCategory as validateCategory,
};
}
type ParseArgs = {
consideredDate?: string;
category?: Category;
};
declare function getCategoryAgeDetails(params: ParseArgs): any;
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 getEventProperties({ tournamentRecord, event }: {
tournamentRecord: any;
event: any;
}): {
error: {
message: string;
code: string;
};
entryScaleAttributes?: undefined;
hasSeededParticipants?: undefined;
hasRankedParticipants?: undefined;
hasRatedParticipants?: undefined;
} | {
entryScaleAttributes: any;
hasSeededParticipants: any;
hasRankedParticipants: any;
hasRatedParticipants: any;
error?: undefined;
};
type CategoryCanContainArgs = {
childCategory: Category;
withDetails?: boolean;
category: Category;
};
declare function categoryCanContain({ childCategory, withDetails, category }: CategoryCanContainArgs): any;
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[];
};
type GetFlightProfileArgs = {
eventId?: string;
event: Event$1;
};
declare function getFlightProfile({ event, eventId }: GetFlightProfileArgs): {
error: {
message: string;
code: string;
};
flightProfile?: undefined;
} | {
flightProfile: 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 GetEventArgs = {
context: {
[key: string]: any;
};
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
event: Event$1;
};
declare function getEvent({ tournamentRecord, drawDefinition, context, event }: GetEventArgs): any;
declare const query$9_categoryCanContain: typeof categoryCanContain;
declare const query$9_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const query$9_getEvent: typeof getEvent;
declare const query$9_getEventProperties: typeof getEventProperties;
declare const query$9_getEventStructures: typeof getEventStructures;
declare const query$9_getEventTimeItem: typeof getEventTimeItem;
declare const query$9_getEvents: typeof getEvents;
declare const query$9_getFlightProfile: typeof getFlightProfile;
declare const query$9_getScaledEntries: typeof getScaledEntries;
declare namespace query$9 {
export {
query$9_categoryCanContain as categoryCanContain,
query$9_getCategoryAgeDetails as getCategoryAgeDetails,
query$9_getEvent as getEvent,
query$9_getEventProperties as getEventProperties,
query$9_getEventStructures as getEventStructures,
query$9_getEventTimeItem as getEventTimeItem,
query$9_getEvents as getEvents,
query$9_getFlightProfile as getFlightProfile,
query$9_getScaledEntries as getScaledEntries,
};
}
declare const index$h_addDrawDefinition: typeof addDrawDefinition;
declare const index$h_addEvent: typeof addEvent;
declare const index$h_addFlight: typeof addFlight;
declare const index$h_assignSeedPositions: typeof assignSeedPositions;
declare const index$h_attachFlightProfile: typeof attachFlightProfile;
declare const index$h_categoryCanContain: typeof categoryCanContain;
declare const index$h_deleteDrawDefinitions: typeof deleteDrawDefinitions;
declare const index$h_deleteEvents: typeof deleteEvents;
declare const index$h_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw;
declare const index$h_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws;
declare const index$h_generateEventsFromTieFormat: typeof generateEventsFromTieFormat;
declare const index$h_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const index$h_getEvent: typeof getEvent;
declare const index$h_getEventProperties: typeof getEventProperties;
declare const index$h_getEventStructures: typeof getEventStructures;
declare const index$h_getEventTimeItem: typeof getEventTimeItem;
declare const index$h_getEvents: typeof getEvents;
declare const index$h_getFlightProfile: typeof getFlightProfile;
declare const index$h_getScaledEntries: typeof getScaledEntries;
declare const index$h_modifyEvent: typeof modifyEvent;
declare const index$h_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming;
declare const index$h_modifyPairAssignment: typeof modifyPairAssignment;
declare const index$h_refreshEventDrawOrder: typeof refreshEventDrawOrder;
declare const index$h_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const index$h_removeScaleValues: typeof removeScaleValues;
declare const index$h_removeSeeding: typeof removeSeeding;
declare const index$h_setEventDates: typeof setEventDates;
declare const index$h_setEventDisplay: typeof setEventDisplay;
declare const index$h_setEventEndDate: typeof setEventEndDate;
declare const index$h_setEventStartDate: typeof setEventStartDate;
declare const index$h_updateDrawIdsOrder: typeof updateDrawIdsOrder;
declare const index$h_validateCategory: typeof validateCategory;
declare namespace index$h {
export {
index$h_addDrawDefinition as addDrawDefinition,
index$h_addEvent as addEvent,
index$h_addFlight as addFlight,
index$h_assignSeedPositions as assignSeedPositions,
index$h_attachFlightProfile as attachFlightProfile,
index$h_categoryCanContain as categoryCanContain,
index$h_deleteDrawDefinitions as deleteDrawDefinitions,
index$h_deleteEvents as deleteEvents,
index$h_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw,
index$h_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws,
generate$4 as generate,
index$h_generateEventsFromTieFormat as generateEventsFromTieFormat,
index$h_getCategoryAgeDetails as getCategoryAgeDetails,
index$h_getEvent as getEvent,
index$h_getEventProperties as getEventProperties,
index$h_getEventStructures as getEventStructures,
index$h_getEventTimeItem as getEventTimeItem,
index$h_getEvents as getEvents,
index$h_getFlightProfile as getFlightProfile,
index$h_getScaledEntries as getScaledEntries,
index$h_modifyEvent as modifyEvent,
index$h_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming,
index$h_modifyPairAssignment as modifyPairAssignment,
mutate$a as mutate,
query$9 as query,
index$h_refreshEventDrawOrder as refreshEventDrawOrder,
index$h_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
index$h_removeScaleValues as removeScaleValues,
index$h_removeSeeding as removeSeeding,
index$h_setEventDates as setEventDates,
index$h_setEventDisplay as setEventDisplay,
index$h_setEventEndDate as setEventEndDate,
index$h_setEventStartDate as setEventStartDate,
index$h_updateDrawIdsOrder as updateDrawIdsOrder,
index$h_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 ScaleItemsWithParticipantId = {
participantId: string;
scaleItems: any[];
};
type GenerateSeedingScaleItemsArgs = {
scaleAttributes?: ScaleAttributes;
stageEntries: Entry[];
scaledEntries: any[];
seedsCount: number;
scaleName: string;
};
declare function generateSeedingScaleItems({ scaleAttributes, scaledEntries, stageEntries, seedsCount, scaleName, }: GenerateSeedingScaleItemsArgs): {
scaleItemsWithParticipantIds?: ScaleItemsWithParticipantId[];
error?: ErrorType;
info?: any;
};
type GenerateFlightProfileArgs = {
scaleAttributes: ScaleAttributes;
attachFlightProfile?: boolean;
tournamentRecord: Tournament;
deleteExisting?: boolean;
sortDescending?: boolean;
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;
};
declare function generateStatCrew(params: any): (ResultType & {
valid?: boolean;
}) | {
success: boolean;
json: any[];
xml: string[];
};
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 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 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$g_drawMatic: typeof drawMatic;
declare const index$g_generateAdHocMatchUps: typeof generateAdHocMatchUps;
declare const index$g_generateAdHocRounds: typeof generateAdHocRounds;
declare const index$g_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures;
declare const index$g_generateCourts: typeof generateCourts;
declare const index$g_generateDrawDefinition: typeof generateDrawDefinition;
declare const index$g_generateDrawMaticRound: typeof generateDrawMaticRound;
declare const index$g_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks;
declare const index$g_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition;
declare const index$g_generateFlightProfile: typeof generateFlightProfile;
declare const index$g_generateLineUps: typeof generateLineUps;
declare const index$g_generateQualifyingStructure: typeof generateQualifyingStructure;
declare const index$g_generateSeedingScaleItems: typeof generateSeedingScaleItems;
declare const index$g_generateStatCrew: typeof generateStatCrew;
declare const index$g_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
declare const index$g_roundRobinGroups: typeof roundRobinGroups;
declare namespace index$g {
export {
index$g_drawMatic as drawMatic,
garman$1 as garman,
index$g_generateAdHocMatchUps as generateAdHocMatchUps,
index$g_generateAdHocRounds as generateAdHocRounds,
index$g_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures,
index$g_generateCourts as generateCourts,
index$g_generateDrawDefinition as generateDrawDefinition,
index$g_generateDrawMaticRound as generateDrawMaticRound,
index$g_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks,
index$g_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition,
index$g_generateFlightProfile as generateFlightProfile,
index$g_generateLineUps as generateLineUps,
index$g_generateQualifyingStructure as generateQualifyingStructure,
index$g_generateSeedingScaleItems as generateSeedingScaleItems,
index$g_generateStatCrew as generateStatCrew,
index$g_generateVoluntaryConsolation as generateVoluntaryConsolation,
index$g_roundRobinGroups as roundRobinGroups,
};
}
declare function isValidMatchUpFormat({ matchUpFormat }: {
matchUpFormat: string;
}): boolean;
declare function stringify(matchUpFormatObject: any, preserveRedundant?: boolean): string | undefined;
type ParsedFormat = {
finalSetFormat?: any;
simplified?: boolean;
exactly?: number;
setFormat?: any;
bestOf?: number;
};
declare function parse(matchUpFormatCode: string): ParsedFormat | undefined;
declare const index$f_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$f_parse: typeof parse;
declare const index$f_stringify: typeof stringify;
declare namespace index$f {
export {
isValidMatchUpFormat as isValid,
index$f_isValidMatchUpFormat as isValidMatchUpFormat,
index$f_parse as parse,
index$f_stringify as stringify,
};
}
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 ToggleParticipantCheckInStateArgs = {
tournamentRecords?: TournamentRecords;
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
activeTournamentId?: string;
participantId: string;
tournamentId?: string;
matchUpIds?: string[];
matchUpId: string;
};
declare function toggleParticipantCheckInState(params: ToggleParticipantCheckInStateArgs): any;
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 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 RemoveTieMatchUpParticipantIdArgs = {
policyDefinitions?: PolicyDefinitions;
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
participantId: string;
tieMatchUpId: string;
event: Event$1;
};
declare function removeTieMatchUpParticipantId(params: RemoveTieMatchUpParticipantIdArgs): ResultType & {
modifiedLineUp?: LineUp;
};
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;
};
declare function enableTieAutoCalc({ tournamentRecord, drawDefinition, matchUpId, event }: {
tournamentRecord: any;
drawDefinition: any;
matchUpId: any;
event: any;
}): any;
declare function removeDelegatedOutcome({ drawDefinition, event, matchUpId }: {
drawDefinition: any;
event: any;
matchUpId: any;
}): {
success?: boolean;
error?: ErrorType;
info?: any;
} | {
error: {
message: string;
code: string;
};
};
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;
};
declare function substituteParticipant(params: any): ResultType | {
error: {
message: string;
code: string;
};
};
declare function checkOutParticipant(params: CheckInOutParticipantArgs): any;
declare function disableTieAutoCalc({ drawDefinition, matchUpId, event }: {
drawDefinition: any;
matchUpId: any;
event: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
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;
};
declare function checkInParticipant(params: CheckInOutParticipantArgs): any;
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 SetMatchUpStatusArgs = {
tournamentRecords?: {
[key: string]: Tournament;
};
policyDefinitions?: PolicyDefinitions;
disableScoreValidation?: boolean;
allowChangePropagation?: 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): any;
declare function bulkMatchUpStatusUpdate(params: any): any;
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 ResetAdHocMatchUps = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
removeAssignments?: boolean;
roundNumbers?: number[];
matchUpIds?: string[];
structureId?: string;
event: Event$1;
};
declare function resetAdHocMatchUps(params: ResetAdHocMatchUps): any;
declare function setOrderOfFinish(params: any): ResultType | {
error: {
message: string;
code: string;
};
};
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 ApplyLineUps = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
lineUps: TeamCompetitor[];
matchUpId: string;
event: Event$1;
};
declare function applyLineUps(params: ApplyLineUps): any;
type ResetTieFormatArgs = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
matchUpId: string;
uuids?: string[];
event?: Event$1;
};
declare function resetTieFormat(params: ResetTieFormatArgs): ResultType & {
deletedMatchUpIds?: string[];
newMatchUps?: MatchUp[];
success?: boolean;
};
type ResetScoreCardArgs = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
tiebreakReset?: boolean;
matchUpStatus?: string;
matchUpId: string;
event?: Event$1;
};
declare function resetScorecard(params: ResetScoreCardArgs): ResultType;
declare const mutate$9_applyLineUps: typeof applyLineUps;
declare const mutate$9_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant;
declare const mutate$9_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId;
declare const mutate$9_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate;
declare const mutate$9_checkInParticipant: typeof checkInParticipant;
declare const mutate$9_checkOutParticipant: typeof checkOutParticipant;
declare const mutate$9_disableTieAutoCalc: typeof disableTieAutoCalc;
declare const mutate$9_enableTieAutoCalc: typeof enableTieAutoCalc;
declare const mutate$9_removeDelegatedOutcome: typeof removeDelegatedOutcome;
declare const mutate$9_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant;
declare const mutate$9_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId;
declare const mutate$9_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId;
declare const mutate$9_resetAdHocMatchUps: typeof resetAdHocMatchUps;
declare const mutate$9_resetMatchUpLineUps: typeof resetMatchUpLineUps;
declare const mutate$9_resetScorecard: typeof resetScorecard;
declare const mutate$9_resetTieFormat: typeof resetTieFormat;
declare const mutate$9_setDelegatedOutcome: typeof setDelegatedOutcome;
declare const mutate$9_setMatchUpFormat: typeof setMatchUpFormat;
declare const mutate$9_setMatchUpStatus: typeof setMatchUpStatus;
declare const mutate$9_setOrderOfFinish: typeof setOrderOfFinish;
declare const mutate$9_substituteParticipant: typeof substituteParticipant;
declare const mutate$9_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const mutate$9_updateTieMatchUpScore: typeof updateTieMatchUpScore;
declare namespace mutate$9 {
export {
mutate$9_applyLineUps as applyLineUps,
mutate$9_assignMatchUpSideParticipant as assignMatchUpSideParticipant,
mutate$9_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId,
mutate$9_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate,
mutate$9_checkInParticipant as checkInParticipant,
mutate$9_checkOutParticipant as checkOutParticipant,
mutate$9_disableTieAutoCalc as disableTieAutoCalc,
mutate$9_enableTieAutoCalc as enableTieAutoCalc,
publicFindMatchUp as findMatchUp,
mutate$9_removeDelegatedOutcome as removeDelegatedOutcome,
mutate$9_removeMatchUpSideParticipant as removeMatchUpSideParticipant,
mutate$9_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId,
mutate$9_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId,
mutate$9_resetAdHocMatchUps as resetAdHocMatchUps,
mutate$9_resetMatchUpLineUps as resetMatchUpLineUps,
mutate$9_resetScorecard as resetScorecard,
mutate$9_resetTieFormat as resetTieFormat,
mutate$9_setDelegatedOutcome as setDelegatedOutcome,
mutate$9_setMatchUpFormat as setMatchUpFormat,
mutate$9_setMatchUpStatus as setMatchUpStatus,
mutate$9_setOrderOfFinish as setOrderOfFinish,
mutate$9_substituteParticipant as substituteParticipant,
mutate$9_toggleParticipantCheckInState as toggleParticipantCheckInState,
mutate$9_updateTieMatchUpScore as updateTieMatchUpScore,
};
}
declare function getMatchUpFormatTimingUpdate({ tournamentRecords }: {
tournamentRecords: any;
}): {
error?: ErrorType;
} | {
methods: QueueMethod[];
};
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 GetModifiedMatchUpFormatTimingArgs = {
tournamentRecord: Tournament;
matchUpFormat: string;
event: Event$1;
};
declare function getModifiedMatchUpFormatTiming(params: GetModifiedMatchUpFormatTimingArgs): ResultType & {
matchUpFormat?: string;
recoveryTimes?: any[];
averageTimes?: any[];
};
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 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 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: {};
};
declare function getMatchUpDailyLimitsUpdate({ tournamentRecords }: {
tournamentRecords: any;
}): {
error?: ErrorType;
} | {
methods: QueueMethod[];
};
type ParticiapntScheduledMatchUps = {
scheduleAttributes?: string[];
matchUps?: HydratedMatchUp[];
};
declare function participantScheduledMatchUps({ scheduleAttributes, matchUps, }: ParticiapntScheduledMatchUps): {
error: {
message: string;
code: string;
};
} | {
scheduledMatchUps: {};
success: boolean;
error?: undefined;
};
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 GetMatchUpCompetitivenessArgs = {
tournamentRecord?: Tournament;
profileBands?: any;
matchUp: MatchUp;
};
declare function getMatchUpCompetitiveProfile({ tournamentRecord, profileBands, matchUp, }: GetMatchUpCompetitivenessArgs): {
competitiveness?: any;
pctSpread?: number;
success?: boolean;
error?: ErrorType;
};
declare function getCheckedInParticipantIds({ matchUp }: {
matchUp: HydratedMatchUp;
}): ResultType & {
allRelevantParticipantIds?: string[];
allParticipantsCheckedIn?: boolean;
checkedInParticipantIds?: string[];
};
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: any;
error?: undefined;
};
type MatchUpActionsArgs = {
inContextDrawMatchUps?: HydratedMatchUp[];
restrictAdHocRoundParticipants?: boolean;
tournamentParticipants?: Participant[];
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[];
};
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 GetAllStructureMatchUps = {
scheduleVisibilityFilters?: ScheduleVisibilityFilters;
tournamentAppliedPolicies?: PolicyDefinitions;
participantsProfile?: ParticipantsProfile;
tournamentParticipants?: Participant[];
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;
};
declare function allTournamentMatchUps(params?: GetMatchUpsArgs): ResultType & {
matchUps?: HydratedMatchUp[];
};
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 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 GetMatchUpDailyLimitsArgs = {
tournamentRecords: {
[key: string]: Tournament;
};
tournamentId?: string;
};
declare function getMatchUpDailyLimits({ tournamentRecords, tournamentId }: GetMatchUpDailyLimitsArgs): ResultType & {
matchUpDailyLimits?: any;
};
declare function checkMatchUpIsComplete({ matchUp }: {
matchUp: any;
}): any;
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 | undefined;
}[];
accuracy: any;
nonZone: number;
success: boolean;
error?: undefined;
info?: undefined;
context?: undefined;
};
type CalculateWinCriteriaArgs = {
collectionGroups?: {
groupValue?: number;
groupNumber?: number;
}[];
collectionDefinitions?: CollectionDefinition[];
};
declare function calculateWinCriteria({ collectionDefinitions, collectionGroups, }: CalculateWinCriteriaArgs): ResultType & {
aggregateValue?: boolean;
valueGoal?: number;
};
declare function getHomeParticipantId(params: ScheduledMatchUpArgs): any;
declare function tournamentMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult;
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 GetMatchUpFormatArgs = {
tournamentRecord: Tournament;
drawDefinition?: DrawDefinition;
structureId?: string;
matchUpId?: string;
eventId?: string;
drawId?: string;
event?: Event$1;
};
declare function getMatchUpFormat(params: GetMatchUpFormatArgs): any;
declare function validMatchUp(matchUp: any): boolean;
declare function validMatchUps(matchUps: any): boolean;
declare function allEventMatchUps(params: GetMatchUpsArgs): {
error: {
message: string;
code: string;
};
matchUps?: undefined;
groupInfo?: undefined;
} | {
matchUps: HydratedMatchUp[];
groupInfo: any;
error?: undefined;
};
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 function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }: {
profileBands: any;
tournamentRecord: any;
matchUps: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
competitiveBands: any;
error?: undefined;
};
type GetRoundMatchUpsArgs = {
matchUps?: HydratedMatchUp[];
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;
declare function getAllDrawMatchUps(params: any): ResultType & {
matchUps?: HydratedMatchUp[];
matchUpsMap?: MatchUpsMap;
};
declare function eventMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult;
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 getMatchUpType(params: {
matchUp: {
sides?: {
participant?: {
participantType?: string;
};
}[];
matchUpType?: string;
};
}): ResultType & {
matchUpType?: string;
};
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;
};
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;
};
type FilterMatchUpsArgs = MatchUpFilters & {
matchUps: HydratedMatchUp[];
};
declare function filterMatchUps(params: FilterMatchUpsArgs): HydratedMatchUp[];
declare const query$8_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const query$8_allDrawMatchUps: typeof allDrawMatchUps;
declare const query$8_allEventMatchUps: typeof allEventMatchUps;
declare const query$8_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const query$8_analyzeMatchUp: typeof analyzeMatchUp;
declare const query$8_calculateWinCriteria: typeof calculateWinCriteria;
declare const query$8_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const query$8_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const query$8_drawMatchUps: typeof drawMatchUps;
declare const query$8_eventMatchUps: typeof eventMatchUps;
declare const query$8_filterMatchUps: typeof filterMatchUps;
declare const query$8_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const query$8_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const query$8_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const query$8_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const query$8_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const query$8_getHomeParticipantId: typeof getHomeParticipantId;
declare const query$8_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const query$8_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const query$8_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const query$8_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const query$8_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const query$8_getMatchUpFormat: typeof getMatchUpFormat;
declare const query$8_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const query$8_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const query$8_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const query$8_getMatchUpType: typeof getMatchUpType;
declare const query$8_getMatchUpsStats: typeof getMatchUpsStats;
declare const query$8_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const query$8_getParticipantResults: typeof getParticipantResults;
declare const query$8_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const query$8_getRoundMatchUps: typeof getRoundMatchUps;
declare const query$8_getRounds: typeof getRounds;
declare const query$8_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const query$8_matchUpActions: typeof matchUpActions;
declare const query$8_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const query$8_tallyParticipantResults: typeof tallyParticipantResults;
declare const query$8_tournamentMatchUps: typeof tournamentMatchUps;
declare const query$8_validMatchUp: typeof validMatchUp;
declare const query$8_validMatchUps: typeof validMatchUps;
declare namespace query$8 {
export {
query$8_allCompetitionMatchUps as allCompetitionMatchUps,
query$8_allDrawMatchUps as allDrawMatchUps,
query$8_allEventMatchUps as allEventMatchUps,
query$8_allTournamentMatchUps as allTournamentMatchUps,
query$8_analyzeMatchUp as analyzeMatchUp,
query$8_calculateWinCriteria as calculateWinCriteria,
query$8_checkMatchUpIsComplete as checkMatchUpIsComplete,
query$8_competitionScheduleMatchUps as competitionScheduleMatchUps,
query$8_drawMatchUps as drawMatchUps,
query$8_eventMatchUps as eventMatchUps,
query$8_filterMatchUps as filterMatchUps,
query$8_getAllDrawMatchUps as getAllDrawMatchUps,
query$8_getAllStructureMatchUps as getAllStructureMatchUps,
query$8_getCheckedInParticipantIds as getCheckedInParticipantIds,
query$8_getCompetitionMatchUps as getCompetitionMatchUps,
query$8_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
query$8_getHomeParticipantId as getHomeParticipantId,
query$8_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
query$8_getMatchUpContextIds as getMatchUpContextIds,
query$8_getMatchUpDailyLimits as getMatchUpDailyLimits,
query$8_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
query$8_getMatchUpDependencies as getMatchUpDependencies,
query$8_getMatchUpFormat as getMatchUpFormat,
query$8_getMatchUpFormatTiming as getMatchUpFormatTiming,
query$8_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
query$8_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
query$8_getMatchUpType as getMatchUpType,
query$8_getMatchUpsStats as getMatchUpsStats,
query$8_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
query$8_getParticipantResults as getParticipantResults,
query$8_getPredictiveAccuracy as getPredictiveAccuracy,
query$8_getRoundMatchUps as getRoundMatchUps,
query$8_getRounds as getRounds,
query$8_isValidMatchUpFormat as isValidMatchUpFormat,
query$8_matchUpActions as matchUpActions,
query$8_participantScheduledMatchUps as participantScheduledMatchUps,
query$8_tallyParticipantResults as tallyParticipantResults,
query$8_tournamentMatchUps as tournamentMatchUps,
query$8_validMatchUp as validMatchUp,
query$8_validMatchUps as validMatchUps,
};
}
declare const index$e_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const index$e_allDrawMatchUps: typeof allDrawMatchUps;
declare const index$e_allEventMatchUps: typeof allEventMatchUps;
declare const index$e_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const index$e_analyzeMatchUp: typeof analyzeMatchUp;
declare const index$e_applyLineUps: typeof applyLineUps;
declare const index$e_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant;
declare const index$e_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId;
declare const index$e_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate;
declare const index$e_calculateWinCriteria: typeof calculateWinCriteria;
declare const index$e_checkInParticipant: typeof checkInParticipant;
declare const index$e_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const index$e_checkOutParticipant: typeof checkOutParticipant;
declare const index$e_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const index$e_disableTieAutoCalc: typeof disableTieAutoCalc;
declare const index$e_drawMatchUps: typeof drawMatchUps;
declare const index$e_enableTieAutoCalc: typeof enableTieAutoCalc;
declare const index$e_eventMatchUps: typeof eventMatchUps;
declare const index$e_filterMatchUps: typeof filterMatchUps;
declare const index$e_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const index$e_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const index$e_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const index$e_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const index$e_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const index$e_getHomeParticipantId: typeof getHomeParticipantId;
declare const index$e_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const index$e_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const index$e_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const index$e_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const index$e_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const index$e_getMatchUpFormat: typeof getMatchUpFormat;
declare const index$e_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const index$e_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const index$e_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const index$e_getMatchUpType: typeof getMatchUpType;
declare const index$e_getMatchUpsStats: typeof getMatchUpsStats;
declare const index$e_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const index$e_getParticipantResults: typeof getParticipantResults;
declare const index$e_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const index$e_getRoundMatchUps: typeof getRoundMatchUps;
declare const index$e_getRounds: typeof getRounds;
declare const index$e_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$e_matchUpActions: typeof matchUpActions;
declare const index$e_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const index$e_removeDelegatedOutcome: typeof removeDelegatedOutcome;
declare const index$e_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant;
declare const index$e_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId;
declare const index$e_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId;
declare const index$e_resetAdHocMatchUps: typeof resetAdHocMatchUps;
declare const index$e_resetMatchUpLineUps: typeof resetMatchUpLineUps;
declare const index$e_resetScorecard: typeof resetScorecard;
declare const index$e_resetTieFormat: typeof resetTieFormat;
declare const index$e_setDelegatedOutcome: typeof setDelegatedOutcome;
declare const index$e_setMatchUpFormat: typeof setMatchUpFormat;
declare const index$e_setMatchUpStatus: typeof setMatchUpStatus;
declare const index$e_setOrderOfFinish: typeof setOrderOfFinish;
declare const index$e_substituteParticipant: typeof substituteParticipant;
declare const index$e_tallyParticipantResults: typeof tallyParticipantResults;
declare const index$e_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const index$e_tournamentMatchUps: typeof tournamentMatchUps;
declare const index$e_updateTieMatchUpScore: typeof updateTieMatchUpScore;
declare const index$e_validMatchUp: typeof validMatchUp;
declare const index$e_validMatchUps: typeof validMatchUps;
declare namespace index$e {
export {
index$e_allCompetitionMatchUps as allCompetitionMatchUps,
index$e_allDrawMatchUps as allDrawMatchUps,
index$e_allEventMatchUps as allEventMatchUps,
index$e_allTournamentMatchUps as allTournamentMatchUps,
index$e_analyzeMatchUp as analyzeMatchUp,
index$e_applyLineUps as applyLineUps,
index$e_assignMatchUpSideParticipant as assignMatchUpSideParticipant,
index$e_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId,
index$e_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate,
index$e_calculateWinCriteria as calculateWinCriteria,
index$e_checkInParticipant as checkInParticipant,
index$e_checkMatchUpIsComplete as checkMatchUpIsComplete,
index$e_checkOutParticipant as checkOutParticipant,
index$e_competitionScheduleMatchUps as competitionScheduleMatchUps,
index$e_disableTieAutoCalc as disableTieAutoCalc,
index$e_drawMatchUps as drawMatchUps,
index$e_enableTieAutoCalc as enableTieAutoCalc,
index$e_eventMatchUps as eventMatchUps,
index$e_filterMatchUps as filterMatchUps,
publicFindMatchUp as findMatchUp,
index$e_getAllDrawMatchUps as getAllDrawMatchUps,
index$e_getAllStructureMatchUps as getAllStructureMatchUps,
index$e_getCheckedInParticipantIds as getCheckedInParticipantIds,
index$e_getCompetitionMatchUps as getCompetitionMatchUps,
index$e_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
index$e_getHomeParticipantId as getHomeParticipantId,
index$e_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
index$e_getMatchUpContextIds as getMatchUpContextIds,
index$e_getMatchUpDailyLimits as getMatchUpDailyLimits,
index$e_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
index$e_getMatchUpDependencies as getMatchUpDependencies,
index$e_getMatchUpFormat as getMatchUpFormat,
index$e_getMatchUpFormatTiming as getMatchUpFormatTiming,
index$e_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
index$e_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
index$e_getMatchUpType as getMatchUpType,
index$e_getMatchUpsStats as getMatchUpsStats,
index$e_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
index$e_getParticipantResults as getParticipantResults,
index$e_getPredictiveAccuracy as getPredictiveAccuracy,
index$e_getRoundMatchUps as getRoundMatchUps,
index$e_getRounds as getRounds,
index$e_isValidMatchUpFormat as isValidMatchUpFormat,
index$e_matchUpActions as matchUpActions,
mutate$9 as mutate,
index$e_participantScheduledMatchUps as participantScheduledMatchUps,
query$8 as query,
index$e_removeDelegatedOutcome as removeDelegatedOutcome,
index$e_removeMatchUpSideParticipant as removeMatchUpSideParticipant,
index$e_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId,
index$e_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId,
index$e_resetAdHocMatchUps as resetAdHocMatchUps,
index$e_resetMatchUpLineUps as resetMatchUpLineUps,
index$e_resetScorecard as resetScorecard,
index$e_resetTieFormat as resetTieFormat,
index$e_setDelegatedOutcome as setDelegatedOutcome,
index$e_setMatchUpFormat as setMatchUpFormat,
index$e_setMatchUpStatus as setMatchUpStatus,
index$e_setOrderOfFinish as setOrderOfFinish,
index$e_substituteParticipant as substituteParticipant,
index$e_tallyParticipantResults as tallyParticipantResults,
index$e_toggleParticipantCheckInState as toggleParticipantCheckInState,
index$e_tournamentMatchUps as tournamentMatchUps,
index$e_updateTieMatchUpScore as updateTieMatchUpScore,
index$e_validMatchUp as validMatchUp,
index$e_validMatchUps as validMatchUps,
};
}
declare function generateOutcomeFromScoreString(params: any): any;
type GenerateTournamentRecordArgs = {
participantsProfile?: ParticipantsProfile;
scheduleCompletedMatchUps?: boolean;
tournamentExtensions?: Extension[];
policyDefinitions?: PolicyDefinitions;
completeAllMatchUps?: boolean;
tournamentAttributes?: any;
ratingsParameters?: any;
tournamentName?: string;
schedulingProfile?: any;
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 generateEventWithDraw(params: any): any;
declare function generateParticipants(params: any): {
participants?: any[];
error?: ErrorType;
};
declare function generateOutcome(params: any): {
error: {
message: string;
code: string;
};
matchUpStatusProfile?: undefined;
outcome?: undefined;
} | {
error: {
message: string;
code: string;
};
matchUpStatusProfile: any;
outcome?: undefined;
} | {
outcome: {
score: {
sets: never[];
scoreStringSide1: string;
side2ScoreString: string;
};
matchUpStatus: string;
winningSide: any;
};
error?: undefined;
matchUpStatusProfile?: undefined;
} | {
outcome: {
score: {
sets: never[];
scoreStringSide1: string;
side2ScoreString: string;
};
matchUpStatus: string;
};
error?: undefined;
matchUpStatusProfile?: undefined;
} | {
outcome: {
winningSide: any;
matchUpStatus: string;
score: {
sets: any;
scoreStringSide1: string | {
error?: ErrorType;
info?: ErrorType | string;
};
scoreStringSide2: string | {
error?: ErrorType;
info?: ErrorType | string;
};
} | undefined;
};
error?: undefined;
matchUpStatusProfile?: undefined;
};
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 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;
};
declare function modifyTournamentRecord(params: any): any;
declare const mutate$8_anonymizeTournamentRecord: typeof anonymizeTournamentRecord;
declare const mutate$8_modifyTournamentRecord: typeof modifyTournamentRecord;
declare namespace mutate$8 {
export {
mutate$8_anonymizeTournamentRecord as anonymizeTournamentRecord,
mutate$8_modifyTournamentRecord as modifyTournamentRecord,
};
}
declare const index$d_anonymizeTournamentRecord: typeof anonymizeTournamentRecord;
declare const index$d_generateEventWithDraw: typeof generateEventWithDraw;
declare const index$d_generateOutcome: typeof generateOutcome;
declare const index$d_generateOutcomeFromScoreString: typeof generateOutcomeFromScoreString;
declare const index$d_generateParticipants: typeof generateParticipants;
declare const index$d_generateTournamentRecord: typeof generateTournamentRecord;
declare const index$d_modifyTournamentRecord: typeof modifyTournamentRecord;
declare namespace index$d {
export {
index$d_anonymizeTournamentRecord as anonymizeTournamentRecord,
generate$3 as generate,
index$d_generateEventWithDraw as generateEventWithDraw,
index$d_generateOutcome as generateOutcome,
index$d_generateOutcomeFromScoreString as generateOutcomeFromScoreString,
index$d_generateParticipants as generateParticipants,
index$d_generateTournamentRecord as generateTournamentRecord,
index$d_modifyTournamentRecord as modifyTournamentRecord,
mutate$8 as mutate,
};
}
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 AddPersonRequestsArgs = {
tournamentRecords: TournamentRecords;
requests: Request[];
personId: string;
};
declare function addPersonRequests(params: AddPersonRequestsArgs): (ResultType & {
valid?: boolean;
}) | {
error: {
message: string;
code: string;
};
};
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 modifyIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, tournamentRecord }: {
individualParticipantIds: any;
groupingParticipantId: any;
tournamentRecord: any;
}): ResultType;
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 modifyParticipantsSignInStatus({ tournamentRecord, participantIds, signInState }: {
tournamentRecord: any;
participantIds: any;
signInState: any;
}): any;
type AddIndividualParticipantIdsType = {
individualParticipantIds: string[];
removeFromOtherTeams?: boolean;
groupingParticipantId: string;
tournamentRecord: Tournament;
};
declare function addIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, removeFromOtherTeams, tournamentRecord, }: AddIndividualParticipantIdsType): ResultType & {
groupingParticipant?: Participant;
added?: number;
};
declare function modifyParticipantOtherName({ tournamentRecord, participantId, participantOtherName }: {
tournamentRecord: any;
participantId: any;
participantOtherName: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
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 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;
};
declare function addDynamicRatings(params: any): 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;
participantId?: string;
success?: boolean;
error?: ErrorType;
info?: any;
};
declare function modifyParticipantName({ tournamentRecord, participantName, participantId }: {
tournamentRecord: any;
participantName: any;
participantId: any;
}): {
error: {
message: string;
code: string;
};
info?: undefined;
} | {
error: {
message: string;
code: string;
};
info: string;
} | {
success: boolean;
error?: undefined;
info?: undefined;
};
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;
participant?: undefined;
scaledParticipant?: undefined;
} | {
error: {
message: string;
code: string;
};
info: string;
participant?: undefined;
scaledParticipant?: undefined;
} | {
error: {
message: string;
code: string;
};
participant: Participant;
info?: undefined;
scaledParticipant?: undefined;
} | {
error: {
message: string;
code: string;
};
scaledParticipant: any;
info?: undefined;
participant?: undefined;
} | {
scaledParticipants: any[];
success: boolean;
error?: undefined;
info?: undefined;
participant?: undefined;
scaledParticipant?: undefined;
};
declare function removeRatings(params: {
tournamentRecord: Tournament;
eventType: EventTypeUnion;
asDynamic?: boolean;
ratingType: string;
}): ResultType & {
valid?: boolean;
};
declare function removePenalty(params: any): {
error?: ErrorType;
success?: boolean;
penalty?: Penalty;
} | {
error: {
message: string;
code: string;
};
};
declare function modifyPenalty(params: any): {
modifications?: any;
error?: ErrorType;
success?: boolean;
penalty?: Penalty;
} | {
error: {
message: string;
code: string;
};
};
type DeleteParticipantsArgs = {
addIndividualParticipantsToEvents?: boolean;
tournamentRecord: Tournament;
participantIds: string[];
};
declare function deleteParticipants(params: DeleteParticipantsArgs): {
participantsRemovedCount?: number;
success?: boolean;
error?: ErrorType;
};
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;
};
declare function modifyParticipant(params: any): any;
type AddParticipantsType = {
allowDuplicateParticipantIdPairs?: boolean;
returnParticipants?: boolean;
participants?: Participant[];
tournamentRecord: Tournament;
};
declare function addParticipants({ allowDuplicateParticipantIdPairs, returnParticipants, tournamentRecord, participants, }: AddParticipantsType): any;
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 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 addPersons({ participantRole, tournamentRecord, persons }: {
participantRole?: any;
tournamentRecord: any;
persons: 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;
};
};
declare const mutate$7_addDynamicRatings: typeof addDynamicRatings;
declare const mutate$7_addIndividualParticipantIds: typeof addIndividualParticipantIds;
declare const mutate$7_addParticipant: typeof addParticipant;
declare const mutate$7_addParticipants: typeof addParticipants;
declare const mutate$7_addPenalty: typeof addPenalty;
declare const mutate$7_addPersonRequests: typeof addPersonRequests;
declare const mutate$7_addPersons: typeof addPersons;
declare const mutate$7_createGroupParticipant: typeof createGroupParticipant;
declare const mutate$7_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes;
declare const mutate$7_deleteParticipants: typeof deleteParticipants;
declare const mutate$7_mergeParticipants: typeof mergeParticipants;
declare const mutate$7_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds;
declare const mutate$7_modifyParticipant: typeof modifyParticipant;
declare const mutate$7_modifyParticipantName: typeof modifyParticipantName;
declare const mutate$7_modifyParticipantOtherName: typeof modifyParticipantOtherName;
declare const mutate$7_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus;
declare const mutate$7_modifyPenalty: typeof modifyPenalty;
declare const mutate$7_modifyPersonRequests: typeof modifyPersonRequests;
declare const mutate$7_regenerateParticipantNames: typeof regenerateParticipantNames;
declare const mutate$7_removeIndividualParticipantIds: typeof removeIndividualParticipantIds;
declare const mutate$7_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams;
declare const mutate$7_removePenalty: typeof removePenalty;
declare const mutate$7_removePersonRequests: typeof removePersonRequests;
declare const mutate$7_removeRatings: typeof removeRatings;
declare const mutate$7_scaledTeamAssignment: typeof scaledTeamAssignment;
declare const mutate$7_setParticipantScaleItem: typeof setParticipantScaleItem;
declare const mutate$7_setParticipantScaleItems: typeof setParticipantScaleItems;
declare namespace mutate$7 {
export {
mutate$7_addDynamicRatings as addDynamicRatings,
mutate$7_addIndividualParticipantIds as addIndividualParticipantIds,
mutate$7_addParticipant as addParticipant,
mutate$7_addParticipants as addParticipants,
mutate$7_addPenalty as addPenalty,
mutate$7_addPersonRequests as addPersonRequests,
mutate$7_addPersons as addPersons,
mutate$7_createGroupParticipant as createGroupParticipant,
mutate$7_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes,
mutate$7_deleteParticipants as deleteParticipants,
publicFindParticipant as findParticipant,
mutate$7_mergeParticipants as mergeParticipants,
mutate$7_modifyIndividualParticipantIds as modifyIndividualParticipantIds,
mutate$7_modifyParticipant as modifyParticipant,
mutate$7_modifyParticipantName as modifyParticipantName,
mutate$7_modifyParticipantOtherName as modifyParticipantOtherName,
mutate$7_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus,
mutate$7_modifyPenalty as modifyPenalty,
mutate$7_modifyPersonRequests as modifyPersonRequests,
mutate$7_regenerateParticipantNames as regenerateParticipantNames,
mutate$7_removeIndividualParticipantIds as removeIndividualParticipantIds,
mutate$7_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams,
mutate$7_removePenalty as removePenalty,
mutate$7_removePersonRequests as removePersonRequests,
mutate$7_removeRatings as removeRatings,
mutate$7_scaledTeamAssignment as scaledTeamAssignment,
mutate$7_setParticipantScaleItem as setParticipantScaleItem,
mutate$7_setParticipantScaleItems as setParticipantScaleItems,
};
}
declare function getCompetitionParticipants(params: any): ResultType & {
mappedMatchUps?: {
[key: string]: HydratedMatchUp;
};
participantIdsWithConflicts?: string[];
participants?: HydratedParticipant[];
participantMap?: ParticipantMap;
matchUps?: MatchUp[];
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 GetMembershipArgs = {
tournamentRecord: Tournament;
participantId: string;
};
declare function getParticipantMembership({ tournamentRecord, participantId, }: GetMembershipArgs): ResultType | {
[key: string]: string[];
};
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 GetParticipantScaleItemArgs = {
tournamentRecords?: TournamentRecords;
scaleAttributes: ScaleAttributes;
tournamentRecord?: Tournament;
participantId: string;
};
declare function getParticipantScaleItem(params: GetParticipantScaleItemArgs): {
tournamentId?: string;
scaleItem?: ScaleItem;
error?: ErrorType;
};
interface ParticipantScaleItemArgs {
scaleAttributes: ScaleAttributes;
requireTimeStamp?: boolean;
participant: Participant;
}
declare function participantScaleItem({ requireTimeStamp, scaleAttributes, participant, }: ParticipantScaleItemArgs): ResultType & {
scaleItem?: ScaleItem;
};
type GetPairedParticipantArgs = {
tournamentParticipants?: any[];
tournamentRecord?: Tournament;
participantIds: string[];
};
declare function getPairedParticipant({ tournamentParticipants, tournamentRecord, participantIds, }: GetPairedParticipantArgs): {
duplicatedPairParticipants?: any[];
participant?: Participant;
error?: ErrorType;
success?: boolean;
};
declare function getParticipantSignInStatus({ tournamentRecord, participantId }: {
tournamentRecord: any;
participantId: any;
}): false | "SIGNED_IN" | {
error: {
message: string;
code: string;
};
} | undefined;
type FilterParticipantsArgs = {
participantFilters: ParticipantFilters;
participants: HydratedParticipant[];
tournamentRecord: Tournament;
};
declare function filterParticipants({ participantFilters, tournamentRecord, participants, }: FilterParticipantsArgs): HydratedParticipant[];
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 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 ValidateLineUpArgs = {
tieFormat?: TieFormat;
lineUp: LineUp;
};
declare function validateLineUp({ lineUp, tieFormat }: ValidateLineUpArgs): {
valid: boolean;
errors: string[];
error: {
message: string;
code: string;
} | undefined;
};
declare const query$7_filterParticipants: typeof filterParticipants;
declare const query$7_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const query$7_getPairedParticipant: typeof getPairedParticipant;
declare const query$7_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const query$7_getParticipantMembership: typeof getParticipantMembership;
declare const query$7_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const query$7_getParticipantSchedules: typeof getParticipantSchedules;
declare const query$7_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const query$7_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const query$7_getParticipants: typeof getParticipants;
declare const query$7_getScaleValues: typeof getScaleValues;
declare const query$7_participantScaleItem: typeof participantScaleItem;
declare const query$7_validateLineUp: typeof validateLineUp;
declare namespace query$7 {
export {
query$7_filterParticipants as filterParticipants,
query$7_getCompetitionParticipants as getCompetitionParticipants,
query$7_getPairedParticipant as getPairedParticipant,
query$7_getParticipantEventDetails as getParticipantEventDetails,
query$7_getParticipantMembership as getParticipantMembership,
query$7_getParticipantScaleItem as getParticipantScaleItem,
query$7_getParticipantSchedules as getParticipantSchedules,
query$7_getParticipantSignInStatus as getParticipantSignInStatus,
query$7_getParticipantTimeItem as getParticipantTimeItem,
query$7_getParticipants as getParticipants,
query$7_getScaleValues as getScaleValues,
query$7_participantScaleItem as participantScaleItem,
query$7_validateLineUp as validateLineUp,
};
}
declare const index$c_addDynamicRatings: typeof addDynamicRatings;
declare const index$c_addIndividualParticipantIds: typeof addIndividualParticipantIds;
declare const index$c_addParticipant: typeof addParticipant;
declare const index$c_addParticipants: typeof addParticipants;
declare const index$c_addPenalty: typeof addPenalty;
declare const index$c_addPersonRequests: typeof addPersonRequests;
declare const index$c_addPersons: typeof addPersons;
declare const index$c_createGroupParticipant: typeof createGroupParticipant;
declare const index$c_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes;
declare const index$c_deleteParticipants: typeof deleteParticipants;
declare const index$c_filterParticipants: typeof filterParticipants;
declare const index$c_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const index$c_getPairedParticipant: typeof getPairedParticipant;
declare const index$c_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const index$c_getParticipantMembership: typeof getParticipantMembership;
declare const index$c_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const index$c_getParticipantSchedules: typeof getParticipantSchedules;
declare const index$c_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const index$c_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const index$c_getParticipants: typeof getParticipants;
declare const index$c_getScaleValues: typeof getScaleValues;
declare const index$c_mergeParticipants: typeof mergeParticipants;
declare const index$c_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds;
declare const index$c_modifyParticipant: typeof modifyParticipant;
declare const index$c_modifyParticipantName: typeof modifyParticipantName;
declare const index$c_modifyParticipantOtherName: typeof modifyParticipantOtherName;
declare const index$c_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus;
declare const index$c_modifyPenalty: typeof modifyPenalty;
declare const index$c_modifyPersonRequests: typeof modifyPersonRequests;
declare const index$c_participantScaleItem: typeof participantScaleItem;
declare const index$c_regenerateParticipantNames: typeof regenerateParticipantNames;
declare const index$c_removeIndividualParticipantIds: typeof removeIndividualParticipantIds;
declare const index$c_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams;
declare const index$c_removePenalty: typeof removePenalty;
declare const index$c_removePersonRequests: typeof removePersonRequests;
declare const index$c_removeRatings: typeof removeRatings;
declare const index$c_scaledTeamAssignment: typeof scaledTeamAssignment;
declare const index$c_setParticipantScaleItem: typeof setParticipantScaleItem;
declare const index$c_setParticipantScaleItems: typeof setParticipantScaleItems;
declare const index$c_validateLineUp: typeof validateLineUp;
declare namespace index$c {
export {
index$c_addDynamicRatings as addDynamicRatings,
index$c_addIndividualParticipantIds as addIndividualParticipantIds,
index$c_addParticipant as addParticipant,
index$c_addParticipants as addParticipants,
index$c_addPenalty as addPenalty,
index$c_addPersonRequests as addPersonRequests,
index$c_addPersons as addPersons,
index$c_createGroupParticipant as createGroupParticipant,
index$c_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes,
index$c_deleteParticipants as deleteParticipants,
index$c_filterParticipants as filterParticipants,
publicFindParticipant as findParticipant,
index$c_getCompetitionParticipants as getCompetitionParticipants,
index$c_getPairedParticipant as getPairedParticipant,
index$c_getParticipantEventDetails as getParticipantEventDetails,
index$c_getParticipantMembership as getParticipantMembership,
index$c_getParticipantScaleItem as getParticipantScaleItem,
index$c_getParticipantSchedules as getParticipantSchedules,
index$c_getParticipantSignInStatus as getParticipantSignInStatus,
index$c_getParticipantTimeItem as getParticipantTimeItem,
index$c_getParticipants as getParticipants,
index$c_getScaleValues as getScaleValues,
index$c_mergeParticipants as mergeParticipants,
index$c_modifyIndividualParticipantIds as modifyIndividualParticipantIds,
index$c_modifyParticipant as modifyParticipant,
index$c_modifyParticipantName as modifyParticipantName,
index$c_modifyParticipantOtherName as modifyParticipantOtherName,
index$c_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus,
index$c_modifyPenalty as modifyPenalty,
index$c_modifyPersonRequests as modifyPersonRequests,
mutate$7 as mutate,
index$c_participantScaleItem as participantScaleItem,
query$7 as query,
index$c_regenerateParticipantNames as regenerateParticipantNames,
index$c_removeIndividualParticipantIds as removeIndividualParticipantIds,
index$c_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams,
index$c_removePenalty as removePenalty,
index$c_removePersonRequests as removePersonRequests,
index$c_removeRatings as removeRatings,
index$c_scaledTeamAssignment as scaledTeamAssignment,
index$c_setParticipantScaleItem as setParticipantScaleItem,
index$c_setParticipantScaleItems as setParticipantScaleItems,
index$c_validateLineUp as validateLineUp,
};
}
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 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 const mutate$6_attachPolicies: typeof attachPolicies;
declare const mutate$6_removePolicy: typeof removePolicy;
declare namespace mutate$6 {
export {
mutate$6_attachPolicies as attachPolicies,
mutate$6_removePolicy as removePolicy,
};
}
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 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 const query$6_findPolicy: typeof findPolicy;
declare const query$6_getAppliedPolicies: typeof getAppliedPolicies;
declare const query$6_getPolicyDefinitions: typeof getPolicyDefinitions;
declare namespace query$6 {
export {
query$6_findPolicy as findPolicy,
query$6_getAppliedPolicies as getAppliedPolicies,
query$6_getPolicyDefinitions as getPolicyDefinitions,
};
}
declare const index$b_attachPolicies: typeof attachPolicies;
declare const index$b_findPolicy: typeof findPolicy;
declare const index$b_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$b_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$b_removePolicy: typeof removePolicy;
declare namespace index$b {
export {
index$b_attachPolicies as attachPolicies,
index$b_findPolicy as findPolicy,
index$b_getAppliedPolicies as getAppliedPolicies,
index$b_getPolicyDefinitions as getPolicyDefinitions,
mutate$6 as mutate,
query$6 as query,
index$b_removePolicy as removePolicy,
};
}
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;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
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;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function unPublishParticipants(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function unPublishOrderOfPlay(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function publishParticipants(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function publishOrderOfPlay(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function unPublishEvent({ removePriorValues, tournamentRecord, status, event }: {
removePriorValues?: boolean | undefined;
tournamentRecord: any;
status?: string | undefined;
event: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
eventId: any;
error?: undefined;
};
type PublishingDetail = {
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;
};
declare const mutate$5_publishEvent: typeof publishEvent;
declare const mutate$5_publishEventSeeding: typeof publishEventSeeding;
declare const mutate$5_publishOrderOfPlay: typeof publishOrderOfPlay;
declare const mutate$5_publishParticipants: typeof publishParticipants;
declare const mutate$5_setEventDisplay: typeof setEventDisplay;
declare const mutate$5_unPublishEvent: typeof unPublishEvent;
declare const mutate$5_unPublishEventSeeding: typeof unPublishEventSeeding;
declare const mutate$5_unPublishOrderOfPlay: typeof unPublishOrderOfPlay;
declare const mutate$5_unPublishParticipants: typeof unPublishParticipants;
declare namespace mutate$5 {
export {
mutate$5_publishEvent as publishEvent,
mutate$5_publishEventSeeding as publishEventSeeding,
mutate$5_publishOrderOfPlay as publishOrderOfPlay,
mutate$5_publishParticipants as publishParticipants,
mutate$5_setEventDisplay as setEventDisplay,
mutate$5_unPublishEvent as unPublishEvent,
mutate$5_unPublishEventSeeding as unPublishEventSeeding,
mutate$5_unPublishOrderOfPlay as unPublishOrderOfPlay,
mutate$5_unPublishParticipants as unPublishParticipants,
};
}
declare function getTournamentPublishStatus(params: any): any;
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;
};
declare function getEventPublishStatus({ event, status }: {
event: any;
status?: string | undefined;
}): any;
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;
};
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;
};
declare function getDrawData(params: any): {
structures?: any[];
success?: boolean;
error?: ErrorType;
drawInfo?: any;
};
type GetVenueDataArgs = {
tournamentRecord: Tournament;
venueId: string;
};
declare function getVenueData(params: GetVenueDataArgs): {
success?: boolean;
error?: ErrorType;
venueData?: any;
};
type GetCourtInfoArgs = {
tournamentRecord: Tournament;
internalUse?: boolean;
courtId: string;
};
declare function getCourtInfo({ tournamentRecord, internalUse, courtId }: GetCourtInfoArgs): {
error?: ErrorType;
success?: boolean;
courtInfo?: any;
};
type GetEventDataArgs = {
participantsProfile?: ParticipantsProfile;
includePositionAssignments?: boolean;
policyDefinitions?: PolicyDefinitions;
allParticipantResults?: boolean;
sortConfig?: StructureSortConfig;
hydrateParticipants?: boolean;
tournamentRecord: Tournament;
usePublishState?: boolean;
refreshResults?: boolean;
pressureRating?: boolean;
contextProfile?: any;
eventId?: string;
status?: string;
event?: Event$1;
};
declare function getEventData(params: GetEventDataArgs): {
participants?: HydratedParticipant[];
error?: ErrorType;
success?: boolean;
eventData?: any;
};
declare const query$5_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const query$5_getAllEventData: typeof getAllEventData;
declare const query$5_getCourtInfo: typeof getCourtInfo;
declare const query$5_getDrawData: typeof getDrawData;
declare const query$5_getEventData: typeof getEventData;
declare const query$5_getEventPublishStatus: typeof getEventPublishStatus;
declare const query$5_getPublishState: typeof getPublishState;
declare const query$5_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const query$5_getVenueData: typeof getVenueData;
declare namespace query$5 {
export {
query$5_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
query$5_getAllEventData as getAllEventData,
query$5_getCourtInfo as getCourtInfo,
query$5_getDrawData as getDrawData,
query$5_getEventData as getEventData,
query$5_getEventPublishStatus as getEventPublishStatus,
query$5_getPublishState as getPublishState,
query$5_getTournamentPublishStatus as getTournamentPublishStatus,
query$5_getVenueData as getVenueData,
};
}
declare const index$a_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const index$a_getAllEventData: typeof getAllEventData;
declare const index$a_getCourtInfo: typeof getCourtInfo;
declare const index$a_getDrawData: typeof getDrawData;
declare const index$a_getEventData: typeof getEventData;
declare const index$a_getEventPublishStatus: typeof getEventPublishStatus;
declare const index$a_getPublishState: typeof getPublishState;
declare const index$a_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const index$a_getVenueData: typeof getVenueData;
declare const index$a_publishEvent: typeof publishEvent;
declare const index$a_publishEventSeeding: typeof publishEventSeeding;
declare const index$a_publishOrderOfPlay: typeof publishOrderOfPlay;
declare const index$a_publishParticipants: typeof publishParticipants;
declare const index$a_setEventDisplay: typeof setEventDisplay;
declare const index$a_unPublishEvent: typeof unPublishEvent;
declare const index$a_unPublishEventSeeding: typeof unPublishEventSeeding;
declare const index$a_unPublishOrderOfPlay: typeof unPublishOrderOfPlay;
declare const index$a_unPublishParticipants: typeof unPublishParticipants;
declare namespace index$a {
export {
index$a_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
index$a_getAllEventData as getAllEventData,
index$a_getCourtInfo as getCourtInfo,
index$a_getDrawData as getDrawData,
index$a_getEventData as getEventData,
index$a_getEventPublishStatus as getEventPublishStatus,
index$a_getPublishState as getPublishState,
index$a_getTournamentPublishStatus as getTournamentPublishStatus,
index$a_getVenueData as getVenueData,
mutate$5 as mutate,
index$a_publishEvent as publishEvent,
index$a_publishEventSeeding as publishEventSeeding,
index$a_publishOrderOfPlay as publishOrderOfPlay,
index$a_publishParticipants as publishParticipants,
query$5 as query,
index$a_setEventDisplay as setEventDisplay,
index$a_unPublishEvent as unPublishEvent,
index$a_unPublishEventSeeding as unPublishEventSeeding,
index$a_unPublishOrderOfPlay as unPublishOrderOfPlay,
index$a_unPublishParticipants as unPublishParticipants,
};
}
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;
declare function credits(): string;
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;
type GetCompetitionPenaltiesArgs = {
tournamentRecords: TournamentRecords;
};
declare function getCompetitionPenalties({ tournamentRecords }: GetCompetitionPenaltiesArgs): {
error: {
message: string;
code: string;
};
penalties?: undefined;
} | {
penalties: Penalty[];
error?: undefined;
};
declare function getCompetitionDateRange({ tournamentRecords }: {
tournamentRecords: TournamentRecords;
}): {
startDate?: Date;
endDate?: Date;
error?: ErrorType;
};
type GetTournamentPenaltiesArgs = {
tournamentRecord: Tournament;
};
declare function getTournamentPenalties({ tournamentRecord }: GetTournamentPenaltiesArgs): {
error?: ErrorType;
penalties?: Penalty[];
};
declare function getTournamentPersons({ tournamentRecord, participantFilters }: {
tournamentRecord: any;
participantFilters: any;
}): {
error: {
message: string;
code: string;
};
tournamentPersons?: undefined;
} | {
tournamentPersons: unknown[];
error?: undefined;
};
type GetAggregateTeamResultsArgs = {
finishingPositionRangeBounsPoints?: {
[key: string]: number;
};
tournamentRecord: Tournament;
};
declare function getAggregateTeamResults(params: GetAggregateTeamResultsArgs): (ResultType & {
valid?: boolean;
}) | {
individualResults: {};
teamResults: {};
success: boolean;
};
declare function analyzeTournament({ tournamentRecord }: {
tournamentRecord: any;
}): {
error: {
message: string;
code: string;
};
} | {
analysis: any;
success: boolean;
error?: undefined;
};
declare function getTournamentInfo(params?: {
tournamentRecord: Tournament;
usePublishState?: boolean;
}): {
tournamentInfo?: any;
eventInfo?: any[];
error?: ErrorType;
};
type GetTournamentPointsArgs = {
participantFilters?: ParticipantFilters;
policyDefinitions?: PolicyDefinitions;
tournamentRecord: Tournament;
level?: number;
};
declare function getTournamentPoints({ participantFilters, policyDefinitions, tournamentRecord, level, }: GetTournamentPointsArgs): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
participantsWithOutcomes: HydratedParticipant[] | undefined;
personPoints: {};
pairPoints: {};
teamPoints: {};
error?: undefined;
};
declare function analyzeDraws({ tournamentRecord }: {
tournamentRecord: any;
}): {
error?: ErrorType;
drawsAnalysis?: any;
success?: boolean;
};
declare const query$4_analyzeDraws: typeof analyzeDraws;
declare const query$4_analyzeTournament: typeof analyzeTournament;
declare const query$4_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const query$4_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const query$4_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const query$4_getAppliedPolicies: typeof getAppliedPolicies;
declare const query$4_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const query$4_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const query$4_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const query$4_getTournamentInfo: typeof getTournamentInfo;
declare const query$4_getTournamentPenalties: typeof getTournamentPenalties;
declare const query$4_getTournamentPersons: typeof getTournamentPersons;
declare const query$4_getTournamentPoints: typeof getTournamentPoints;
declare const query$4_getTournamentStructures: typeof getTournamentStructures;
declare const query$4_getTournamentTimeItem: typeof getTournamentTimeItem;
declare namespace query$4 {
export {
query$4_analyzeDraws as analyzeDraws,
query$4_analyzeTournament as analyzeTournament,
query$4_getAggregateTeamResults as getAggregateTeamResults,
query$4_getAllowedDrawTypes as getAllowedDrawTypes,
query$4_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
query$4_getAppliedPolicies as getAppliedPolicies,
query$4_getCompetitionDateRange as getCompetitionDateRange,
query$4_getCompetitionPenalties as getCompetitionPenalties,
query$4_getPolicyDefinitions as getPolicyDefinitions,
query$4_getTournamentInfo as getTournamentInfo,
query$4_getTournamentPenalties as getTournamentPenalties,
query$4_getTournamentPersons as getTournamentPersons,
query$4_getTournamentPoints as getTournamentPoints,
query$4_getTournamentStructures as getTournamentStructures,
query$4_getTournamentTimeItem as getTournamentTimeItem,
};
}
type GenderValidityCheckArgs = {
referenceGender?: GenderUnion;
matchUpType?: string;
gender?: GenderUnion;
};
declare function tieFormatGenderValidityCheck(params: GenderValidityCheckArgs): ResultType;
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 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;
};
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;
};
declare const query$3_compareTieFormats: typeof compareTieFormats;
declare const query$3_getTieFormat: typeof getTieFormat;
declare const query$3_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const query$3_validateCollectionDefinition: typeof validateCollectionDefinition;
declare namespace query$3 {
export {
query$3_compareTieFormats as compareTieFormats,
query$3_getTieFormat as getTieFormat,
query$3_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
query$3_validateCollectionDefinition as validateCollectionDefinition,
};
}
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;
};
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 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;
};
type GetPersonRequestsArgs = {
tournamentRecords: {
[key: string]: Tournament;
};
requestType?: string;
};
declare function getPersonRequests(params: GetPersonRequestsArgs): {
personRequests?: PersonRequests;
error?: ErrorType;
};
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 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 courtGridRows({ courtPrefix, minRowsCount, courtsData }: {
courtPrefix?: string | undefined;
minRowsCount: any;
courtsData: any;
}): {
error: {
message: string;
code: string;
};
courtPrefix?: undefined;
rows?: undefined;
} | {
courtPrefix: string;
rows: any[];
error?: undefined;
};
declare function publicFindCourt(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 const query$2_courtGridRows: typeof courtGridRows;
declare const query$2_findVenue: typeof findVenue;
declare const query$2_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const query$2_getPersonRequests: typeof getPersonRequests;
declare const query$2_getProfileRounds: typeof getProfileRounds;
declare const query$2_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const query$2_getSchedulingProfile: typeof getSchedulingProfile;
declare const query$2_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const query$2_publicFindCourt: typeof publicFindCourt;
declare namespace query$2 {
export {
query$2_courtGridRows as courtGridRows,
query$2_findVenue as findVenue,
query$2_getMatchUpsToSchedule as getMatchUpsToSchedule,
query$2_getPersonRequests as getPersonRequests,
query$2_getProfileRounds as getProfileRounds,
query$2_getScheduledRoundsDetails as getScheduledRoundsDetails,
query$2_getSchedulingProfile as getSchedulingProfile,
query$2_getSchedulingProfileIssues as getSchedulingProfileIssues,
query$2_publicFindCourt as publicFindCourt,
};
}
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[];
};
declare function getCourts({ tournamentRecord, venueId, venueIds }: {
tournamentRecord: any;
venueId: any;
venueIds: any;
}): {
error: {
message: string;
code: string;
};
courts?: undefined;
} | {
courts: any;
error?: undefined;
};
declare const query$1_getCompetitionVenues: typeof getCompetitionVenues;
declare const query$1_getCourts: typeof getCourts;
declare const query$1_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const query$1_publicFindVenue: typeof publicFindVenue;
declare namespace query$1 {
export {
query$1_getCompetitionVenues as getCompetitionVenues,
query$1_getCourts as getCourts,
query$1_getVenuesAndCourts as getVenuesAndCourts,
query$1_publicFindVenue as publicFindVenue,
};
}
declare const index$9_addGoesTo: typeof addGoesTo;
declare const index$9_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const index$9_allDrawMatchUps: typeof allDrawMatchUps;
declare const index$9_allEventMatchUps: typeof allEventMatchUps;
declare const index$9_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const index$9_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const index$9_analyzeDraws: typeof analyzeDraws;
declare const index$9_analyzeMatchUp: typeof analyzeMatchUp;
declare const index$9_analyzeTournament: typeof analyzeTournament;
declare const index$9_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const index$9_calculateWinCriteria: typeof calculateWinCriteria;
declare const index$9_categoryCanContain: typeof categoryCanContain;
declare const index$9_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const index$9_checkValidEntries: typeof checkValidEntries;
declare const index$9_compareTieFormats: typeof compareTieFormats;
declare const index$9_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const index$9_courtGridRows: typeof courtGridRows;
declare const index$9_credits: typeof credits;
declare const index$9_drawMatchUps: typeof drawMatchUps;
declare const index$9_eventMatchUps: typeof eventMatchUps;
declare const index$9_filterMatchUps: typeof filterMatchUps;
declare const index$9_filterParticipants: typeof filterParticipants;
declare const index$9_findExtension: typeof findExtension;
declare const index$9_findVenue: typeof findVenue;
declare const index$9_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const index$9_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const index$9_getAllEventData: typeof getAllEventData;
declare const index$9_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const index$9_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const index$9_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const index$9_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$9_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const index$9_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const index$9_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const index$9_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const index$9_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const index$9_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const index$9_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const index$9_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const index$9_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const index$9_getCompetitionVenues: typeof getCompetitionVenues;
declare const index$9_getCourtInfo: typeof getCourtInfo;
declare const index$9_getCourts: typeof getCourts;
declare const index$9_getDrawData: typeof getDrawData;
declare const index$9_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const index$9_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const index$9_getDrawStructures: typeof getDrawStructures;
declare const index$9_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const index$9_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const index$9_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const index$9_getEvent: typeof getEvent;
declare const index$9_getEventData: typeof getEventData;
declare const index$9_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const index$9_getEventProperties: typeof getEventProperties;
declare const index$9_getEventPublishStatus: typeof getEventPublishStatus;
declare const index$9_getEventStructures: typeof getEventStructures;
declare const index$9_getEventTimeItem: typeof getEventTimeItem;
declare const index$9_getEvents: typeof getEvents;
declare const index$9_getFlightProfile: typeof getFlightProfile;
declare const index$9_getHomeParticipantId: typeof getHomeParticipantId;
declare const index$9_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const index$9_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const index$9_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const index$9_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const index$9_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const index$9_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const index$9_getMatchUpFormat: typeof getMatchUpFormat;
declare const index$9_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const index$9_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const index$9_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const index$9_getMatchUpType: typeof getMatchUpType;
declare const index$9_getMatchUpsMap: typeof getMatchUpsMap;
declare const index$9_getMatchUpsStats: typeof getMatchUpsStats;
declare const index$9_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const index$9_getMaxEntryPosition: typeof getMaxEntryPosition;
declare const index$9_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const index$9_getPairedParticipant: typeof getPairedParticipant;
declare const index$9_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const index$9_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const index$9_getParticipantMembership: typeof getParticipantMembership;
declare const index$9_getParticipantResults: typeof getParticipantResults;
declare const index$9_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const index$9_getParticipantSchedules: typeof getParticipantSchedules;
declare const index$9_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const index$9_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const index$9_getParticipants: typeof getParticipants;
declare const index$9_getPersonRequests: typeof getPersonRequests;
declare const index$9_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$9_getPositionAssignments: typeof getPositionAssignments;
declare const index$9_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const index$9_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const index$9_getProfileRounds: typeof getProfileRounds;
declare const index$9_getPublishState: typeof getPublishState;
declare const index$9_getRandomQualifierList: typeof getRandomQualifierList;
declare const index$9_getRoundMatchUps: typeof getRoundMatchUps;
declare const index$9_getRounds: typeof getRounds;
declare const index$9_getScaleValues: typeof getScaleValues;
declare const index$9_getScaledEntries: typeof getScaledEntries;
declare const index$9_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const index$9_getSchedulingProfile: typeof getSchedulingProfile;
declare const index$9_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const index$9_getSeedingThresholds: typeof getSeedingThresholds;
declare const index$9_getSeedsCount: typeof getSeedsCount;
declare const index$9_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const index$9_getTeamLineUp: typeof getTeamLineUp;
declare const index$9_getTieFormat: typeof getTieFormat;
declare const index$9_getTimeItem: typeof getTimeItem;
declare const index$9_getTournamentIds: typeof getTournamentIds;
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_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const index$9_getTournamentStructures: typeof getTournamentStructures;
declare const index$9_getTournamentTimeItem: typeof getTournamentTimeItem;
declare const index$9_getValidGroupSizes: typeof getValidGroupSizes;
declare const index$9_getVenueData: typeof getVenueData;
declare const index$9_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const index$9_isAdHoc: typeof isAdHoc;
declare const index$9_isCompletedStructure: typeof isCompletedStructure;
declare const index$9_isValidForQualifying: typeof isValidForQualifying;
declare const index$9_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$9_matchUpActions: typeof matchUpActions;
declare const index$9_participantScaleItem: typeof participantScaleItem;
declare const index$9_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const index$9_positionActions: typeof positionActions;
declare const index$9_publicFindCourt: typeof publicFindCourt;
declare const index$9_publicFindVenue: typeof publicFindVenue;
declare const index$9_tallyParticipantResults: typeof tallyParticipantResults;
declare const index$9_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const index$9_tournamentMatchUps: typeof tournamentMatchUps;
declare const index$9_validMatchUp: typeof validMatchUp;
declare const index$9_validMatchUps: typeof validMatchUps;
declare const index$9_validateCollectionDefinition: typeof validateCollectionDefinition;
declare const index$9_validateLineUp: typeof validateLineUp;
declare namespace index$9 {
export {
index$9_addGoesTo as addGoesTo,
index$9_allCompetitionMatchUps as allCompetitionMatchUps,
index$9_allDrawMatchUps as allDrawMatchUps,
index$9_allEventMatchUps as allEventMatchUps,
index$9_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
index$9_allTournamentMatchUps as allTournamentMatchUps,
index$9_analyzeDraws as analyzeDraws,
index$9_analyzeMatchUp as analyzeMatchUp,
index$9_analyzeTournament as analyzeTournament,
index$9_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
index$9_calculateWinCriteria as calculateWinCriteria,
index$9_categoryCanContain as categoryCanContain,
index$9_checkMatchUpIsComplete as checkMatchUpIsComplete,
index$9_checkValidEntries as checkValidEntries,
index$9_compareTieFormats as compareTieFormats,
index$9_competitionScheduleMatchUps as competitionScheduleMatchUps,
index$9_courtGridRows as courtGridRows,
index$9_credits as credits,
index$9_drawMatchUps as drawMatchUps,
index$9_eventMatchUps as eventMatchUps,
index$9_filterMatchUps as filterMatchUps,
index$9_filterParticipants as filterParticipants,
publicFindDrawDefinition as findDrawDefinition,
index$9_findExtension as findExtension,
index$9_findVenue as findVenue,
index$9_getAggregateTeamResults as getAggregateTeamResults,
index$9_getAllDrawMatchUps as getAllDrawMatchUps,
index$9_getAllEventData as getAllEventData,
index$9_getAllStructureMatchUps as getAllStructureMatchUps,
index$9_getAllowedDrawTypes as getAllowedDrawTypes,
index$9_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
index$9_getAppliedPolicies as getAppliedPolicies,
index$9_getAssignedParticipantIds as getAssignedParticipantIds,
index$9_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
index$9_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
index$9_getCategoryAgeDetails as getCategoryAgeDetails,
index$9_getCheckedInParticipantIds as getCheckedInParticipantIds,
index$9_getCompetitionDateRange as getCompetitionDateRange,
index$9_getCompetitionMatchUps as getCompetitionMatchUps,
index$9_getCompetitionParticipants as getCompetitionParticipants,
index$9_getCompetitionPenalties as getCompetitionPenalties,
index$9_getCompetitionVenues as getCompetitionVenues,
index$9_getCourtInfo as getCourtInfo,
index$9_getCourts as getCourts,
index$9_getDrawData as getDrawData,
index$9_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
index$9_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
index$9_getDrawStructures as getDrawStructures,
index$9_getDrawTypeCoercion as getDrawTypeCoercion,
index$9_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
index$9_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
index$9_getEvent as getEvent,
index$9_getEventData as getEventData,
index$9_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
index$9_getEventProperties as getEventProperties,
index$9_getEventPublishStatus as getEventPublishStatus,
index$9_getEventStructures as getEventStructures,
index$9_getEventTimeItem as getEventTimeItem,
index$9_getEvents as getEvents,
index$9_getFlightProfile as getFlightProfile,
index$9_getHomeParticipantId as getHomeParticipantId,
index$9_getLinkedTournamentIds as getLinkedTournamentIds,
index$9_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
index$9_getMatchUpContextIds as getMatchUpContextIds,
index$9_getMatchUpDailyLimits as getMatchUpDailyLimits,
index$9_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
index$9_getMatchUpDependencies as getMatchUpDependencies,
index$9_getMatchUpFormat as getMatchUpFormat,
index$9_getMatchUpFormatTiming as getMatchUpFormatTiming,
index$9_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
index$9_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
index$9_getMatchUpType as getMatchUpType,
index$9_getMatchUpsMap as getMatchUpsMap,
index$9_getMatchUpsStats as getMatchUpsStats,
index$9_getMatchUpsToSchedule as getMatchUpsToSchedule,
index$9_getMaxEntryPosition as getMaxEntryPosition,
index$9_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
index$9_getPairedParticipant as getPairedParticipant,
index$9_getParticipantEventDetails as getParticipantEventDetails,
index$9_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
index$9_getParticipantMembership as getParticipantMembership,
index$9_getParticipantResults as getParticipantResults,
index$9_getParticipantScaleItem as getParticipantScaleItem,
index$9_getParticipantSchedules as getParticipantSchedules,
index$9_getParticipantSignInStatus as getParticipantSignInStatus,
index$9_getParticipantTimeItem as getParticipantTimeItem,
index$9_getParticipants as getParticipants,
index$9_getPersonRequests as getPersonRequests,
index$9_getPolicyDefinitions as getPolicyDefinitions,
index$9_getPositionAssignments as getPositionAssignments,
index$9_getPositionsPlayedOff as getPositionsPlayedOff,
index$9_getPredictiveAccuracy as getPredictiveAccuracy,
index$9_getProfileRounds as getProfileRounds,
index$9_getPublishState as getPublishState,
index$9_getRandomQualifierList as getRandomQualifierList,
index$9_getRoundMatchUps as getRoundMatchUps,
index$9_getRounds as getRounds,
index$9_getScaleValues as getScaleValues,
index$9_getScaledEntries as getScaledEntries,
index$9_getScheduledRoundsDetails as getScheduledRoundsDetails,
index$9_getSchedulingProfile as getSchedulingProfile,
index$9_getSchedulingProfileIssues as getSchedulingProfileIssues,
index$9_getSeedingThresholds as getSeedingThresholds,
index$9_getSeedsCount as getSeedsCount,
index$9_getStructureSeedAssignments as getStructureSeedAssignments,
index$9_getTeamLineUp as getTeamLineUp,
index$9_getTieFormat as getTieFormat,
index$9_getTimeItem as getTimeItem,
index$9_getTournamentIds as getTournamentIds,
index$9_getTournamentInfo as getTournamentInfo,
index$9_getTournamentPenalties as getTournamentPenalties,
index$9_getTournamentPersons as getTournamentPersons,
index$9_getTournamentPoints as getTournamentPoints,
index$9_getTournamentPublishStatus as getTournamentPublishStatus,
index$9_getTournamentStructures as getTournamentStructures,
index$9_getTournamentTimeItem as getTournamentTimeItem,
index$9_getValidGroupSizes as getValidGroupSizes,
index$9_getVenueData as getVenueData,
index$9_getVenuesAndCourts as getVenuesAndCourts,
index$9_isAdHoc as isAdHoc,
index$9_isCompletedStructure as isCompletedStructure,
index$9_isValidForQualifying as isValidForQualifying,
index$9_isValidMatchUpFormat as isValidMatchUpFormat,
index$9_matchUpActions as matchUpActions,
index$9_participantScaleItem as participantScaleItem,
index$9_participantScheduledMatchUps as participantScheduledMatchUps,
index$9_positionActions as positionActions,
index$9_publicFindCourt as publicFindCourt,
index$9_publicFindVenue as publicFindVenue,
index$9_tallyParticipantResults as tallyParticipantResults,
index$9_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
index$9_tournamentMatchUps as tournamentMatchUps,
index$9_validMatchUp as validMatchUp,
index$9_validMatchUps as validMatchUps,
index$9_validateCollectionDefinition as validateCollectionDefinition,
index$9_validateLineUp as validateLineUp,
};
}
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 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;
};
type GetStructureReportsArgs = {
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 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;
};
declare const index$8_getEntryStatusReports: typeof getEntryStatusReports;
declare const index$8_getParticipantStats: typeof getParticipantStats;
declare const index$8_getStructureReports: typeof getStructureReports;
declare const index$8_getVenuesReport: typeof getVenuesReport;
declare namespace index$8 {
export {
index$8_getEntryStatusReports as getEntryStatusReports,
index$8_getParticipantStats as getParticipantStats,
index$8_getStructureReports as getStructureReports,
index$8_getVenuesReport as getVenuesReport,
};
}
declare function setMatchUpHomeParticipantId(params: AddScheduleAttributeArgs & {
homeParticipantId?: string;
}): ResultType;
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;
};
declare function addMatchUpScheduledDate({ scheduledDate: dateToSchedule, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, }: AddScheduleAttributeArgs & {
scheduledDate?: string;
}): ResultType;
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 removeMatchUpCourtAssignment(params: any): any;
type ProAutoScheduleArgs = {
tournamentRecords: {
[key: string]: Tournament;
};
scheduleCompletedMatchUps?: boolean;
matchUps: HydratedMatchUp[];
scheduledDate: string;
};
declare function proAutoSchedule({ scheduleCompletedMatchUps, tournamentRecords, scheduledDate, 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[];
mappedParticipants?: {
[key: string]: HydratedParticipant;
};
completedMatchUps?: HydratedMatchUp[];
dateMatchUps?: HydratedMatchUp[];
courtPrefix?: string;
error?: ErrorType;
venues?: Venue[];
courtsData?: any;
rows?: any[];
info?: undefined;
};
declare function modifyMatchUpFormatTiming(params: any): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
type BulkUpdateCourtAssignmentsParams = {
tournamentRecords: TournamentRecords;
courtAssignments: any[];
courtDayDate: string;
};
declare function bulkUpdateCourtAssignments(params: BulkUpdateCourtAssignmentsParams): 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): any;
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 addSchedulingProfileRound({ tournamentRecords, scheduleDate, venueId, round }: {
tournamentRecords: any;
scheduleDate: any;
venueId: any;
round: any;
}): any;
type ProConflictsArgs = {
tournamentRecords: {
[key: string]: Tournament;
};
matchUps: HydratedMatchUp[];
};
declare function proConflicts({ tournamentRecords, matchUps, }: ProConflictsArgs): {
error: ErrorType;
info?: any;
} | {
courtIssues: {
[key: string]: any;
};
rowIssues: {
[key: string]: any;
};
};
declare function reorderUpcomingMatchUps(params: any): {
success: boolean;
} | ResultType;
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;
};
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;
};
declare function matchUpScheduleChange(params: any): {
success: boolean;
} | ResultType | {
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;
};
type ScheduleProfileRoundsArgs = {
checkPotentialRequestConflicts?: boolean;
tournamentRecords: TournamentRecords;
scheduleCompletedMatchUps?: boolean;
clearScheduleDates?: boolean;
scheduleDates?: string[];
periodLength?: number;
useGarman?: boolean;
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: {};
overLimitMatchUpIds: {};
scheduledMatchUpIds: {};
noTimeMatchUpIds: {};
requestConflicts: {};
scheduledDates: any;
success: boolean;
} | {
error: {
message: string;
code: string;
};
};
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 AddMatchUpScheduledTimeArgs = {
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
removePriorValues?: boolean;
disableNotice?: boolean;
scheduledTime?: string;
matchUpId?: string;
matchUp?: MatchUp;
};
declare function addMatchUpScheduledTime(params: AddMatchUpScheduledTimeArgs): any;
type SetMatchUpDailyLimitsArgs = {
tournamentRecords?: TournamentRecords;
tournamentRecord?: Tournament;
tournamentId: string;
dailyLimits: any;
};
declare function setMatchUpDailyLimits(params: SetMatchUpDailyLimitsArgs): ResultType;
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): 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: any;
courtId: any;
endTime: any;
venueId: any;
}[] | undefined;
relevantMatchUps: HydratedMatchUp[] | undefined;
dateScheduledMatchUps: HydratedMatchUp[] | undefined;
error?: undefined;
};
declare function validateSchedulingProfile({ tournamentRecords, schedulingProfile }: {
tournamentRecords: any;
schedulingProfile: any;
}): any;
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 AddMatchUpScheduleItemsArgs = {
inContextMatchUps?: HydratedMatchUp[];
drawMatchUps?: HydratedMatchUp[];
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;
}): any;
declare function addMatchUpOfficial({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, participantId, officialType, matchUpId, }: AddScheduleAttributeArgs & {
participantId?: string;
officialType?: string;
}): any;
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;
declare const mutate$4_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
declare const mutate$4_addMatchUpEndTime: typeof addMatchUpEndTime;
declare const mutate$4_addMatchUpOfficial: typeof addMatchUpOfficial;
declare const mutate$4_addMatchUpResumeTime: typeof addMatchUpResumeTime;
declare const mutate$4_addMatchUpScheduleItems: typeof addMatchUpScheduleItems;
declare const mutate$4_addMatchUpScheduledDate: typeof addMatchUpScheduledDate;
declare const mutate$4_addMatchUpScheduledTime: typeof addMatchUpScheduledTime;
declare const mutate$4_addMatchUpStartTime: typeof addMatchUpStartTime;
declare const mutate$4_addMatchUpStopTime: typeof addMatchUpStopTime;
declare const mutate$4_addSchedulingProfileRound: typeof addSchedulingProfileRound;
declare const mutate$4_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts;
declare const mutate$4_assignMatchUpCourt: typeof assignMatchUpCourt;
declare const mutate$4_assignMatchUpVenue: typeof assignMatchUpVenue;
declare const mutate$4_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps;
declare const mutate$4_bulkScheduleMatchUps: typeof bulkScheduleMatchUps;
declare const mutate$4_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps;
declare const mutate$4_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments;
declare const mutate$4_calculateScheduleTimes: typeof calculateScheduleTimes;
declare const mutate$4_clearMatchUpSchedule: typeof clearMatchUpSchedule;
declare const mutate$4_clearScheduledMatchUps: typeof clearScheduledMatchUps;
declare const mutate$4_findMatchUpFormatTiming: typeof findMatchUpFormatTiming;
declare const mutate$4_generateBookings: typeof generateBookings;
declare const mutate$4_generateVirtualCourts: typeof generateVirtualCourts;
declare const mutate$4_matchUpScheduleChange: typeof matchUpScheduleChange;
declare const mutate$4_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming;
declare const mutate$4_proAutoSchedule: typeof proAutoSchedule;
declare const mutate$4_proConflicts: typeof proConflicts;
declare const mutate$4_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const mutate$4_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
declare const mutate$4_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
declare const mutate$4_scheduleMatchUps: typeof scheduleMatchUps;
declare const mutate$4_scheduleProfileRounds: typeof scheduleProfileRounds;
declare const mutate$4_setMatchUpDailyLimits: typeof setMatchUpDailyLimits;
declare const mutate$4_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId;
declare const mutate$4_setSchedulingProfile: typeof setSchedulingProfile;
declare const mutate$4_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const mutate$4_validateSchedulingProfile: typeof validateSchedulingProfile;
declare namespace mutate$4 {
export {
mutate$4_addMatchUpCourtOrder as addMatchUpCourtOrder,
mutate$4_addMatchUpEndTime as addMatchUpEndTime,
mutate$4_addMatchUpOfficial as addMatchUpOfficial,
mutate$4_addMatchUpResumeTime as addMatchUpResumeTime,
mutate$4_addMatchUpScheduleItems as addMatchUpScheduleItems,
mutate$4_addMatchUpScheduledDate as addMatchUpScheduledDate,
mutate$4_addMatchUpScheduledTime as addMatchUpScheduledTime,
mutate$4_addMatchUpStartTime as addMatchUpStartTime,
mutate$4_addMatchUpStopTime as addMatchUpStopTime,
mutate$4_addSchedulingProfileRound as addSchedulingProfileRound,
mutate$4_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts,
mutate$4_assignMatchUpCourt as assignMatchUpCourt,
mutate$4_assignMatchUpVenue as assignMatchUpVenue,
mutate$4_bulkRescheduleMatchUps as bulkRescheduleMatchUps,
mutate$4_bulkScheduleMatchUps as bulkScheduleMatchUps,
mutate$4_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps,
mutate$4_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments,
mutate$4_calculateScheduleTimes as calculateScheduleTimes,
mutate$4_clearMatchUpSchedule as clearMatchUpSchedule,
mutate$4_clearScheduledMatchUps as clearScheduledMatchUps,
mutate$4_findMatchUpFormatTiming as findMatchUpFormatTiming,
mutate$4_generateBookings as generateBookings,
mutate$4_generateVirtualCourts as generateVirtualCourts,
mutate$4_matchUpScheduleChange as matchUpScheduleChange,
mutate$4_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming,
mutate$4_proAutoSchedule as proAutoSchedule,
mutate$4_proConflicts as proConflicts,
mutate$4_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
mutate$4_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
mutate$4_reorderUpcomingMatchUps as reorderUpcomingMatchUps,
mutate$4_scheduleMatchUps as scheduleMatchUps,
mutate$4_scheduleProfileRounds as scheduleProfileRounds,
mutate$4_setMatchUpDailyLimits as setMatchUpDailyLimits,
mutate$4_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId,
mutate$4_setSchedulingProfile as setSchedulingProfile,
mutate$4_toggleParticipantCheckInState as toggleParticipantCheckInState,
mutate$4_validateSchedulingProfile as validateSchedulingProfile,
};
}
declare const index$7_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
declare const index$7_addMatchUpEndTime: typeof addMatchUpEndTime;
declare const index$7_addMatchUpOfficial: typeof addMatchUpOfficial;
declare const index$7_addMatchUpResumeTime: typeof addMatchUpResumeTime;
declare const index$7_addMatchUpScheduleItems: typeof addMatchUpScheduleItems;
declare const index$7_addMatchUpScheduledDate: typeof addMatchUpScheduledDate;
declare const index$7_addMatchUpScheduledTime: typeof addMatchUpScheduledTime;
declare const index$7_addMatchUpStartTime: typeof addMatchUpStartTime;
declare const index$7_addMatchUpStopTime: typeof addMatchUpStopTime;
declare const index$7_addSchedulingProfileRound: typeof addSchedulingProfileRound;
declare const index$7_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts;
declare const index$7_assignMatchUpCourt: typeof assignMatchUpCourt;
declare const index$7_assignMatchUpVenue: typeof assignMatchUpVenue;
declare const index$7_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps;
declare const index$7_bulkScheduleMatchUps: typeof bulkScheduleMatchUps;
declare const index$7_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps;
declare const index$7_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments;
declare const index$7_calculateScheduleTimes: typeof calculateScheduleTimes;
declare const index$7_clearMatchUpSchedule: typeof clearMatchUpSchedule;
declare const index$7_clearScheduledMatchUps: typeof clearScheduledMatchUps;
declare const index$7_courtGridRows: typeof courtGridRows;
declare const index$7_findMatchUpFormatTiming: typeof findMatchUpFormatTiming;
declare const index$7_findVenue: typeof findVenue;
declare const index$7_generateBookings: typeof generateBookings;
declare const index$7_generateVirtualCourts: typeof generateVirtualCourts;
declare const index$7_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const index$7_getPersonRequests: typeof getPersonRequests;
declare const index$7_getProfileRounds: typeof getProfileRounds;
declare const index$7_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const index$7_getSchedulingProfile: typeof getSchedulingProfile;
declare const index$7_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const index$7_matchUpScheduleChange: typeof matchUpScheduleChange;
declare const index$7_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming;
declare const index$7_proAutoSchedule: typeof proAutoSchedule;
declare const index$7_proConflicts: typeof proConflicts;
declare const index$7_publicFindCourt: typeof publicFindCourt;
declare const index$7_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const index$7_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
declare const index$7_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
declare const index$7_scheduleMatchUps: typeof scheduleMatchUps;
declare const index$7_scheduleProfileRounds: typeof scheduleProfileRounds;
declare const index$7_setMatchUpDailyLimits: typeof setMatchUpDailyLimits;
declare const index$7_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId;
declare const index$7_setSchedulingProfile: typeof setSchedulingProfile;
declare const index$7_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const index$7_validateSchedulingProfile: typeof validateSchedulingProfile;
declare namespace index$7 {
export {
index$7_addMatchUpCourtOrder as addMatchUpCourtOrder,
index$7_addMatchUpEndTime as addMatchUpEndTime,
index$7_addMatchUpOfficial as addMatchUpOfficial,
index$7_addMatchUpResumeTime as addMatchUpResumeTime,
index$7_addMatchUpScheduleItems as addMatchUpScheduleItems,
index$7_addMatchUpScheduledDate as addMatchUpScheduledDate,
index$7_addMatchUpScheduledTime as addMatchUpScheduledTime,
index$7_addMatchUpStartTime as addMatchUpStartTime,
index$7_addMatchUpStopTime as addMatchUpStopTime,
index$7_addSchedulingProfileRound as addSchedulingProfileRound,
index$7_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts,
index$7_assignMatchUpCourt as assignMatchUpCourt,
index$7_assignMatchUpVenue as assignMatchUpVenue,
index$7_bulkRescheduleMatchUps as bulkRescheduleMatchUps,
index$7_bulkScheduleMatchUps as bulkScheduleMatchUps,
index$7_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps,
index$7_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments,
index$7_calculateScheduleTimes as calculateScheduleTimes,
index$7_clearMatchUpSchedule as clearMatchUpSchedule,
index$7_clearScheduledMatchUps as clearScheduledMatchUps,
index$7_courtGridRows as courtGridRows,
index$7_findMatchUpFormatTiming as findMatchUpFormatTiming,
index$7_findVenue as findVenue,
index$7_generateBookings as generateBookings,
index$7_generateVirtualCourts as generateVirtualCourts,
index$7_getMatchUpsToSchedule as getMatchUpsToSchedule,
index$7_getPersonRequests as getPersonRequests,
index$7_getProfileRounds as getProfileRounds,
index$7_getScheduledRoundsDetails as getScheduledRoundsDetails,
index$7_getSchedulingProfile as getSchedulingProfile,
index$7_getSchedulingProfileIssues as getSchedulingProfileIssues,
index$7_matchUpScheduleChange as matchUpScheduleChange,
index$7_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming,
mutate$4 as mutate,
index$7_proAutoSchedule as proAutoSchedule,
index$7_proConflicts as proConflicts,
index$7_publicFindCourt as publicFindCourt,
query$2 as query,
index$7_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
index$7_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
index$7_reorderUpcomingMatchUps as reorderUpcomingMatchUps,
index$7_scheduleMatchUps as scheduleMatchUps,
index$7_scheduleProfileRounds as scheduleProfileRounds,
index$7_setMatchUpDailyLimits as setMatchUpDailyLimits,
index$7_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId,
index$7_setSchedulingProfile as setSchedulingProfile,
index$7_toggleParticipantCheckInState as toggleParticipantCheckInState,
index$7_validateSchedulingProfile as validateSchedulingProfile,
};
}
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 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;
};
declare function reverseScore(params?: any): {
reversedScore?: any;
success?: boolean;
error?: ErrorType;
};
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_generateScoreString as generateScoreString,
generate$2_generateTieMatchUpScore as generateTieMatchUpScore,
generate$2_reverseScore as reverseScore,
};
}
declare function calculateHistoryScore(params: any): {
error: {
message: string;
code: string;
};
info?: undefined;
} | {
error: {
message: string;
code: string;
};
info: string;
} | {
servingSide: number;
score: any;
success: boolean;
error?: undefined;
info?: undefined;
};
declare function setServingSide({ matchUp, sideNumber }: {
matchUp: any;
sideNumber: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
};
declare function clearHistory({ matchUp }: {
matchUp: any;
}): {
success?: boolean;
error?: ErrorType;
};
declare function addPoint({ matchUp, point }: {
matchUp: any;
point: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
context?: undefined;
} | {
error: {
message: string;
code: string;
};
context: {
point: any;
};
};
declare function addGame({ matchUp, game }: {
matchUp: any;
game: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
context: {
game: any;
};
};
declare function addShot({ matchUp, shot }: {
matchUp: any;
shot: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
};
declare function addSet({ matchUp, set }: {
matchUp: any;
set: any;
}): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
};
declare function redo({ matchUp }: {
matchUp: any;
}): {
success?: boolean;
error?: ErrorType;
};
declare function undo({ matchUp }: {
matchUp: any;
}): {
success?: boolean;
error?: ErrorType;
};
declare const umo: {};
declare const mutate$3_addGame: typeof addGame;
declare const mutate$3_addPoint: typeof addPoint;
declare const mutate$3_addSet: typeof addSet;
declare const mutate$3_addShot: typeof addShot;
declare const mutate$3_calculateHistoryScore: typeof calculateHistoryScore;
declare const mutate$3_clearHistory: typeof clearHistory;
declare const mutate$3_redo: typeof redo;
declare const mutate$3_setServingSide: typeof setServingSide;
declare const mutate$3_umo: typeof umo;
declare const mutate$3_undo: typeof undo;
declare namespace mutate$3 {
export {
mutate$3_addGame as addGame,
mutate$3_addPoint as addPoint,
mutate$3_addSet as addSet,
mutate$3_addShot as addShot,
mutate$3_calculateHistoryScore as calculateHistoryScore,
mutate$3_clearHistory as clearHistory,
mutate$3_redo as redo,
mutate$3_setServingSide as setServingSide,
mutate$3_umo as umo,
mutate$3_undo as undo,
};
}
declare function keyValueScore(params: any): {
updated: boolean;
info: string;
scoreString?: undefined;
sets?: undefined;
winningSide?: undefined;
matchUpStatus?: undefined;
} | {
updated: any;
scoreString: any;
sets: any;
winningSide: any;
matchUpStatus: any;
info: any;
};
declare function tidyScore(params: any): {
error: {
message: string;
code: string;
};
matchUpStatus?: undefined;
modifications?: undefined;
attributes?: undefined;
isValid?: undefined;
score?: undefined;
} | {
matchUpStatus: any;
modifications: any[];
attributes: any;
isValid: boolean;
score: any;
error?: undefined;
};
declare const help_keyValueScore: typeof keyValueScore;
declare const help_tidyScore: typeof tidyScore;
declare namespace help {
export {
help_keyValueScore as keyValueScore,
parse as parseMatchUpFormat,
stringify as stringifyMatchUpFormat,
help_tidyScore as tidyScore,
};
}
type ValidateTieFormatArgs = {
checkCollectionIds?: boolean;
enforceCategory?: boolean;
enforceGender?: boolean;
gender?: GenderUnion;
category?: Category;
tieFormat?: any;
event?: Event$1;
};
declare function validateTieFormat(params: ValidateTieFormatArgs): ResultType;
type validateScoreTypes = {
existingMatchUpStatus?: string;
matchUpStatus?: string;
matchUpFormat?: string;
winningSide?: number;
score: Score;
};
declare function validateScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: validateScoreTypes): ResultType & {
valid?: boolean;
};
type SetComplementArgs = {
lowValue?: string | number;
tiebreakAt?: number;
isSide1?: boolean;
NoAD?: boolean;
setTo: 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 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;
};
type AnalyzeScoreArgs = {
existingMatchUpStatus?: string;
matchUpStatus?: string;
matchUpFormat?: string;
winningSide?: number;
score: Score;
};
declare function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: AnalyzeScoreArgs): {
valid: boolean;
};
type ParseScoreArgs = {
scoreString: string;
tiebreakTo?: number;
};
type ParsedSetString = {
winningSide: number | undefined;
side1TiebreakScore?: number;
side2TiebreakScore?: number;
side1Score?: number;
side2Score?: number;
setNumber: number;
};
declare function parseScoreString({ tiebreakTo, scoreString }: ParseScoreArgs): ParsedSetString[];
declare function analyzeSet(params: any): {
[key: string]: any;
};
declare const query_analyzeScore: typeof analyzeScore;
declare const query_analyzeSet: typeof analyzeSet;
declare const query_checkScoreHasValue: typeof checkScoreHasValue;
declare const query_checkSetIsComplete: typeof checkSetIsComplete;
declare const query_getSetComplement: typeof getSetComplement;
declare const query_getTiebreakComplement: typeof getTiebreakComplement;
declare const query_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const query_parseScoreString: typeof parseScoreString;
declare const query_validateScore: typeof validateScore;
declare const query_validateTieFormat: typeof validateTieFormat;
declare namespace query {
export {
query_analyzeScore as analyzeScore,
query_analyzeSet as analyzeSet,
query_checkScoreHasValue as checkScoreHasValue,
query_checkSetIsComplete as checkSetIsComplete,
query_getSetComplement as getSetComplement,
query_getTiebreakComplement as getTiebreakComplement,
query_isValidMatchUpFormat as isValidMatchUpFormat,
query_parseScoreString as parseScoreString,
query_validateScore as validateScore,
query_validateTieFormat as validateTieFormat,
};
}
declare const index$6_addGame: typeof addGame;
declare const index$6_addPoint: typeof addPoint;
declare const index$6_addSet: typeof addSet;
declare const index$6_addShot: typeof addShot;
declare const index$6_analyzeScore: typeof analyzeScore;
declare const index$6_analyzeSet: typeof analyzeSet;
declare const index$6_calculateHistoryScore: typeof calculateHistoryScore;
declare const index$6_checkScoreHasValue: typeof checkScoreHasValue;
declare const index$6_checkSetIsComplete: typeof checkSetIsComplete;
declare const index$6_clearHistory: typeof clearHistory;
declare const index$6_generateScoreString: typeof generateScoreString;
declare const index$6_generateTieMatchUpScore: typeof generateTieMatchUpScore;
declare const index$6_getSetComplement: typeof getSetComplement;
declare const index$6_getTiebreakComplement: typeof getTiebreakComplement;
declare const index$6_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$6_keyValueScore: typeof keyValueScore;
declare const index$6_parseScoreString: typeof parseScoreString;
declare const index$6_query: typeof query;
declare const index$6_redo: typeof redo;
declare const index$6_reverseScore: typeof reverseScore;
declare const index$6_setServingSide: typeof setServingSide;
declare const index$6_tidyScore: typeof tidyScore;
declare const index$6_umo: typeof umo;
declare const index$6_undo: typeof undo;
declare const index$6_validateScore: typeof validateScore;
declare const index$6_validateTieFormat: typeof validateTieFormat;
declare namespace index$6 {
export {
index$6_addGame as addGame,
index$6_addPoint as addPoint,
index$6_addSet as addSet,
index$6_addShot as addShot,
index$6_analyzeScore as analyzeScore,
index$6_analyzeSet as analyzeSet,
index$6_calculateHistoryScore as calculateHistoryScore,
index$6_checkScoreHasValue as checkScoreHasValue,
index$6_checkSetIsComplete as checkSetIsComplete,
index$6_clearHistory as clearHistory,
generate$2 as generate,
index$6_generateScoreString as generateScoreString,
index$6_generateTieMatchUpScore as generateTieMatchUpScore,
index$6_getSetComplement as getSetComplement,
index$6_getTiebreakComplement as getTiebreakComplement,
help as helpers,
index$6_isValidMatchUpFormat as isValidMatchUpFormat,
index$6_keyValueScore as keyValueScore,
mutate$3 as mutate,
parse as parseMatchUpFormat,
index$6_parseScoreString as parseScoreString,
index$6_query as query,
index$6_redo as redo,
index$6_reverseScore as reverseScore,
index$6_setServingSide as setServingSide,
stringify as stringifyMatchUpFormat,
index$6_tidyScore as tidyScore,
index$6_umo as umo,
index$6_undo as undo,
index$6_validateScore as validateScore,
index$6_validateTieFormat as validateTieFormat,
};
}
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 RemoveCollectionGroupArgs = {
updateInProgressMatchUps?: boolean;
collectionGroupNumber: number;
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
tieFormatName?: string;
structureId: string;
matchUpId: string;
matchUp?: MatchUp;
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;
};
};
type OrderCollectionDefinitionsArgs = {
tournamentRecord: Tournament;
drawDefinition: DrawDefinition;
structureId?: string;
matchUpId?: string;
matchUp?: MatchUp;
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 RemoveCollectionDefinitionArgs = {
updateInProgressMatchUps?: boolean;
tieFormatComparison?: boolean;
tournamentRecord?: Tournament;
drawDefinition: DrawDefinition;
tieFormatName?: string;
collectionId: string;
structureId?: string;
matchUpId?: string;
matchUp?: MatchUp;
eventId?: string;
event?: Event$1;
};
declare function removeCollectionDefinition({ updateInProgressMatchUps, tieFormatComparison, tournamentRecord, drawDefinition, tieFormatName, collectionId, structureId, matchUpId, eventId, matchUp, event, }: RemoveCollectionDefinitionArgs): {
targetMatchUps?: HydratedMatchUp[];
deletedMatchUpIds?: string[];
tieFormat?: TieFormat;
success?: boolean;
error?: ErrorType;
};
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 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;
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 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 AggreateTieFormatsArgs = {
tournamentRecord: Tournament;
};
declare function aggregateTieFormats({ tournamentRecord, }: AggreateTieFormatsArgs): ResultType & {
addedCount?: number;
};
declare const mutate$2_addCollectionDefinition: typeof addCollectionDefinition;
declare const mutate$2_addCollectionGroup: typeof addCollectionGroup;
declare const mutate$2_aggregateTieFormats: typeof aggregateTieFormats;
declare const mutate$2_modifyCollectionDefinition: typeof modifyCollectionDefinition;
declare const mutate$2_modifyTieFormat: typeof modifyTieFormat;
declare const mutate$2_orderCollectionDefinitions: typeof orderCollectionDefinitions;
declare const mutate$2_removeCollectionDefinition: typeof removeCollectionDefinition;
declare const mutate$2_removeCollectionGroup: typeof removeCollectionGroup;
declare namespace mutate$2 {
export {
mutate$2_addCollectionDefinition as addCollectionDefinition,
mutate$2_addCollectionGroup as addCollectionGroup,
mutate$2_aggregateTieFormats as aggregateTieFormats,
mutate$2_modifyCollectionDefinition as modifyCollectionDefinition,
mutate$2_modifyTieFormat as modifyTieFormat,
mutate$2_orderCollectionDefinitions as orderCollectionDefinitions,
mutate$2_removeCollectionDefinition as removeCollectionDefinition,
mutate$2_removeCollectionGroup as removeCollectionGroup,
};
}
declare const index$5_addCollectionDefinition: typeof addCollectionDefinition;
declare const index$5_addCollectionGroup: typeof addCollectionGroup;
declare const index$5_aggregateTieFormats: typeof aggregateTieFormats;
declare const index$5_compareTieFormats: typeof compareTieFormats;
declare const index$5_getTieFormat: typeof getTieFormat;
declare const index$5_modifyCollectionDefinition: typeof modifyCollectionDefinition;
declare const index$5_modifyTieFormat: typeof modifyTieFormat;
declare const index$5_orderCollectionDefinitions: typeof orderCollectionDefinitions;
declare const index$5_removeCollectionDefinition: typeof removeCollectionDefinition;
declare const index$5_removeCollectionGroup: typeof removeCollectionGroup;
declare const index$5_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const index$5_validateCollectionDefinition: typeof validateCollectionDefinition;
declare namespace index$5 {
export {
index$5_addCollectionDefinition as addCollectionDefinition,
index$5_addCollectionGroup as addCollectionGroup,
index$5_aggregateTieFormats as aggregateTieFormats,
index$5_compareTieFormats as compareTieFormats,
index$5_getTieFormat as getTieFormat,
index$5_modifyCollectionDefinition as modifyCollectionDefinition,
index$5_modifyTieFormat as modifyTieFormat,
mutate$2 as mutate,
index$5_orderCollectionDefinitions as orderCollectionDefinitions,
query$3 as query,
index$5_removeCollectionDefinition as removeCollectionDefinition,
index$5_removeCollectionGroup as removeCollectionGroup,
index$5_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
index$5_validateCollectionDefinition as validateCollectionDefinition,
};
}
declare function createTournamentRecord(params: any): 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 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 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;
};
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;
type RemoveExtensionResult = {
success?: boolean;
error?: ErrorType;
info?: any;
};
declare function removeExtension(params?: {
tournamentRecords?: TournamentRecords;
element?: {
extensions?: any[];
};
discover?: boolean;
name?: string;
}): RemoveExtensionResult;
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 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 AddExtensionArgs$1 = {
tournamentRecords?: TournamentRecords;
activeTournamentId?: string;
creationTime?: boolean;
tournamentId?: string;
extension: Extension;
discover?: boolean;
element?: any;
};
declare function addExtension(params?: AddExtensionArgs$1): {
success?: boolean;
error?: ErrorType;
};
declare function setTournamentName({ tournamentRecord, promotionalName, tournamentName, formalName }: {
tournamentRecord: any;
promotionalName: any;
tournamentName: any;
formalName: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
declare function setTournamentNotes({ tournamentRecord, notes }: {
tournamentRecord: any;
notes: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
};
declare function setTournamentCategories({ tournamentRecord, categories }: {
tournamentRecord: any;
categories: any;
}): {
error: {
message: string;
code: string;
};
} | {
success: boolean;
error?: undefined;
};
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 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;
type AddExtensionArgs = {
tournamentRecord?: Tournament;
drawDefinition?: DrawDefinition;
participantId?: string;
creationTime?: boolean;
extension: Extension;
event?: Event$1;
};
declare function addTournamentExtension(params: AddExtensionArgs): {
success?: boolean;
error?: ErrorType;
};
declare function addDrawDefinitionExtension(params: AddExtensionArgs): {
success?: boolean;
error?: ErrorType;
} | {
error: {
message: string;
code: string;
};
};
declare function addEventExtension(params: AddExtensionArgs): {
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 const mutate$1_addDrawDefinitionExtension: typeof addDrawDefinitionExtension;
declare const mutate$1_addEventExtension: typeof addEventExtension;
declare const mutate$1_addEventTimeItem: typeof addEventTimeItem;
declare const mutate$1_addExtension: typeof addExtension;
declare const mutate$1_addNotes: typeof addNotes;
declare const mutate$1_addOnlineResource: typeof addOnlineResource;
declare const mutate$1_addParticipantExtension: typeof addParticipantExtension;
declare const mutate$1_addParticipantTimeItem: typeof addParticipantTimeItem;
declare const mutate$1_addTimeItem: typeof addTimeItem;
declare const mutate$1_addTournamentExtension: typeof addTournamentExtension;
declare const mutate$1_addTournamentTimeItem: typeof addTournamentTimeItem;
declare const mutate$1_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension;
declare const mutate$1_removeEventExtension: typeof removeEventExtension;
declare const mutate$1_removeExtension: typeof removeExtension;
declare const mutate$1_removeNotes: typeof removeNotes;
declare const mutate$1_removeOnlineResource: typeof removeOnlineResource;
declare const mutate$1_removeParticipantExtension: typeof removeParticipantExtension;
declare const mutate$1_removeTournamentExtension: typeof removeTournamentExtension;
declare const mutate$1_setTournamentCategories: typeof setTournamentCategories;
declare const mutate$1_setTournamentDates: typeof setTournamentDates;
declare const mutate$1_setTournamentEndDate: typeof setTournamentEndDate;
declare const mutate$1_setTournamentName: typeof setTournamentName;
declare const mutate$1_setTournamentNotes: typeof setTournamentNotes;
declare const mutate$1_setTournamentStartDate: typeof setTournamentStartDate;
declare const mutate$1_setTournamentStatus: typeof setTournamentStatus;
declare namespace mutate$1 {
export {
mutate$1_addDrawDefinitionExtension as addDrawDefinitionExtension,
mutate$1_addEventExtension as addEventExtension,
mutate$1_addEventTimeItem as addEventTimeItem,
mutate$1_addExtension as addExtension,
mutate$1_addNotes as addNotes,
mutate$1_addOnlineResource as addOnlineResource,
mutate$1_addParticipantExtension as addParticipantExtension,
mutate$1_addParticipantTimeItem as addParticipantTimeItem,
mutate$1_addTimeItem as addTimeItem,
mutate$1_addTournamentExtension as addTournamentExtension,
mutate$1_addTournamentTimeItem as addTournamentTimeItem,
mutate$1_removeDrawDefinitionExtension as removeDrawDefinitionExtension,
mutate$1_removeEventExtension as removeEventExtension,
mutate$1_removeExtension as removeExtension,
mutate$1_removeNotes as removeNotes,
mutate$1_removeOnlineResource as removeOnlineResource,
mutate$1_removeParticipantExtension as removeParticipantExtension,
mutate$1_removeTournamentExtension as removeTournamentExtension,
mutate$1_setTournamentCategories as setTournamentCategories,
mutate$1_setTournamentDates as setTournamentDates,
mutate$1_setTournamentEndDate as setTournamentEndDate,
mutate$1_setTournamentName as setTournamentName,
mutate$1_setTournamentNotes as setTournamentNotes,
mutate$1_setTournamentStartDate as setTournamentStartDate,
mutate$1_setTournamentStatus as setTournamentStatus,
};
}
declare const index$4_addDrawDefinitionExtension: typeof addDrawDefinitionExtension;
declare const index$4_addEventExtension: typeof addEventExtension;
declare const index$4_addEventTimeItem: typeof addEventTimeItem;
declare const index$4_addExtension: typeof addExtension;
declare const index$4_addNotes: typeof addNotes;
declare const index$4_addOnlineResource: typeof addOnlineResource;
declare const index$4_addParticipantExtension: typeof addParticipantExtension;
declare const index$4_addParticipantTimeItem: typeof addParticipantTimeItem;
declare const index$4_addTimeItem: typeof addTimeItem;
declare const index$4_addTournamentExtension: typeof addTournamentExtension;
declare const index$4_addTournamentTimeItem: typeof addTournamentTimeItem;
declare const index$4_analyzeDraws: typeof analyzeDraws;
declare const index$4_analyzeTournament: typeof analyzeTournament;
declare const index$4_copyTournamentRecord: typeof copyTournamentRecord;
declare const index$4_createTournamentRecord: typeof createTournamentRecord;
declare const index$4_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const index$4_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const index$4_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const index$4_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$4_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const index$4_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const index$4_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$4_getTournamentInfo: typeof getTournamentInfo;
declare const index$4_getTournamentPenalties: typeof getTournamentPenalties;
declare const index$4_getTournamentPersons: typeof getTournamentPersons;
declare const index$4_getTournamentPoints: typeof getTournamentPoints;
declare const index$4_getTournamentStructures: typeof getTournamentStructures;
declare const index$4_getTournamentTimeItem: typeof getTournamentTimeItem;
declare const index$4_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension;
declare const index$4_removeEventExtension: typeof removeEventExtension;
declare const index$4_removeExtension: typeof removeExtension;
declare const index$4_removeNotes: typeof removeNotes;
declare const index$4_removeOnlineResource: typeof removeOnlineResource;
declare const index$4_removeParticipantExtension: typeof removeParticipantExtension;
declare const index$4_removeTournamentExtension: typeof removeTournamentExtension;
declare const index$4_setTournamentCategories: typeof setTournamentCategories;
declare const index$4_setTournamentDates: typeof setTournamentDates;
declare const index$4_setTournamentEndDate: typeof setTournamentEndDate;
declare const index$4_setTournamentName: typeof setTournamentName;
declare const index$4_setTournamentNotes: typeof setTournamentNotes;
declare const index$4_setTournamentStartDate: typeof setTournamentStartDate;
declare const index$4_setTournamentStatus: typeof setTournamentStatus;
declare namespace index$4 {
export {
index$4_addDrawDefinitionExtension as addDrawDefinitionExtension,
index$4_addEventExtension as addEventExtension,
index$4_addEventTimeItem as addEventTimeItem,
index$4_addExtension as addExtension,
index$4_addNotes as addNotes,
index$4_addOnlineResource as addOnlineResource,
index$4_addParticipantExtension as addParticipantExtension,
index$4_addParticipantTimeItem as addParticipantTimeItem,
index$4_addTimeItem as addTimeItem,
index$4_addTournamentExtension as addTournamentExtension,
index$4_addTournamentTimeItem as addTournamentTimeItem,
index$4_analyzeDraws as analyzeDraws,
index$4_analyzeTournament as analyzeTournament,
index$4_copyTournamentRecord as copyTournamentRecord,
index$4_createTournamentRecord as createTournamentRecord,
generate$1 as generate,
index$4_getAggregateTeamResults as getAggregateTeamResults,
index$4_getAllowedDrawTypes as getAllowedDrawTypes,
index$4_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
index$4_getAppliedPolicies as getAppliedPolicies,
index$4_getCompetitionDateRange as getCompetitionDateRange,
index$4_getCompetitionPenalties as getCompetitionPenalties,
index$4_getPolicyDefinitions as getPolicyDefinitions,
index$4_getTournamentInfo as getTournamentInfo,
index$4_getTournamentPenalties as getTournamentPenalties,
index$4_getTournamentPersons as getTournamentPersons,
index$4_getTournamentPoints as getTournamentPoints,
index$4_getTournamentStructures as getTournamentStructures,
index$4_getTournamentTimeItem as getTournamentTimeItem,
mutate$1 as mutate,
query$4 as query,
index$4_removeDrawDefinitionExtension as removeDrawDefinitionExtension,
index$4_removeEventExtension as removeEventExtension,
index$4_removeExtension as removeExtension,
index$4_removeNotes as removeNotes,
index$4_removeOnlineResource as removeOnlineResource,
index$4_removeParticipantExtension as removeParticipantExtension,
index$4_removeTournamentExtension as removeTournamentExtension,
index$4_setTournamentCategories as setTournamentCategories,
index$4_setTournamentDates as setTournamentDates,
index$4_setTournamentEndDate as setTournamentEndDate,
index$4_setTournamentName as setTournamentName,
index$4_setTournamentNotes as setTournamentNotes,
index$4_setTournamentStartDate as setTournamentStartDate,
index$4_setTournamentStatus as setTournamentStatus,
};
}
declare const generate_generateCourts: typeof generateCourts;
declare namespace generate {
export {
generate_generateCourts as generateCourts,
};
}
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;
};
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 AddCourtArgs = {
tournamentRecord: Tournament;
disableNotice?: boolean;
courtId?: string;
venueId: string;
court?: any;
};
declare function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court }: AddCourtArgs): {
error: {
message: string;
code: string;
};
dateAvailability: {
date: any;
startTime?: undefined;
endTime?: undefined;
};
info: string;
booking?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
dateAvailability: {
startTime: any;
date?: undefined;
endTime?: undefined;
};
info: string;
booking?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
dateAvailability: {
endTime: any;
date?: undefined;
startTime?: undefined;
};
info: string;
booking?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
dateAvailability: {
startTime: any;
endTime: any;
date?: undefined;
};
info: string;
booking?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
booking: {
startTime: any;
endTime?: undefined;
};
info: string;
dateAvailability?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
booking: {
endTime: any;
startTime?: undefined;
};
info: string;
dateAvailability?: undefined;
valid?: undefined;
} | {
error: {
message: string;
code: string;
};
} | {
court: any;
venueId: string;
success: boolean;
error?: undefined;
};
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 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 enableCourts(params: any): ResultType & {
valid?: boolean;
};
type EnableVenuesArgs = {
tournamentRecords: TournamentRecords;
enableAll?: boolean;
venueIds: string[];
};
declare function enableVenues(params: EnableVenuesArgs): ResultType & {
valid?: boolean;
};
type DeleteCourtArgs = {
tournamentRecords?: TournamentRecords;
tournamentRecord?: Tournament;
disableNotice?: boolean;
courtId: string;
force?: boolean;
};
declare function deleteCourt(params: DeleteCourtArgs): any;
type ModifyCourtArgs = {
tournamentRecords?: TournamentRecords;
venueMatchUps?: HydratedMatchUp[];
tournamentRecord?: Tournament;
disableNotice?: boolean;
modifications: any;
courtId: string;
force?: boolean;
};
declare function modifyCourt(params: ModifyCourtArgs): any;
type ModifyVenueArgs = {
tournamentRecords?: TournamentRecords;
tournamentRecord?: Tournament;
modifications: any;
venueId: string;
force?: boolean;
};
declare function modifyVenue(params: ModifyVenueArgs): {
error?: ErrorType;
success?: boolean;
venue?: Venue;
} | {
error: any;
};
declare function addVenue(params: any): any;
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_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_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$3_addCourt: typeof addCourt;
declare const index$3_addCourts: typeof addCourts;
declare const index$3_addVenue: typeof addVenue;
declare const index$3_deleteCourt: typeof deleteCourt;
declare const index$3_deleteVenue: typeof deleteVenue;
declare const index$3_deleteVenues: typeof deleteVenues;
declare const index$3_disableCourts: typeof disableCourts;
declare const index$3_disableVenues: typeof disableVenues;
declare const index$3_enableCourts: typeof enableCourts;
declare const index$3_enableVenues: typeof enableVenues;
declare const index$3_generate: typeof generate;
declare const index$3_generateCourts: typeof generateCourts;
declare const index$3_getCompetitionVenues: typeof getCompetitionVenues;
declare const index$3_getCourts: typeof getCourts;
declare const index$3_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const index$3_modifyCourt: typeof modifyCourt;
declare const index$3_modifyCourtAvailability: typeof modifyCourtAvailability;
declare const index$3_modifyVenue: typeof modifyVenue;
declare const index$3_mutate: typeof mutate;
declare const index$3_publicFindVenue: typeof publicFindVenue;
declare namespace index$3 {
export {
index$3_addCourt as addCourt,
index$3_addCourts as addCourts,
index$3_addVenue as addVenue,
index$3_deleteCourt as deleteCourt,
index$3_deleteVenue as deleteVenue,
index$3_deleteVenues as deleteVenues,
index$3_disableCourts as disableCourts,
index$3_disableVenues as disableVenues,
index$3_enableCourts as enableCourts,
index$3_enableVenues as enableVenues,
index$3_generate as generate,
index$3_generateCourts as generateCourts,
index$3_getCompetitionVenues as getCompetitionVenues,
index$3_getCourts as getCourts,
index$3_getVenuesAndCourts as getVenuesAndCourts,
index$3_modifyCourt as modifyCourt,
index$3_modifyCourtAvailability as modifyCourtAvailability,
index$3_modifyVenue as modifyVenue,
index$3_mutate as mutate,
index$3_publicFindVenue as publicFindVenue,
query$1 as query,
};
}
declare namespace index$2 {
export {
index$k as competitionGovernor,
index$j as drawsGovernor,
index$i as entriesGovernor,
index$h as eventGovernor,
index$g as generationGovernor,
index$f as matchUpFormatGovernor,
index$e as matchUpGovernor,
index$d as mocksGovernor,
index$c as participantGovernor,
index$b as policyGovernor,
index$a as publishingGovernor,
index$9 as queryGovernor,
index$8 as reportGovernor,
index$7 as scheduleGovernor,
index$6 as scoreGovernor,
index$5 as tieFormatGovernor,
index$4 as tournamentGovernor,
index$3 as venueGovernor,
};
}
declare function isPowerOf2(n?: any): any;
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 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 function getIsoDateString(schedule: any): any;
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 isTimeString(timeString: any): boolean;
declare function timeStringMinutes(timeString?: any): any;
declare function extractTime(dateString: any): any;
declare function extractDate(dateString: any): any;
declare function convertTime(value: any, time24?: any, keepDate?: any): any;
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?: undefined): Date;
declare function addMinutesToTimeString(timeString?: any, minutes?: any): any;
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;
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 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): string[];
declare function UUID(pre?: any): string;
declare function unique(arr: any): any[];
declare function noNulls(arr: any): any;
declare function shuffleArray(arr: any): 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): any;
declare function randomMember(arr: any): 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$1_JSON2CSV: typeof JSON2CSV;
declare const index$1_UUID: typeof UUID;
declare const index$1_UUIDS: typeof UUIDS;
declare const index$1_allNumeric: typeof allNumeric;
declare const index$1_attributeFilter: typeof attributeFilter;
declare const index$1_chunkArray: typeof chunkArray;
declare const index$1_chunkByNth: typeof chunkByNth;
declare const index$1_chunkSizeProfile: typeof chunkSizeProfile;
declare const index$1_constantToString: typeof constantToString;
declare const index$1_countValues: typeof countValues;
declare const index$1_createMap: typeof createMap;
declare const index$1_dateTime: typeof dateTime;
declare const index$1_definedAttributes: typeof definedAttributes;
declare const index$1_dehydrateMatchUps: typeof dehydrateMatchUps;
declare const index$1_extractAttributes: typeof extractAttributes;
declare const index$1_flattenJSON: typeof flattenJSON;
declare const index$1_generateDateRange: typeof generateDateRange;
declare const index$1_generateHashCode: typeof generateHashCode;
declare const index$1_generateRange: typeof generateRange;
declare const index$1_generateTimeCode: typeof generateTimeCode;
declare const index$1_groupValues: typeof groupValues;
declare const index$1_hasAttributeValues: typeof hasAttributeValues;
declare const index$1_instanceCount: typeof instanceCount;
declare const index$1_intersection: typeof intersection;
declare const index$1_isConvertableInteger: typeof isConvertableInteger;
declare const index$1_isNumeric: typeof isNumeric;
declare const index$1_isOdd: typeof isOdd;
declare const index$1_isPowerOf2: typeof isPowerOf2;
declare const index$1_makeDeepCopy: typeof makeDeepCopy;
declare const index$1_matchUpScheduleSort: typeof matchUpScheduleSort;
declare const index$1_matchUpSort: typeof matchUpSort;
declare const index$1_nearestPowerOf2: typeof nearestPowerOf2;
declare const index$1_nextPowerOf2: typeof nextPowerOf2;
declare const index$1_noNulls: typeof noNulls;
declare const index$1_noNumeric: typeof noNumeric;
declare const index$1_numericSort: typeof numericSort;
declare const index$1_occurrences: typeof occurrences;
declare const index$1_overlap: typeof overlap;
declare const index$1_randomMember: typeof randomMember;
declare const index$1_randomPop: typeof randomPop;
declare const index$1_shuffleArray: typeof shuffleArray;
declare const index$1_structureSort: typeof structureSort;
declare const index$1_subSort: typeof subSort;
declare const index$1_undefinedToNull: typeof undefinedToNull;
declare const index$1_unique: typeof unique;
declare const index$1_visualizeScheduledMatchUps: typeof visualizeScheduledMatchUps;
declare namespace index$1 {
export {
index$1_JSON2CSV as JSON2CSV,
index$1_UUID as UUID,
index$1_UUIDS as UUIDS,
index$1_allNumeric as allNumeric,
index$1_attributeFilter as attributeFilter,
index$1_chunkArray as chunkArray,
index$1_chunkByNth as chunkByNth,
index$1_chunkSizeProfile as chunkSizeProfile,
index$1_constantToString as constantToString,
index$1_countValues as countValues,
index$1_createMap as createMap,
index$1_dateTime as dateTime,
index$1_definedAttributes as definedAttributes,
index$1_dehydrateMatchUps as dehydrateMatchUps,
index$1_extractAttributes as extractAttributes,
index$1_flattenJSON as flattenJSON,
index$1_generateDateRange as generateDateRange,
index$1_generateHashCode as generateHashCode,
index$1_generateRange as generateRange,
index$1_generateTimeCode as generateTimeCode,
index$1_groupValues as groupValues,
index$1_hasAttributeValues as hasAttributeValues,
index$1_instanceCount as instanceCount,
index$1_intersection as intersection,
index$1_isConvertableInteger as isConvertableInteger,
index$1_isNumeric as isNumeric,
index$1_isOdd as isOdd,
index$1_isPowerOf2 as isPowerOf2,
index$1_makeDeepCopy as makeDeepCopy,
index$1_matchUpScheduleSort as matchUpScheduleSort,
index$1_matchUpSort as matchUpSort,
index$1_nearestPowerOf2 as nearestPowerOf2,
index$1_nextPowerOf2 as nextPowerOf2,
index$1_noNulls as noNulls,
index$1_noNumeric as noNumeric,
index$1_numericSort as numericSort,
index$1_occurrences as occurrences,
index$1_overlap as overlap,
index$1_randomMember as randomMember,
index$1_randomPop as randomPop,
index$1_shuffleArray as shuffleArray,
index$1_structureSort as structureSort,
index$1_subSort as subSort,
index$1_undefinedToNull as undefinedToNull,
index$1_unique as unique,
index$1_visualizeScheduledMatchUps as visualizeScheduledMatchUps,
};
}
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 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): string[];
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 = {
notices: Notice[];
topic: string;
};
declare function callListener(payload: any): Promise<any>;
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_getDevContext: typeof getDevContext;
declare const globalState_getMethods: typeof getMethods;
declare const globalState_getNotices: typeof getNotices;
declare const globalState_getProvider: typeof getProvider;
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_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_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 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_getDevContext as getDevContext, globalState_getMethods as getMethods, globalState_getNotices as getNotices, globalState_getProvider as getProvider, 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_setDeepCopy as setDeepCopy, globalState_setDevContext as setDevContext, globalState_setGlobalLog as setGlobalLog, globalState_setGlobalMethods as setGlobalMethods, globalState_setGlobalSubscriptions as setGlobalSubscriptions, globalState_setMethods as setMethods, 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 };
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 };
}
declare const forge: {};
declare function asyncEngine(test?: boolean): FactoryEngine & {
error?: any;
};
declare const syncEngine: FactoryEngine;
declare const askEngine: FactoryEngine;
declare const matchUpEngine: FactoryEngine;
declare const mocksEngine: FactoryEngine;
declare const competitionEngine: FactoryEngine;
declare const tournamentEngine: FactoryEngine;
declare const scaleEngine: FactoryEngine;
declare function countryToFlag(isoCode: string): string;
declare function flagIOC(ioc: string): string;
declare const fixtures: {
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[];
};
};
matchUpFormats: {
FORMAT_STANDARD: string;
FORMAT_STANDARD_NOAD: string;
FORMAT_ATP_DOUBLES: string;
FORMAT_SHORT_SETS: string;
FORMAT_FAST4: 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;
};
};
TIME_TENNIS_DUAL: {
collectionDefinitions: ({
scoreValue: number;
matchUpType: string;
collectionName: string;
matchUpFormat: string;
gender: string;
matchUpCount: number;
matchUpValue?: undefined;
} | {
matchUpValue: number;
matchUpType: string;
collectionName: string;
matchUpFormat: string;
gender: string;
matchUpCount: number;
scoreValue?: undefined;
})[];
tieFormatName: string;
winCriteria: {
aggregateValue: boolean;
};
};
TIME_TENNIS_PRO_CIRCUIT: {
collectionDefinitions: ({
scoreValue: number;
matchUpType: string;
collectionName: string;
matchUpFormat: string;
gender: string;
matchUpCount: number;
matchUpValue?: undefined;
} | {
matchUpValue: number;
matchUpType: string;
collectionName: string;
matchUpFormat: string;
gender: string;
matchUpCount: number;
scoreValue?: undefined;
})[];
tieFormatName: string;
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_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_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;
}[];
};
};
};
flagIOC: typeof flagIOC;
};
declare const auditConstants: {
AUTO_SCHEDULING_AUDIT: string;
DELETE_EVENTS: string;
DELETE_DRAW_DEFINITIONS: 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;
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;
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;
};
};
DRAW: any;
RANDOM: any;
TOP_DOWN: any;
BOTTOM_UP: any;
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;
CONTEXT: string;
DELEGATED_OUTCOME: string;
DISABLED: string;
DISABLE_LINKS: string;
DISABLE_AUTO_CALC: string;
DISPLAY: string;
DRAW_DELETIONS: string;
DRAW_PROFILE: string;
ENTRY_PROFILE: string;
EVENT_PROFILE: string;
EVENT_WITHDRAWAL_REQUESTS: string;
FLIGHT_PROFILE: string;
GROUPING_ATTRIBUTE: string;
LINEUPS: string;
LINKED_TOURNAMENTS: string;
MATCHUP_HISTORY: string;
PARTICIPANT_REPRESENTATIVES: string;
PERSON_REQUESTS: string;
POSITION_ACTIONS: string;
RANKING_POINTS: string;
REGISTRATION: string;
ROUND_TARGET: 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: {
ANY: any;
MALE: any;
FEMALE: any;
MIXED: any;
OTHER: any;
};
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;
};
declare const participantRoles: {
ADMINISTRATION: any;
CAPTAIN: any;
COACH: any;
COMPETITOR: any;
MEDIA: any;
MEDICAL: any;
OFFICIAL: any;
OTHER: any;
SECURITY: 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_VALUE: string;
};
declare const ratingConstants: {
ELO: string;
NTRP: string;
TRN: string;
UTR: string;
WTN: string;
};
declare const requestConstants: {
DO_NOT_SCHEDULE: string;
};
declare const resourceContants: {
RESOURCE_SUB_TYPE: string;
RESOURCE_TYPE: string;
IDENTIFIER: 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;
SCHEDULE_ISSUE_IDS: string;
SCHEDULE_CONFLICT: string;
SCHEDULE_WARNING: string;
SCHEDULE_ERROR: string;
SCHEDULE_ISSUE: string;
SCHEDULE_STATE: 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 tieFormatConstants: {
COLLEGE_D3: string;
COLLEGE_DEFAULT: string;
COLLEGE_JUCO: string;
DOMINANT_DUO: string;
DOMINANT_DUO_MIXED: string;
LAVER_CUP: string;
TEAM_DOUBLES_3_AGGREGATION: string;
TIME_TENNIS_DUAL: string;
TIME_TENNIS_PRO_CIRCUIT: 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_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;
UPDATE_INCONTEXT_MATCHUP: string;
};
declare const tournamentConstants: {
ABANDONED: string;
ACTIVE: string;
CANCELLED: string;
COMPLETED: string;
IN_PROGRESS: string;
};
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 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;
};
declare const index_activeMatchUpStatuses: typeof activeMatchUpStatuses;
declare const index_auditConstants: typeof auditConstants;
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_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_policyConstants: typeof policyConstants;
declare const index_positionActionConstants: typeof positionActionConstants;
declare const index_ratingConstants: typeof ratingConstants;
declare const index_recoveryTimeRequiredMatchUpStatuses: typeof recoveryTimeRequiredMatchUpStatuses;
declare const index_requestConstants: typeof requestConstants;
declare const index_resourceContants: typeof resourceContants;
declare const index_resultConstants: typeof resultConstants;
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_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_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_particicipantsRequiredMatchUpStatuses as particicipantsRequiredMatchUpStatuses,
index_participantConstants as participantConstants,
index_participantRoles as participantRoles,
index_participantTypes as participantTypes,
index_penaltyConstants as penaltyConstants,
index_policyConstants as policyConstants,
index_positionActionConstants as positionActionConstants,
index_ratingConstants as ratingConstants,
index_recoveryTimeRequiredMatchUpStatuses as recoveryTimeRequiredMatchUpStatuses,
index_requestConstants as requestConstants,
index_resourceContants as resourceContants,
index_resultConstants as resultConstants,
index_scaleConstants as scaleConstants,
index_scheduleConstants as scheduleConstants,
index_sortingConstants as sortingConstants,
index_surfaceConstants as surfaceConstants,
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 { activeMatchUpStatuses, askEngine, asyncEngine, auditConstants, competitionEngine, index$k as competitionGovernor, completedMatchUpStatuses, directingMatchUpStatuses, displayConstants, drawDefinitionConstants, index$j as drawsGovernor, index$i as entriesGovernor, entryStatusConstants, errorConditionConstants, eventConstants, index$h as eventGovernor, extensionConstants, index as factoryConstants, fixtures, flightConstants, forge, genderConstants, index$g as generationGovernor, globalState, index$2 as governors, keyValueConstants, matchUpActionConstants, matchUpEngine, index$f as matchUpFormatCode, index$f as matchUpFormatGovernor, index$e as matchUpGovernor, matchUpStatusConstants, matchUpTypes, mocksEngine, index$d as mocksGovernor, nonDirectingMatchUpStatuses, particicipantsRequiredMatchUpStatuses, participantConstants, index$c as participantGovernor, participantRoles, participantTypes, penaltyConstants, policyConstants, index$b as policyGovernor, positionActionConstants, index$a as publishingGovernor, index$9 as queryGovernor, ratingConstants, recoveryTimeRequiredMatchUpStatuses, index$8 as reportGovernor, requestConstants, resourceContants, resultConstants, scaleConstants, scaleEngine, scheduleConstants, index$7 as scheduleGovernor, index$6 as scoreGovernor, sortingConstants, surfaceConstants, syncEngine, tieFormatConstants, index$5 as tieFormatGovernor, timeItemConstants, index$1 as tools, topicConstants, tournamentConstants, tournamentEngine, index$4 as tournamentGovernor, upcomingMatchUpStatuses, index$1 as utilities, validMatchUpStatuses, venueConstants, index$3 as venueGovernor, factoryVersion as version, weekdayConstants };
export type { AddScheduleAttributeArgs, Address, AddressProps, AddressTypeUnion, Availability, BallTypeUnion, BiographicalInformation, Booking, Category, CategoryUnion, CheckInOutParticipantArgs, CollectionAssignment, CollectionDefinition, CollectionGroup, CollectionValueProfile, Contact, ContextContent, ContextProfile, CountryCodeUnion, Court, CourtPosition, CourtPositionUnion, Directives, DisciplineUnion, DrawDefinition, DrawLink, DrawLinkSource, DrawLinkTarget, DrawMaticArgs, DrawStatusUnion, DrawTypeUnion, Entry, EntryStatusUnion, Event$1 as Event, EventTypeUnion, ExitProfiles, Extension, FactoryEngine, FinishingPositionUnion, Flight, FlightProfile, Game, GenderUnion, GenerateDrawDefinitionArgs, GetMatchUpsArgs, GroupInfo, GroupsMatchUpsResult, HydratedCourt, HydratedMatchUp, HydratedParticipant, HydratedSide, HydratedVenue, IdCollections, IndoorOutdoorUnion, Interleave, LengthUnitUnion, LineUp, LinkTypeUnion, MappedMatchUps, MappedParticipant, MatchUp, MatchUpFilters, MatchUpFinishingPositionRange, MatchUpStatusUnion, MatchUpsMap, OnlineResource, OnlineResourceTypeUnion, Organisation, Participant, ParticipantFilters, ParticipantMap, ParticipantRoleUnion, ParticipantStatusUnion, ParticipantTypeUnion, ParticipantsProfile, Penalty, PenaltyTypeUnion, Person, PersonData, PersonRequests, PlayingDoubleHandCodeUnion, PlayingHandCodeUnion, PlayoffAttributes, Point, PolicyDefinitions, PositionAssignment, PositioningProfileUnion, PrizeMoney, QueueMethod, RegistrationProfile, ResultType, RoundProfile, ScaleAttributes, ScaleItem, ScheduleAnalysis, ScheduleConflict, ScheduleTimesResult, ScheduleTiming, ScheduleVisibilityFilters, ScheduledMatchUpArgs, Score, SeedAssignment, SeedBlock, SeedingProfile, SeedingProfileUnion, Set, SexUnion, Shot, ShotDetailUnion, ShotOutcomeUnion, ShotTypeUnion, Side, StageTypeUnion, Structure, StructureParticipation, StructureProfile, StructureSortConfig, StructureTypeUnion, Substitution, SurfaceCategoryUnion, Tally, Team, TeamCompetitor, TeamKey, TieFormat, TimeItem, Tournament, TournamentLevelUnion, TournamentRecords, TournamentStatusUnion, UnifiedPersonID, UnifiedTournamentID, UnifiedVenueID, Venue, WeightUnitUnion, WheelchairClassUnion, WinCriteria, WinReasonUnion, weekdayUnion };