tods-competition-factory/dist/tods-competition-factory.d.ts

Create and mutate TODS compliant tournament objects

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