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 = {
    firstStageSequenceOnly?: boolean;
    tournamentRecord: Tournament;
    extensionProfiles?: any[];
    firstFlightOnly?: boolean;
};
declare function getStructureReports(params: GetStructureReportsArgs): {
    error: {
        message: string;
        code: string;
    };
    eventStructureReports?: undefined;
    structureReports?: undefined;
    flightReports?: undefined;
} | {
    eventStructureReports: unknown[];
    structureReports: any[] | undefined;
    flightReports: any[];
    error?: undefined;
};

type 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 };