declare function factoryVersion(): string;

type ServerRule$1 = 'ALTERNATE_GAMES' | 'WINNER_SERVES';
interface competitionFormat {
    competitionFormatId?: string;
    competitionFormatName?: string;
    matchUpFormat?: string;
    sport?: SportUnion;
    timerProfile?: TimerProfile$1;
    timeoutRules?: TimeoutRules$1;
    substitutionRules?: SubstitutionRules$1;
    playerRules?: PlayerRules$1;
    penaltyProfile?: PenaltyProfile$1;
    penaltyBoxProfile?: PenaltyBoxProfile$1;
    pointProfile?: PointProfile$1;
    pointMultipliers?: PointMultiplier$1[];
    serverRule?: ServerRule$1;
    extensions?: Extension[];
    notes?: string;
}
type SportUnion = 'TENNIS' | 'PADEL' | 'PICKLEBALL' | 'SQUASH' | 'BADMINTON' | 'TABLE_TENNIS' | 'INTENNSE' | 'TYPTI' | 'VOLLEYBALL' | 'FENCING' | 'OTHER';
interface TimerProfile$1 {
    shotClockSeconds?: number;
    segmentTimers?: SegmentTimer[];
    changeoverSeconds?: number;
    setBreakSeconds?: number;
}
interface SegmentTimer {
    segmentType: 'set' | 'half' | 'quarter' | 'period' | 'round' | 'frame' | 'map';
    minutes: number;
    direction?: 'up' | 'down';
    stoppageTime?: boolean;
}
type TimeoutScope = 'MATCHUP' | 'SET' | 'HALF' | 'SEGMENT';
interface TimeoutRules$1 {
    count: number;
    per: TimeoutScope;
    durationSeconds?: number;
    maxPerSide?: number;
}
type SubstitutionTiming = 'BETWEEN_GAMES' | 'BETWEEN_POINTS' | 'ANY';
interface SubstitutionRules$1 {
    allowed: boolean;
    maxPerMatchUp?: number;
    maxPerSegment?: number;
    allowedMatchUpTypes?: ('SINGLES' | 'DOUBLES')[];
    timing?: SubstitutionTiming;
    minRosterSize?: number;
    maxRosterSize?: number;
}
interface PlayerRules$1 {
    maxMinutesPerSegment?: number;
    matchUpTypes?: ('SINGLES' | 'DOUBLES')[];
}
interface PenaltyProfile$1 {
    sport?: SportUnion;
    penaltyTypes: PenaltyTypeDefinition[];
    escalation?: PenaltyEscalation[];
}
interface PenaltyTypeDefinition {
    penaltyType: string;
    label: string;
    category?: 'code_violation' | 'time_violation' | 'conduct' | 'other';
}
interface PenaltyEscalation {
    step: number;
    consequence: 'warning' | 'point' | 'game' | 'default';
}
interface PenaltyBoxProfile$1 {
    durationSeconds: number;
}
interface PointProfile$1 {
    sport?: SportUnion;
    pointResults: PointResultDefinition[];
    strokeTypes?: string[];
    serveLocations?: string[];
}
interface PointResultDefinition {
    result: string;
    label: string;
    isError?: boolean;
    isServe?: boolean;
}
interface PointMultiplier$1 {
    condition: {
        results?: string[];
        strokes?: string[];
        setTypes?: string[];
    };
    value: number;
}

interface Tournament {
    activeDates?: Date[] | string[];
    createdAt?: Date | string;
    endDate?: string;
    events?: Event$1[];
    extensions?: Extension[];
    factory?: {
        version?: string;
        [key: string]: any;
    };
    formalName?: string;
    hostCountryCode?: CountryCodeUnion;
    indoorOutdoor?: IndoorOutdoorUnion;
    isMock?: boolean;
    linkedTournamentIds?: string[];
    localTimeZone?: string;
    matchUps?: MatchUp$1[];
    notes?: string;
    onlineResources?: OnlineResource[];
    parentOrganisationId?: string;
    parentOrganisation?: Organisation;
    participants?: Participant$1[];
    processCodes?: string[];
    promotionalName?: string;
    registrationProfile?: RegistrationProfile;
    scheduling?: {
        profile?: any;
        dailyLimits?: any;
        timing?: any;
        practice?: {
            defaultCapacity?: number | null;
        };
        [key: string]: any;
    };
    season?: string;
    startDate?: string;
    surfaceCategory?: SurfaceCategoryUnion;
    timeItems?: TimeItem[];
    totalPrizeMoney?: PrizeMoney[];
    tournamentCategories?: Category[];
    tournamentGroups?: string[];
    tournamentId: string;
    tournamentLevel?: TournamentLevelUnion;
    tournamentName?: string;
    tournamentOtherIds?: UnifiedTournamentID[];
    tournamentRank?: string;
    tournamentStatus?: TournamentStatusUnion;
    tournamentTier?: TierClassification;
    updatedAt?: Date | string;
    venues?: Venue[];
    weekdays?: WeekdayUnion[];
}
type TournamentStatusUnion = 'ABANDONDED' | 'CANCELLED' | 'ACTIVE' | 'COMPLETED';
interface Organisation {
    onlineResources?: OnlineResource[];
    organisationAbbreviation: string;
    parentOrganisationId?: string;
    extensions?: Extension[];
    organisationName: string;
    organisationId: string;
    notes?: string;
}
interface Event$1 {
    activeDates?: Date[] | string[];
    allowedDrawTypes?: DrawTypeUnion[];
    category?: Category;
    competitionFormat?: competitionFormat;
    createdAt?: Date | string;
    discipline?: DisciplineUnion;
    drawDefinitions?: DrawDefinition[];
    endDate?: string;
    entries?: Entry[];
    eventAbbreviation?: string;
    eventId: string;
    eventLevel?: TournamentLevelUnion;
    eventName?: string;
    eventOrder?: number;
    eventRank?: string;
    eventTier?: TierClassification;
    eventType?: EventTypeUnion;
    extensions?: Extension[];
    flightProfile?: any;
    gender?: GenderUnion;
    indoorOutdoor?: IndoorOutdoorUnion;
    isMock?: boolean;
    links?: DrawLink[];
    matchUpFormat?: string;
    notes?: string;
    processCodes?: string[];
    startDate?: string;
    surfaceCategory?: SurfaceCategoryUnion;
    tennisOfficialIds?: string[];
    tieFormat?: TieFormat;
    tieFormatId?: string;
    tieFormats?: TieFormat[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    weekdays?: WeekdayUnion[];
    wheelchairClass?: WheelchairClassUnion;
}
declare const DrawTypeEnum: {
    readonly AD_HOC: "AD_HOC";
    readonly ADAPTIVE: "ADAPTIVE";
    readonly COMPASS: "COMPASS";
    readonly CURTIS_cONSOLATION: "CURTIS_CONSOLATION";
    readonly DOUBLE_eLIMINATION: "DOUBLE_ELIMINATION";
    readonly FEED_IN: "FEED_IN";
    readonly FEED_IN_CHAMPIONSHIP: "FEED_IN_CHAMPIONSHIP";
    readonly FEED_IN_CHAMPIONSHIP_TO_QF: "FEED_IN_CHAMPIONSHIP_TO_QF";
    readonly FEED_IN_CHAMPIONSHIP_TO_R16: "FEED_IN_CHAMPIONSHIP_TO_R16";
    readonly FEED_In_CHAMPIONSHIP_TO_SF: "FEED_IN_CHAMPIONSHIP_TO_SF";
    readonly FIRST_MATCH_LOSER_CONSOLATION: "FIRST_MATCH_LOSER_CONSOLATION";
    readonly FIRST_ROUND_LOSER_CONSOLATION: "FIRST_ROUND_LOSER_CONSOLATION";
    readonly MODIFIED_FEED_IN_CHAMPIONSHIP: "MODIFIED_FEED_IN_CHAMPIONSHIP";
    readonly LUCKY_DRAW: "LUCKY_DRAW";
    readonly OLYMPIC: "OLYMPIC";
    readonly OTHER: "OTHER";
    readonly PAGE_PLAYOFF: "PAGE_PLAYOFF";
    readonly PLAYOFF: "PLAYOFF";
    readonly ROUND_ROBIN: "ROUND_ROBIN";
    readonly ROUND_ROBIN_WITH_PLAYOFF: "ROUND_ROBIN_WITH_PLAYOFF";
    readonly SINGLE_ELIMINATION: "SINGLE_ELIMINATION";
    readonly SWISS: "SWISS";
};
type DrawTypeUnion = keyof typeof DrawTypeEnum;
interface Category {
    ageCategoryCode?: string;
    ageMax?: number;
    ageMaxDate?: string;
    ageMin?: number;
    ageMinDate?: string;
    ballType?: BallTypeUnion;
    categoryName?: string;
    categoryType?: string;
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    ratingMax?: number;
    ratingMin?: number;
    ratingType?: string;
    subType?: string;
    timeItems?: TimeItem[];
    type?: CategoryUnion;
    updatedAt?: Date | string;
}
declare enum BallTypeEnum {
    HIGH_ALTITUDE = "HIGH_ALTITUDE",
    Stage1Green = "STAGE1GREEN",
    Stage2Orange = "STAGE2ORANGE",
    Stage3Red = "STAGE3RED",
    T2STANDARD_PRESSURELESS = "T2STANDARD_PRESSURELESS",
    T2STANDARD_PRESSURISED = "T2STANDARD_PRESSURISED",
    TYPE1FAST = "TYPE1FAST",
    TYPE3SLOW = "TYPE3SLOW"
}
type BallTypeUnion = keyof typeof BallTypeEnum;
interface Extension {
    description?: string;
    name: string;
    value: any;
}
interface TimeItem {
    createdAt?: Date | string;
    itemDate?: Date | string;
    itemSubTypes?: string[];
    itemType?: string;
    itemValue?: any;
}
type DisciplineUnion = 'BEACH_TENNIS' | 'TENNIS' | 'WHEELCHAIR_TENNIS';
type CategoryUnion = 'AGE' | 'BOTH' | 'LEVEL';
interface DrawDefinition {
    activeDates?: Date[] | string[];
    automated?: boolean;
    competitionFormat?: competitionFormat;
    createdAt?: Date | string;
    drawId: string;
    drawName?: string;
    drawOrder?: number;
    drawRepresentativeIds?: string[];
    drawStatus?: DrawStatusUnion;
    drawType?: DrawTypeUnion;
    endDate?: string;
    entries?: Entry[];
    extensions?: Extension[];
    competitionState?: any;
    draftState?: any;
    flightProfile?: any;
    flightNumber?: number;
    isMock?: boolean;
    lineUps?: any;
    links?: DrawLink[];
    matchUpFormat?: string;
    matchUps?: MatchUp$1[];
    matchUpType?: EventTypeUnion;
    notes?: string;
    processCodes?: string[];
    startDate?: string;
    structures?: Structure[];
    tieFormat?: TieFormat;
    tieFormatId?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
type DrawStatusUnion = 'COMPLETE' | 'IN_PROGRESS' | 'TO_BE_PLAYED';
interface Entry {
    createdAt?: Date | string;
    entryId?: string;
    entryPosition?: number;
    entryStage?: StageTypeUnion;
    entryStageSequence?: number;
    entryStatus?: EntryStatusUnion;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    participantId: string;
    roundTarget?: number;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    scaleValue?: number;
}
declare enum StageTypeEnum {
    CONSOLATION = "CONSOLATION",
    MAIN = "MAIN",
    PLAY_OFF = "PLAY_OFF",
    QUALIFYING = "QUALIFYING",
    VOLUNTARY_CONSOLATION = "VOLUNTARY_CONSOLATION"
}
type StageTypeUnion = keyof typeof StageTypeEnum;
declare enum EntryStatusEnum {
    ALTERNATE = "ALTERNATE",
    CONFIRMED = "CONFIRMED",
    DIRECT_ACCEPTANCE = "DIRECT_ACCEPTANCE",
    FEED_IN = "FEED_IN",
    JUNIOR_EXEMPT = "JUNIOR_EXEMPT",
    LUCKY_LOSER = "LUCKY_LOSER",
    ORGANISER_ACCEPTANCE = "ORGANISER_ACCEPTANCE",
    QUALIFIER = "QUALIFIER",
    REGISTERED = "REGISTERED",
    SPECIAL_EXEMPT = "SPECIAL_EXEMPT",
    UNGROUPED = "UNGROUPED",
    UNPAIRED = "UNPAIRED",
    WILDCARD = "WILDCARD",
    WITHDRAWN = "WITHDRAWN"
}
type EntryStatusUnion = keyof typeof EntryStatusEnum;
interface DrawLink {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    linkCondition?: string;
    linkType: LinkTypeUnion;
    notes?: string;
    source: DrawLinkSource;
    target: DrawLinkTarget;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum LinkTypeEnum {
    LOSER = "LOSER",
    POSITION = "POSITION",
    WINNER = "WINNER"
}
type LinkTypeUnion = keyof typeof LinkTypeEnum;
interface DrawLinkSource {
    bestOf?: number;
    createdAt?: Date | string;
    drawId?: string;
    extensions?: Extension[];
    finishingPositions?: number[];
    isMock?: boolean;
    notes?: string;
    rankBy?: string;
    qualifyingPositions?: number;
    remainder?: boolean;
    roundNumber?: number;
    structureId: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface DrawLinkTarget {
    createdAt?: Date | string;
    drawId?: string;
    extensions?: Extension[];
    feedProfile: PositioningProfileUnion;
    groupedOrder?: number[];
    isMock?: boolean;
    notes?: string;
    positionInterleave?: Interleave;
    roundNumber: number;
    structureId: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum PositioningProfileEnum {
    BOTTOM_UP = "BOTTOM_UP",
    DRAW = "DRAW",
    LOSS_POSITION = "LOSS_POSITION",
    RANDOM = "RANDOM",
    TOP_DOWN = "TOP_DOWN",
    WATERFALL = "WATERFALL"
}
type PositioningProfileUnion = keyof typeof PositioningProfileEnum;
declare enum SeedingProfileEnum {
    CLUSTER = "CLUSTER",
    SEPARATE = "SEPARATE",
    WATERFALL = "WATERFALL"
}
type SeedingProfileUnion = keyof typeof SeedingProfileEnum;
interface Interleave {
    interleave: number;
    offset: number;
}
type EventTypeUnion = 'SINGLES' | 'DOUBLES' | 'TEAM' | 'HYBRID';
interface MatchUpSchedule {
    allocatedCourts?: any[];
    calledAt?: string;
    courtAnnotation?: string;
    courtId?: string;
    courtOrder?: number;
    homeParticipantId?: string;
    official?: any;
    scheduledDate?: string;
    scheduledTime?: string;
    timeModifiers?: string[];
    venueId?: string;
    [key: string]: any;
}
interface MatchUp$1 {
    collectionId?: string;
    collectionPosition?: number;
    createdAt?: Date | string;
    delegatedOutcome?: any;
    disableAutoCalc?: boolean;
    drawPositions?: number[];
    endDate?: string;
    extensions?: Extension[];
    finishingPositionRange?: MatchUpFinishingPositionRange;
    finishingRound?: number;
    indoorOutdoor?: IndoorOutdoorUnion;
    isMock?: boolean;
    loserMatchUpId?: string;
    matchUpDuration?: string;
    matchUpFormat?: string;
    matchUpId: string;
    matchUpStatus?: MatchUpStatusUnion;
    matchUpStatusCodes?: any[];
    matchUpType?: EventTypeUnion;
    notes?: string;
    orderOfFinish?: number;
    processCodes?: string[];
    roundName?: string;
    roundNumber?: number;
    roundPosition?: number;
    schedule?: MatchUpSchedule;
    score?: Score$1;
    sides?: Side$1[];
    startDate?: string;
    surfaceCategory?: SurfaceCategoryUnion;
    tieFormat?: TieFormat;
    tieFormatId?: string;
    tieMatchUps?: MatchUp$1[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winnerMatchUpId?: string;
    winningSide?: number;
}
interface MatchUpFinishingPositionRange {
    loser: number[];
    winner: number[];
}
type IndoorOutdoorUnion = 'INDOOR' | 'MIXED' | 'OUTDOOR';
declare enum MatchUpStatusEnum {
    ABANDONED = "ABANDONED",
    AWAITING_RESULT = "AWAITING_RESULT",
    BYE = "BYE",
    CANCELLED = "CANCELLED",
    COMPLETED = "COMPLETED",
    DEAD_RUBBER = "DEAD_RUBBER",
    DEFAULTED = "DEFAULTED",
    DOUBLE_DEFAULT = "DOUBLE_DEFAULT",
    DOUBLE_WALKOVER = "DOUBLE_WALKOVER",
    IN_PROGRESS = "IN_PROGRESS",
    INCOMPLETE = "INCOMPLETE",
    NOT_PLAYED = "NOT_PLAYED",
    RETIRED = "RETIRED",
    SUSPENDED = "SUSPENDED",
    TO_BE_PLAYED = "TO_BE_PLAYED",
    WALKOVER = "WALKOVER"
}
type MatchUpStatusUnion = keyof typeof MatchUpStatusEnum;
interface Score$1 {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    scoreStringSide1?: string;
    scoreStringSide2?: string;
    sets?: Set[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface Set {
    createdAt?: Date | string;
    extensions?: Extension[];
    games?: Game[];
    isMock?: boolean;
    notes?: string;
    setDuration?: string;
    setFormat?: string;
    setNumber?: number;
    side1PointScore?: number | string;
    side1Score?: number;
    side1TiebreakScore?: number;
    side2PointScore?: number | string;
    side2Score?: number;
    side2TiebreakScore?: number;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winningSide?: number;
}
interface Game {
    createdAt?: Date | string;
    extensions?: Extension[];
    gameDuration?: string;
    gameFormat?: string;
    gameNumber?: number;
    isMock?: boolean;
    notes?: string;
    points?: Point$1[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winningSide?: number;
    winReason?: WinReasonUnion;
}
interface Point$1 {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    pointDuration?: string;
    pointNumber?: number;
    shots?: Shot[];
    side1Score?: string;
    side2Score?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winningSide?: number;
    winReason?: WinReasonUnion;
}
interface Shot {
    bounceAt?: CourtPosition;
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    participantId: string;
    shotDetail?: ShotDetailUnion;
    shotMadeFrom?: CourtPosition;
    shotNumber?: number;
    shotOutcome?: ShotOutcomeUnion;
    shotType?: ShotTypeUnion;
    sideNumber?: number;
    speed?: number;
    spin?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface CourtPosition {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    positionName?: CourtPositionUnion;
    timeAtPosition?: Date | string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    x?: number;
    y?: number;
}
declare enum CourtPositionEnum {
    BaSELINE = "BASELINE",
    LEFT_SERVICE_COURT = "LEFT_SERVICE_COURT",
    NET = "NET",
    RIGHT_SERVICE_COURT = "RIGHT_SERVICE_COURT",
    SERVICELINE = "SERVICELINE"
}
type CourtPositionUnion = keyof typeof CourtPositionEnum;
declare enum ShotDetailEnum {
    DRIVE = "DRIVE",
    DRIVE_VOLLEY = "DRIVE_VOLLEY",
    DROP_SHOT = "DROP_SHOT",
    GROUND_STROKE = "GROUND_STROKE",
    HALF_VOLLEY = "HALF_VOLLEY",
    LOB = "LOB",
    PASSING_SHOT = "PASSING_SHOT",
    SMASH = "SMASH",
    TRICK = "TRICK",
    VOLLEY = "VOLLEY"
}
type ShotDetailUnion = keyof typeof ShotDetailEnum;
declare enum ShotOutcomeEnum {
    IN = "IN",
    LET = "LET",
    NET = "NET",
    OUT = "OUT"
}
type ShotOutcomeUnion = keyof typeof ShotOutcomeEnum;
declare enum ShotTypeEnum {
    BACKHAND = "BACKHAND",
    FOREHAND = "FOREHAND",
    SERVE = "SERVE"
}
type ShotTypeUnion = keyof typeof ShotTypeEnum;
declare enum WinReasonEnum {
    ACE = "ACE",
    DOUBLE_FAULT = "DOUBLE_FAULT",
    ERROR = "ERROR",
    FORCED = "FORCED",
    NETcORD = "NET_CORD",
    PENALTY = "PENALTY",
    UNFORCED = "UNFORCED",
    WINNER = "WINNER"
}
type WinReasonUnion = keyof typeof WinReasonEnum;
interface Side$1 {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    lineUp?: TeamCompetitor$1[];
    notes?: string;
    participantId?: string;
    participant?: Participant$1;
    sideNumber?: number;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface TeamCompetitor$1 {
    collectionAssignments?: CollectionAssignment$1[];
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    participantId: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface Team {
    gender?: GenderEnum;
    homeVenueIds?: string[];
    nativeTeamName?: string;
    otherTeamNames?: string[];
    parentOrganisationId?: string;
    personIds?: string[];
    previousTeamNames?: string[];
    teamId: string;
    teamName?: string;
}
interface CollectionAssignment$1 {
    collectionId: string;
    collectionPosition: number;
    previousParticipantId?: string;
    substitutionOrder?: number;
}
declare enum SurfaceCategoryEnum {
    ARTIFICIAL = "ARTIFICIAL",
    CARPET = "CARPET",
    CLAY = "CLAY",
    GRASS = "GRASS",
    HARD = "HARD"
}
type SurfaceCategoryUnion = keyof typeof SurfaceCategoryEnum;
interface TieFormat {
    collectionDefinitions: CollectionDefinition[];
    collectionGroups?: CollectionGroup[];
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    tieFormatId?: string;
    tieFormatName?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winCriteria: WinCriteria;
}
interface CollectionDefinition {
    collectionValueProfiles?: CollectionValueProfile[];
    collectionGroupNumber?: number;
    category?: Category;
    collectionId: string;
    collectionName?: string;
    collectionOrder?: number;
    collectionValue?: number;
    createdAt?: Date | string;
    extensions?: Extension[];
    gender?: GenderUnion;
    isMock?: boolean;
    matchUpCount?: number;
    matchUpFormat?: string;
    matchUpType?: EventTypeUnion;
    matchUpValue?: number;
    notes?: string;
    processCodes?: string[];
    scoreValue?: number;
    setValue?: number;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winCriteria?: WinCriteria;
}
interface CollectionValueProfile {
    collectionPosition: number;
    createdAt?: Date | string;
    updatedAt?: Date | string;
    extensions?: Extension[];
    timeItems?: TimeItem[];
    matchUpValue: number;
    isMock?: boolean;
    notes?: string;
}
declare enum GenderEnum {
    FEMALE_ABBR = "F",
    MIXED_ABBR = "X",
    MALE_ABBR = "M",
    ANY_ABBR = "A",
    FEMALE = "FEMALE",
    OTHER = "OTHER",
    MIXED = "MIXED",
    MALE = "MALE",
    ANY = "ANY"
}
type GenderUnion = keyof typeof GenderEnum;
interface WinCriteria {
    aggregateValue?: boolean;
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    valueGoal: number;
}
interface CollectionGroup {
    createdAt?: Date | string;
    extensions?: Extension[];
    groupName?: string;
    groupNumber: number;
    groupValue?: number;
    isMock?: boolean;
    notes?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    winCriteria?: WinCriteria;
}
interface Structure {
    competitionFormat?: competitionFormat;
    createdAt?: Date | string;
    extensions?: Extension[];
    finishingPosition?: FinishingPositionUnion;
    isMock?: boolean;
    matchUpFormat?: string;
    matchUps?: MatchUp$1[];
    matchUpType?: EventTypeUnion;
    notes?: string;
    positionAssignments?: PositionAssignment[];
    processCodes?: string[];
    qualifyingRoundNumber?: number;
    roundLimit?: number;
    roundOffset?: number;
    roundTarget?: number;
    seedAssignments?: SeedAssignment[];
    seedingProfile?: SeedingProfileUnion;
    seedLimit?: number;
    stage?: StageTypeUnion;
    stageSequence?: number;
    structureAbbreviation?: string;
    structureId: string;
    structureName?: string;
    structures?: Structure[];
    structureOrder?: number;
    structureType?: StructureTypeUnion;
    tieFormat?: TieFormat;
    tieFormatId?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum FinishingPositionEnum {
    ROUND_OUTCOME = "ROUND_OUTCOME",
    WIN_RATIO = "WIN_RATIO"
}
type FinishingPositionUnion = keyof typeof FinishingPositionEnum;
interface TallyResult {
    GEMscore?: number;
    allDefaults?: number;
    defaults?: number;
    defeats?: any[];
    gamesLost?: number;
    gamesPct?: number;
    gamesWon?: number;
    groupOrder?: number;
    matchUpsCancelled?: number;
    matchUpsLost?: number;
    matchUpsPct?: number;
    matchUpsWon?: number;
    pointsLost?: number;
    pointsPct?: number;
    pointsWon?: number;
    pressureOrder?: number;
    pressureScores?: number[];
    provisionalOrder?: number;
    rankOrder?: number;
    retirements?: number;
    setsLost?: number;
    setsPct?: number;
    setsWon?: number;
    subOrder?: number;
    tieDoublesLost?: number;
    tieDoublesWon?: number;
    tieMatchUpsLost?: number;
    tieMatchUpsWon?: number;
    tieSinglesLost?: number;
    tieSinglesWon?: number;
    ties?: number;
    victories?: any[];
    walkovers?: number;
    [key: string]: any;
}
interface PositionAssignment {
    bye?: boolean;
    createdAt?: Date | string;
    disableLinks?: boolean;
    drawPosition: number;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    participantId?: string;
    qualifier?: boolean;
    tally?: TallyResult;
    subOrder?: number;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface SeedAssignment {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    participantId?: string;
    seedNumber: number;
    seedValue: number | string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum StructureTypeEnum {
    CONTAINER = "CONTAINER",
    ITEM = "ITEM"
}
type StructureTypeUnion = keyof typeof StructureTypeEnum;
interface TierClassification {
    system: string;
    value: string;
    numericRank?: number;
}
declare enum TournamentLevelEnum {
    CLUB = "CLUB",
    DISTRICT = "DISTRICT",
    INTERNATIONAL = "INTERNATIONAL",
    LOCAL = "LOCAL",
    NATIONAL = "NATIONAL",
    Recreational = "RECREATIONAL",
    REGIONAL = "REGIONAL",
    ZONAL = "ZONAL"
}
type TournamentLevelUnion = keyof typeof TournamentLevelEnum;
declare enum WheelchairClassEnum {
    QUAD = "QUAD",
    STANDARD = "STANDARD"
}
type WheelchairClassUnion = keyof typeof WheelchairClassEnum;
declare enum CountryCodeEnum {
    ASM = "ASM",
    ATA = "ATA",
    Abw = "ABW",
    Afg = "AFG",
    Ago = "AGO",
    Aia = "AIA",
    Ala = "ALA",
    Alb = "ALB",
    And = "AND",
    Ant = "ANT",
    Are = "ARE",
    Arg = "ARG",
    Arm = "ARM",
    Atf = "ATF",
    Atg = "ATG",
    Aus = "AUS",
    Aut = "AUT",
    Aze = "AZE",
    Bdi = "BDI",
    Bel = "BEL",
    Ben = "BEN",
    Bfa = "BFA",
    Bgd = "BGD",
    Bgr = "BGR",
    Bhr = "BHR",
    Bhs = "BHS",
    Bih = "BIH",
    Blm = "BLM",
    Blr = "BLR",
    Blz = "BLZ",
    Bmu = "BMU",
    Bol = "BOL",
    Bra = "BRA",
    Brb = "BRB",
    Brn = "BRN",
    Btn = "BTN",
    Bvt = "BVT",
    Bwa = "BWA",
    COM = "COM",
    Caf = "CAF",
    Can = "CAN",
    Cck = "CCK",
    Cgd = "CGD",
    Che = "CHE",
    Chl = "CHL",
    Chn = "CHN",
    Civ = "CIV",
    Cmr = "CMR",
    Cod = "COD",
    Cog = "COG",
    Cok = "COK",
    Col = "COL",
    Cpv = "CPV",
    Cri = "CRI",
    Cub = "CUB",
    Cuw = "CUW",
    Cxr = "CXR",
    Cym = "CYM",
    Cyp = "CYP",
    Cze = "CZE",
    DMA = "DMA",
    DOM = "DOM",
    Deu = "DEU",
    Dji = "DJI",
    Dnk = "DNK",
    Dza = "DZA",
    Ecu = "ECU",
    Egy = "EGY",
    Eri = "ERI",
    Ese = "ESE",
    Esh = "ESH",
    Esp = "ESP",
    Eth = "ETH",
    FSM = "FSM",
    Fin = "FIN",
    Fji = "FJI",
    Flk = "FLK",
    Fra = "FRA",
    Fro = "FRO",
    Gab = "GAB",
    Gbr = "GBR",
    Geo = "GEO",
    Ggy = "GGY",
    Gha = "GHA",
    Gib = "GIB",
    Gin = "GIN",
    Glp = "GLP",
    Gmb = "GMB",
    Gnb = "GNB",
    Gnq = "GNQ",
    Grc = "GRC",
    Grd = "GRD",
    Grl = "GRL",
    Gtm = "GTM",
    Guf = "GUF",
    Gum = "GUM",
    Guy = "GUY",
    Hkg = "HKG",
    Hmd = "HMD",
    Hnd = "HND",
    Hrv = "HRV",
    Hti = "HTI",
    Hun = "HUN",
    IRQ = "IRQ",
    ISR = "ISR",
    Idn = "IDN",
    Imn = "IMN",
    Ind = "IND",
    Iot = "IOT",
    Irl = "IRL",
    Irn = "IRN",
    Isl = "ISL",
    Ita = "ITA",
    Jam = "JAM",
    Jey = "JEY",
    Jor = "JOR",
    Jpn = "JPN",
    Kaz = "KAZ",
    Ken = "KEN",
    Kgz = "KGZ",
    Khm = "KHM",
    Kir = "KIR",
    Kna = "KNA",
    Kor = "KOR",
    Kos = "KOS",
    Kwt = "KWT",
    Lao = "LAO",
    Lbn = "LBN",
    Lbr = "LBR",
    Lby = "LBY",
    Lca = "LCA",
    Lie = "LIE",
    Lka = "LKA",
    Lso = "LSO",
    Ltu = "LTU",
    Lux = "LUX",
    Lva = "LVA",
    MAC = "MAC",
    MDA = "MDA",
    MNG = "MNG",
    Maf = "MAF",
    Mar = "MAR",
    Mco = "MCO",
    Mdg = "MDG",
    Mdv = "MDV",
    Mex = "MEX",
    Mhl = "MHL",
    Mkd = "MKD",
    Mli = "MLI",
    Mlt = "MLT",
    Mmr = "MMR",
    Mne = "MNE",
    Mnp = "MNP",
    Moz = "MOZ",
    Mrt = "MRT",
    Msr = "MSR",
    Mtq = "MTQ",
    Mus = "MUS",
    Mwi = "MWI",
    Mys = "MYS",
    Myt = "MYT",
    NIC = "NIC",
    NPL = "NPL",
    Nam = "NAM",
    Ncl = "NCL",
    Ner = "NER",
    Nfk = "NFK",
    Nga = "NGA",
    Niu = "NIU",
    Nld = "NLD",
    Nmp = "NMP",
    Nor = "NOR",
    Nru = "NRU",
    Nzl = "NZL",
    Omn = "OMN",
    PNG = "PNG",
    Pak = "PAK",
    Pan = "PAN",
    Pcn = "PCN",
    Per = "PER",
    Phl = "PHL",
    Plw = "PLW",
    Pol = "POL",
    Pri = "PRI",
    Prk = "PRK",
    Prt = "PRT",
    Pry = "PRY",
    Pse = "PSE",
    Pyf = "PYF",
    Qat = "QAT",
    Reu = "REU",
    Rou = "ROU",
    Rus = "RUS",
    Rwa = "RWA",
    SDN = "SDN",
    SPM = "SPM",
    SSD = "SSD",
    Sau = "SAU",
    Sen = "SEN",
    Sgp = "SGP",
    Sgs = "SGS",
    Shn = "SHN",
    Sjm = "SJM",
    Slb = "SLB",
    Sle = "SLE",
    Slv = "SLV",
    Smr = "SMR",
    Smx = "SMX",
    Som = "SOM",
    Srb = "SRB",
    Stp = "STP",
    Sur = "SUR",
    Svk = "SVK",
    Svn = "SVN",
    Swe = "SWE",
    Swz = "SWZ",
    Syc = "SYC",
    Syr = "SYR",
    TLS = "TLS",
    Tca = "TCA",
    Tcd = "TCD",
    Tgo = "TGO",
    Tha = "THA",
    Tjk = "TJK",
    Tkl = "TKL",
    Tkm = "TKM",
    Ton = "TON",
    Tto = "TTO",
    Tun = "TUN",
    Tur = "TUR",
    Tuv = "TUV",
    Twn = "TWN",
    Tza = "TZA",
    Uga = "UGA",
    Ukr = "UKR",
    Umi = "UMI",
    Ury = "URY",
    Usa = "USA",
    Uzb = "UZB",
    Vat = "VAT",
    Vct = "VCT",
    Ven = "VEN",
    Vgb = "VGB",
    Vir = "VIR",
    Vnm = "VNM",
    Vut = "VUT",
    Wlf = "WLF",
    Wsm = "WSM",
    Yem = "YEM",
    Zaf = "ZAF",
    Zmb = "ZMB",
    Zwe = "ZWE"
}
type CountryCodeUnion = `${CountryCodeEnum}`;
interface OnlineResource {
    createdAt?: Date | string;
    extensions?: Extension[];
    identifier?: string;
    isMock?: boolean;
    name?: string;
    notes?: string;
    provider?: string;
    resourceSubType?: string;
    resourceType?: OnlineResourceTypeUnion;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum OnlineResourceTypeEnum {
    EMAIL = "EMAIL",
    OTHER = "OTHER",
    SOCIAl_MEDIA = "SOCIAL_MEDIA",
    URL = "URL"
}
type OnlineResourceTypeUnion = keyof typeof OnlineResourceTypeEnum;
interface Participant$1 {
    contacts?: Contact[];
    createdAt?: Date | string;
    extensions?: Extension[];
    homeVenueIds?: string[];
    individualParticipantIds?: string[];
    isMock?: boolean;
    notes?: string;
    onlineResources?: OnlineResource[];
    participantId: string;
    participantName?: string;
    participantOtherName?: string;
    participantRole?: ParticipantRoleUnion;
    participantRoleResponsibilities?: string[];
    participantStatus?: ParticipantStatusUnion;
    participantType?: ParticipantTypeUnion;
    penalties?: Penalty[];
    person?: Person$1;
    personId?: string;
    representing?: CountryCodeUnion;
    teamId?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    useOtherName?: boolean;
}
interface Contact {
    createdAt?: Date | string;
    emailAddress?: string;
    extensions?: Extension[];
    fax?: string;
    isMock?: boolean;
    isPublic?: boolean;
    mobileTelephone?: string;
    name?: string;
    notes?: string;
    telephone?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum ParticipantRoleEnum {
    ADMINISTRATION = "ADMINISTRATION",
    CAPTAIN = "CAPTAIN",
    COACH = "COACH",
    COMPETITOR = "COMPETITOR",
    DIRECTOR = "DIRECTOR",
    HOSPITALITY = "HOSPITALITY",
    MEDIA = "MEDIA",
    MEDICAL = "MEDICAL",
    OFFICIAL = "OFFICIAL",
    OTHER = "OTHER",
    PHYSIO = "PHYSIO",
    SECURITY = "SECURITY",
    STRINGER = "STRINGER",
    SUPERVISOR = "SUPERVISOR",
    TRAINER = "TRAINER",
    TRANSPORT = "TRANSPORT",
    VOLUNTEER = "VOLUNTEER"
}
type ParticipantRoleUnion = keyof typeof ParticipantRoleEnum;
declare enum ParticipantStatusEnum {
    ACTIVE = "ACTIVE",
    WITHDRAWN = "WITHDRAWN"
}
type ParticipantStatusUnion = keyof typeof ParticipantStatusEnum;
declare enum ParticipantTypeEnum {
    GROUP = "GROUP",
    INDIVIDUAL = "INDIVIDUAL",
    PAIR = "PAIR",
    TEAM = "TEAM"
}
type ParticipantTypeUnion = keyof typeof ParticipantTypeEnum;
interface Penalty {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    issuedAt?: string;
    matchUpId?: string;
    notes?: string;
    penaltyCode?: string;
    penaltyId: string;
    penaltyType: PenaltyTypeUnion;
    refereeParticipantId?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
declare enum PenaltyTypeEnum {
    BALL_ABUSE = "BALL_ABUSE",
    COACHING = "COACHING",
    DRESS_CODE_VIOLATION = "DRESS_CODE_VIOLATION",
    EQUIMENT_VIOLATION = "EQUIMENT_VIOLATION",
    FAILUIRE_TO_SIGN_IN = "FAILUIRE_TO_SIGN_IN",
    FAILURE_TO_COMPLETE = "FAILURE_TO_COMPLETE",
    INELIGIBILITY = "INELIGIBILITY",
    LEAVING_THE_COURT = "LEAVING_THE_COURT",
    NO_SHOW = "NO_SHOW",
    OTHER = "OTHER",
    PHYSICAL_ABUSE = "PHYSICAL_ABUSE",
    PROHIBITED_SUBSTANCE = "PROHIBITED_SUBSTANCE",
    PUNCTUALITY = "PUNCTUALITY",
    RACKET_ABUSE = "RACKET_ABUSE",
    REFUSAL_TO_PLAY = "REFUSAL_TO_PLAY",
    UNSPORTSMANLIKE_CONDUCT = "UNSPORTSMANLIKE_CONDUCT",
    VERBAL_ABUSE = "VERBAL_ABUSE"
}
type PenaltyTypeUnion = keyof typeof PenaltyTypeEnum;
interface Person$1 {
    addresses?: Address[];
    biographicalInformation?: BiographicalInformation;
    birthDate?: string;
    birthYear?: number;
    contacts?: Contact[];
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    nationalityCode?: string;
    nativeFamilyName?: string;
    nativeGivenName?: string;
    notes?: string;
    onlineResources?: OnlineResource[];
    otherNames?: string[];
    parentOrganisationId?: string;
    passportFamilyName?: string;
    passportGivenName?: string;
    personId: string;
    personOtherIds?: UnifiedPersonID[];
    previousNames?: string[];
    sectionId?: string;
    sex?: SexUnion;
    standardFamilyName?: string;
    standardGivenName?: string;
    status?: string;
    tennisId?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    wheelchair?: boolean;
}
interface Address {
    addressLine1?: string;
    addressLine2?: string;
    addressLine3?: string;
    addressName?: string;
    addressType?: AddressTypeUnion;
    city?: string;
    countryCode?: CountryCodeUnion;
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    latitude?: string;
    longitude?: string;
    notes?: string;
    postalCode?: string;
    state?: string;
    timeItems?: TimeItem[];
    timeZone?: string;
    updatedAt?: Date | string;
}
declare enum AddressTypeEnum {
    HOME = "HOME",
    MAIL = "MAIL",
    PRIMARY = "PRIMARY",
    RESIDENTIAL = "RESIDENTIAL",
    VENUE = "VENUE",
    WORK = "WORK"
}
type AddressTypeUnion = keyof typeof AddressTypeEnum;
interface TeamAttribute {
    teamId?: string;
    teamName?: string;
    jerseyNumber?: string;
    jerseyName?: string;
    position?: string;
    captain?: boolean;
}
interface BiographicalInformation {
    ageBeganTennis?: number;
    ageTurnedPro?: number;
    birthCountryCode?: CountryCodeUnion;
    coachId?: string;
    createdAt?: Date | string;
    doublePlayingHand?: PlayingDoubleHandCodeUnion;
    extensions?: Extension[];
    height?: number;
    heightUnit?: LengthUnitUnion;
    isMock?: boolean;
    notes?: string;
    organisationIds?: string[];
    placeOfResidence?: string;
    playingHand?: PlayingHandCodeUnion;
    residenceCountryCode?: CountryCodeUnion;
    teamAttributes?: TeamAttribute[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    weight?: number;
    weightUnit?: WeightUnitEnum;
}
declare enum PlayingDoubleHandCodeEnum {
    BACKHAND = "BACKHAND",
    BOTH = "BOTH",
    FOREHAND = "FOREHAND",
    NONE = "NONE"
}
type PlayingDoubleHandCodeUnion = keyof typeof PlayingDoubleHandCodeEnum;
declare enum LengthUnitEnum {
    CENTIMETER = "CENTIMETER",
    METER = "METER",
    MILLIMETER = "MILLIMETER"
}
type LengthUnitUnion = keyof typeof LengthUnitEnum;
declare enum PlayingHandCodeEnum {
    AMBIDEXTROUS = "AMBIDEXTROUS",
    LEFT = "LEFT",
    RIGHT = "RIGHT"
}
type PlayingHandCodeUnion = keyof typeof PlayingHandCodeEnum;
declare enum WeightUnitEnum {
    GRAM = "GRAM",
    KILOGRAM = "KILOGRAM"
}
type WeightUnitUnion = keyof typeof WeightUnitEnum;
interface UnifiedPersonID {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    organisationId: string;
    personId: string;
    timeItems?: TimeItem[];
    uniqueOrganisationName?: string;
    updatedAt?: Date | string;
}
declare enum SexEnum {
    FEMALE = "FEMALE",
    MALE = "MALE",
    OTHER = "OTHER"
}
type SexUnion = keyof typeof SexEnum;
interface RegistrationProfile {
    createdAt?: Date | string;
    entriesClose?: Date | string;
    entriesOpen?: Date | string;
    updatedAt?: Date | string;
    withdrawalDeadline?: Date | string;
    eligibilityNotes?: string;
    entryFees?: RegistrationEntryFee[];
    entryMethod?: string;
    entryUrl?: string;
    accommodation?: LogisticsSection;
    hospitality?: LogisticsSection;
    medicalInfo?: LogisticsSection;
    transportation?: LogisticsSection;
    contingencyPlan?: string;
    dressCode?: string;
    awardsCeremonyDate?: string;
    awardsDescription?: string;
    drawCeremonyDate?: string;
    socialEvents?: SocialEvent[];
    codeOfConduct?: DocumentLink;
    regulations?: DocumentLink[];
    sponsors?: Sponsor[];
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    timeItems?: TimeItem[];
}
interface LogisticsSection {
    notes?: string;
    options?: LogisticsOption[];
}
interface LogisticsOption {
    address?: string;
    description?: string;
    email?: string;
    extensions?: Extension[];
    name: string;
    notes?: string;
    phone?: string;
    priceRange?: string;
    url?: string;
}
interface SocialEvent {
    date?: string;
    description?: string;
    location?: string;
    name: string;
    time?: string;
}
interface Sponsor {
    logoUrl?: string;
    name: string;
    tier?: string;
    websiteUrl?: string;
}
interface DocumentLink {
    description?: string;
    name: string;
    url?: string;
}
interface RegistrationEntryFee {
    amount: number;
    category?: string;
    currencyCode: string;
    eventType?: EventTypeUnion;
    extensions?: Extension[];
}
interface PrizeMoney {
    amount: number;
    createdAt?: Date | string;
    currencyCode: string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface UnifiedTournamentID {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    organisationId: string;
    timeItems?: TimeItem[];
    tournamentId: string;
    uniqueOrganisationName?: string;
    updatedAt?: Date | string;
}
interface Venue {
    addresses?: Address[];
    contacts?: Contact[];
    courts?: Court[];
    createdAt?: Date | string;
    dateAvailability?: Availability[];
    defaultEndTime?: string;
    defaultStartTime?: string;
    disabled?: boolean | {
        dates?: string[];
    };
    extensions?: Extension[];
    isMock?: boolean;
    isPrimary?: boolean;
    notes?: string;
    onlineResources?: OnlineResource[];
    parentOrganisationId?: string;
    roles?: string[];
    subVenues?: Venue[];
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
    venueAbbreviation?: string;
    venueId: string;
    venueName?: string;
    venueOtherIds?: UnifiedVenueID[];
    venueType?: string;
}
interface Court {
    altitude?: number;
    courtDimensions?: string;
    courtId: string;
    courtName?: string;
    createdAt?: Date | string;
    dateAvailability?: Availability[];
    disabled?: boolean | {
        dates?: string[];
    };
    extensions?: Extension[];
    floodlit?: boolean;
    indoorOutdoor?: IndoorOutdoorUnion;
    isMock?: boolean;
    latitude?: string;
    longitude?: string;
    notes?: string;
    onlineResources?: OnlineResource[];
    pace?: string;
    surfaceCategory?: SurfaceCategoryUnion;
    surfacedDate?: Date | string;
    surfaceType?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface Availability {
    bookings?: Booking[];
    createdAt?: Date | string;
    date?: string;
    endTime?: string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    startTime?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface Booking {
    bookingId?: string;
    bookingType?: string;
    capacity?: number | null;
    createdAt?: Date | string;
    endTime?: string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    registrations?: PracticeRegistration[];
    startTime?: string;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
type PracticeRegistrationStatus = 'CONFIRMED' | 'CANCELLED';
interface PracticeRegistration {
    cancelledAt?: Date | string;
    createdAt?: Date | string;
    endTime: string;
    extensions?: Extension[];
    notes?: string;
    participantId: string;
    registeredAt?: Date | string;
    registrationId: string;
    startTime: string;
    status?: PracticeRegistrationStatus;
    timeItems?: TimeItem[];
    updatedAt?: Date | string;
}
interface UnifiedVenueID {
    createdAt?: Date | string;
    extensions?: Extension[];
    isMock?: boolean;
    notes?: string;
    organisationId: string;
    timeItems?: TimeItem[];
    uniqueOrganisationName?: string;
    updatedAt?: Date | string;
    venueId: string;
}
declare enum WeekdayEnum {
    MON = "MON",
    TUE = "TUE",
    WED = "WED",
    THU = "THU",
    FRI = "FRI",
    SAT = "SAT",
    SUN = "SUN"
}
type WeekdayUnion = keyof typeof WeekdayEnum;

type HydratedCourt = {
    [key: string]: any;
} & Court;
type HydratedVenue = {
    [key: string]: any;
} & Venue;
interface HydratedMatchUp extends MatchUp$1 {
    [key: string | number]: any;
    structureId: string;
    drawId: string;
    eventId: string;
    tournamentId: string;
    sides?: HydratedSide[];
}
type HydratedParticipant = {
    individualParticipants?: HydratedParticipant[];
    [key: string | number]: any;
} & Participant$1;
type HydratedSide = Side$1 & {
    participant?: HydratedParticipant;
    [key: string | number]: any;
};

interface QueryFacade {
    tournament(args?: any): Tournament | undefined;
    tournamentInfo(args?: any): any;
    tournamentTimeItem(args?: any): TimeItem | undefined;
    linkedTournamentIds(args?: any): string[] | undefined;
    policyDefinitions(args?: any): PolicyDefinitions | undefined;
    participants(args?: any): HydratedParticipant[];
    event(args?: any): Event$1 | undefined;
    events(args?: any): Event$1[];
    eventData(args?: any): any;
    eventRankingPoints(args?: any): any;
    flightProfile(args?: any): FlightProfile | undefined;
    drawDefinition(args?: any): DrawDefinition | undefined;
    draftState(args?: any): any;
    publishState(args?: any): any;
    availablePlayoffProfiles(args?: any): any[];
    validGroupSizes(args?: any): number[];
    assignedParticipantIds(args?: any): string[];
    swissChart(args?: any): any;
    structureSeedAssignments(args?: any): any[];
    positionAssignments(args?: any): any[];
    matchUp(args?: any): HydratedMatchUp | undefined;
    matchUps(args?: any): HydratedMatchUp[];
    drawMatchUps(args?: any): HydratedMatchUp[];
    eventMatchUps(args?: any): HydratedMatchUp[];
    competitionMatchUps(args?: any): HydratedMatchUp[];
    matchUpsMap(args?: any): MatchUpsMap | undefined;
    venue(args?: any): Venue | undefined;
    venuesAndCourts(args?: any): Venue[];
    tally(args?: any): any;
    extension(args?: any): Extension | undefined;
    competitionVenues(args?: any): Venue[];
    competitionParticipants(args?: any): HydratedParticipant[];
}

type Unwrap<T> = Exclude<T, {
    error: {
        code: string;
    };
}>;
declare function unwrap<T>(result: T, opts?: {
    methodName?: string;
}): Unwrap<T>;
declare function unwrapOr<T, F>(result: T, fallback: F): Unwrap<T> | F;

type JsonPatchOp = {
    op: 'add';
    path: string;
    value: unknown;
} | {
    op: 'remove';
    path: string;
} | {
    op: 'replace';
    path: string;
    value: unknown;
};
type JsonPatch = JsonPatchOp[];
declare function generatePatch(before: unknown, after: unknown): JsonPatch;

type EmittedNotice = {
    topic: string;
    payloads: unknown[];
};
type DryRunResult = {
    wouldSucceed: boolean;
    results: any[];
    patch: JsonPatch;
    willEmitNotices: EmittedNotice[];
    error?: any;
    rolledBack: true;
};
declare function dryRun(engine: FactoryEngine, directives: Directives): DryRunResult;

type ExplainResult = {
    wouldSucceed: boolean;
    reason?: {
        code?: string;
        message?: string;
        info?: string;
    };
    willEmitTopics: string[];
    touchesPaths: string[];
    detail: DryRunResult;
};
declare function explain(engine: FactoryEngine, method: string, params?: Record<string, any>): ExplainResult;

interface EngineInspectionCounts {
    tournaments: number;
    events: number;
    drawDefinitions: number;
    structures: number;
    matchUps: number;
    participants: number;
    venues: number;
    courts: number;
}
interface EngineInspection {
    version: string;
    schemaWriteMode: string;
    saveDrawDeletions: boolean;
    auditAuthorityServer: boolean;
    loaded: {
        tournamentIds: string[];
        currentTournamentId?: string;
        counts: EngineInspectionCounts;
    };
    subscriptions: {
        topics: string[];
    };
    devContext: any;
}

interface AddEventPayload {
    tournamentId: string;
    event: Event$1;
}
interface AddDrawDefinitionPayload {
    tournamentId: string;
    eventId: string;
    drawDefinition: DrawDefinition;
}
interface ModifyDrawDefinitionPayload {
    tournamentId: string;
    eventId: string;
    drawDefinition: DrawDefinition;
}
interface DeletedDrawIdsPayload {
    tournamentId: string;
    eventId?: string;
    drawId: string;
}
interface AddMatchUpsPayload {
    tournamentId: string;
    eventId: string;
    matchUps: MatchUp$1[];
}
interface ModifyMatchUpPayload {
    tournamentId: string;
    matchUp: MatchUp$1;
    context?: {
        [key: string]: any;
    };
}
interface DeletedMatchUpIdsPayload {
    tournamentId: string;
    eventId?: string;
    matchUpIds: string[];
    action?: string;
}
interface AddParticipantsPayload {
    tournamentId?: string;
    participants: any[];
}
interface ModifyParticipantsPayload {
    tournamentId?: string;
    participants: any[];
}
interface DeleteParticipantsPayload {
    tournamentId?: string;
    participantIds: string[];
}
interface PublishEventPayload {
    tournamentId: string;
    eventData: any;
}
interface ModifyTournamentDetailPayload {
    tournamentRecord: Tournament;
}
interface TopicPayloadMap {
    addEvent: AddEventPayload;
    addDrawDefinition: AddDrawDefinitionPayload;
    modifyDrawDefinition: ModifyDrawDefinitionPayload;
    deletedDrawIds: DeletedDrawIdsPayload;
    addMatchUps: AddMatchUpsPayload;
    modifyMatchUp: ModifyMatchUpPayload;
    deletedMatchUpIds: DeletedMatchUpIdsPayload;
    addParticipants: AddParticipantsPayload;
    modifyParticipants: ModifyParticipantsPayload;
    deleteParticipants: DeleteParticipantsPayload;
    publishEvent: PublishEventPayload;
    modifyTournamentDetail: ModifyTournamentDetailPayload;
    [topic: string]: unknown;
}
type Topic = keyof TopicPayloadMap & string;

type Unsubscribe = () => void;
type EventHandler<T extends Topic> = (payload: TopicPayloadMap[T]) => void;
type EventPredicate<T extends Topic> = (payload: TopicPayloadMap[T]) => boolean;
interface EventBus {
    on<T extends Topic>(topic: T, handler: EventHandler<T>): Unsubscribe;
    once<T extends Topic>(topic: T, handler: EventHandler<T>): Unsubscribe;
    off<T extends Topic>(topic: T, handler?: EventHandler<T>): void;
    waitFor<T extends Topic>(topic: T, predicate?: EventPredicate<T>): Promise<TopicPayloadMap[T]>;
}

type ErrorType = {
    message: string;
    info?: string;
    code: string;
};
declare const INVALID_TIME_ZONE: {
    message: string;
    code: string;
};
declare const errorConditionConstants: {
    ANACHRONISM: {
        message: string;
        code: string;
    };
    BOOKING_NOT_FOUND: {
        message: string;
        code: string;
    };
    CANNOT_CHANGE_WINNING_SIDE: {
        message: string;
        code: string;
    };
    CAPACITY_EXCEEDED: {
        message: string;
        code: string;
    };
    REGISTRATION_NOT_FOUND: {
        message: string;
        code: string;
    };
    CANNOT_MODIFY_TIEFORMAT: {
        message: string;
        code: string;
    };
    TOURNAMENT_CATEGORY_IN_USE: {
        message: string;
        code: string;
    };
    CANNOT_MODIFY_PARTICIPANT_TYPE: {
        message: string;
        code: string;
    };
    CANNOT_REMOVE_MAIN_STRUCTURE: {
        message: string;
        code: string;
    };
    CANNOT_REMOVE_PARTICIPANTS: {
        message: string;
        code: string;
    };
    CATEGORY_MISMATCH: {
        message: string;
        code: string;
    };
    COURT_EXISTS: {
        message: string;
        code: string;
    };
    COURT_NOT_FOUND: {
        message: string;
        code: string;
    };
    EXISTING_DRAFT: {
        message: string;
        code: string;
    };
    EXISTING_MATCHUPS: {
        message: string;
        code: string;
    };
    DRAW_DEFINITION_NOT_FOUND: {
        message: string;
        code: string;
    };
    DRAW_ID_EXISTS: {
        message: string;
        code: string;
    };
    DRAW_POSITION_ACTIVE: {
        message: string;
        code: string;
    };
    DRAW_POSITION_ASSIGNED: {
        message: string;
        code: string;
    };
    DRAW_POSITION_NOT_CLEARED: {
        message: string;
        code: string;
    };
    DRAW_POSITION_NOT_FOUND: {
        message: string;
        code: string;
    };
    DRAW_SIZE_MISMATCH: {
        message: string;
        code: string;
    };
    DUPLICATE_ENTRY: {
        message: string;
        code: string;
    };
    DUPLICATE_VALUE: {
        message: string;
        code: string;
    };
    ENTRY_STATUS_NOT_ALLOWED_FOR_EVENT: {
        message: string;
        code: string;
    };
    ENTRY_STATUS_NOT_ALLOWED_IN_STAGE: {
        message: string;
        code: string;
    };
    EVENT_EXISTS: {
        message: string;
        code: string;
    };
    EVENT_NOT_FOUND: {
        message: string;
        code: string;
    };
    EXISTING_DRAW_DEFINITIONS: {
        message: string;
        code: string;
    };
    EXISTING_END_TIME: {
        message: string;
        code: string;
    };
    EXISTING_FLIGHT: {
        message: string;
        code: string;
    };
    EXISTING_MATCHUP_ID: {
        message: string;
        code: string;
    };
    EXISTING_OUTCOME: {
        message: string;
        code: string;
    };
    EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT: {
        message: string;
        code: string;
    };
    EXISTING_PARTICIPANT: {
        message: string;
        code: string;
    };
    EXISTING_POLICY_TYPE: {
        message: string;
        code: string;
    };
    EXISTING_PROFILE: {
        message: string;
        code: string;
    };
    EXISTING_ROUND: {
        message: string;
        code: string;
    };
    EXISTING_STAGE: {
        message: string;
        code: string;
    };
    EXISTING_STRUCTURE: {
        message: string;
        code: string;
    };
    INCOMPATIBLE_MATCHUP_STATUS: {
        message: string;
        code: string;
    };
    INCOMPLETE_SOURCE_STRUCTURE: {
        message: string;
        code: string;
    };
    INSUFFICIENT_DRAW_POSITIONS: {
        message: string;
        code: string;
    };
    INVALID_ACTION: {
        message: string;
        code: string;
    };
    INVALID_ASSIGNMENT: {
        message: string;
        code: string;
    };
    INVALID_BOOKINGS: {
        message: string;
        code: string;
    };
    INVALID_CATEGORY: {
        message: string;
        code: string;
    };
    INVALID_COLLECTION_DEFINITION: {
        message: string;
        code: string;
    };
    INVALID_CONFIGURATION: {
        message: string;
        code: string;
    };
    INVALID_DATE_AVAILABILITY: {
        message: string;
        code: string;
    };
    INVALID_DATE: {
        message: string;
        code: string;
    };
    INVALID_DRAW_DEFINITION: {
        message: string;
        code: string;
    };
    INVALID_DRAW_POSITION_FOR_SEEDING: {
        message: string;
        code: string;
    };
    INVALID_DRAW_POSITION: {
        message: string;
        code: string;
    };
    INVALID_DRAW_SIZE: {
        message: string;
        code: string;
    };
    INVALID_END_TIME: {
        message: string;
        code: string;
    };
    INVALID_ENTRIES: {
        message: string;
        code: string;
    };
    INVALID_EVENT_TYPE: {
        message: string;
        code: string;
    };
    INVALID_GAME_SCORES: {
        message: string;
        code: string;
    };
    INVALID_GENDER: {
        message: string;
        code: string;
    };
    INVALID_MATCHUP_FORMAT: {
        message: string;
        code: string;
    };
    INVALID_MATCHUP_STATUS: {
        message: string;
        code: string;
    };
    INVALID_MATCHUP_STATUS_BYE: {
        message: string;
        code: string;
    };
    INVALID_MATCHUP: {
        message: string;
        code: string;
    };
    INVALID_OBJECT: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT_ID: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT_IDS: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT_ROLE: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT_SEEDING: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT_TYPE: {
        message: string;
        code: string;
    };
    INVALID_PARTICIPANT: {
        message: string;
        code: string;
    };
    INVALID_POLICY_DEFINITION: {
        message: string;
        code: string;
    };
    INVALID_RECORDS: {
        message: string;
        code: string;
    };
    INVALID_SCALE_ITEM: {
        message: string;
        code: string;
    };
    INVALID_SEED_NUMBER: {
        message: string;
        code: string;
    };
    INVALID_SEED_POSITION: {
        message: string;
        code: string;
    };
    INVALID_SET_NUMBER: {
        message: string;
        code: string;
    };
    INVALID_SIDE_NUMBER: {
        message: string;
        code: string;
    };
    INVALID_SCORE: {
        message: string;
        code: string;
    };
    INVALID_STAGE: {
        message: string;
        code: string;
    };
    INVALID_START_TIME: {
        message: string;
        code: string;
    };
    INVALID_STRUCTURE: {
        message: string;
        code: string;
    };
    INVALID_STOP_TIME: {
        message: string;
        code: string;
    };
    INVALID_TIE_FORMAT: {
        message: string;
        code: string;
    };
    INVALID_TIME: {
        message: string;
        code: string;
    };
    INVALID_TIME_ITEM: {
        message: string;
        code: string;
    };
    INVALID_TOURNAMENT_DATES: {
        message: string;
        code: string;
    };
    INVALID_TOURNAMENT_RECORD: {
        message: string;
        code: string;
    };
    INVALID_VALUES: {
        message: string;
        code: string;
    };
    INVALID_WINNING_SIDE: {
        message: string;
        code: string;
    };
    LUCKY_DRAW_BYE_LIMIT: {
        message: string;
        code: string;
    };
    MATCHUP_NOT_FOUND: {
        message: string;
        code: string;
    };
    METHOD_NOT_FOUND: {
        message: string;
        code: string;
    };
    MUTATION_LOCKED: {
        message: string;
        code: string;
    };
    MUTATION_LOCK_EXISTS: {
        message: string;
        code: string;
    };
    MUTATION_LOCK_NOT_FOUND: {
        message: string;
        code: string;
    };
    MISSING_ASSIGNMENTS: {
        message: string;
        code: string;
    };
    MISSING_ASYNC_STATE_PROVIDER: {
        message: string;
        code: string;
    };
    MISSING_AVOIDANCE_POLICY: {
        message: string;
        code: string;
    };
    MISSING_BIRTH_DATE: {
        message: string;
        code: string;
    };
    MISSING_COLLECTION_DEFINITION: {
        message: string;
        code: string;
    };
    MISSING_COURT_ID: {
        message: string;
        code: string;
    };
    MISSING_COURTS_INFO: {
        message: string;
        code: string;
    };
    MISSING_DATE_AVAILABILITY: {
        message: string;
        code: string;
    };
    MISSING_DATE: {
        message: string;
        code: string;
    };
    MISSING_DRAW_DEFINITION: {
        message: string;
        code: string;
    };
    MISSING_DRAW_ID: {
        message: string;
        code: string;
    };
    MISSING_DRAW_POSITION: {
        message: string;
        code: string;
    };
    MISSING_DRAW_POSITIONS: {
        message: string;
        code: string;
    };
    MISSING_DRAW_SIZE: {
        message: string;
        code: string;
    };
    MISSING_ENTRIES: {
        message: string;
        code: string;
    };
    MISSING_EVENT: {
        message: string;
        code: string;
    };
    MISSING_QUALIFIED_PARTICIPANTS: {
        message: string;
        code: string;
    };
    MISSING_MATCHUP_FORMAT: {
        message: string;
        code: string;
    };
    MISSING_MATCHUP_ID: {
        message: string;
        code: string;
    };
    MISSING_MATCHUP_IDS: {
        message: string;
        code: string;
    };
    MISSING_MATCHUP: {
        message: string;
        code: string;
    };
    MISSING_MATCHUPS: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANT_COUNT: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANT_ID: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANT_IDS: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANT_ROLE: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANT: {
        message: string;
        code: string;
    };
    MISSING_PARTICIPANTS: {
        message: string;
        code: string;
    };
    MISSING_PENALTY_ID: {
        message: string;
        code: string;
    };
    MISSING_PENALTY_TYPE: {
        message: string;
        code: string;
    };
    MISSING_PERSON_DETAILS: {
        message: string;
        code: string;
    };
    MISSING_POLICY_ATTRIBUTES: {
        message: string;
        code: string;
    };
    MISSING_POLICY_DEFINITION: {
        message: string;
        code: string;
    };
    MISSING_POLICY_TYPE: {
        message: string;
        code: string;
    };
    MISSING_POSITION_ASSIGNMENTS: {
        message: string;
        code: string;
    };
    MISSING_ROUND_NUMBER: {
        message: string;
        code: string;
    };
    MISSING_SCHEDULE: {
        message: string;
        code: string;
    };
    MISSING_SCORING_POLICY: {
        message: string;
        code: string;
    };
    MISSING_SEED_ASSIGNMENTS: {
        message: string;
        code: string;
    };
    MISSING_SEEDCOUNT_THRESHOLDS: {
        message: string;
        code: string;
    };
    MISSING_SEEDING_POLICY: {
        message: string;
        code: string;
    };
    MISSING_SET_NUMBER: {
        message: string;
        code: string;
    };
    MISSING_SET_OBJECT: {
        message: string;
        code: string;
    };
    MISSING_SIDE_NUMBER: {
        message: string;
        code: string;
    };
    MISSING_STAGE: {
        message: string;
        code: string;
    };
    MISSING_STRUCTURE_ID: {
        message: string;
        code: string;
    };
    MISSING_STRUCTURE: {
        message: string;
        code: string;
    };
    MISSING_MAIN_STRUCTURE: {
        message: string;
        code: string;
    };
    MISSING_STRUCTURES: {
        message: string;
        code: string;
    };
    MISSING_TARGET_LINK: {
        message: string;
        code: string;
    };
    MISSING_TIE_FORMAT: {
        message: string;
        code: string;
    };
    MISSING_TIME_ITEM: {
        message: string;
        code: string;
    };
    MISSING_TIME_ITEMS: {
        message: string;
        code: string;
    };
    MISSING_TOURNAMENT_ID: {
        message: string;
        code: string;
    };
    MISSING_TOURNAMENT_RECORD: {
        message: string;
        code: string;
    };
    MISSING_TOURNAMENT_RECORDS: {
        message: string;
        code: string;
    };
    MISSING_VALUE: {
        message: string;
        code: string;
    };
    MISSING_VENUE_ID: {
        message: string;
        code: string;
    };
    MODIFICATIONS_FAILED: {
        message: string;
        code: string;
    };
    NO_CANDIDATES: {
        message: string;
        code: string;
    };
    NO_DRAW_POSITIONS_AVAILABLE_FOR_QUALIFIERS: {
        message: string;
        code: string;
    };
    NO_MODIFICATIONS_APPLIED: {
        message: string;
        code: string;
    };
    NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS: {
        message: string;
        code: string;
    };
    NO_PARTICIPANT_REMOVED: {
        message: string;
        code: string;
    };
    NO_VALID_ACTIONS: {
        message: string;
        code: string;
    };
    NO_VALID_ATTRIBUTES: {
        message: string;
        code: string;
    };
    NO_VALID_DATES: {
        message: string;
        code: string;
    };
    NOT_FOUND: {
        message: string;
        code: string;
    };
    NOT_IMPLEMENTED: {
        message: string;
        code: string;
    };
    PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE: {
        message: string;
        code: string;
    };
    PARTICIPANT_ID_EXISTS: {
        message: string;
        code: string;
    };
    PARTICIPANT_NOT_CHECKED_IN: {
        message: string;
        code: string;
    };
    PARTICIPANT_NOT_FOUND: {
        message: string;
        code: string;
    };
    PARTICIPANT_PAIR_EXISTS: {
        message: string;
        code: string;
    };
    PENALTY_NOT_FOUND: {
        message: string;
        code: string;
    };
    POLICY_NOT_ATTACHED: {
        message: string;
        code: string;
    };
    POLICY_NOT_FOUND: {
        message: string;
        code: string;
    };
    SCHEDULE_NOT_CLEARED: {
        message: string;
        code: string;
    };
    SCHEDULE_CONFLICT_DOUBLE_BOOKING: {
        message: string;
        code: string;
    };
    SCHEDULE_CONFLICT_COURT_UNAVAILABLE: {
        message: string;
        code: string;
    };
    SCHEDULED_MATCHUPS: {
        message: string;
        code: string;
    };
    SCORES_PRESENT: {
        message: string;
        code: string;
    };
    SEEDSCOUNT_GREATER_THAN_DRAW_SIZE: {
        message: string;
        code: string;
    };
    STAGE_SEQUENCE_LIMIT: {
        message: string;
        code: string;
    };
    STRUCTURE_NOT_FOUND: {
        message: string;
        code: string;
    };
    TEAM_NOT_FOUND: {
        message: string;
        code: string;
    };
    UNABLE_TO_ASSIGN_COURT: {
        message: string;
        code: string;
    };
    UNAUTHORIZED_LOCK_OPERATION: {
        message: string;
        code: string;
    };
    UNLINKED_STRUCTURES: {
        message: string;
        code: string;
    };
    UNRECOGNIZED_DRAW_TYPE: {
        message: string;
        code: string;
    };
    UNRECOGNIZED_MATCHUP_FORMAT: {
        message: string;
        code: string;
    };
    UNRECOGNIZED_MATCHUP_STATUS: {
        message: string;
        code: string;
    };
    VALUE_UNCHANGED: {
        message: string;
        code: string;
    };
    VENUE_EXISTS: {
        message: string;
        code: string;
    };
};

type GenderInput = 'MALE' | 'FEMALE' | 'MIXED' | 'ANY' | 'OTHER';
interface EventSeed {
    eventName?: string;
    eventLevel?: string;
    category?: {
        categoryName?: string;
        ageCategoryCode?: string;
        ratingType?: string;
        ratingMin?: number;
        ratingMax?: number;
    };
    startDate?: string;
    endDate?: string;
}
interface DrawOpts {
    drawType?: string;
    drawName?: string;
    seedsCount?: number;
    matchUpFormat?: string;
    automated?: boolean | {
        seedsOnly: boolean;
    };
    qualifyingProfiles?: any[];
    withPlayoffs?: any;
    drawEntries?: any[];
}
interface EntriesOpts {
    entryStage?: string;
    entryStatus?: string;
    enforceGender?: boolean;
    enforceCategory?: boolean;
}
interface BuildResult {
    success: boolean;
    error?: ErrorType;
    eventId: string;
    drawIds: string[];
    directives: Directives;
    results?: any[];
}
interface ParticipantBuildResult {
    success: boolean;
    error?: ErrorType;
    participantId: string;
    directives: Directives;
    results?: any[];
}
interface PersonInput {
    givenName: string;
    familyName: string;
    sex?: 'M' | 'F' | 'X';
    nationalityCode?: string;
    personId?: string;
}

declare class EventBuilder {
    private readonly engine;
    private readonly _eventId;
    private eventState;
    private drawSpec;
    private entriesSpec;
    constructor(engine: FactoryEngine, seed?: Partial<EventSeed>);
    singles(): this;
    doubles(): this;
    team(tieFormat?: any | string): this;
    hybrid(): this;
    named(eventName: string): this;
    gender(gender: GenderInput): this;
    category(category: EventSeed['category']): this;
    dates(startDate: string, endDate: string): this;
    tieFormat(tieFormat: any | string): this;
    entries(participantIds: string[], opts?: EntriesOpts): this;
    draw(drawSize: number, opts?: DrawOpts): this;
    get eventId(): string;
    get drawIds(): string[];
    toDirectives(): Directives;
    toRequest(): {
        directives: Directives;
        eventId: string;
        drawIds: string[];
    };
    create(opts?: {
        rollbackOnError?: boolean;
    }): BuildResult;
}

declare class ParticipantBuilder {
    private readonly engine;
    private readonly _participantId;
    private shape;
    private participantRole;
    constructor(engine: FactoryEngine);
    individual(person: PersonInput): this;
    pair(individualParticipantIds: [string, string], name?: string): this;
    team(name: string, individualParticipantIds?: string[]): this;
    role(role: string): this;
    get participantId(): string;
    private buildParticipant;
    toDirectives(): Directives;
    toRequest(): {
        directives: Directives;
        participantId: string;
    };
    create(opts?: {
        rollbackOnError?: boolean;
    }): ParticipantBuildResult;
}

interface BuildFacade {
    event(seed?: Partial<EventSeed>): EventBuilder;
    participant(): ParticipantBuilder;
}

declare const forge: {};

declare const SINGLES_EVENT = "SINGLES";
declare const DOUBLES_EVENT = "DOUBLES";
declare const TEAM_EVENT = "TEAM";
declare const eventConstants: {
    AGE: string;
    BOTH: string;
    DOUBLES: string;
    DOUBLES_EVENT: string;
    HYBRID: string;
    HYBRID_EVENT: string;
    RATING: string;
    SINGLES: string;
    SINGLES_EVENT: string;
    TEAM_EVENT: string;
    TEAM: string;
};

type SignedInStatusUnion = typeof SIGNED_IN | typeof SIGNED_OUT;
declare const SIGNED_OUT = "SIGNED_OUT";
declare const SIGNED_IN = "SIGNED_IN";
type PaymentStatusUnion = typeof PAID | typeof UNPAID | typeof PARTIAL | typeof WAIVED | typeof REFUNDED;
declare const REFUNDED = "REFUNDED";
declare const PARTIAL = "PARTIAL";
declare const WAIVED = "WAIVED";
declare const UNPAID = "UNPAID";
declare const PAID = "PAID";
declare const participantTypes: {
    TEAM_PARTICIPANT: string;
    INDIVIDUAL: string;
    GROUP: string;
    TEAM: string;
    PAIR: string;
};
declare const participantConstants: {
    INDIVIDUAL: string;
    GROUP: string;
    PAIR: string;
    TEAM: string;
    SIGN_IN_STATUS: string;
    SIGNED_OUT: string;
    SIGNED_IN: string;
    PAYMENT_STATUS: string;
    REFUNDED: string;
    PARTIAL: string;
    WAIVED: string;
    UNPAID: string;
    PAID: string;
};

declare const POLICY_TYPE_VOLUNTARY_CONSOLATION = "voluntaryConsolation";
declare const POLICY_TYPE_COMPETITIVE_BANDS = "competitiveBands";
declare const POLICY_TYPE_ROUND_ROBIN_TALLY = "roundRobinTally";
declare const POLICY_TYPE_POSITION_ACTIONS = "positionActions";
declare const POLICY_TYPE_MATCHUP_ACTIONS = "matchUpActions";
declare const POLICY_TYPE_RANKING_POINTS = "rankingPoints";
declare const POLICY_TYPE_ROUND_NAMING = "roundNaming";
declare const POLICY_TYPE_PARTICIPANT = "participant";
declare const POLICY_TYPE_PROGRESSION = "progression";
declare const POLICY_TYPE_SCHEDULING = "scheduling";
declare const POLICY_TYPE_AVOIDANCE = "avoidance";
declare const POLICY_TYPE_PRIVACY = "participant";
declare const POLICY_TYPE_DISPLAY = "display";
declare const POLICY_TYPE_SCORING = "scoring";
declare const POLICY_TYPE_SEEDING = "seeding";
declare const POLICY_TYPE_FEED_IN = "feedIn";
declare const POLICY_TYPE_SANCTIONING = "sanctioning";
declare const POLICY_TYPE_AUDIT = "audit";
declare const POLICY_TYPE_COMPETITION = "competition";
declare const POLICY_TYPE_DRAWS = "draws";
declare const POLICY_TYPE_PRINT = "print";
type ValidPolicyTypes = typeof POLICY_TYPE_VOLUNTARY_CONSOLATION | typeof POLICY_TYPE_COMPETITIVE_BANDS | typeof POLICY_TYPE_ROUND_ROBIN_TALLY | typeof POLICY_TYPE_POSITION_ACTIONS | typeof POLICY_TYPE_MATCHUP_ACTIONS | typeof POLICY_TYPE_RANKING_POINTS | typeof POLICY_TYPE_ROUND_NAMING | typeof POLICY_TYPE_PARTICIPANT | typeof POLICY_TYPE_PROGRESSION | typeof POLICY_TYPE_SCHEDULING | typeof POLICY_TYPE_AVOIDANCE | typeof POLICY_TYPE_DISPLAY | typeof POLICY_TYPE_PRIVACY | typeof POLICY_TYPE_COMPETITION | typeof POLICY_TYPE_FEED_IN | typeof POLICY_TYPE_SCORING | typeof POLICY_TYPE_SEEDING | typeof POLICY_TYPE_SANCTIONING | typeof POLICY_TYPE_AUDIT | typeof POLICY_TYPE_DRAWS | typeof POLICY_TYPE_PRINT;
declare const policyConstants: {
    readonly POLICY_TYPE_VOLUNTARY_CONSOLATION: "voluntaryConsolation";
    readonly POLICY_TYPE_COMPETITIVE_BANDS: "competitiveBands";
    readonly POLICY_TYPE_ROUND_ROBIN_TALLY: "roundRobinTally";
    readonly POLICY_TYPE_POSITION_ACTIONS: "positionActions";
    readonly POLICY_TYPE_MATCHUP_ACTIONS: "matchUpActions";
    readonly POLICY_TYPE_RANKING_POINTS: "rankingPoints";
    readonly POLICY_TYPE_ROUND_NAMING: "roundNaming";
    readonly POLICY_TYPE_PARTICIPANT: "participant";
    readonly POLICY_TYPE_PROGRESSION: "progression";
    readonly POLICY_TYPE_SCHEDULING: "scheduling";
    readonly POLICY_TYPE_AVOIDANCE: "avoidance";
    readonly POLICY_TYPE_COMPETITION: "competition";
    readonly POLICY_TYPE_DISPLAY: "display";
    readonly POLICY_TYPE_PRIVACY: "participant";
    readonly POLICY_TYPE_FEED_IN: "feedIn";
    readonly POLICY_TYPE_SCORING: "scoring";
    readonly POLICY_TYPE_SEEDING: "seeding";
    readonly POLICY_TYPE_SANCTIONING: "sanctioning";
    readonly POLICY_TYPE_AUDIT: "audit";
    readonly POLICY_TYPE_DRAWS: "draws";
    readonly POLICY_TYPE_PRINT: "print";
};

type FactoryEngineMethod = 'addAdHocMatchUps' | 'addCertification' | 'addCertificationRequirement' | 'addCollectionDefinition' | 'addCollectionGroup' | 'addCourt' | 'addCourtGridBooking' | 'addCourts' | 'addDrawDefinition' | 'addDrawDefinitionExtension' | 'addDrawDefinitionTimeItem' | 'addDrawEntries' | 'addDynamicRatings' | 'addEvaluation' | 'addEvaluationPolicy' | 'addEvent' | 'addEventEntries' | 'addEventEntryPairs' | 'addEventExtension' | 'addEventTimeItem' | 'addExtension' | 'addFinishingRounds' | 'addFlight' | 'addGoesTo' | 'addIndividualParticipantIds' | 'addLinkedConsolationStructure' | 'addMatchUpCourtOrder' | 'addMatchUpEndTime' | 'addMatchUpOfficial' | 'addMatchUpResumeTime' | 'addMatchUpScheduledDate' | 'addMatchUpScheduledTime' | 'addMatchUpScheduleItems' | 'addMatchUpStartTime' | 'addMatchUpStopTime' | 'addMutationLock' | 'addNotes' | 'addOnlineResource' | 'addParticipant' | 'addParticipantExtension' | 'addParticipants' | 'addParticipantTimeItem' | 'addPenalty' | 'addPersonOtherId' | 'addPersonRequests' | 'addPersons' | 'addPlayoffStructures' | 'addPoint' | 'addPracticeRegistration' | 'addQualifyingStructure' | 'addSchedulingProfileRound' | 'addSuspension' | 'addTimeItem' | 'addTournamentExtension' | 'addTournamentTimeItem' | 'addVenue' | 'addVoluntaryConsolationStructure' | 'adHocPositionSwap' | 'aggregateTieFormats' | 'allCompetitionMatchUps' | 'allDrawMatchUps' | 'allEventMatchUps' | 'allocateTeamMatchUpCourts' | 'allPlayoffPositionsFilled' | 'allTournamentMatchUps' | 'alternateDrawPositionAssignment' | 'analyzeDraws' | 'analyzeMatchUp' | 'analyzeScore' | 'analyzeSequence' | 'analyzeSet' | 'analyzeTournament' | 'anonymizeTournamentRecord' | 'applyAvailabilityToTournamentRecord' | 'applyDerivedRankings' | 'applyLineUps' | 'applyTournamentRankingPoints' | 'assignDrawPosition' | 'assignDrawPositionBye' | 'assignMatchUpCourt' | 'assignMatchUpSideParticipant' | 'assignMatchUpVenue' | 'assignOfficial' | 'assignSeedPositions' | 'assignTieMatchUpParticipantId' | 'attachConsolationStructures' | 'attachFlightProfile' | 'attachPlayoffStructures' | 'attachPolicies' | 'attachQualifyingStructure' | 'attachStructures' | 'auditAuthorityServer' | 'automatedPlayoffPositioning' | 'automatedPositioning' | 'autoSeeding' | 'buildDayRange' | 'buildDrawHierarchy' | 'buildEdges' | 'buildReportContext' | 'buildSchedulingProfileFromUISelections' | 'bulkMatchUpStatusUpdate' | 'bulkRescheduleMatchUps' | 'bulkScheduleMatchUps' | 'bulkScheduleTournamentMatchUps' | 'bulkUpdateCourtAssignments' | 'bulkUpdatePublishedEventIds' | 'calculateCapacityStats' | 'calculateCourtHours' | 'calculateMatchStatistics' | 'calculateMatchUpMargin' | 'calculatePointsTo' | 'calculateScheduleTimes' | 'calculateWinCriteria' | 'categoryCanContain' | 'checkInParticipant' | 'checkMatchUpIsComplete' | 'checkOutParticipant' | 'checkScoreHasValue' | 'checkSetIsComplete' | 'checkValidEntries' | 'clampDragToCollisions' | 'clampToDayRange' | 'cleanExpiredMutationLocks' | 'clearMatchUpSchedule' | 'clearScheduledMatchUps' | 'compareCapacityCurves' | 'compareTieFormats' | 'competitionScheduleMatchUps' | 'completeDrawMatchUps' | 'computePlanItemId' | 'copyTournamentRecord' | 'courtDayKey' | 'courtGridRows' | 'courtKey' | 'createFollowByEvaluator' | 'createGroupParticipant' | 'createMatchUp' | 'createOfficialRecord' | 'createTeamsFromParticipantAttributes' | 'createTournamentRecord' | 'credits' | 'deduceMatchUpFormat' | 'deleteAdHocMatchUps' | 'deleteCourt' | 'deleteCourts' | 'deleteDrawDefinitions' | 'deleteEvents' | 'deleteFlightAndFlightDraw' | 'deleteFlightProfileAndFlightDraws' | 'deleteParticipants' | 'deleteVenue' | 'deleteVenues' | 'deriveRailSegments' | 'destroyPairEntries' | 'destroyPairEntry' | 'devContext' | 'diffMinutes' | 'disableCourts' | 'disableTieAutoCalc' | 'disableVenues' | 'drawMatchUps' | 'drawMatic' | 'dryRun' | 'enableCourts' | 'enableTieAutoCalc' | 'enableVenues' | 'enrichPointHistory' | 'EvaluatorRegistry' | 'eventMatchUps' | 'execute' | 'executionQueue' | 'explain' | 'exportMatchUpJSON' | 'extractDay' | 'filterCapacityCurve' | 'filterMatchUps' | 'filterParticipants' | 'findBlocksContainingTime' | 'findDrawDefinition' | 'findExtension' | 'findMatchUp' | 'findMatchUpFormatTiming' | 'findParticipant' | 'findPolicy' | 'findVenue' | 'formatConflicts' | 'generateAdHocMatchUps' | 'generateAdHocRounds' | 'generateAndPopulatePlayoffStructures' | 'generateBookings' | 'generateCapacityCurve' | 'generateConsolationStructure' | 'generateCourts' | 'generateDrawDefinition' | 'generateDrawMaticRound' | 'generateDrawStructuresAndLinks' | 'generateDrawTypeAndModifyDrawDefinition' | 'generateEventsFromTieFormat' | 'generateEventWithDraw' | 'generateFlightProfile' | 'generateLineUps' | 'generateOutcome' | 'generateOutcomeFromScoreString' | 'generateParticipants' | 'generateQualifyingStructure' | 'generateRankingList' | 'generateReport' | 'generateScoreString' | 'generateSeedingScaleItems' | 'generateStatCrew' | 'generateSwissRound' | 'generateTieMatchUpScore' | 'generateTournamentRecord' | 'generateVirtualCourts' | 'generateVoluntaryConsolation' | 'getAggregateTeamResults' | 'getAllDrawMatchUps' | 'getAllEventData' | 'getAllowedDrawTypes' | 'getAllowedMatchUpFormats' | 'getAllStructureMatchUps' | 'getApplicableAwardProfileLevels' | 'getAppliedPolicies' | 'getAssignedParticipantIds' | 'getAuditAuthorityServer' | 'getAvailableMatchUpsCount' | 'getAvailablePlayoffProfiles' | 'getAvailableReports' | 'getAwardPoints' | 'getAwardProfile' | 'getCategoryAgeDetails' | 'getCheckedInParticipantIds' | 'getCompetitionDateRange' | 'getCompetitionFormat' | 'getCompetitionLeaderboard' | 'getCompetitionMatchUps' | 'getCompetitionParticipants' | 'getCompetitionParticipantState' | 'getCompetitionPenalties' | 'getCompetitionPolicy' | 'getCompetitionState' | 'getCompetitionVenues' | 'getCourtInfo' | 'getCourts' | 'getDevContext' | 'getDraftState' | 'getDrawData' | 'getDrawDefinitionTimeItem' | 'getDrawParticipantRepresentativeIds' | 'getDrawStructures' | 'getDrawTypeCoercion' | 'getEligibleVoluntaryConsolationParticipants' | 'getEntriesAndSeedsCount' | 'getEntryStatusReports' | 'getEpisodes' | 'getEvaluations' | 'getEvaluationSummary' | 'getEvaluationTemplate' | 'getEvent' | 'getEventData' | 'getEventMatchUpFormatTiming' | 'getEventProperties' | 'getEventPublishStatus' | 'getEventRankingPoints' | 'getEvents' | 'getEventStructures' | 'getEventTimeItem' | 'getFlightProfile' | 'getHighestSeverity' | 'getHomeParticipantId' | 'getLinkedTournamentIds' | 'getLuckyDrawRoundStatus' | 'getMatchUpCompetitiveProfile' | 'getMatchUpContextIds' | 'getMatchUpDailyLimits' | 'getMatchUpDailyLimitsUpdate' | 'getMatchUpDependencies' | 'getMatchUpFormat' | 'getMatchUpFormatTiming' | 'getMatchUpFormatTimingUpdate' | 'getMatchUpScheduleDetails' | 'getMatchUpsMap' | 'getMatchUpsStats' | 'getMatchUpsToSchedule' | 'getMatchUpType' | 'getMaxEntryPosition' | 'getModifiedMatchUpFormatTiming' | 'getMutationLocks' | 'getOfficialAssignments' | 'getOfficialCertifications' | 'getOfficialEligibility' | 'getPairedParticipant' | 'getParticipantEventDetails' | 'getParticipantIdFinishingPositions' | 'getParticipantMembership' | 'getParticipantPaymentStatus' | 'getParticipantPoints' | 'getParticipantResults' | 'getParticipants' | 'getParticipantScaleItem' | 'getParticipantSchedules' | 'getParticipantSignInStatus' | 'getParticipantStats' | 'getParticipantTimeItem' | 'getPersonRequests' | 'getPolicyDefinitions' | 'getPositionAssignments' | 'getPositionsPlayedOff' | 'getPracticeRegistrations' | 'getPredictiveAccuracy' | 'getProfileRounds' | 'getPublishState' | 'getQualityWinPoints' | 'getQuickStats' | 'getRandomQualifierList' | 'getRegistrationProfile' | 'getRoundMatchUps' | 'getRounds' | 'getRoundVisibilityState' | 'getSaveDrawDeletions' | 'getScaledEntries' | 'getScaleValues' | 'getScheduledRoundsDetails' | 'getSchedulingProfile' | 'getSchedulingProfileIssues' | 'getSchemaWriteMode' | 'getScore' | 'getScoreboard' | 'getSeedingThresholds' | 'getSeedsCount' | 'getSetComplement' | 'getSetScoreString' | 'getState' | 'getStructureReports' | 'getStructureSeedAssignments' | 'getSwissChart' | 'getSwissStandings' | 'getTally' | 'getTeamLineUp' | 'getTiebreakComplement' | 'getTieFormat' | 'getTimeItem' | 'getTournament' | 'getTournamentId' | 'getTournamentIds' | 'getTournamentInfo' | 'getTournamentPenalties' | 'getTournamentPersons' | 'getTournamentPointAwards' | 'getTournamentPoints' | 'getTournamentPublishStatus' | 'getTournamentStructures' | 'getTournamentTimeItem' | 'getValidGroupSizes' | 'getVenueData' | 'getVenuesAndCourts' | 'getVenuesReport' | 'getWinner' | 'groupByMatch' | 'groupConflictsBySeverity' | 'hasLuckyRounds' | 'hhmmToMinutes' | 'hydrateTournamentRecord' | 'importMethods' | 'inferServeSide' | 'initializeCompetitionState' | 'initializeDraft' | 'inspect' | 'intervalsOverlap' | 'isAdHoc' | 'isAggregateFormat' | 'isComplete' | 'isCompletedStructure' | 'isEmbargoed' | 'isValid' | 'isValidForQualifying' | 'isValidMatchUpFormat' | 'isVisiblyPublished' | 'iterateDayTicks' | 'keyValueScore' | 'linkTournaments' | 'luckyDrawAdvancement' | 'luckyLoserDrawPositionAssignment' | 'matchUpActions' | 'matchUpScheduleChange' | 'mcpValidator' | 'mergeAdjacentSegments' | 'mergeOverlappingAvailability' | 'mergeParticipants' | 'migrateTournamentRecord' | 'minutesToHhmm' | 'modifyCertification' | 'modifyCollectionDefinition' | 'modifyCourt' | 'modifyCourtAvailability' | 'modifyDrawDefinition' | 'modifyDrawName' | 'modifyEntriesStatus' | 'modifyEvaluation' | 'modifyEvent' | 'modifyEventEntries' | 'modifyEventMatchUpFormatTiming' | 'modifyIndividualParticipantIds' | 'modifyMatchUpFormatTiming' | 'modifyPairAssignment' | 'modifyParticipant' | 'modifyParticipantName' | 'modifyParticipantOtherName' | 'modifyParticipantsPaymentStatus' | 'modifyParticipantsSignInStatus' | 'modifyPenalty' | 'modifyPersonRequests' | 'modifySeedAssignment' | 'modifyTieFormat' | 'modifyTournamentRecord' | 'modifyVenue' | 'newTournamentRecord' | 'off' | 'on' | 'once' | 'orderCollectionDefinitions' | 'overlappingRange' | 'parse' | 'parseCSV' | 'parseMatchUpFormat' | 'parseMCPPoint' | 'parseScoreString' | 'participantScaleItem' | 'participantScheduledMatchUps' | 'pbpValidator' | 'pointParser' | 'positionActions' | 'predictDrawCompetitiveBands' | 'predictMatchUpCompetitiveBands' | 'proAutoSchedule' | 'processCompetitionMatchUp' | 'processCompetitionRound' | 'proConflicts' | 'promoteAlternate' | 'promoteAlternates' | 'pruneDrawDefinition' | 'publicFindCourt' | 'publicFindVenue' | 'publishEvent' | 'publishEventSeeding' | 'publishOrderOfPlay' | 'publishParticipants' | 'qualifierDrawPositionAssignment' | 'qualifierProgression' | 'queryOfficialRecord' | 'railsToDateAvailability' | 'rangesOverlap' | 'refreshEventDrawOrder' | 'regenerateParticipantNames' | 'remapDrawDefinitionMatchUpIds' | 'removeCertification' | 'removeCollectionDefinition' | 'removeCollectionGroup' | 'removeCourtGridBooking' | 'removeDelegatedOutcome' | 'removeDrawDefinitionExtension' | 'removeDrawEntries' | 'removeDrawPositionAssignment' | 'removeEvaluation' | 'removeEventEntries' | 'removeEventExtension' | 'removeEventMatchUpFormatTiming' | 'removeExtension' | 'removeIndividualParticipantIds' | 'removeMatchUpCourtAssignment' | 'removeMatchUpOutcome' | 'removeMatchUpSideParticipant' | 'removeMutationLock' | 'removeNotes' | 'removeOfficialAssignment' | 'removeOnlineResource' | 'removeOrphanedTieFormats' | 'removeParticipantExtension' | 'removeParticipantIdsFromAllTeams' | 'removePenalty' | 'removePersonRequests' | 'removePolicy' | 'removePracticeRegistration' | 'removeRatings' | 'removeRoundMatchUps' | 'removeScaleValues' | 'removeSeededParticipant' | 'removeSeeding' | 'removeStageEntries' | 'removeStructure' | 'removeSuspension' | 'removeTieMatchUpParticipantId' | 'removeTournamentExtension' | 'removeTournamentRecord' | 'removeUnlinkedTournamentRecords' | 'renameStructures' | 'reorderUpcomingMatchUps' | 'replaceTieMatchUpParticipantId' | 'reset' | 'resetAdHocMatchUps' | 'resetCompetitionState' | 'resetDrawDefinition' | 'resetMatchUpLineUps' | 'resetQualifyingStructure' | 'resetScorecard' | 'resetTieFormat' | 'resetVoluntaryConsolationStructure' | 'resolveCourtId' | 'resolveDraftPositions' | 'resolvePointValue' | 'resolveStatus' | 'resolveVenueId' | 'reverseScore' | 'runValidationPipeline' | 'sampleCapacityCurve' | 'saveDrawDeletions' | 'scaledTeamAssignment' | 'scheduleMatchUps' | 'scheduleProfileGrid' | 'scheduleProfileRounds' | 'schemaWriteMode' | 'ScoringEngine' | 'seedWithdrawalCascade' | 'setDelegatedOutcome' | 'setDrawParticipantRepresentativeIds' | 'setDrawPositionPreferences' | 'setEntryPosition' | 'setEntryPositions' | 'setEventDates' | 'setEventDisplay' | 'setEventEndDate' | 'setEventStartDate' | 'setMatchUpCalledAt' | 'setMatchUpDailyLimits' | 'setMatchUpFormat' | 'setMatchUpHomeParticipantId' | 'setMatchUpState' | 'setMatchUpStatus' | 'setOrderOfFinish' | 'setParticipantScaleItem' | 'setParticipantScaleItems' | 'setPositionAssignments' | 'setPracticeDefaultCapacity' | 'setRegistrationProfile' | 'setSchedulingProfile' | 'setState' | 'setStructureOrder' | 'setSubOrder' | 'setTournamentCategories' | 'setTournamentDates' | 'setTournamentEndDate' | 'setTournamentId' | 'setTournamentLocalTimeZone' | 'setTournamentName' | 'setTournamentNotes' | 'setTournamentRecord' | 'setTournamentStartDate' | 'setTournamentStatus' | 'setTournamentTier' | 'shiftAdHocRounds' | 'shotParser' | 'shotSplitter' | 'snapIsoToGranularity' | 'snapToGranularity' | 'sortBlocksByStart' | 'sortEdges' | 'stringify' | 'stringifyMatchUpFormat' | 'substituteParticipant' | 'suggestFormatPlans' | 'swapAdHocRounds' | 'swapDrawPositionAssignments' | 'tallyParticipantResults' | 'tieFormatGenderValidityCheck' | 'timeInsideBlock' | 'todsAvailabilityToBlocks' | 'toggleParticipantCheckInState' | 'toStatObjects' | 'tournamentMatchUps' | 'transitionAssignmentStatus' | 'transitionCertificationStatus' | 'transitionEvaluationStatus' | 'unlinkTournament' | 'unlinkTournaments' | 'unPublishEvent' | 'unPublishEventSeeding' | 'unPublishOrderOfPlay' | 'unPublishParticipants' | 'updateDrawIdsOrder' | 'updatePracticeRegistration' | 'updateTeamLineUp' | 'updateTieMatchUpScore' | 'validateCategory' | 'validateCertification' | 'validateCollectionDefinition' | 'validateDateAvailability' | 'validateLineUp' | 'validateMatchUp' | 'validateMatchUpScore' | 'validateMCPMatch' | 'validateOfficiatingStatusTransition' | 'validatePlayoffGroups' | 'validateSchedulingProfile' | 'validateSchedulingProfileFormat' | 'validateScore' | 'validateSegments' | 'validateSet' | 'validateSetScore' | 'validateTieFormat' | 'validMatchUp' | 'validMatchUps' | 'venueDayKey' | 'venueKey' | 'version' | 'waitFor' | 'withdrawParticipantAtDrawPosition';

declare function modifyPersonRequests(params: any): ResultType & {
    valid?: boolean;
};

type RemovePersonRequests = {
    tournamentRecords: TournamentRecords;
    requestType?: string;
    requestId?: string;
    personId?: string;
    date?: string;
};
declare function removePersonRequests(params: RemovePersonRequests): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
};

type GenerateDrawMaticRoundArgs = {
    adHocRatings?: {
        [key: string]: number;
    };
    updateParticipantRatings?: boolean;
    ignoreLastRoundNumber?: boolean;
    restrictEntryStatus?: boolean;
    iterationMatchUps?: MatchUp$1[];
    drawDefinition: DrawDefinition;
    tournamentRecord: Tournament;
    generateMatchUps?: boolean;
    eventType?: EventTypeUnion;
    salted?: number | boolean;
    participantIds?: string[];
    dynamicRatings?: boolean;
    convertToELO?: boolean;
    refreshDynamic?: boolean;
    minimizeDelta?: boolean;
    encounterValue?: number;
    sameTeamValue?: number;
    maxIterations?: number;
    matchUpIds?: string[];
    structure?: Structure;
    random?: () => number;
    roundNumber?: number;
    structureId?: string;
    scaleName?: string;
    idPrefix?: string;
    isMock?: boolean;
    drawId?: string;
    event: Event$1;
};
type DrawMaticRoundResult = {
    modifiedScaleValues?: {
        [key: string]: number;
    };
    participantIdPairings?: string[][];
    sourceRatingType?: string;
    candidatesCount?: number;
    outputScaleName?: string;
    deltaCandidate?: any;
    roundNumber?: number;
    matchUps?: MatchUp$1[];
    iterations?: number;
    success?: boolean;
    maxDelta?: number;
    maxDiff?: number;
};
declare function generateDrawMaticRound(params: GenerateDrawMaticRoundArgs): ResultType & DrawMaticRoundResult;

type AddPersonRequestsArgs = {
    tournamentRecords: TournamentRecords;
    requests: Request[];
    personId: string;
};
declare function addPersonRequests(params: AddPersonRequestsArgs): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
};

declare function generateDrawDefinition(params: GenerateDrawDefinitionArgs): ResultType & {
    existingDrawDefinition?: boolean;
    drawDefinition?: DrawDefinition;
    qualifyingConflicts?: any[];
    positioningReports?: any[];
    structureId?: string;
    success?: boolean;
    error?: ErrorType;
    conflicts?: any[];
};

type GetValidGroupSizesArgs = {
    groupSizeLimit?: number;
    drawSize: number;
};
declare function getValidGroupSizes(params: GetValidGroupSizesArgs): ResultType & {
    validGroupSizes?: number[];
};

type ShiftRoundsArgs = {
    drawDefinition: DrawDefinition;
    targetRoundNumber: number;
    roundNumber: number;
    structureId: string;
};
declare function shiftAdHocRounds(params: ShiftRoundsArgs): ResultType;

type GetAvailableMatchUpsCountArgs = {
    drawDefinition: DrawDefinition;
    structureId?: string;
    roundNumber?: number;
};
declare function getAvailableMatchUpsCount(params: GetAvailableMatchUpsCountArgs): ResultType & {
    availableMatchUpsCount?: number;
    roundMatchUpsCount?: number;
    lastRoundNumber?: number;
};

type SwapRoundsArgs = {
    roundNumbers: [number, number];
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    structureId: string;
    event?: Event$1;
};
declare function swapAdHocRounds(params: SwapRoundsArgs): ResultType;

type SwissPolicy = {
    totalRounds: number;
    tiebreakMethods?: string[];
    pairingMethod?: 'SCORE_GROUP' | 'RATING_BASED';
    allowDraws?: boolean;
    colorAlternation?: boolean;
    hardNoRepeat?: boolean;
};
type ScoreGroup = {
    wins: number;
    losses: number;
    draws: number;
    participantIds: string[];
};
type SwissStanding = {
    participantId: string;
    wins: number;
    losses: number;
    draws: number;
    points: number;
    buchholz?: number;
    medianBuchholz?: number;
    sonnebornBerger?: number;
    progressiveScore?: number;
    opponentIds: string[];
    rank: number;
};
type SwissState = {
    roundsPlayed: number;
    totalRounds: number;
    scoreGroups: ScoreGroup[];
    standings: SwissStanding[];
};
type OpponentOutcome = 'WIN' | 'LOSS' | 'DRAW';
type SwissParticipantRecord = {
    participantId: string;
    wins: number;
    losses: number;
    draws: number;
    points: number;
    opponentIds: string[];
    opponentOutcomes: Map<string, OpponentOutcome>;
    roundPoints: number[];
};

type GenerateSwissRoundArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    swissPolicy?: SwissPolicy;
    participantIds?: string[];
    structureId?: string;
    matchUpIds?: string[];
    scaleName?: string;
    idPrefix?: string;
    isMock?: boolean;
    event: Event$1;
};
type GenerateSwissRoundResult = ResultType & {
    byeParticipantId?: string;
    roundNumber?: number;
    matchUps?: MatchUp$1[];
};
declare function generateSwissRound(params: GenerateSwissRoundArgs): GenerateSwissRoundResult;

type GenerateDrawTypeAndModify = {
    policyDefinitions?: PolicyDefinitions;
    appliedPolicies?: PolicyDefinitions;
    finishingPositionLimit?: number;
    tournamentRecord?: Tournament;
    matchUpType?: EventTypeUnion;
    drawDefinition: DrawDefinition;
    drawTypeCoercion?: boolean;
    qualifyingOnly?: boolean;
    modifyOriginal?: boolean;
    qualifiersCount?: number;
    stageSequence?: number;
    matchUpFormat?: string;
    structureOptions?: any;
    tieFormat?: TieFormat;
    drawType?: string;
    drawSize?: number;
    feedPolicy?: any;
    isMock?: boolean;
    event?: Event$1;
};
declare function generateDrawTypeAndModifyDrawDefinition(params: GenerateDrawTypeAndModify): ResultType & {
    inContextDrawMatchUps?: HydratedMatchUp[];
    drawDefinition?: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
    structures?: Structure[];
    matchUps?: MatchUp$1[];
    links?: DrawLink[];
    success?: boolean;
};

declare function setMatchUpHomeParticipantId(params: AddScheduleAttributeArgs & {
    homeParticipantId?: string;
}): ResultType;

type ScaleItemsWithParticipantId = {
    participantId: string;
    scaleItems: any[];
};
type GenerateSeedingScaleItemsArgs = {
    scaleAttributes?: ScaleAttributes;
    scaledEntries: any[] | null;
    stageEntries: Entry[];
    seedsCount: number;
    scaleName?: string;
};
declare function generateSeedingScaleItems({ scaleAttributes, scaledEntries, stageEntries, seedsCount, scaleName, }: GenerateSeedingScaleItemsArgs): {
    scaleItemsWithParticipantIds?: ScaleItemsWithParticipantId[];
    error?: ErrorType;
    info?: any;
};

type GenerateVoluntaryConsolationArgs = {
    playoffAttributes?: PlayoffAttributes;
    tournamentRecord: Tournament;
    seedingProfile?: SeedingProfile;
    drawDefinition: DrawDefinition;
    matchUpType?: EventTypeUnion;
    applyPositioning?: boolean;
    staggeredEntry?: boolean;
    structureOptions?: {
        groupSize?: number;
    };
    random?: () => number;
    structureName?: string;
    matchUpFormat?: string;
    tieFormat?: TieFormat;
    automated?: boolean;
    placeByes?: boolean;
    drawType?: string;
    isMock?: boolean;
    event?: Event$1;
};
declare function generateVoluntaryConsolation(params: GenerateVoluntaryConsolationArgs): {
    structures?: Structure[];
    links?: DrawLink[];
    success?: boolean;
    error?: ErrorType;
};

declare function getMatchUpFormatTimingUpdate({ tournamentRecords }: {
    tournamentRecords: any;
}): {
    error?: ErrorType;
} | {
    methods: QueueMethod[];
};

type CalculateScheduleTimesArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    calculateStartTimeFromCourts?: boolean;
    remainingScheduleTimes?: string[];
    defaultRecoveryMinutes?: number;
    averageMatchUpMinutes?: number;
    clearScheduleDates?: boolean;
    periodLength?: number;
    scheduleDate: string;
    venueIds?: string[];
    startTime?: string;
    endTime?: string;
};
declare function calculateScheduleTimes({ calculateStartTimeFromCourts, defaultRecoveryMinutes, averageMatchUpMinutes, remainingScheduleTimes, clearScheduleDates, tournamentRecords, periodLength, scheduleDate, startTime, venueIds, endTime, }: CalculateScheduleTimesArgs): {
    dateScheduledMatchUpIds?: string[];
    totalMatchUps?: number;
    scheduleTimes?: any[];
    timingProfile?: any;
    error?: ErrorType;
    venueId?: string;
};

type GenerateAdHocMatchUpsArgs = {
    participantIdPairings?: {
        participantIds: [string | undefined, string | undefined];
    }[];
    ignoreLastRoundNumber?: boolean;
    restrictMatchUpsCount?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    matchUpsCount?: number;
    matchUpIds?: string[];
    roundNumber?: number;
    structureId?: string;
    newRound?: boolean;
    idPrefix?: string;
    isMock?: boolean;
    event: Event$1;
};
declare function generateAdHocMatchUps(params: GenerateAdHocMatchUpsArgs): {
    matchUpsCount?: number;
    roundNumber?: number;
    matchUps?: MatchUp$1[];
    error?: ErrorType;
    info?: any;
};

type GenerateQualifyingStructureArgs = {
    hasExistingDrawDefinition?: boolean;
    appliedPolicies?: PolicyDefinitions;
    qualifyingRoundNumber: number;
    drawDefinition: DrawDefinition;
    qualifyingPositions?: number;
    participantsCount?: number;
    targetStructureId: string;
    qualifyingOnly?: boolean;
    drawType?: DrawTypeUnion;
    structureOptions?: any;
    matchUpFormat?: string;
    structureName?: string;
    tieFormat?: TieFormat;
    structureId?: string;
    roundTarget: number;
    drawSize?: number;
    idPrefix?: string;
    isMock?: boolean;
    uuids?: string[];
    event?: Event$1;
};
declare function generateQualifyingStructure(params: GenerateQualifyingStructureArgs): {
    qualifyingDrawPositionsCount?: number;
    qualifiersCount?: number;
    structure?: Structure;
    error?: ErrorType;
    success?: boolean;
    link?: DrawLink;
};

type GetEligibleVoluntaryConsolationParticipantsArgs = {
    excludedMatchUpStatuses?: MatchUpStatusUnion[];
    policyDefinitions?: PolicyDefinitions;
    includeEventParticipants?: boolean;
    includeQualifyingStage?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    finishingRoundLimit?: number;
    roundNumberLimit?: number;
    matchUpsLimit?: number;
    requirePlay?: boolean;
    requireLoss?: boolean;
    allEntries?: boolean;
    winsLimit?: number;
    event?: Event$1;
};
declare function getEligibleVoluntaryConsolationParticipants({ excludedMatchUpStatuses, includeEventParticipants, includeQualifyingStage, finishingRoundLimit, policyDefinitions, roundNumberLimit, tournamentRecord, drawDefinition, matchUpsLimit, requirePlay, requireLoss, allEntries, winsLimit, event, }: GetEligibleVoluntaryConsolationParticipantsArgs): {
    eligibleParticipants?: Participant$1[];
    losingParticipantIds?: string[];
    error?: ErrorType;
};

type GetEventMatchUpFormatTimingArgs = {
    tournamentRecord: Tournament;
    matchUpFormats?: string[];
    categoryType?: string;
    event: Event$1;
};
declare function getEventMatchUpFormatTiming({ tournamentRecord, matchUpFormats, categoryType, event, }: GetEventMatchUpFormatTimingArgs): {
    eventMatchUpFormatTiming?: any;
    error?: ErrorType;
    info?: string;
};

type ProAutoScheduleArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    matchUpDailyLimits?: {
        [key: string]: number;
    };
    matchUps: HydratedMatchUp[];
    minCourtGridRows?: number;
    scheduledDate: string;
    courtIds?: string[];
};
declare function proAutoSchedule({ matchUpDailyLimits, minCourtGridRows, tournamentRecords, scheduledDate, courtIds, matchUps, }: ProAutoScheduleArgs): {
    mappedParticipants?: {
        [key: string]: HydratedParticipant;
    };
    completedMatchUps?: HydratedMatchUp[];
    dateMatchUps?: HydratedMatchUp[];
    courtPrefix?: string;
    error?: ErrorType;
    venues?: Venue[];
    courtsData?: any;
    rows?: any[];
} | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    info: string;
    error: {
        message: string;
        code: string;
    };
} | {
    scheduled: HydratedMatchUp[];
    notScheduled: HydratedMatchUp[];
    overLimitMatchUpIds: string[];
    mappedParticipants?: {
        [key: string]: HydratedParticipant;
    };
    completedMatchUps?: HydratedMatchUp[];
    dateMatchUps?: HydratedMatchUp[];
    courtPrefix?: string;
    error?: ErrorType;
    venues?: Venue[];
    courtsData?: any;
    rows?: any[];
    info?: undefined;
};

type NamingEntry = {
    [key: string]: {
        name: string;
        abbreviation: string;
        structureId?: string;
    };
};

type GenerateAndPopulateArgs = {
    addNameBaseToAttributeName?: boolean;
    finishingPositionNaming?: NamingEntry;
    playoffStructureNameBase?: string;
    playoffAttributes?: NamingEntry;
    finishingPositionLimit?: number;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    roundProfiles?: RoundProfile[];
    playoffPositions?: number[];
    roundOffsetLimit?: number;
    exitProfileLimit?: boolean;
    playoffGroups?: any[];
    roundNumbers?: number[];
    structureId: string;
    idPrefix?: string;
    isMock?: boolean;
    uuids?: string[];
    event?: Event$1;
};
declare function generateAndPopulatePlayoffStructures(params: GenerateAndPopulateArgs): ResultType & {
    drawDefinition?: DrawDefinition;
    matchUpModifications?: any[];
    structures?: Structure[];
    links?: DrawLink[];
    success?: boolean;
};

type BaselineRatingSource = 'SCALE' | 'SEEDING' | 'MANUAL';
type ActualOutputMethod = 'POINT_SHARE' | 'WEIGHTED';
type PairingMethod = 'DRAW_MATIC' | 'SWISS' | 'LEVEL_BASED';
type RatingSource = 'DYNAMIC_FORM' | 'BASELINE';
type ProcessingGranularity = 'PER_MATCHUP' | 'PER_ROUND';
type RatingAggregation = 'AVERAGE' | 'MIN' | 'MAX' | 'SUM';
type PrimaryRanking = 'PRESSURE_RATING' | 'DYNAMIC_FORM_RATING' | 'WINS' | 'POINTS';
type CompetitionTiebreak = 'HEAD_TO_HEAD' | 'HEAD_TO_HEAD_PRESSURE' | 'POINT_DIFFERENTIAL' | 'STRENGTH_OF_OPPOSITION' | 'DYNAMIC_FORM_RATING' | 'PRESSURE_RATING' | 'BUCHHOLZ' | 'SONNEBORN_BERGER';
type CompetitionPolicy = {
    policyName?: string;
    ratingPolicy: {
        baselineRating: {
            source: BaselineRatingSource;
            scaleName?: string;
            frozenDuringEvent: true;
        };
        dynamicFormRating: {
            enabled: boolean;
            initializeFrom: 'BASELINE';
            kFactor: number;
            logisticScale: number;
        };
        pressureRating?: {
            enabled: boolean;
            expectationSource: 'BASELINE_ONLY';
            actualOutputMethod: ActualOutputMethod;
            weights?: {
                pointShare: number;
                pointDifferential?: number;
                contextFactor?: number;
            };
        };
        ratingAggregation?: RatingAggregation;
    };
    pairingPolicy: {
        method: PairingMethod;
        ratingSource: RatingSource;
        laneSize?: number;
        avoidRepeatOpponents: boolean;
        sameTeamValue?: number;
    };
    victoryPolicy: {
        primaryRanking: PrimaryRanking;
        tiebreakOrder?: CompetitionTiebreak[];
    };
    processingGranularity: ProcessingGranularity;
};
type CompetitionParticipantState = {
    participantId: string;
    baselineRating: number;
    dynamicFormRating: number;
    pressureRating: number;
    roundsPlayed: number;
    wins: number;
    losses: number;
    draws: number;
    totalPointsWon: number;
    totalPointsLost: number;
    ratingHistory: CompetitionRatingHistoryEntry[];
};
type CompetitionRatingHistoryEntry = {
    roundNumber: number;
    opponentParticipantId: string;
    dynamicFormRatingBefore: number;
    dynamicFormRatingAfter: number;
    pressureDelta: number;
    actualOutput: number;
    expectedOutput: number;
};
type CompetitionRoundState = {
    roundNumber: number;
    laneAssignments?: Array<{
        laneNumber: number;
        participantIds: string[];
    }>;
    processed: boolean;
};
type CompetitionLeaderboardRow = {
    participantId: string;
    rank: number;
    baselineRating: number;
    dynamicFormRating: number;
    pressureRating: number;
    wins: number;
    losses: number;
    draws: number;
    pointsWon: number;
    pointsLost: number;
};
type CompetitionState = {
    participantStates: Record<string, CompetitionParticipantState>;
    roundStates: Record<number, CompetitionRoundState>;
    leaderboard?: CompetitionLeaderboardRow[];
};

type GetCompetitionParticipantStateArgs = {
    drawDefinition: DrawDefinition;
    participantId: string;
};
type GetCompetitionParticipantStateResult = ResultType & {
    participantState?: CompetitionParticipantState;
};
declare function getCompetitionParticipantState({ drawDefinition, participantId, }: GetCompetitionParticipantStateArgs): GetCompetitionParticipantStateResult;

type GetMatchUpsToScheduleArgs = {
    matchUpPotentialParticipantIds?: {
        [key: string]: string[];
    };
    matchUpScheduleTimes?: {
        [key: string]: string;
    };
    matchUpNotBeforeTimes?: {
        [key: string]: any;
    };
    scheduleCompletedMatchUps?: boolean;
    dateScheduledMatchUpIds?: string[];
    orderedMatchUpIds?: string[];
    clearDate?: boolean;
    matchUps: any[];
};
declare function getMatchUpsToSchedule(params: GetMatchUpsToScheduleArgs): {
    matchUpsToSchedule?: any[];
    error?: ErrorType;
    matchUpMap?: any;
};

declare function addMatchUpScheduledDate({ scheduledDate: dateToSchedule, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, }: AddScheduleAttributeArgs & {
    scheduledDate?: string;
}): ResultType;

declare function drawMatic(params: DrawMaticArgs): ResultType & {
    matchUps?: MatchUp$1[];
    roundResults?: DrawMaticRoundResult[];
};

type GenerateAdHocRoundsArgs = {
    restrictMatchUpsCount?: boolean;
    restrictRoundsCount?: boolean;
    drawDefinition: DrawDefinition;
    matchUpsCount?: number;
    matchUpIds?: string[];
    roundNumber?: number;
    structureId?: string;
    roundsCount: number;
    newRound?: boolean;
    idPrefix?: string;
    isMock?: boolean;
    event: Event$1;
};
declare function generateAdHocRounds(params: GenerateAdHocRoundsArgs): ResultType & {
    matchUps?: MatchUp$1[];
};

declare function setPositionAssignments({ structurePositionAssignments, provisionalPositioning, tournamentRecord, drawDefinition, event, }: any): any;

type GenerateFlightProfileArgs = {
    scaleAttributes: ScaleAttributes;
    attachFlightProfile?: boolean;
    tournamentRecord: Tournament;
    deleteExisting?: boolean;
    sortDescending?: boolean;
    random?: () => number;
    drawNameRoot?: string;
    scaleSortMethod?: any;
    stage?: StageTypeUnion;
    drawNames?: string[];
    scaledEntries?: any;
    flightsCount: number;
    splitMethod: string;
    uuids?: string[];
    event: Event$1;
};
declare function generateFlightProfile(params: GenerateFlightProfileArgs): {
    flightProfile?: FlightProfile;
    splitEntries?: Entry[][];
    success?: boolean;
    error?: ErrorType;
};

type TieMatchUpScore = {
    scoreStringSide1?: string;
    scoreStringSide2?: string;
    winningSide?: number;
    set?: any;
};
type GenerateTieMatchUpScoreArgs = {
    sideAdjustments?: [number, number];
    drawDefinition?: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
    matchUp: HydratedMatchUp;
    structure?: Structure;
    tieFormat?: TieFormat;
    separator?: string;
    event?: Event$1;
};
declare function generateTieMatchUpScore(params: GenerateTieMatchUpScoreArgs): TieMatchUpScore & ResultType;

type GetModifiedMatchUpFormatTimingArgs = {
    tournamentRecord: Tournament;
    matchUpFormat: string;
    event: Event$1;
};
declare function getModifiedMatchUpFormatTiming(params: GetModifiedMatchUpFormatTimingArgs): ResultType & {
    matchUpFormat?: string;
    recoveryTimes?: any[];
    averageTimes?: any[];
};

type InitializeCompetitionStateArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    participantIds: string[];
    event?: Event$1;
};
type InitializeCompetitionStateResult = ResultType & {
    competitionState?: CompetitionState;
};
declare function initializeCompetitionState(params: InitializeCompetitionStateArgs): InitializeCompetitionStateResult;

type ProConflictsArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    useDeepDependencies?: boolean;
    matchUps: HydratedMatchUp[];
};
declare function proConflicts({ useDeepDependencies, tournamentRecords, matchUps, }: ProConflictsArgs): {
    error: ErrorType;
    info?: any;
} | {
    courtIssues: {
        [key: string]: any;
    };
    rowIssues: {
        [key: string]: any;
    };
};

type ProcessCompetitionMatchUpArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    matchUp: MatchUp$1;
    event?: Event$1;
};
declare function processCompetitionMatchUp(params: ProcessCompetitionMatchUpArgs): ResultType;

interface QualifierProgressionArgs {
    drawDefinition: DrawDefinition;
    tournamentRecord: Tournament;
    targetRoundNumber?: number;
    event: Event$1;
    randomList?: number[];
}
declare function qualifierProgression({ targetRoundNumber, tournamentRecord, drawDefinition, event, randomList, }: QualifierProgressionArgs): ResultType;

type GetMatchUpFormatTimingArgs = {
    defaultRecoveryMinutes?: number;
    defaultAverageMinutes?: number;
    tournamentRecord: Tournament;
    matchUpFormat: string;
    categoryName?: string;
    categoryType?: string;
    eventType?: EventTypeUnion;
    event?: Event$1;
};
declare function getMatchUpFormatTiming({ defaultAverageMinutes, defaultRecoveryMinutes, tournamentRecord, matchUpFormat, categoryName, categoryType, eventType, event, }: GetMatchUpFormatTimingArgs): (ResultType & {
    typeChangeRecoveryMinutes?: number;
    recoveryMinutes?: number;
    averageMinutes?: number;
}) | {
    error: {
        message: string;
        code: string;
    };
};

type AssignMatchUpSideParticipantArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    participantId: string;
    sideNumber: number;
    matchUpId: string;
    event: Event$1;
};
declare function assignMatchUpSideParticipant({ tournamentRecord, drawDefinition, participantId, sideNumber, matchUpId, event, }: AssignMatchUpSideParticipantArgs): ResultType & {
    sidesSwapped?: boolean;
};

type GetCompetitionLeaderboardArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    event?: Event$1;
};
type GetCompetitionLeaderboardResult = ResultType & {
    leaderboard?: CompetitionLeaderboardRow[];
};
declare function getCompetitionLeaderboard(params: GetCompetitionLeaderboardArgs): GetCompetitionLeaderboardResult;

type ProcessCompetitionRoundArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    roundNumber: number;
    matchUps: MatchUp$1[];
    event?: Event$1;
};
declare function processCompetitionRound(params: ProcessCompetitionRoundArgs): ResultType;

declare function scheduleMatchUps(params: any): (ResultType & {
    valid?: boolean;
}) | {
    requestConflicts: unknown[];
    remainingScheduleTimes: any[] | undefined;
    individualParticipantProfiles: any;
    matchUpNotBeforeTimes: any;
    participantIdsAtLimit: any;
    skippedScheduleTimes: string[];
    overLimitMatchUpIds: any;
    scheduledMatchUpIds: string[];
    noTimeMatchUpIds: any[];
    recoveryTimeDeferred: {};
    dependencyDeferred: {};
    success: boolean;
};

declare function setDrawParticipantRepresentativeIds({ representativeParticipantIds, drawDefinition }: {
    representativeParticipantIds: any;
    drawDefinition: any;
}): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

declare function setStructureOrder({ drawDefinition, orderMap }: {
    drawDefinition: any;
    orderMap: any;
}): ResultType;

type ValidateOfficiatingStatusTransitionArgs = {
    entityType: 'certification' | 'evaluation' | 'assignment';
    fromStatus: string;
    toStatus: string;
};
declare function validateOfficiatingStatusTransition({ entityType, fromStatus, toStatus, }: ValidateOfficiatingStatusTransitionArgs): {
    error: {
        message: string;
        code: string;
    };
    context: {
        message: string;
        entityType?: undefined;
        fromStatus?: undefined;
        toStatus?: undefined;
        validTargets?: undefined;
    };
} | {
    error: ErrorType;
    context: {
        entityType: "certification" | "evaluation" | "assignment";
        fromStatus: string;
        message: string;
        toStatus?: undefined;
        validTargets?: undefined;
    };
} | {
    error: ErrorType;
    context: {
        entityType: "certification" | "evaluation" | "assignment";
        fromStatus: string;
        toStatus: string;
        validTargets: string[];
        message?: undefined;
    };
} | {
    valid: boolean;
    success: boolean;
    error?: undefined;
    context?: undefined;
};

type GenerateDrawStructuresAndLinksArgs = {
    playoffAttributes?: PlayoffAttributes;
    appliedPolicies?: PolicyDefinitions;
    enforceMinimumDrawSize?: boolean;
    drawDefinition: DrawDefinition;
    overwriteExisting?: boolean;
    drawTypeCoercion?: boolean;
    staggeredEntry?: boolean;
    qualifyingOnly?: boolean;
    qualifyingProfiles?: any;
    structureName?: string;
    tieFormat?: TieFormat;
    matchUpType?: string;
    drawType?: string;
    drawSize?: number;
    idPrefix?: string;
    isMock?: boolean;
    uuids?: string[];
};
declare function generateDrawStructuresAndLinks(params: GenerateDrawStructuresAndLinksArgs): any;

type ModifySeedAssignmentArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    seedValue?: string | number;
    participantId: string;
    validation?: boolean;
    structureId: string;
    event?: Event$1;
};
declare function modifySeedAssignment({ validation, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }: ModifySeedAssignmentArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type RenameStructuresArgs = {
    drawDefinition: DrawDefinition;
    structureDetails: {
        structureId: string;
        structureName: string;
    }[];
};
declare function renameStructures({ drawDefinition, structureDetails }: RenameStructuresArgs): ResultType;

declare function resetVoluntaryConsolationStructure({ tournamentRecord, drawDefinition, resetEntries, event }: {
    tournamentRecord: any;
    drawDefinition: any;
    resetEntries: any;
    event: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

declare function enableTieAutoCalc({ tournamentRecord, drawDefinition, matchUpId, event }: {
    tournamentRecord: any;
    drawDefinition: any;
    matchUpId: any;
    event: any;
}): any;

declare function getDrawParticipantRepresentativeIds({ drawDefinition }: {
    drawDefinition: any;
}): (ResultType & {
    extension?: Extension;
}) | {
    representativeParticipantIds: any;
};

type RemoveStructureArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    structureId: string;
    force?: boolean;
    event: Event$1;
};
declare function removeStructure(params: RemoveStructureArgs): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
} | {
    removedMatchUpIds: string[];
    removedStructureIds: string[];
    success: boolean;
    error?: undefined;
};

type ResetCompetitionStateArgs = {
    drawDefinition: DrawDefinition;
};
declare function resetCompetitionState({ drawDefinition }: ResetCompetitionStateArgs): ResultType;

declare function withdrawParticipantAtDrawPosition(params: any): ResultType & {
    participantId?: string;
};

type AddVoluntaryConsolationStructureArgs = {
    structureAbbreviation?: string;
    drawDefinition: DrawDefinition;
    structureName?: string;
    matchUpType?: string;
    structureId?: string;
};
declare function addVoluntaryConsolationStructure({ structureName, structureAbbreviation, drawDefinition, matchUpType, structureId, }: AddVoluntaryConsolationStructureArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type BulkScheduleMachUpsArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    scheduleCompletedMatchUps?: boolean;
    tournamentRecord?: Tournament;
    scheduleByeMatchUps?: boolean;
    errorOnAnachronism?: boolean;
    removePriorValues?: boolean;
    checkChronology?: boolean;
    matchUpDependencies?: any;
    matchUpIds?: string[];
    matchUpDetails?: any;
    schedule?: any;
};
declare function bulkScheduleTournamentMatchUps({ scheduleCompletedMatchUps, scheduleByeMatchUps, errorOnAnachronism, checkChronology, matchUpDependencies, removePriorValues, tournamentRecords, tournamentRecord, matchUpDetails, matchUpIds, schedule, }: BulkScheduleMachUpsArgs): {
    error?: ErrorType;
    scheduled?: number;
    warnings?: any[];
};

declare function luckyLoserDrawPositionAssignment(params: any): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type ModifyEventMatchUpFormatTimingArgs = {
    tournamentRecord: Tournament;
    recoveryMinutes?: number;
    averageMinutes?: number;
    matchUpFormat: string;
    categoryType?: string;
    tournamentId?: string;
    eventId: string;
    event?: Event$1;
};
declare function modifyEventMatchUpFormatTiming(params: ModifyEventMatchUpFormatTimingArgs): (ResultType & {
    valid?: boolean;
}) | {
    success: boolean;
    error?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
};

type RemoveEventMatchUpFormatTimingArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    eventId: string;
    event?: Event$1;
};
declare function removeEventMatchUpFormatTiming(params: RemoveEventMatchUpFormatTimingArgs): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
} | {
    error: {
        message: string;
        code: string;
    };
};

type SetDrawPositionPreferencesArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    participantId: string;
    preferences: number[];
};
declare function setDrawPositionPreferences({ drawDefinition, participantId, preferences, }: SetDrawPositionPreferencesArgs): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};

type ToggleParticipantCheckInStateArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    activeTournamentId?: string;
    participantId: string;
    tournamentId?: string;
    matchUpIds?: string[];
    matchUpId: string;
};
declare function toggleParticipantCheckInState(params: ToggleParticipantCheckInStateArgs): any;

declare function anonymizeTournamentRecord({ keepExtensions, anonymizeParticipantNames, tournamentRecord, tournamentName, personIds, tournamentId, }: {
    keepExtensions?: never[] | undefined;
    anonymizeParticipantNames?: boolean | undefined;
    tournamentRecord: any;
    tournamentName: any;
    personIds?: never[] | undefined;
    tournamentId: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type TallyParticipantResultsArgs = {
    policyDefinitions?: PolicyDefinitions;
    generateReport?: boolean;
    pressureRating?: string;
    matchUpFormat?: string;
    perPlayer?: number;
    subOrderMap?: any;
    matchUps: any[];
};
type TallyResultType = {
    completedTieMatchUps?: boolean;
    bracketComplete?: boolean;
    participantResults?: any;
    readableReport?: string;
    report?: string[];
    order?: any[];
};
declare function tallyParticipantResults({ policyDefinitions, generateReport, pressureRating, matchUpFormat, matchUps, subOrderMap, perPlayer, }: TallyParticipantResultsArgs): TallyResultType & ResultType;

type GetCompetitionPolicyArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    event?: Event$1;
};
type GetCompetitionPolicyResult = ResultType & {
    competitionPolicy?: CompetitionPolicy;
};
declare function getCompetitionPolicy(params: GetCompetitionPolicyArgs): GetCompetitionPolicyResult;

declare function removeMatchUpCourtAssignment(params: any): any;

type LoserLinkDefinition = {
    sourceRoundNumber: number;
    targetRoundNumber: number;
};
type GenerateConsolationArgs = {
    structureName?: string;
    structureType?: string;
    matchUpFormat?: string;
    matchUpType?: string;
    drawSize?: number;
};
type AddLinkedConsolationStructureArgs = GenerateConsolationArgs & {
    drawDefinition: any;
    structureId?: string;
    links: LoserLinkDefinition[];
};
declare function generateConsolationStructure({ structureName, structureType, drawSize, matchUpFormat, matchUpType, }: GenerateConsolationArgs): any;
declare function addLinkedConsolationStructure({ drawDefinition, structureId: mainStructureId, structureName, structureType, drawSize, matchUpFormat, matchUpType, links: linkDefs, }: AddLinkedConsolationStructureArgs): any;

type AddMatchUpScheduleItemsArgs = {
    inContextMatchUps?: HydratedMatchUp[];
    drawMatchUps?: HydratedMatchUp[];
    proConflictDetection?: boolean;
    drawDefinition: DrawDefinition;
    errorOnAnachronism?: boolean;
    removePriorValues?: boolean;
    checkChronology?: boolean;
    matchUpDependencies?: any;
    disableNotice?: boolean;
    tournamentRecords: any;
    tournamentRecord: any;
    matchUpId: string;
    schedule: any;
    event?: Event$1;
};
declare function addMatchUpScheduleItems(params: AddMatchUpScheduleItemsArgs): {
    error?: ErrorType;
    success?: boolean;
    warnings?: any[];
    info?: any;
};
declare function addMatchUpCourtOrder({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, courtOrder, matchUpId, }: AddScheduleAttributeArgs & {
    courtOrder?: number;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};
declare function addMatchUpOfficial({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, participantId, officialType, matchUpId, }: AddScheduleAttributeArgs & {
    participantId?: string;
    officialType?: string;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};
declare function addMatchUpStartTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, startTime, event, }: AddScheduleAttributeArgs & {
    startTime?: string;
}): any;
declare function addMatchUpEndTime({ validateTimeSeries, removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, endTime, event, }: AddScheduleAttributeArgs & {
    validateTimeSeries?: boolean;
    endTime?: string;
}): any;
declare function addMatchUpStopTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, matchUpId, stopTime, event, }: AddScheduleAttributeArgs & {
    stopTime?: string;
}): any;
declare function addMatchUpResumeTime({ removePriorValues, tournamentRecord, drawDefinition, disableNotice, resumeTime, matchUpId, event, }: AddScheduleAttributeArgs & {
    resumeTime?: string;
}): any;

type GenerateLineUpsArgs = {
    useDefaultEventRanking?: boolean;
    tournamentRecord: Tournament;
    drawDefinition?: DrawDefinition;
    scaleAccessor: any;
    singlesOnly?: boolean;
    tieFormat?: TieFormat;
    attach?: boolean;
    event: Event$1;
};
declare function generateLineUps(params: GenerateLineUpsArgs): ResultType & {
    lineUps?: {
        [key: string]: LineUp;
    };
    participantsToAdd?: any[];
};

type GetCompetitionStateArgs = {
    drawDefinition: DrawDefinition;
};
type GetCompetitionStateResult = ResultType & {
    competitionState?: CompetitionState;
};
declare function getCompetitionState({ drawDefinition }: GetCompetitionStateArgs): GetCompetitionStateResult;

type GetParticipantResultsArgs = {
    matchUps: HydratedMatchUp[];
    participantIds?: string[];
    pressureRating?: string;
    groupingTotal?: string;
    matchUpFormat?: string;
    perPlayer?: number;
    tallyPolicy?: any;
};
declare function getParticipantResults({ participantIds, pressureRating, groupingTotal, matchUpFormat, tallyPolicy, perPlayer, matchUps, }: GetParticipantResultsArgs): {
    participantResults: {};
};

type GetSchedulingProfileIssuesArgs = {
    tournamentRecords: TournamentRecords;
    scheduleDates?: string[];
    periodLength?: number;
};
declare function getSchedulingProfileIssues(params?: GetSchedulingProfileIssuesArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    issues: any[];
    error?: undefined;
} | {
    success: boolean;
    issuesCount: number;
    profileIssues: {
        matchUpIdShouldBeAfter: any;
    };
    roundIndexShouldBeAfter: {};
    error?: undefined;
};

declare function modifyMatchUpFormatTiming(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type PositionActionsArgs = {
    inContextDrawMatchUps?: HydratedMatchUp[];
    restrictAdHocRoundParticipants?: boolean;
    tournamentParticipants?: Participant$1[];
    policyDefinitions?: PolicyDefinitions;
    provisionalPositioning?: boolean;
    tournamentRecord?: Tournament;
    returnParticipants?: boolean;
    drawDefinition: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
    drawPosition: number;
    structureId: string;
    matchUpId?: string;
    event?: Event$1;
};
declare function positionActions(params: PositionActionsArgs): ResultType & {
    isActiveDrawPosition?: boolean;
    hasPositionAssigned?: boolean;
    isDrawPosition?: boolean;
    isByePosition?: boolean;
    validActions?: any[];
};

type RemapArgs = {
    targetMatchUpIds: TargetMatchUpId[];
    drawDefinition: DrawDefinition;
};
declare function remapDrawDefinitionMatchUpIds({ targetMatchUpIds, drawDefinition, }: RemapArgs): ResultType & {
    remappedCount?: number;
};

type ReplaceTieMatchUpParticipantIdArgs = {
    policyDefinitions?: PolicyDefinitions;
    existingParticipantId: string;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    newParticipantId: string;
    enforceGender?: boolean;
    substitution?: boolean;
    tieMatchUpId: string;
    event: Event$1;
};
declare function replaceTieMatchUpParticipantId(params: ReplaceTieMatchUpParticipantIdArgs): ResultType & {
    participantRemoved?: string;
    participantAdded?: string;
    modifiedLineUp?: LineUp;
};

type AssignDrawPositionByeArgs = {
    provisionalPositioning?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    isPositionAction?: boolean;
    matchUpsMap?: MatchUpsMap;
    structure?: Structure;
    drawPosition: number;
    structureId?: string;
    loserMatchUp?: MatchUp$1;
    event?: Event$1;
};
declare function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, loserMatchUp, matchUpsMap, structureId, structure, event, }: AssignDrawPositionByeArgs): any;

type AssignMatchUpSideParticipantIdArgs = {
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    teamParticipantId?: string;
    enforceGender?: boolean;
    participantId: string;
    tieMatchUpId: string;
    sideNumber?: number;
    event: Event$1;
};
declare function assignTieMatchUpParticipantId(params: AssignMatchUpSideParticipantIdArgs): ResultType & {
    deletedParticipantId?: string;
    modifiedLineUp?: LineUp;
};

type BulkUpdateCourtAssignmentsParams = {
    tournamentRecords: TournamentRecords;
    courtAssignments: any[];
    courtDayDate: string;
};
declare function bulkUpdateCourtAssignments(params: BulkUpdateCourtAssignmentsParams): any;

declare function createTournamentRecord(params: any): any;

type GetScheduledRoundsDetailsArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    scheduleCompletedMatchUps?: boolean;
    containedStructureIds?: string[];
    matchUps?: HydratedMatchUp[];
    tournamentRecord?: Tournament;
    periodLength?: number;
    rounds: any[];
};
type RoundsDetailsResult = {
    greatestAverageMinutes?: number;
    scheduledRoundsDetails?: any[];
    orderedMatchUpIds?: string[];
    matchUpFormatCohorts?: any;
    recoveryMinutesMap?: any;
    averageMinutesMap?: any;
    error?: ErrorType;
    success?: boolean;
    minutesMap?: any;
    info?: string;
};
declare function getScheduledRoundsDetails(params: GetScheduledRoundsDetailsArgs): RoundsDetailsResult;

type ModifyParticipantsPaymentStatusArgs = {
    tournamentRecord: any;
    participantIds: string[];
    paymentState: PaymentStatusUnion;
};
declare function modifyParticipantsPaymentStatus({ tournamentRecord, participantIds, paymentState, }: ModifyParticipantsPaymentStatusArgs): any;

declare function removeDrawPositionAssignment(params: any): ResultType & {
    participantId?: string;
};

type MutationLockScope = 'SCHEDULING' | 'SCORING' | 'DRAWS' | 'MATCHUPS' | 'PARTICIPANTS' | 'ENTRIES' | 'EVENTS' | 'VENUES' | 'PUBLISHING' | 'TOURNAMENT' | 'TIE_FORMAT' | 'POLICY' | 'COMPETITION' | 'RANKING';
interface MutationLock {
    lockId: string;
    lockToken: string;
    scope: MutationLockScope;
    methods?: string[];
    expiresAt: string | null;
    createdAt: string;
}

type RemoveMutationLockArgs = {
    tournamentRecord: Tournament;
    drawDefinition?: {
        drawId: string;
        extensions?: any[];
    };
    event?: {
        eventId: string;
        extensions?: any[];
    };
    venueId?: string;
    lockId?: string;
    scope?: MutationLockScope;
    lockToken?: string;
    forceRelease?: boolean;
};
declare function removeMutationLock(params: RemoveMutationLockArgs): {
    success?: boolean;
    error?: ErrorType;
    info?: string;
};

type RemoveTieMatchUpParticipantIdArgs = {
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    participantId: string;
    tieMatchUpId: string;
    event: Event$1;
};
declare function removeTieMatchUpParticipantId(params: RemoveTieMatchUpParticipantIdArgs): ResultType & {
    modifiedLineUp?: LineUp;
};

declare function addSchedulingProfileRound({ tournamentRecords, scheduleDate, venueId, round }: {
    tournamentRecords: any;
    scheduleDate: any;
    venueId: any;
    round: any;
}): any;

type AllocateTeamMatchUpCourtsArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    removePriorValues?: boolean;
    disableNotice?: boolean;
    courtDayDate?: string;
    matchUpId: string;
    courtIds: any;
};
declare function allocateTeamMatchUpCourts({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, courtDayDate, matchUpId, courtIds, }: AllocateTeamMatchUpCourtsArgs): ResultType | {
    matchUp?: HydratedMatchUp;
    structure?: Structure;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
    context?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    context: {
        courtIds: any;
    };
};

type StructurePositionAssignmentType = {
    positionAssignments: PositionAssignment[];
    structureId: string;
};
type AutomatedPlayoffPositioningArgs = {
    provisionalPositioning?: boolean;
    seedingProfile?: SeedingProfile;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    applyPositioning?: boolean;
    random?: () => number;
    structureId: string;
    placeByes?: boolean;
    seedsOnly?: boolean;
    event?: Event$1;
};
declare function automatedPlayoffPositioning(params: AutomatedPlayoffPositioningArgs): {
    structurePositionAssignments?: StructurePositionAssignmentType[];
    positioningReports?: {
        [key: string]: any;
    }[];
    success?: boolean;
    error?: ErrorType;
};

type GenerateScoreString = {
    addOutcomeString?: boolean;
    autoComplete?: boolean;
    matchUpStatus?: string;
    matchUpFormat?: string;
    winnerFirst?: boolean;
    winningSide?: number;
    setTBlast?: boolean;
    reversed?: boolean;
    sets: any;
};
declare function generateScoreString(params: GenerateScoreString): string | {
    error?: ErrorType;
    info?: ErrorType | string;
};

type MatchUpActionsArgs = {
    inContextDrawMatchUps?: HydratedMatchUp[];
    restrictAdHocRoundParticipants?: boolean;
    tournamentParticipants?: Participant$1[];
    tournamentRecords?: TournamentRecords;
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
    enforceGender?: boolean;
    participantId?: string;
    tournamentId?: string;
    sideNumber?: number;
    matchUpId?: string;
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
declare function matchUpActions(params?: MatchUpActionsArgs): ResultType & {
    structureIsComplete?: boolean;
    isDoubleExit?: boolean;
    isByeMatchUp?: boolean;
    validActions?: any[];
};

declare function modifyIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, tournamentRecord }: {
    individualParticipantIds: any;
    groupingParticipantId: any;
    tournamentRecord: any;
}): ResultType;

declare function modifyParticipantsSignInStatus({ tournamentRecord, participantIds, signInState }: {
    tournamentRecord: any;
    participantIds: any;
    signInState: any;
}): any;

type RemoveIndividualParticipantIdsArgs = {
    addIndividualParticipantsToEvents?: boolean;
    individualParticipantIds: string[];
    groupingParticipantId: string;
    tournamentRecord: Tournament;
    suppressErrors?: boolean;
};
declare function removeIndividualParticipantIds({ addIndividualParticipantsToEvents, individualParticipantIds, groupingParticipantId, tournamentRecord, suppressErrors, }: RemoveIndividualParticipantIdsArgs): ResultType;
type RemoveParticipantIdsFromAllTeamsArgs = {
    participantRole?: ParticipantRoleUnion;
    individualParticipantIds?: string[];
    tournamentRecord: Tournament;
    groupingTypes?: string[];
};
declare function removeParticipantIdsFromAllTeams({ participantRole, individualParticipantIds, groupingTypes, tournamentRecord, }: RemoveParticipantIdsFromAllTeamsArgs): {
    success: boolean;
} | {
    error: {
        message: string;
        code: string;
    };
};

type RemoveMatchUpSideParticipantArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    sideNumber?: number;
    matchUpId: string;
    event?: Event$1;
};
declare function removeMatchUpSideParticipant(params: RemoveMatchUpSideParticipantArgs): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    sideNumber: number;
} | {
    error: {
        message: string;
        code: string;
    };
    sideNumber?: undefined;
};

type ResolveDraftPositionsArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    random?: () => number;
    applyResults?: boolean;
    tierIndex?: number;
    event?: Event$1;
};
declare function resolveDraftPositions({ tournamentRecord, drawDefinition, applyResults, tierIndex: targetTierIndex, random, event, }: ResolveDraftPositionsArgs): any;

type CopyTournamentRecordArgs = {
    tournamentRecord: Tournament;
    copyParticipants?: boolean;
    extensionList?: string[];
    itemTypeList?: string[];
    tournamentName: string;
    startDate: string;
    endDate?: string;
};
declare function copyTournamentRecord(params: CopyTournamentRecordArgs): (ResultType & {
    valid?: boolean;
}) | {
    tournamentRecord: {
        participants: any[];
        parentOrganisation: any;
        venues: any;
        extensions: any;
        timeItems: any;
        events: any[];
        weekdays: ("MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT" | "SUN")[];
        tournamentName: string;
        startDate: string;
        tournamentId: string;
        endDate: string;
    };
    success: boolean;
};

declare function generateVirtualCourts(params: any): {
    error: {
        message: string;
        code: string;
    };
    courts: any;
    virtualCourts?: undefined;
    assignedBookings?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    courts?: undefined;
    virtualCourts?: undefined;
    assignedBookings?: undefined;
} | {
    virtualCourts: any[];
    assignedBookings: any[];
    error?: undefined;
    courts?: undefined;
};

declare function removeDelegatedOutcome({ drawDefinition, event, matchUpId }: {
    drawDefinition: any;
    event: any;
    matchUpId: any;
}): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

declare function addDrawDefinitionTimeItem({ drawDefinition, timeItem }: {
    drawDefinition: any;
    timeItem: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

declare function addDynamicRatings(params: any): any;

type AddMutationLockArgs = {
    tournamentRecord: Tournament;
    drawDefinition?: {
        drawId: string;
        extensions?: any[];
    };
    event?: {
        eventId: string;
        extensions?: any[];
    };
    venueId?: string;
    scope: MutationLockScope;
    lockToken: string;
    expiresAt?: string | null;
    methods?: string[];
};
declare function addMutationLock(params: AddMutationLockArgs): {
    success?: boolean;
    error?: ErrorType;
    lockId?: string;
    info?: string;
};

declare function attachQualifyingStructure(params: any): ResultType;

type GetAvailablePlayoffProfileArgs = {
    drawDefinition: DrawDefinition;
    structureId?: string;
};
declare function getAvailablePlayoffProfiles({ drawDefinition, structureId }: GetAvailablePlayoffProfileArgs): any;

type PredictionAnchor = {
    probability: number;
    delta: number;
};
type PredictionModel = {
    competitiveAnchors: PredictionAnchor[];
    decisiveAnchors: PredictionAnchor[];
};
type BandPrediction = {
    competitive: number;
    decisive: number;
    routine: number;
};

type ProjectionMode = 'BALANCED_BRACKET' | 'ROUND_ROBIN' | 'MIN_DELTA';
type ProjectedPair = [number, number];
type PredictDrawCompetitiveBandsArgs = {
    predictionModel?: PredictionModel;
    projectionMode?: ProjectionMode;
    tournamentRecord?: Tournament;
    groupSize?: number;
    ratings: number[];
    drawType?: string;
    drawSize?: number;
};
type PredictDrawCompetitiveBandsResult = BandPrediction & {
    perMatchUpPredictions?: BandPrediction[];
    projectionMode?: ProjectionMode;
    projectedPairs?: ProjectedPair[];
    expectedMatchCount?: number;
    error?: ErrorType;
};
declare function predictDrawCompetitiveBands({ tournamentRecord, projectionMode, predictionModel, groupSize, ratings, drawType, }: PredictDrawCompetitiveBandsArgs): PredictDrawCompetitiveBandsResult;

declare function reorderUpcomingMatchUps(params: any): {
    success: boolean;
} | ResultType;

declare const SanctioningStatusEnum: {
    readonly DRAFT: "DRAFT";
    readonly SUBMITTED: "SUBMITTED";
    readonly UNDER_REVIEW: "UNDER_REVIEW";
    readonly APPROVED: "APPROVED";
    readonly CONDITIONALLY_APPROVED: "CONDITIONALLY_APPROVED";
    readonly REJECTED: "REJECTED";
    readonly WITHDRAWN: "WITHDRAWN";
    readonly MODIFICATION_REQUESTED: "MODIFICATION_REQUESTED";
    readonly ACTIVE: "ACTIVE";
    readonly POST_EVENT: "POST_EVENT";
    readonly CLOSED: "CLOSED";
    readonly ISSUES_FLAGGED: "ISSUES_FLAGGED";
};
type SanctioningStatus = (typeof SanctioningStatusEnum)[keyof typeof SanctioningStatusEnum];
declare const EndorsementStatusEnum: {
    readonly PENDING: "PENDING";
    readonly ENDORSED: "ENDORSED";
    readonly DECLINED: "DECLINED";
    readonly NOT_REQUIRED: "NOT_REQUIRED";
};
type EndorsementStatus = (typeof EndorsementStatusEnum)[keyof typeof EndorsementStatusEnum];
declare const AmendmentStatusEnum: {
    readonly PROPOSED: "PROPOSED";
    readonly UNDER_REVIEW: "UNDER_REVIEW";
    readonly APPROVED: "APPROVED";
    readonly REJECTED: "REJECTED";
};
type AmendmentStatus = (typeof AmendmentStatusEnum)[keyof typeof AmendmentStatusEnum];
declare const ComplianceStatusEnum: {
    readonly NOT_APPLICABLE: "NOT_APPLICABLE";
    readonly PENDING: "PENDING";
    readonly IN_PROGRESS: "IN_PROGRESS";
    readonly COMPLIANT: "COMPLIANT";
    readonly ISSUES_FLAGGED: "ISSUES_FLAGGED";
};
type ComplianceStatus = (typeof ComplianceStatusEnum)[keyof typeof ComplianceStatusEnum];
declare const ComplianceItemStatusEnum: {
    readonly PENDING: "PENDING";
    readonly SUBMITTED: "SUBMITTED";
    readonly VERIFIED: "VERIFIED";
    readonly OVERDUE: "OVERDUE";
    readonly WAIVED: "WAIVED";
};
type ComplianceItemStatus = (typeof ComplianceItemStatusEnum)[keyof typeof ComplianceItemStatusEnum];
declare const SanctioningRelationshipEnum: {
    readonly PRIMARY: "PRIMARY";
    readonly SECONDARY: "SECONDARY";
    readonly INDEPENDENT: "INDEPENDENT";
};
type SanctioningRelationship = (typeof SanctioningRelationshipEnum)[keyof typeof SanctioningRelationshipEnum];
declare const AmendmentSeverityEnum: {
    readonly MINOR: "MINOR";
    readonly SUBSTANTIAL: "SUBSTANTIAL";
};
type AmendmentSeverity = (typeof AmendmentSeverityEnum)[keyof typeof AmendmentSeverityEnum];
interface SanctioningRecord {
    sanctioningId: string;
    status: SanctioningStatus;
    version: number;
    createdAt: string;
    updatedAt: string;
    submittedAt?: string;
    reviewedAt?: string;
    approvedAt?: string;
    applicant: Applicant;
    endorsement?: Endorsement;
    endorsements?: Endorsement[];
    reviewer?: Reviewer;
    proposal: TournamentProposal;
    governingBodyId: string;
    governingBody?: Organisation;
    sanctioningLevel?: string;
    applicantProviderId?: string;
    sanctioningPolicy?: string;
    policyVersion?: string;
    policySnapshot?: SanctioningPolicy;
    linkedSanctioningIds?: string[];
    parentSanctioningId?: string;
    sanctioningRelationship?: SanctioningRelationship;
    conditions?: Condition[];
    reviewNotes?: ReviewNote[];
    amendments?: Amendment[];
    statusHistory?: StatusTransition[];
    compliance?: ComplianceRecord;
    extensions?: Extension[];
    timeItems?: TimeItem[];
}
interface Applicant {
    organisationId?: string;
    organisationName?: string;
    contactName?: string;
    contactEmail?: string;
    contactPhone?: string;
    credentials?: Credential[];
    extensions?: Extension[];
}
interface Credential {
    credentialType: string;
    credentialId?: string;
    issuedBy?: string;
    issuedDate?: string;
    expirationDate?: string;
    verified?: boolean;
}
interface Endorsement {
    status: EndorsementStatus;
    endorserId?: string;
    endorserName?: string;
    endorsedAt?: string;
    declinedAt?: string;
    declineReason?: string;
    endorserNotes?: string;
    endorserContact?: PersonReference;
    conditions?: string[];
    endorsementLevel?: number;
    prerequisiteEndorserId?: string;
    extensions?: Extension[];
}
interface PersonReference {
    personName?: string;
    email?: string;
    phone?: string;
    role?: string;
    certificationLevel?: string;
}
interface Reviewer {
    reviewerId?: string;
    reviewerName?: string;
    extensions?: Extension[];
}
interface TournamentProposal {
    tournamentName: string;
    formalName?: string;
    promotionalName?: string;
    tournamentLevel?: TournamentLevelUnion;
    sanctioningTier?: string;
    discipline?: DisciplineUnion;
    proposedStartDate: string;
    proposedEndDate: string;
    hostCountryCode?: CountryCodeUnion;
    venues?: VenueProposal[];
    indoorOutdoor?: IndoorOutdoorUnion;
    surfaceCategory?: SurfaceCategoryUnion;
    localTimeZone?: string;
    events: EventProposal[];
    totalPrizeMoney?: PrizeMoney[];
    entryFees?: EntryFee[];
    sanctionFee?: PrizeMoney;
    officials?: OfficialProposal[];
    tournamentDirector?: PersonReference;
    referee?: PersonReference;
    insuranceCertificate?: DocumentReference;
    safetyPlan?: DocumentReference;
    medicalPlan?: DocumentReference;
    antiCorruptionCompliance?: boolean;
    safeguardingCompliance?: boolean;
    registrationProfile?: RegistrationProfile;
    calendarSection?: string;
    calendarConflictCheck?: boolean;
    extensions?: Extension[];
}
interface EventProposal {
    eventProposalId?: string;
    eventName: string;
    eventType: EventTypeUnion;
    gender?: GenderUnion;
    category?: Category;
    drawType?: DrawTypeUnion;
    allowedDrawTypes?: DrawTypeUnion[];
    drawSize?: number;
    qualifyingDrawSize?: number;
    matchUpFormat?: string;
    allowedMatchUpFormats?: string[];
    tieFormat?: TieFormat;
    indoorOutdoor?: IndoorOutdoorUnion;
    surfaceCategory?: SurfaceCategoryUnion;
    prizeMoney?: PrizeMoney[];
    wheelchairClass?: WheelchairClassUnion;
    extensions?: Extension[];
}
interface VenueProposal {
    venueName: string;
    venueId?: string;
    address?: string;
    city?: string;
    state?: string;
    countryCode?: CountryCodeUnion;
    numberOfCourts?: number;
    surfaceCategory?: SurfaceCategoryUnion;
    indoorOutdoor?: IndoorOutdoorUnion;
    coordinates?: Coordinates;
    extensions?: Extension[];
}
interface Coordinates {
    latitude: number;
    longitude: number;
}
interface EntryFee {
    amount: number;
    currencyCode: string;
    eventType?: EventTypeUnion;
    category?: string;
    extensions?: Extension[];
}
interface OfficialProposal {
    role: string;
    personName?: string;
    certificationLevel?: string;
    certificationBody?: string;
    extensions?: Extension[];
}
interface DocumentReference {
    documentType: string;
    documentId?: string;
    documentUrl?: string;
    uploadedAt?: string;
    verified?: boolean;
    extensions?: Extension[];
}
interface Condition {
    conditionId: string;
    description: string;
    met: boolean;
    metAt?: string;
    metNotes?: string;
    createdAt?: string;
    extensions?: Extension[];
}
interface ReviewNote {
    noteId: string;
    reviewerId?: string;
    reviewerName?: string;
    note: string;
    createdAt: string;
    extensions?: Extension[];
}
interface StatusTransition {
    fromStatus: SanctioningStatus;
    toStatus: SanctioningStatus;
    transitionedAt: string;
    transitionedBy?: string;
    reason?: string;
}
interface Amendment {
    amendmentId: string;
    status: AmendmentStatus;
    proposedAt: string;
    resolvedAt?: string;
    proposedBy?: string;
    reviewerNotes?: string;
    changes: ProposalChange[];
    severity: AmendmentSeverity;
    withinTimeline: boolean;
    extensions?: Extension[];
}
interface ProposalChange {
    field: string;
    previousValue: any;
    proposedValue: any;
    changeType: 'MODIFIED' | 'ADDED' | 'REMOVED';
}
interface ComplianceRecord {
    status: ComplianceStatus;
    items: ComplianceItem[];
    notes?: ReviewNote[];
    completedAt?: string;
}
declare const ComplianceItemTypeEnum: {
    readonly RESULTS_SUBMISSION: "RESULTS_SUBMISSION";
    readonly FINANCIAL_RECONCILIATION: "FINANCIAL_RECONCILIATION";
    readonly INCIDENT_REPORT: "INCIDENT_REPORT";
    readonly PRIZE_MONEY_CONFIRMATION: "PRIZE_MONEY_CONFIRMATION";
    readonly SANCTION_FEE_PAYMENT: "SANCTION_FEE_PAYMENT";
    readonly SUPERVISOR_REPORT: "SUPERVISOR_REPORT";
    readonly FACILITY_REPORT: "FACILITY_REPORT";
    readonly SAFEGUARDING_REPORT: "SAFEGUARDING_REPORT";
    readonly CUSTOM: "CUSTOM";
};
type ComplianceItemType = (typeof ComplianceItemTypeEnum)[keyof typeof ComplianceItemTypeEnum];
interface ComplianceItem {
    itemId: string;
    itemType: ComplianceItemType;
    description: string;
    required: boolean;
    status: ComplianceItemStatus;
    deadline?: string;
    submittedAt?: string;
    verifiedAt?: string;
    value?: any;
    extensions?: Extension[];
}
interface SanctioningPolicy {
    policyName: string;
    policyVersion: string;
    effectiveDate: string;
    supersededDate?: string;
    governingBodyId: string;
    tiers: SanctioningTier[];
    calendarRules?: CalendarRules;
    personnelRules?: PersonnelRules;
    amendmentRules?: AmendmentRules;
    postEventRequirements?: PostEventRequirement[];
    transitionGuards?: TransitionGuard[];
    requireEndorsement?: boolean;
    requiredEndorsementCount?: number;
    requireInsurance?: boolean;
    requireSafetyPlan?: boolean;
    requireMedicalPlan?: boolean;
    requireAntiCorruption?: boolean;
    requireSafeguarding?: boolean;
    minimumLeadWeeks?: number;
    resultsDeadlineDays?: number;
    requirePostEventReport?: boolean;
    extensions?: Extension[];
}
interface SanctioningTier {
    tierName: string;
    tierLevel: number;
    allowedEventTypes?: EventTypeUnion[];
    allowedCategories?: Category[];
    allowedGenders?: GenderUnion[];
    allowedDisciplines?: DisciplineUnion[];
    allowedDrawTypes?: DrawTypeUnion[];
    allowedDrawSizes?: number[];
    maxQualifyingDrawSize?: number;
    qualifyingAllowed?: boolean;
    maxWildcards?: number;
    maxAlternates?: number;
    maxQualifiers?: number;
    allowedMatchUpFormats?: string[];
    minimumPrizeMoney?: number;
    maximumPrizeMoney?: number;
    currencyCode?: string;
    sanctionFeePercent?: number;
    sanctionFeeFixed?: number;
    minimumCourts?: number;
    requireBackdrops?: boolean;
    requireScoreboards?: boolean;
    minimumOfficials?: number;
    officialCertificationLevel?: string;
    tdRefereeSameAllowed?: boolean;
    minimumParticipants?: number;
    rankingPointsProfile?: string;
    prerequisiteTiers?: string[];
    prerequisiteEventCount?: number;
    minimumLeadWeeks?: number;
    extensions?: Extension[];
}
interface CalendarRules {
    proximityRadiusKm?: number;
    proximityWeeks?: number;
    blackoutDates?: string[];
    mandatoryWeeks?: string[];
    maxEventsPerWeek?: number;
    calendarSections?: CalendarSection[];
}
interface CalendarSection {
    sectionId: string;
    sectionName: string;
    countryCodes?: CountryCodeUnion[];
    regionCodes?: string[];
}
interface CalendarEvent {
    sanctioningId?: string;
    tournamentId?: string;
    tournamentName?: string;
    startDate: string;
    endDate: string;
    sanctioningTier?: string;
    calendarSection?: string;
    countryCode?: CountryCodeUnion;
    coordinates?: Coordinates;
}
interface CalendarContext {
    existingEvents: CalendarEvent[];
    calendarRules: CalendarRules;
}
interface PersonnelRules {
    roles: PersonnelRole[];
}
interface PersonnelRole {
    roleName: string;
    required: boolean;
    minimumCount?: number;
    certificationRequired?: string;
    safeguardingRequired?: boolean;
}
interface AmendmentRules {
    substantialChangeFields?: string[];
    noChangeWindowWeeks?: number;
    substantialChangeWindowWeeks?: number;
    prizeMoneyIncrease?: 'ALLOWED' | 'REQUIRES_REVIEW' | 'PROHIBITED';
    prizeMoneyDecrease?: 'ALLOWED' | 'REQUIRES_REVIEW' | 'PROHIBITED';
    lateChangePenalty?: boolean;
}
interface PostEventRequirement {
    itemType: ComplianceItemType;
    description: string;
    required: boolean;
    deadlineDays: number;
    tiers?: string[];
}
type TransitionGuardType = 'ENDORSEMENT_REQUIRED' | 'PROPOSAL_VALID' | 'ALL_CONDITIONS_MET' | 'COMPLIANCE_COMPLETE' | 'CUSTOM';
interface TransitionGuard {
    from: SanctioningStatus;
    to: SanctioningStatus;
    guard: TransitionGuardType;
    customGuardField?: string;
    message?: string;
    tiers?: string[];
}
type SanctioningRecords = {
    [sanctioningId: string]: SanctioningRecord;
};
type SanctioningDirective = {
    pipe?: {
        [key: string]: boolean;
    };
    params?: {
        [key: string]: any;
    };
    method: string;
};
type SanctioningDirectives = SanctioningDirective[];

declare const CertificationStatusEnum: {
    readonly ACTIVE: "ACTIVE";
    readonly EXPIRED: "EXPIRED";
    readonly SUSPENDED: "SUSPENDED";
    readonly REVOKED: "REVOKED";
    readonly PENDING_RENEWAL: "PENDING_RENEWAL";
};
type CertificationStatus = (typeof CertificationStatusEnum)[keyof typeof CertificationStatusEnum];
declare const EvaluationStatusEnum: {
    readonly DRAFT: "DRAFT";
    readonly SUBMITTED: "SUBMITTED";
    readonly REVIEWED: "REVIEWED";
    readonly APPROVED: "APPROVED";
    readonly REJECTED: "REJECTED";
};
type EvaluationStatus = (typeof EvaluationStatusEnum)[keyof typeof EvaluationStatusEnum];
declare const AssignmentStatusEnum: {
    readonly PROPOSED: "PROPOSED";
    readonly CONFIRMED: "CONFIRMED";
    readonly DECLINED: "DECLINED";
    readonly CANCELLED: "CANCELLED";
    readonly COMPLETED: "COMPLETED";
};
type AssignmentStatus = (typeof AssignmentStatusEnum)[keyof typeof AssignmentStatusEnum];
declare const OfficialRoleSubtypeEnum: {
    readonly CHAIR_UMPIRE: "CHAIR_UMPIRE";
    readonly LINE_UMPIRE: "LINE_UMPIRE";
    readonly REFEREE: "REFEREE";
    readonly CHIEF_UMPIRE: "CHIEF_UMPIRE";
    readonly DEPUTY_REFEREE: "DEPUTY_REFEREE";
    readonly REVIEW_OFFICIAL: "REVIEW_OFFICIAL";
    readonly COURT_SUPERVISOR: "COURT_SUPERVISOR";
};
type OfficialRoleSubtype = (typeof OfficialRoleSubtypeEnum)[keyof typeof OfficialRoleSubtypeEnum];
declare const CertificationFamilyEnum: {
    readonly UMPIRE: "UMPIRE";
    readonly REFEREE: "REFEREE";
    readonly CHIEF_UMPIRE: "CHIEF_UMPIRE";
    readonly REVIEW_OFFICIAL: "REVIEW_OFFICIAL";
};
type CertificationFamily = (typeof CertificationFamilyEnum)[keyof typeof CertificationFamilyEnum];
declare const CertificationLevelEnum: {
    readonly WHITE_BADGE: "WHITE_BADGE";
    readonly BRONZE_BADGE: "BRONZE_BADGE";
    readonly SILVER_BADGE: "SILVER_BADGE";
    readonly GOLD_BADGE: "GOLD_BADGE";
};
type CertificationLevel = (typeof CertificationLevelEnum)[keyof typeof CertificationLevelEnum];
declare const ScoringTypeEnum: {
    readonly NUMERIC: "NUMERIC";
    readonly SCALE: "SCALE";
    readonly CHECKLIST: "CHECKLIST";
    readonly TEXT: "TEXT";
};
type ScoringType = (typeof ScoringTypeEnum)[keyof typeof ScoringTypeEnum];
declare const ScoringMethodEnum: {
    readonly WEIGHTED_AVERAGE: "WEIGHTED_AVERAGE";
    readonly SIMPLE_AVERAGE: "SIMPLE_AVERAGE";
    readonly SUM: "SUM";
};
type ScoringMethod = (typeof ScoringMethodEnum)[keyof typeof ScoringMethodEnum];
interface OfficiatingStatusTransition {
    fromStatus: string;
    toStatus: string;
    transitionedAt: string;
    transitionedBy?: string;
    reason?: string;
}
interface OfficialCertification {
    certificationId: string;
    personId: string;
    organisationId: string;
    certificationFamily: string;
    certificationLevel?: string;
    status: CertificationStatus;
    validFrom?: string;
    validUntil?: string;
    requirements?: CertificationRequirementResult[];
    documentReferences?: DocumentReference[];
    notes?: string;
    statusHistory?: OfficiatingStatusTransition[];
    extensions?: Extension[];
    timeItems?: TimeItem[];
}
interface CertificationRequirementResult {
    requirementId: string;
    description?: string;
    met: boolean;
    metAt?: string;
    notes?: string;
}
interface CertificationRequirement {
    requirementId: string;
    certificationFamily: string;
    certificationLevel: string;
    organisationId: string;
    description?: string;
    requirements: RequirementItem[];
    prerequisiteLevels?: string[];
    minimumAssignments?: number;
    minimumEvaluationScore?: number;
    validityPeriodMonths?: number;
    extensions?: Extension[];
}
interface RequirementItem {
    itemId: string;
    description: string;
    required: boolean;
}
interface OfficialEvaluation {
    evaluationId: string;
    evaluatorPersonId: string;
    subjectPersonId: string;
    tournamentId?: string;
    tournamentName?: string;
    matchUpId?: string;
    evaluationDate: string;
    overallRating: number;
    status: EvaluationStatus;
    policyName?: string;
    scores: EvaluationScore[];
    comments?: string;
    documentReference?: DocumentReference;
    statusHistory?: OfficiatingStatusTransition[];
    extensions?: Extension[];
    timeItems?: TimeItem[];
}
interface EvaluationScore {
    criterionId: string;
    sectionId: string;
    value: number | boolean | string;
    notes?: string;
}
interface EvaluationPolicy {
    policyName: string;
    policyVersion: string;
    organisationId: string;
    officialRoleSubtype: string;
    sections: EvaluationSection[];
    scoringMethod: ScoringMethod;
    passingThreshold?: number;
    extensions?: Extension[];
}
interface EvaluationSection {
    sectionId: string;
    sectionName: string;
    weight?: number;
    criteria: EvaluationCriterion[];
}
interface EvaluationCriterion {
    criterionId: string;
    criterionName: string;
    description?: string;
    scoringType: ScoringType;
    scaleOptions?: ScaleOption[];
    numericRange?: {
        min: number;
        max: number;
    };
    required: boolean;
    weight?: number;
}
interface ScaleOption {
    value: number;
    label: string;
}
interface EvaluationFormField {
    fieldId: string;
    sectionId: string;
    sectionName: string;
    criterionId: string;
    criterionName: string;
    description?: string;
    scoringType: ScoringType;
    scaleOptions?: ScaleOption[];
    numericRange?: {
        min: number;
        max: number;
    };
    required: boolean;
    weight?: number;
    sectionWeight?: number;
}
interface OfficialAssignment {
    assignmentId: string;
    personId: string;
    tournamentId: string;
    roleSubtype: string;
    status: AssignmentStatus;
    assignedDate: string;
    startDate?: string;
    endDate?: string;
    assignedBy?: string;
    notes?: string;
    statusHistory?: OfficiatingStatusTransition[];
    extensions?: Extension[];
    timeItems?: TimeItem[];
}
interface OfficialSuspension {
    suspensionId: string;
    personId: string;
    organisationId?: string;
    suspensionType?: string;
    suspensionNotes?: string;
    suspendedFrom?: string;
    suspendedUntil?: string;
    extensions?: Extension[];
}
interface OfficialRecord {
    officialRecordId: string;
    personId: string;
    organisationId?: string;
    certifications: OfficialCertification[];
    evaluations: OfficialEvaluation[];
    assignments: OfficialAssignment[];
    suspensions: OfficialSuspension[];
    certificationRequirements: CertificationRequirement[];
    evaluationPolicies: EvaluationPolicy[];
    createdAt: string;
    updatedAt: string;
    extensions?: Extension[];
    timeItems?: TimeItem[];
}
type OfficialRecords = {
    [officialRecordId: string]: OfficialRecord;
};
type OfficiatingDirective = {
    pipe?: {
        [key: string]: boolean;
    };
    params?: {
        [key: string]: any;
    };
    method: string;
};
type OfficiatingDirectives = OfficiatingDirective[];

type TransitionCertificationStatusArgs = {
    officialRecord: OfficialRecord;
    certificationId: string;
    toStatus: CertificationStatus;
    transitionedBy?: string;
    reason?: string;
};
declare function transitionCertificationStatus({ officialRecord, certificationId, toStatus, transitionedBy, reason, }: TransitionCertificationStatusArgs): {
    error?: any;
    certification?: OfficialCertification;
    success?: boolean;
};

type AddIndividualParticipantIdsType = {
    individualParticipantIds: string[];
    removeFromOtherTeams?: boolean;
    groupingParticipantId: string;
    tournamentRecord: Tournament;
};
declare function addIndividualParticipantIds({ individualParticipantIds, groupingParticipantId, removeFromOtherTeams, tournamentRecord, }: AddIndividualParticipantIdsType): ResultType & {
    groupingParticipant?: Participant$1;
    added?: number;
};

type AdHocPositionSwapArgs = {
    drawDefinition: DrawDefinition;
    tournamentRecord: Tournament;
    participantIds: string[];
    structureId: string;
    roundNumber: number;
    event: Event$1;
};
declare function adHocPositionSwap(params: AdHocPositionSwapArgs): ResultType;

declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, event, }: {
    alternateParticipantId: any;
    tournamentRecord: any;
    drawDefinition: any;
    drawPosition: any;
    structureId: any;
    event: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type BulkRescheduleMatchUpsArgs = {
    tournamentRecords: TournamentRecords;
    tournamentRecord: Tournament;
    matchUpIds: string[];
    scheduleChange: any;
    dryRun?: boolean;
};
declare function bulkRescheduleMatchUps(params: BulkRescheduleMatchUpsArgs): ResultType & {
    allRescheduled?: boolean;
    notRescheduled?: any[];
    rescheduled?: any[];
};

type ClearScheduledMatchUpsArgs = {
    ignoreMatchUpStatuses?: MatchUpStatusUnion[];
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    scheduleAttributes?: string[];
    scheduledDates: string[];
    venueIds?: string[];
};
declare function clearScheduledMatchUps(params: ClearScheduledMatchUpsArgs): ResultType & {
    clearedScheduleCount?: number;
};

type CompareTieFormatsArgs = {
    considerations?: {
        collectionName?: boolean;
        collectionOrder?: boolean;
    };
    ancestor: TieFormat;
    descendant: any;
};
declare function compareTieFormats({ considerations, descendant, ancestor }: CompareTieFormatsArgs): {
    different: any;
    invalid: 0 | any[];
    success: boolean;
    matchUpFormatDifferences: any[];
    matchUpCountDifference: number;
    descendantDifferences: any;
    ancestorDifferences: any;
    orderDifference: boolean;
    valueDifference: number;
    nameDifference: boolean;
    descendantDesc: any;
    ancestorDesc: any;
};

declare function deleteFlightProfileAndFlightDraws({ autoPublish, tournamentRecord, auditData, event, force }: {
    autoPublish?: boolean | undefined;
    tournamentRecord: any;
    auditData: any;
    event: any;
    force: any;
}): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: any;
};

declare function generateOutcomeFromScoreString(params: any): any;

declare function qualifierDrawPositionAssignment({ qualifyingParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }: {
    qualifyingParticipantId: any;
    tournamentRecord: any;
    drawDefinition: any;
    drawPosition: any;
    structureId: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

interface ResetQualifyingStructureArgs {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    structureId: string;
    event?: Event$1;
}
declare function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, structureId, }: ResetQualifyingStructureArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type AddCertificationRequirementArgs = {
    officialRecord: OfficialRecord;
    requirementId?: string;
    certificationFamily: string;
    certificationLevel: string;
    organisationId: string;
    description?: string;
    requirements: RequirementItem[];
    prerequisiteLevels?: string[];
    minimumAssignments?: number;
    minimumEvaluationScore?: number;
    validityPeriodMonths?: number;
    extensions?: any[];
};
declare function addCertificationRequirement({ officialRecord, requirementId, certificationFamily, certificationLevel, organisationId, description, requirements, prerequisiteLevels, minimumAssignments, minimumEvaluationScore, validityPeriodMonths, extensions, }: AddCertificationRequirementArgs): {
    error?: any;
    certificationRequirement?: CertificationRequirement;
    success?: boolean;
};

type GetAssignedParticipantIdsArgs = {
    drawDefinition: DrawDefinition;
    stages?: StageTypeUnion[];
};
declare function getAssignedParticipantIds({ drawDefinition, stages }: GetAssignedParticipantIdsArgs): ResultType & {
    assignedParticipantIds?: string[];
};

type getDrawTypeCoercionArgs = {
    policyDefinitions?: PolicyDefinitions;
    appliedPolicies?: PolicyDefinitions;
    drawType?: string;
};
declare function getDrawTypeCoercion({ policyDefinitions, appliedPolicies, drawType }: getDrawTypeCoercionArgs): any;

declare function matchUpScheduleChange(params: any): {
    success: boolean;
} | ResultType | {
    error: {
        message: string;
        code: string;
    };
};

declare function modifyParticipantOtherName({ tournamentRecord, participantId, participantOtherName }: {
    tournamentRecord: any;
    participantId: any;
    participantOtherName: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
};

type RegenArgs = {
    formats: {
        [key: string]: {
            personFormat: string;
            doublesJoiner: string;
        };
    }[];
    tournamentRecord: Tournament;
};
declare function regenerateParticipantNames({ tournamentRecord, formats }: RegenArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type RemoveSeededParticipantArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    participantId: string;
    structureId: string;
};
declare function removeSeededParticipant({ tournamentRecord, drawDefinition, participantId, structureId, }: RemoveSeededParticipantArgs): ResultType;

type ScheduleProfileRoundsArgs = {
    checkPotentialRequestConflicts?: boolean;
    tournamentRecords: TournamentRecords;
    scheduleCompletedMatchUps?: boolean;
    excludeNoDateCompleted?: boolean;
    clearScheduleDates?: boolean;
    excludePriorDates?: boolean;
    scheduleDates?: string[];
    periodLength?: number;
    useGarman?: boolean;
    courtIds?: string[];
    dryRun?: boolean;
    pro?: boolean;
};
declare function scheduleProfileRounds(params: ScheduleProfileRoundsArgs): (ResultType & {
    valid?: boolean;
}) | {
    schedulingProfile?: any;
    modifications?: number;
    error?: ErrorType;
    issues?: string[];
} | {
    schedulingProfileModifications: any;
    schedulingProfileIssues: any[] | undefined;
    dateSchedulingProfiles: any[];
    recoveryTimeDeferredMatchUpIds: {};
    dependencyDeferredMatchUpIds: {};
    matchUpScheduleTimes: {};
    overLimitMatchUpIds: {};
    scheduledMatchUpIds: {};
    noTimeMatchUpIds: {};
    requestConflicts: {};
    scheduledDates: any[];
    success: boolean;
} | {
    schedulingProfileModifications: any;
    schedulingProfileIssues: any;
    scheduleTimesRemaining: {};
    dateSchedulingProfiles: any;
    skippedScheduleTimes: {};
    recoveryTimeDeferredMatchUpIds: {};
    dependencyDeferredMatchUpIds: {};
    matchUpScheduleTimes: {};
    overLimitMatchUpDetails: {};
    overLimitMatchUpIds: {};
    scheduledMatchUpIds: {};
    noTimeMatchUpIds: {};
    requestConflicts: {};
    scheduledDates: any;
    success: boolean;
} | {
    error: {
        message: string;
        code: string;
    };
};

type SetMatchUpStatusArgs$1 = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    scheduledDates?: string[];
    stageSequences?: number[];
    structureIds?: string[];
    matchUpFormat: string;
    structureId?: string;
    eventIds?: string[];
    eventType?: string;
    matchUpId?: string;
    drawIds?: string[];
    stages?: string[];
    eventId?: string;
    drawId?: string;
    force?: boolean;
    event?: Event$1;
};
declare function setMatchUpFormat(params: SetMatchUpStatusArgs$1): ResultType | {
    success?: boolean;
    error?: ErrorType;
    info?: string;
} | {
    modificationsCount: number;
    success: boolean;
};

type SetMatchUpStatusArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    policyDefinitions?: PolicyDefinitions;
    disableScoreValidation?: boolean;
    allowChangePropagation?: boolean;
    propagateExitStatus?: boolean;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    disableAutoCalc?: boolean;
    enableAutoCalc?: boolean;
    matchUpFormat?: string;
    tournamentId?: string;
    setTBlast?: boolean;
    matchUpId: string;
    eventId?: string;
    drawId?: string;
    schedule?: any;
    notes?: string;
    event?: Event$1;
    outcome?: any;
};
declare function setMatchUpStatus(params: SetMatchUpStatusArgs): ResultType | {
    success?: boolean;
    error?: ErrorType;
    info?: string;
} | {
    error: {
        message: string;
        code: string;
    };
};

type AddFinishingRoundsArgs = {
    finishingPositionOffset?: number;
    finishingPositionLimit?: number;
    positionsFed?: number;
    roundsCount?: number;
    roundLimit?: number;
    matchUps: MatchUp$1[];
    lucky?: boolean;
    fmlc?: boolean;
};
declare function addFinishingRounds({ finishingPositionOffset, finishingPositionLimit, positionsFed, roundsCount, roundLimit, matchUps, lucky, fmlc, }: AddFinishingRoundsArgs): MatchUp$1[];

type AddQualifyingstructureArgs = {
    qualifyingRoundNumber: number;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    qualifyingPositions: number;
    targetStructureId: string;
    roundTarget: number;
    structureName: string;
    matchUpType: string;
    drawSize: number;
    drawType: string;
    eventId: string;
    event: Event$1;
};
declare function addQualifyingStructure(params: AddQualifyingstructureArgs): ResultType | {
    qualifyingDrawPositionsCount?: number;
    qualifiersCount?: number;
    structure?: Structure;
    error?: ErrorType;
    success?: boolean;
    link?: DrawLink;
} | {
    error: {
        message: string;
        code: string;
    };
};

type BulkScheduleMatchUpsArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    scheduleCompletedMatchUps?: boolean;
    tournamentRecord?: Tournament;
    scheduleByeMatchUps?: boolean;
    errorOnAnachronism?: boolean;
    removePriorValues?: boolean;
    checkChronology?: boolean;
    matchUpContextIds?: any;
    matchUpIds?: string[];
    matchUpDetails: any;
    schedule?: any;
};
declare function bulkScheduleMatchUps(params: BulkScheduleMatchUpsArgs): (ResultType & {
    valid?: boolean;
}) | {
    error?: ErrorType;
    scheduled?: number;
    warnings?: any[];
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};

declare function checkOutParticipant(params: CheckInOutParticipantArgs): any;

declare function clearMatchUpSchedule({ scheduleAttributes, tournamentRecord, drawDefinition, matchUpId, }: {
    scheduleAttributes?: string[] | undefined;
    tournamentRecord: any;
    drawDefinition: any;
    matchUpId: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type GenerateTeamsArgs = {
    participantAttribute?: string;
    tournamentRecord: Tournament;
    addParticipants?: boolean;
    personAttribute?: string;
    teamNames?: string[];
    accessor?: string;
    uuids?: string[];
};
declare function createTeamsFromParticipantAttributes({ addParticipants, participantAttribute, tournamentRecord, personAttribute, teamNames, accessor, uuids, }: GenerateTeamsArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    participantsAdded: number;
    success: boolean;
    error?: undefined;
} | {
    newParticipants: any[];
    success: boolean;
    error?: undefined;
};

declare function disableTieAutoCalc({ drawDefinition, matchUpId, event }: {
    drawDefinition: any;
    matchUpId: any;
    event: any;
}): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

type GenerateCourtsArgs = {
    tournamentRecord?: Tournament;
    courtNames?: string[];
    namePrefix?: string;
    startTime?: string;
    endTime?: string;
    idPrefix?: string;
    uuids?: string[];
    dates?: string[];
    count: number;
};
type GenerateCourtsResult = {
    courts?: Court[];
};
declare function generateCourts(params: GenerateCourtsArgs): ResultType & GenerateCourtsResult;

type GenerateEventsFromTieFormatArgs = {
    entryStatus?: EntryStatusUnion;
    addEntriesFromTeams?: boolean;
    tournamentRecord: Tournament;
    tieFormatName?: string;
    tieFormat?: TieFormat;
    addEvents?: boolean;
    uuids?: string[];
};
declare function generateEventsFromTieFormat(params: GenerateEventsFromTieFormatArgs): any;

declare function generateStatCrew(params: any): (ResultType & {
    valid?: boolean;
}) | {
    success: boolean;
    json: any[];
    xml: string[];
};

declare function getCompetitionParticipants(params: any): ResultType & {
    mappedMatchUps?: {
        [key: string]: HydratedMatchUp;
    };
    participantIdsWithConflicts?: string[];
    participants?: HydratedParticipant[];
    participantMap?: ParticipantMap;
    matchUps?: MatchUp$1[];
    derivedEventInfo?: any;
    derivedDrawInfo?: any;
    success?: boolean;
};

type getParticipantEventDetailsType = {
    tournamentRecord: Tournament;
    participantId: string;
};
declare function getParticipantEventDetails({ tournamentRecord, participantId, }: getParticipantEventDetailsType): ResultType & {
    eventDetails?: {
        eventName?: string;
        eventId: string;
    }[];
};

type GetSwissStandingsArgs = {
    tiebreakMethods?: string[];
    drawDefinition: DrawDefinition;
    structureId?: string;
};
type GetSwissStandingsResult = {
    standings?: SwissStanding[];
    scoreGroups?: ScoreGroup[];
    roundsPlayed?: number;
    error?: ErrorType;
    success?: boolean;
};
declare function getSwissStandings({ tiebreakMethods, drawDefinition, structureId, }: GetSwissStandingsArgs): GetSwissStandingsResult;

type SetMatchUpStateArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    policyDefinitions?: PolicyDefinitions;
    appliedPolicies?: PolicyDefinitions;
    matchUpStatus?: MatchUpStatusUnion;
    allowChangePropagation?: boolean;
    disableScoreValidation?: boolean;
    projectedWinningSide?: number;
    propagateExitStatus?: boolean;
    matchUpStatusCodes?: string[];
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    autoCalcDisabled?: boolean;
    disableAutoCalc?: boolean;
    enableAutoCalc?: boolean;
    matchUpFormat?: string;
    matchUpTieId?: string;
    tieMatchUpId?: string;
    removeScore?: boolean;
    winningSide?: number;
    matchUpId: string;
    schedule?: any;
    notes?: string;
    outcome?: any;
    event?: Event$1;
    score?: any;
};
declare function setMatchUpState(params: SetMatchUpStateArgs): any;

type TransitionAssignmentStatusArgs = {
    officialRecord: OfficialRecord;
    assignmentId: string;
    toStatus: AssignmentStatus;
    transitionedBy?: string;
    reason?: string;
};
declare function transitionAssignmentStatus({ officialRecord, assignmentId, toStatus, transitionedBy, reason, }: TransitionAssignmentStatusArgs): {
    error?: any;
    assignment?: OfficialAssignment;
    success?: boolean;
};

type TransitionEvaluationStatusArgs = {
    officialRecord: OfficialRecord;
    evaluationId: string;
    toStatus: EvaluationStatus;
    transitionedBy?: string;
    reason?: string;
};
declare function transitionEvaluationStatus({ officialRecord, evaluationId, toStatus, transitionedBy, reason, }: TransitionEvaluationStatusArgs): {
    error?: any;
    evaluation?: OfficialEvaluation;
    success?: boolean;
};

declare function checkInParticipant(params: CheckInOutParticipantArgs): any;

type GenerateBookingsArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    dateScheduledMatchUps?: HydratedMatchUp[];
    defaultRecoveryMinutes?: number;
    averageMatchUpMinutes?: number;
    matchUps?: HydratedMatchUp[];
    periodLength?: number;
    scheduleDate?: string;
    venueIds?: string[];
};
declare function generateBookings({ defaultRecoveryMinutes, averageMatchUpMinutes, dateScheduledMatchUps, tournamentRecords, venueIds, periodLength, scheduleDate, matchUps, }: GenerateBookingsArgs): {
    error: {
        message: string;
        code: string;
    };
    bookings?: undefined;
    relevantMatchUps?: undefined;
    dateScheduledMatchUps?: undefined;
} | {
    bookings: {
        recoveryMinutes: number | undefined;
        averageMinutes: number | undefined;
        periodLength: number;
        startTime: string | undefined;
        courtId: string | undefined;
        endTime: string;
        venueId: string | undefined;
    }[] | undefined;
    relevantMatchUps: HydratedMatchUp[] | undefined;
    dateScheduledMatchUps: HydratedMatchUp[] | undefined;
    error?: undefined;
};

type GetApplicableAwardProfileLevelsArgs = {
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    eventId?: string;
    drawId?: string;
};
declare function getApplicableAwardProfileLevels({ policyDefinitions, tournamentRecord, eventId, drawId, }: GetApplicableAwardProfileLevelsArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    levels: number[];
    error?: undefined;
};

type LuckyParticipantInfo = {
    participantId: string;
    participantName?: string;
    matchUpId: string;
    scoreString?: string;
    margin?: number;
    gameRatio?: number;
    pointRatio?: number;
    setRatio?: number;
    gameDifferential?: number;
    setsWonByLoser?: number;
};
type ConsolidationLinkInfo = {
    targetStructureId: string;
    targetRoundNumber: number;
    feedProfile?: string;
    losersPlaced: boolean;
};
type LuckyRoundInfo = {
    roundNumber: number;
    matchUpsCount: number;
    completedCount: number;
    isComplete: boolean;
    isPreFeedRound: boolean;
    needsLuckySelection: boolean;
    nextRoundHasOpenPosition: boolean;
    requiredLuckyLoserCount: number;
    advancingWinners?: LuckyParticipantInfo[];
    eligibleLosers?: LuckyParticipantInfo[];
    consolidationLinks?: ConsolidationLinkInfo[];
};
type GetLuckyDrawRoundStatusArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    structureId?: string;
    cumulativeMargin?: boolean;
};
type GetLuckyDrawRoundStatusResult = {
    isLuckyDraw?: boolean;
    rounds?: LuckyRoundInfo[];
    success?: boolean;
    error?: ErrorType;
};
declare function getLuckyDrawRoundStatus({ tournamentRecord, drawDefinition, structureId, cumulativeMargin, }: GetLuckyDrawRoundStatusArgs): GetLuckyDrawRoundStatusResult;

declare function getMatchUpDailyLimitsUpdate({ tournamentRecords }: {
    tournamentRecords: any;
}): {
    error?: ErrorType;
} | {
    methods: QueueMethod[];
};

declare function getTournamentPublishStatus(params: any): any;

type TierMethod = 'ENTRY_ORDER' | 'RANKING' | 'RATING';
type InitializeDraftArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    scaleAttributes?: ScaleAttributes;
    preferencesCount?: number;
    tierMethod?: TierMethod;
    ascending?: boolean;
    structureId?: string;
    tierCount?: number;
    event?: Event$1;
    force?: boolean;
};
declare function initializeDraft({ tournamentRecord, drawDefinition, scaleAttributes, preferencesCount, tierMethod, ascending, structureId, tierCount, event, force, }: InitializeDraftArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    draftState: {
        status: "SEEDS_PLACED";
        structureId: string;
        preferencesCount: number;
        tierMethod: TierMethod;
        scaleAttributes: ScaleAttributes | undefined;
        ascending: boolean;
        tiers: {
            participantIds: string[];
            resolved: boolean;
        }[];
        preferences: Record<string, number[]>;
        unassignedDrawPositions: any[];
    };
    unassignedDrawPositions: any[];
    tiers: {
        participantIds: string[];
        resolved: boolean;
    }[];
    success: boolean;
    error?: undefined;
};

type PredictMatchUpCompetitiveBandsArgs = {
    predictionModel?: PredictionModel;
    tournamentRecord?: Tournament;
    side1Rating?: number;
    side2Rating?: number;
};
declare function predictMatchUpCompetitiveBands({ tournamentRecord, predictionModel, side1Rating, side2Rating, }: PredictMatchUpCompetitiveBandsArgs): BandPrediction & {
    delta?: number;
    error?: ErrorType;
};

declare function removeRatings(params: {
    tournamentRecord: Tournament;
    eventType: EventTypeUnion;
    asDynamic?: boolean;
    ratingType: string;
}): ResultType & {
    valid?: boolean;
};

type ScheduleProfileGridArgs = {
    tournamentRecords: TournamentRecords;
    matchUpDailyLimits?: {
        [key: string]: number;
    };
    scheduleCompletedMatchUps?: boolean;
    clearScheduleDates?: boolean;
    minCourtGridRows?: number;
    scheduleDates?: string[];
    courtIds?: string[];
};
declare function scheduleProfileGrid(params: ScheduleProfileGridArgs): (ResultType & {
    valid?: boolean;
}) | {
    schedulingProfile?: any;
    modifications?: number;
    error?: ErrorType;
    issues?: string[];
} | {
    error: {
        message: string;
        code: string;
    };
} | {
    scheduledMatchUpIds: Record<string, string[]>;
    notScheduledMatchUpIds: Record<string, string[]>;
    overLimitMatchUpIds: Record<string, string[]>;
    scheduledDates: string[];
    success: boolean;
    error?: undefined;
};

type SeedWithdrawalCascadeArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    structureId?: string;
    drawPosition: number;
    event?: Event$1;
};
declare function seedWithdrawalCascade({ tournamentRecord, drawDefinition, structureId, drawPosition, event, }: SeedWithdrawalCascadeArgs): ResultType & {
    vacatedDrawPosition?: number;
};

type SetParticipantScaleItemArgs = {
    tournamentRecord: Tournament;
    removePriorValues?: boolean;
    participantId: string;
    scaleItem?: ScaleItem;
};
declare function setParticipantScaleItem(params: SetParticipantScaleItemArgs): any;
type SetParticipantScaleItemsArgs = {
    scaleItemsWithParticipantIds: {
        scaleItems: ScaleItem[];
        participantId: string;
    }[];
    context?: {
        [key: string]: any;
    };
    tournamentRecord: Tournament;
    removePriorValues?: boolean;
    auditData?: any;
};
declare function setParticipantScaleItems(params: SetParticipantScaleItemsArgs): any;

declare function substituteParticipant(params: any): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type ValidateCertificationArgs = {
    officialRecord: OfficialRecord;
    certificationId: string;
    asOfDate?: string;
};
declare function validateCertification({ officialRecord, certificationId, asOfDate, }: ValidateCertificationArgs): {
    error?: any;
    success?: boolean;
    valid?: boolean;
    certification?: OfficialCertification;
    reasons?: string[];
};

declare function addPlayoffStructures(params: any): ResultType & {
    addedStructureIds?: string[];
};

type AssignMatchUpCourtArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    removePriorValues?: boolean;
    disableNotice?: boolean;
    courtDayDate: string;
    matchUpId: string;
    courtId: string;
};
declare function assignMatchUpCourt({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, courtDayDate, matchUpId, courtId, }: AssignMatchUpCourtArgs): {
    error?: ErrorType;
    success?: boolean;
};

type AssignMatchUpVenueArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    removePriorValues?: boolean;
    disableNotice?: boolean;
    matchUpId: string;
    venueId?: string;
};
declare function assignMatchUpVenue({ removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, matchUpId, venueId, }: AssignMatchUpVenueArgs): ResultType | {
    success?: boolean;
    venue?: Venue;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

type AutomatedPositioningArgs = {
    inContextDrawMatchUps?: HydratedMatchUp[];
    participants?: HydratedParticipant[];
    appliedPolicies?: PolicyDefinitions;
    provisionalPositioning?: boolean;
    seedingProfile?: SeedingProfile;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    multipleStructures?: boolean;
    applyPositioning?: boolean;
    matchUpsMap?: MatchUpsMap;
    placementGroup?: number;
    random?: () => number;
    placeByes?: boolean;
    structureId: string;
    seedsOnly?: boolean;
    seedLimit?: number;
    drawType?: string;
    drawSize?: number;
    event?: Event$1;
};
declare function automatedPositioning(params: AutomatedPositioningArgs): ResultType & {
    positionAssignments?: PositionAssignment[];
    positioningReport?: {
        [key: string]: any;
    }[];
    success?: boolean;
    conflicts?: any[];
};

type CleanExpiredArgs = {
    tournamentRecord: Tournament;
};
declare function cleanExpiredMutationLocks(params: CleanExpiredArgs): {
    success?: boolean;
    error?: ErrorType;
    removedCount?: number;
};

type GetOfficialCertificationsArgs = {
    officialRecord: OfficialRecord;
    certificationFamily?: string;
    certificationLevel?: string;
    organisationId?: string;
    activeOnly?: boolean;
};
declare function getOfficialCertifications({ officialRecord, certificationFamily, certificationLevel, organisationId, activeOnly, }: GetOfficialCertificationsArgs): {
    error?: any;
    success?: boolean;
    certifications?: OfficialCertification[];
};

type GetMembershipArgs = {
    tournamentRecord: Tournament;
    participantId: string;
};
declare function getParticipantMembership({ tournamentRecord, participantId, }: GetMembershipArgs): ResultType | {
    [key: string]: string[];
};

type GetPersonRequestsArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    requestType?: string;
};
declare function getPersonRequests(params: GetPersonRequestsArgs): {
    personRequests?: PersonRequests;
    error?: ErrorType;
};

interface GetRandomQualifierListParams {
    drawDefinition: DrawDefinition;
    random?: () => number;
}
declare const getRandomQualifierList: ({ drawDefinition, random }: GetRandomQualifierListParams) => any[] | ResultType;

type GetStructureSeedAssignmentsArgs = {
    provisionalPositioning?: boolean;
    drawDefinition?: DrawDefinition;
    returnAllProxies?: boolean;
    structure?: Structure;
    structureId?: string;
};
declare function getStructureSeedAssignments({ provisionalPositioning, returnAllProxies, drawDefinition, structureId, structure, }: GetStructureSeedAssignmentsArgs): {
    seedAssignments?: SeedAssignment[];
    stageSequence?: number;
    stage?: StageTypeUnion;
    seedLimit?: number;
    error?: ErrorType;
};

declare function isAggregateFormat(parsed: any): boolean;

type LuckyDrawAdvancementArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    participantId?: string;
    participantIds?: string[];
    structureId?: string;
    random?: () => number;
    roundNumber: number;
    event?: Event$1;
};
declare function luckyDrawAdvancement({ tournamentRecord, drawDefinition, participantId, participantIds, structureId, roundNumber, random, event, }: LuckyDrawAdvancementArgs): ResultType;

type ModifyCollectionDefinitionArgs = {
    updateInProgressMatchUps?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    collectionOrder?: number;
    collectionName?: string;
    tieFormatName?: string;
    matchUpFormat?: string;
    matchUpType?: EventTypeUnion;
    matchUpCount?: number;
    gender?: GenderUnion;
    collectionId: string;
    structureId?: string;
    category?: Category;
    matchUpId?: string;
    eventId?: string;
    event?: Event$1;
    collectionValueProfiles?: CollectionValueProfile[];
    collectionValue?: number;
    matchUpValue?: number;
    scoreValue?: number;
    setValue?: number;
};
declare function modifyCollectionDefinition({ updateInProgressMatchUps, tournamentRecord, collectionOrder, collectionName, tieFormatName, drawDefinition, matchUpFormat, matchUpCount, collectionId, matchUpType, structureId, matchUpId, category, eventId, gender, event, collectionValueProfiles, collectionValue, matchUpValue, scoreValue, setValue, }: ModifyCollectionDefinitionArgs): ResultType & {
    tieFormat?: TieFormat;
    modifications?: any[];
};

type ModifyDrawArgs = {
    drawUpdates: {
        drawName: string;
        policyDefinitions: PolicyDefinitions;
    };
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    drawId: string;
    event: Event$1;
};
declare function modifyDrawDefinition({ tournamentRecord, drawDefinition, drawUpdates, drawId, event, }: ModifyDrawArgs): ResultType;

declare function modifyPairAssignment(params: any): any;

declare function modifyPenalty(params: any): {
    modifications?: any;
    error?: ErrorType;
    success?: boolean;
    penalty?: Penalty;
} | {
    error: {
        message: string;
        code: string;
    };
};

type OrderCollectionDefinitionsArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    structureId?: string;
    matchUpId?: string;
    matchUp?: MatchUp$1;
    eventId?: string;
    orderMap: any;
    event?: Event$1;
};
declare function orderCollectionDefinitions({ tournamentRecord, drawDefinition, structureId, matchUpId, orderMap, eventId, matchUp, event, }: OrderCollectionDefinitionsArgs): ResultType | {
    matchUp?: HydratedMatchUp;
    structure?: Structure;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

type ParticiapntScheduledMatchUps = {
    scheduleAttributes?: string[];
    matchUps?: HydratedMatchUp[];
};
declare function participantScheduledMatchUps({ scheduleAttributes, matchUps, }: ParticiapntScheduledMatchUps): {
    error: {
        message: string;
        code: string;
    };
} | {
    scheduledMatchUps: {};
    success: boolean;
    error?: undefined;
};

type RemoveCollectionDefinitionArgs = {
    updateInProgressMatchUps?: boolean;
    tieFormatComparison?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    tieFormatName?: string;
    collectionId: string;
    structureId?: string;
    matchUpId?: string;
    matchUp?: MatchUp$1;
    eventId?: string;
    event?: Event$1;
};
declare function removeCollectionDefinition({ updateInProgressMatchUps, tieFormatComparison, tournamentRecord, drawDefinition, tieFormatName, collectionId, structureId, matchUpId, eventId, matchUp, event, }: RemoveCollectionDefinitionArgs): {
    targetMatchUps?: MatchUp$1[];
    deletedMatchUpIds?: string[];
    tieFormat?: TieFormat;
    success?: boolean;
    error?: ErrorType;
};

type RemoveOfficialAssignmentArgs = {
    officialRecord: OfficialRecord;
    assignmentId: string;
};
declare function removeOfficialAssignment({ officialRecord, assignmentId }: RemoveOfficialAssignmentArgs): any;

declare function removePenalty(params: any): {
    error?: ErrorType;
    success?: boolean;
    penalty?: Penalty;
} | {
    error: {
        message: string;
        code: string;
    };
};

type ResetMatchUpLineUps = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    inheritance?: boolean;
    matchUpId: string;
    event?: Event$1;
};
declare function resetMatchUpLineUps({ inheritance, tournamentRecord, drawDefinition, matchUpId, event, }: ResetMatchUpLineUps): {
    error: {
        message: string;
        code: string;
    };
} | {
    modificationsCount: number;
    success: boolean;
    error?: undefined;
};

type SetMatchUpCalledAtArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    disableNotice?: boolean;
    calledAt?: string | null;
    matchUpId: string;
    event?: Event$1;
};
declare function setMatchUpCalledAt(params: SetMatchUpCalledAtArgs): ResultType;

type UpdateTieMatchUpScoreArgs = {
    tournamentRecords?: TournamentRecords;
    appliedPolicies?: PolicyDefinitions;
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    exitWhenNoValues?: boolean;
    matchUpsMap?: MatchUpsMap;
    matchUpStatus?: string;
    tournamentId?: string;
    removeScore?: boolean;
    matchUpId: string;
    event?: Event$1;
};
declare function updateTieMatchUpScore(params: UpdateTieMatchUpScoreArgs): {
    removeWinningSide?: boolean;
    tieFormatRemoved?: boolean;
    winningSide?: number;
    error?: ErrorType;
    success?: boolean;
    score?: any;
};

type ApplyTournamentRankingPointsArgs = {
    tournamentRecord: Tournament;
    policyDefinitions?: PolicyDefinitions;
    participantFilters?: ParticipantFilters;
    scaleName?: string;
    level?: number;
    removePriorValues?: boolean;
};
declare function applyTournamentRankingPoints({ tournamentRecord, policyDefinitions, participantFilters, scaleName, level, removePriorValues, }: ApplyTournamentRankingPointsArgs): any;

type CompetitionScheduleMatchUpsArgs = {
    tournamentRecords: TournamentRecords;
    policyDefinitions?: PolicyDefinitions;
    courtCompletedMatchUps?: boolean;
    alwaysReturnCompleted?: boolean;
    contextFilters?: MatchUpFilters;
    matchUpFilters?: MatchUpFilters;
    hydrateParticipants?: boolean;
    withCourtGridRows?: boolean;
    activeTournamentId?: string;
    sortDateMatchUps?: boolean;
    minCourtGridRows?: number;
    usePublishState?: boolean;
    sortCourtsData?: boolean;
    nextMatchUps?: boolean;
    status?: string;
};
declare function competitionScheduleMatchUps(params: CompetitionScheduleMatchUpsArgs): {
    mappedParticipants?: {
        [key: string]: HydratedParticipant;
    };
    completedMatchUps?: HydratedMatchUp[];
    dateMatchUps?: HydratedMatchUp[];
    courtPrefix?: string;
    error?: ErrorType;
    venues?: Venue[];
    courtsData?: any;
    rows?: any[];
};

type CreateGroupParticipantType = {
    participantRoleResponsibilities?: string[];
    individualParticipantIds: string[];
    tournamentRecord: Tournament;
    participantRole?: string;
    participantId: string;
    groupName: string;
};
declare function createGroupParticipant({ individualParticipantIds, participantRoleResponsibilities, participantRole, tournamentRecord, participantId, groupName, }: CreateGroupParticipantType): {
    participant?: Participant$1;
    participantId?: string;
    success?: boolean;
    error?: ErrorType;
    info?: any;
};

type GetCompetitionPenaltiesArgs = {
    tournamentRecords: TournamentRecords;
};
declare function getCompetitionPenalties({ tournamentRecords }: GetCompetitionPenaltiesArgs): {
    error: {
        message: string;
        code: string;
    };
    penalties?: undefined;
} | {
    penalties: Penalty[];
    error?: undefined;
};

type GetMatchUpCompetitivenessArgs = {
    tournamentRecord?: Tournament;
    profileBands?: any;
    matchUp: MatchUp$1;
};
declare function getMatchUpCompetitiveProfile({ tournamentRecord, profileBands, matchUp, }: GetMatchUpCompetitivenessArgs): {
    competitiveness?: any;
    pctSpread?: number;
    success?: boolean;
    error?: ErrorType;
};

type GetParticipantSchedulesArgs = {
    tournamentRecord: Tournament;
    participantFilters?: any;
};
declare function getParticipantSchedules({ participantFilters, tournamentRecord }: GetParticipantSchedulesArgs): {
    error: {
        message: string;
        code: string;
    };
    context?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    context: {
        participantFilters: any;
    };
} | {
    success: boolean;
    participantSchedules: any[];
    error?: undefined;
    context?: undefined;
};

type GetPositionsPlayedOff = {
    drawDefinition: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
    structureIds?: string[];
};
declare function getPositionsPlayedOff({ drawDefinition, structureIds, matchUpsMap }: GetPositionsPlayedOff): {
    error: {
        message: string;
        code: string;
    };
    context: {
        structureIds: never;
    };
    positionsNotPlayedOff?: undefined;
    positionsPlayedOff?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    context?: undefined;
    positionsNotPlayedOff?: undefined;
    positionsPlayedOff?: undefined;
} | {
    positionsNotPlayedOff: any[];
    positionsPlayedOff: any[];
    error?: undefined;
    context?: undefined;
};

type GetProfileRoundsArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord?: Tournament;
    schedulingProfile?: any;
    withRoundId?: boolean;
};
declare function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentRecord, withRoundId, }: GetProfileRoundsArgs): {
    segmentedRounds?: {
        [key: string]: any;
    };
    profileRounds?: any[];
    error?: ErrorType;
};

type MigrationCounts = {
    tournament: number;
    events: number;
    entries: number;
    drawDefinitions: number;
    structures: number;
    positionAssignments: number;
    matchUps: number;
    matchUpScheduleTimeItems: number;
    venues: number;
    courts: number;
};
type MigrationResult = ResultType & {
    promoted?: MigrationCounts;
    totalPromoted?: number;
};
type MigrateTournamentRecordArgs = {
    tournamentRecord: Tournament;
    clearLegacy?: boolean;
};
declare function migrateTournamentRecord({ tournamentRecord, clearLegacy, }: MigrateTournamentRecordArgs): MigrationResult;

declare function pruneDrawDefinition({ matchPlayDrawPositions, tournamentRecord, drawDefinition, drawId, }: {
    matchPlayDrawPositions?: boolean | undefined;
    tournamentRecord: any;
    drawDefinition: any;
    drawId: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    matchUps: MatchUp$1[];
    success: boolean;
    error?: undefined;
};

type RemovePracticeRegistrationArgs = {
    tournamentRecord: Tournament;
    courtId: string;
    date: string;
    bookingId: string;
    registrationId: string;
    disableNotice?: boolean;
};
declare function removePracticeRegistration(params: RemovePracticeRegistrationArgs): ResultType;

declare function resetDrawDefinition({ tournamentRecord, removeScheduling, removeAssignments, drawDefinition }: {
    tournamentRecord: any;
    removeScheduling: any;
    removeAssignments: any;
    drawDefinition: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

declare function setDelegatedOutcome(params: any): {
    success?: boolean;
    error?: ErrorType;
} | {
    matchUp?: HydratedMatchUp;
    structure?: Structure;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};

type SetPracticeDefaultCapacityArgs = {
    tournamentRecord: Tournament;
    defaultCapacity: number | null;
    disableNotice?: boolean;
};
declare function setPracticeDefaultCapacity({ tournamentRecord, defaultCapacity, disableNotice, }: SetPracticeDefaultCapacityArgs): ResultType;

declare function swapDrawPositionAssignments({ tournamentRecord, drawDefinition, drawPositions, structureId, event }: {
    tournamentRecord: any;
    drawDefinition: any;
    drawPositions: any;
    structureId: any;
    event: any;
}): any;

type MatchUpConflict = {
    matchUpId: string;
    scheduledDate?: string;
    scheduledTime?: string;
};
type PracticeConflict = {
    bookingId?: string;
    courtId: string;
    date: string;
    registrationId: string;
    startTime: string;
    endTime: string;
};
type ConflictReport = {
    matchUps: MatchUpConflict[];
    practiceRegistrations: PracticeConflict[];
};

type Updates = {
    startTime?: string;
    endTime?: string;
    notes?: string;
    status?: PracticeRegistrationStatus;
};
type UpdatePracticeRegistrationArgs = {
    tournamentRecord: Tournament;
    courtId: string;
    date: string;
    bookingId: string;
    registrationId: string;
    updates: Updates;
    disableNotice?: boolean;
};
type UpdatePracticeRegistrationResult = ResultType & {
    registration?: PracticeRegistration;
    conflicts?: ConflictReport;
};
declare function updatePracticeRegistration(params: UpdatePracticeRegistrationArgs): UpdatePracticeRegistrationResult;

type AssignDrawPositionArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    participantId?: string;
    drawPosition?: number;
    structureId?: string;
    qualifier?: boolean;
    event?: Event$1;
    bye?: boolean;
};
declare function assignDrawPosition({ tournamentRecord, drawDefinition, participantId, drawPosition, structureId, qualifier, event, bye, }: AssignDrawPositionArgs): ResultType;

type AttachPoliciesArgs = {
    tournamentRecords?: TournamentRecords;
    policyDefinitions: PolicyDefinitions;
    drawDefinition?: DrawDefinition;
    tournamentRecord?: Tournament;
    allowReplacement?: boolean;
    tournamentId?: string;
    event?: Event$1;
};
declare function attachPolicies(params: AttachPoliciesArgs): ResultType & {
    applied?: string[];
};

type GenerateTournamentRecordArgs = {
    participants?: Participant$1[];
    participantsProfile?: ParticipantsProfile;
    scheduleCompletedMatchUps?: boolean;
    tournamentExtensions?: Extension[];
    policyDefinitions?: PolicyDefinitions;
    completeAllMatchUps?: boolean;
    tournamentAttributes?: any;
    ratingsParameters?: any;
    tournamentName?: string;
    schedulingProfile?: any;
    random?: () => number;
    autoSchedule?: boolean;
    leagueProfiles?: any[];
    eventProfiles?: any[];
    venueProfiles?: any[];
    drawProfiles?: any[];
    startDate?: string;
    endDate?: string;
    isMock?: boolean;
    uuids?: string[];
};
declare function generateTournamentRecord(params: GenerateTournamentRecordArgs): any;

declare function getCompetitionDateRange({ tournamentRecords }: {
    tournamentRecords: TournamentRecords;
}): {
    startDate?: string;
    endDate?: string;
    error?: ErrorType;
};

type GetParticipantScaleItemArgs = {
    tournamentRecords?: TournamentRecords;
    scaleAttributes: ScaleAttributes;
    tournamentRecord?: Tournament;
    participantId: string;
};
declare function getParticipantScaleItem(params: GetParticipantScaleItemArgs): {
    tournamentId?: string;
    scaleItem?: ScaleItem;
    error?: ErrorType;
};

type SwissChartNode = {
    wins: number;
    losses: number;
    draws: number;
    participantIds: string[];
};
type SwissChartRound = {
    roundNumber: number;
    nodes: SwissChartNode[];
};
type GetSwissChartArgs = {
    drawDefinition: DrawDefinition;
    structureId?: string;
};
type GetSwissChartResult = {
    rounds?: SwissChartRound[];
    totalRounds?: number;
    error?: ErrorType;
    success?: boolean;
};
declare function getSwissChart({ drawDefinition, structureId }: GetSwissChartArgs): GetSwissChartResult;

type GetTournamentPenaltiesArgs = {
    tournamentRecord: Tournament;
};
declare function getTournamentPenalties({ tournamentRecord }: GetTournamentPenaltiesArgs): {
    error?: ErrorType;
    penalties?: Penalty[];
};

declare function isValidForQualifying({ structureId, drawDefinition }: {
    structureId: any;
    drawDefinition: any;
}): any;

declare function modifyParticipantName({ tournamentRecord, participantName, participantId }: {
    tournamentRecord: any;
    participantName: any;
    participantId: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
};

declare function removeStageEntries({ drawDefinition, entryStage }: {
    drawDefinition: any;
    entryStage: string;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type AddCollectionDefinitionArgs = {
    collectionDefinition: CollectionDefinition;
    policyDefinitions?: PolicyDefinitions;
    updateInProgressMatchUps?: boolean;
    referenceGender?: GenderUnion;
    drawDefinition: DrawDefinition;
    referenceCategory?: Category;
    tournamentRecord: Tournament;
    enforceCategory?: boolean;
    enforceGender?: boolean;
    tieFormatName?: string;
    structureId?: string;
    matchUpId?: string;
    matchUp?: MatchUp$1;
    eventId?: string;
    uuids?: string[];
    event?: Event$1;
};
declare function addCollectionDefinition({ updateInProgressMatchUps, collectionDefinition, referenceCategory, tournamentRecord, policyDefinitions, enforceCategory, referenceGender, drawDefinition, tieFormatName, enforceGender, structureId, matchUpId, matchUp, eventId, uuids, event, }: AddCollectionDefinitionArgs): ResultType & {
    tieFormat?: TieFormat;
    targetMatchUps?: any;
    addedMatchUps?: any;
};

type AddDrawDefinitionArgs = {
    flight?: {
        flightNumber: number;
    };
    suppressNotifications?: boolean;
    tournamentRecord?: Tournament;
    modifyEventEntries?: boolean;
    drawDefinition: DrawDefinition;
    existingDrawCount?: number;
    allowReplacement?: boolean;
    checkEntryStatus?: boolean;
    tournamentId?: string;
    event: Event$1;
};
declare function addDrawDefinition(params: AddDrawDefinitionArgs): ResultType & {
    modifiedEventEntryStatusCount?: number;
};

type AddPenaltyArgs = {
    refereeParticipantId?: string;
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    penaltyType: PenaltyTypeUnion;
    participantIds: string[];
    extensions?: Extension[];
    penaltyCode: string;
    penaltyId?: string;
    matchUpId?: string;
    issuedAt?: string;
    notes?: string;
};
declare function addPenalty(params: AddPenaltyArgs): ResultType & {
    penaltyId?: string;
};

type CompetitionMatchUpsArgs$1 = {
    scheduleVisibilityFilters?: ScheduleVisibilityFilters;
    participantsProfile?: ParticipantsProfile;
    tournamentRecords: TournamentRecords;
    policyDefinitions?: PolicyDefinitions;
    matchUpFilters?: MatchUpFilters;
    contextFilters?: MatchUpFilters;
    afterRecoveryTimes?: boolean;
    usePublishState?: boolean;
    nextMatchUps?: boolean;
    inContext?: boolean;
};
declare function allCompetitionMatchUps({ scheduleVisibilityFilters, afterRecoveryTimes, participantsProfile, tournamentRecords, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs$1): {
    matchUps?: HydratedMatchUp[];
    error?: ErrorType;
};

type BuildDrawHierarchyArgs = {
    matchUpType?: string;
    matchUps: any[];
};
declare function buildDrawHierarchy({ matchUps, matchUpType }: BuildDrawHierarchyArgs): any;

declare function getCheckedInParticipantIds({ matchUp }: {
    matchUp: HydratedMatchUp;
}): ResultType & {
    allRelevantParticipantIds?: string[];
    allParticipantsCheckedIn?: boolean;
    checkedInParticipantIds?: string[];
};

type GetDraftStateArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
};
declare function getDraftState({ drawDefinition }: GetDraftStateArgs): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
    draftState?: undefined;
    summary?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
    draftState?: undefined;
    summary?: undefined;
} | {
    draftState: any;
    summary: {
        status: any;
        totalParticipants: any;
        preferencesSubmitted: number;
        preferencesOutstanding: number;
        tiersTotal: any;
        tiersResolved: any;
        unassignedDrawPositions: any;
        preferencesCount: any;
    };
    error?: undefined;
    info?: undefined;
};

declare function getLinkedTournamentIds({ tournamentRecords, }: {
    tournamentRecords: TournamentRecords;
}): ResultType & {
    linkedTournamentIds?: string[];
};

type GetOfficialAssignmentsArgs = {
    officialRecord: OfficialRecord;
    tournamentId?: string;
    roleSubtype?: string;
    status?: AssignmentStatus;
};
declare function getOfficialAssignments({ officialRecord, tournamentId, roleSubtype, status, }: GetOfficialAssignmentsArgs): {
    error?: any;
    success?: boolean;
    assignments?: OfficialAssignment[];
};

type GetOfficialEligibilityArgs = {
    officialRecord: OfficialRecord;
    certificationFamily: string;
    certificationLevel?: string;
    organisationId?: string;
    asOfDate?: string;
};
declare function getOfficialEligibility({ officialRecord, certificationFamily, certificationLevel, organisationId, asOfDate, }: GetOfficialEligibilityArgs): {
    error?: any;
    success?: boolean;
    eligible?: boolean;
    reasons?: string[];
};

declare function getRegistrationProfile(params?: {
    tournamentRecord: Tournament;
}): {
    registrationProfile?: RegistrationProfile;
    error?: any;
};

type ScheduledRoundDetail = {
    published?: boolean;
    embargo?: string;
};
type PublishingDetail = {
    scheduledRounds?: {
        [roundNumber: number]: ScheduledRoundDetail;
    };
    roundLimit?: number;
    published?: boolean;
    embargo?: string;
};
type DrawPublishingDetails = {
    structureDetails?: {
        [key: string]: PublishingDetail;
    };
    stageDetails?: {
        [key: string]: PublishingDetail;
    };
    publishingDetail: PublishingDetail;
    structureIdsToRemove?: string[];
    structureIdsToAdd?: string[];
    stagesToRemove?: string[];
    stagesToAdd?: string[];
};
type PublishEventType = {
    includePositionAssignments?: boolean;
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    removePriorValues?: boolean;
    returnEventData?: boolean;
    eventDataParams?: any;
    drawIds?: string[];
    status?: string;
    event?: Event$1;
    drawDetails?: {
        [key: string]: DrawPublishingDetails;
    };
    drawIdsToRemove?: string[];
    drawIdsToAdd?: string[];
};
declare function publishEvent(params: PublishEventType): ResultType & {
    eventData?: any;
};

interface RoundVisibility {
    hidden?: boolean;
    embargoed?: boolean;
}
declare function getRoundVisibilityState(structureDetail?: PublishingDetail, matchUps?: {
    roundNumber?: number;
}[]): Record<number, RoundVisibility> | undefined;

declare function removeDrawEntries({ autoEntryPositions, participantIds, drawDefinition, drawId, stages, event, }: {
    autoEntryPositions?: boolean | undefined;
    participantIds: any;
    drawDefinition: any;
    drawId: any;
    stages: any;
    event: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

declare function reverseScore(params?: any): {
    reversedScore?: any;
    success?: boolean;
    error?: ErrorType;
};

type ScaledTeamAssignmentArgs = {
    individualParticipantIds?: string[];
    clearExistingAssignments?: boolean;
    reverseAssignmentOrder?: boolean;
    teamParticipantIds?: string[];
    tournamentRecord: Tournament;
    scaledParticipants?: any[];
    initialTeamIndex?: number;
    scaleAttributes?: any;
    teamNameBase?: string;
    teamsCount?: number;
    eventId?: string;
    event?: Event$1;
};
declare function scaledTeamAssignment({ clearExistingAssignments, individualParticipantIds, reverseAssignmentOrder, initialTeamIndex, scaledParticipants, teamParticipantIds, tournamentRecord, scaleAttributes, teamNameBase, teamsCount, eventId, event, }: ScaledTeamAssignmentArgs): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    error: {
        message: string;
        code: string;
    };
    teamParticipantIds?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    participant: any;
} | {
    error: {
        message: string;
        code: string;
    };
    participant?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    scaledParticipant: any;
} | {
    scaledParticipants: any[];
    success: boolean;
    error?: undefined;
    scaledParticipant?: undefined;
};

interface MatchUp {
    matchUpId: string;
    matchUpFormat: string;
    matchUpStatus: MatchUpStatus;
    matchUpType: MatchUpType;
    sides: Side[];
    score: Score;
    winningSide?: number;
    startTime?: string;
    endTime?: string;
    schedule?: Schedule;
    collectionPosition?: number;
    roundNumber?: number;
    roundPosition?: number;
    createdAt?: string;
    updatedAt?: string;
    serverFlip?: boolean;
    history?: MatchUpHistory;
}
interface Side {
    sideNumber: number;
    participantId?: string;
    participant?: Participant;
    lineUp?: TeamCompetitor[];
}
interface Participant {
    participantId: string;
    participantName?: string;
    participantType: ParticipantType;
    participantRole: ParticipantRole;
    participantStatus?: ParticipantStatus;
    person?: Person;
    individualParticipants?: Participant[];
}
interface Person {
    personId?: string;
    standardGivenName?: string;
    standardFamilyName?: string;
    nationalityCode?: string;
    sex?: 'MALE' | 'FEMALE' | 'OTHER';
}
interface TeamCompetitor {
    participantId: string;
    collectionAssignments?: CollectionAssignment[];
}
interface CollectionAssignment {
    collectionId: string;
    collectionPosition?: number;
    previousParticipantId?: string;
    substitutionOrder?: number;
}
interface SubstitutionEvent {
    sideNumber: 1 | 2;
    outParticipantId: string;
    inParticipantId: string;
    beforePointIndex: number;
    timestamp?: string;
}
interface Score {
    sets: SetScore[];
    scoreStringSide1?: string;
    scoreStringSide2?: string;
}
interface SetScore {
    setNumber: number;
    side1Score?: number;
    side2Score?: number;
    side1TiebreakScore?: number;
    side2TiebreakScore?: number;
    side1GameScores?: number[];
    side2GameScores?: number[];
    winningSide?: number;
    setFormat?: string;
    hardBoundaries?: number[];
    currentStreak?: {
        side: 0 | 1;
        count: number;
    };
    isTiebreakOnly?: boolean;
    isTimed?: boolean;
}
interface Schedule {
    scheduledTime?: string;
    scheduledDate?: string;
    venueId?: string;
    courtId?: string;
}
interface MatchUpHistory {
    points: Point[];
    states?: MatchUpState[];
    entries?: ScoreEntry[];
    substitutions?: SubstitutionEvent[];
}
interface ScoreEntry {
    type: 'point' | 'game' | 'set' | 'endSegment' | 'setInitialScore' | 'substitution' | 'setServer';
    data: any;
    timestamp: string;
    pointIndex?: number;
}
interface Point {
    pointNumber: number;
    winner: 0 | 1;
    winningSide?: 1 | 2;
    server?: 0 | 1;
    serverSideNumber?: 1 | 2;
    serverParticipantId?: string;
    timestamp?: string;
    rallyLength?: number;
    score?: string;
    result?: PointResult;
    stroke?: StrokeType;
    hand?: 'Forehand' | 'Backhand';
    serve?: 1 | 2;
    serveLocation?: ServeLocation;
    rally?: RallyShot[];
    location?: string;
    breakpoint?: boolean;
    code?: string;
    pointsToGame?: [number, number];
    pointsToSet?: [number, number];
    pointsToMatch?: [number, number];
    gamesToSet?: [number, number];
    serveSide?: 'deuce' | 'ad';
    isBreakpoint?: boolean;
    scoreValue?: number;
    activePlayers?: [string, string] | [string[], string[]];
    wrongSide?: boolean;
    wrongServer?: boolean;
    penaltyPoint?: boolean;
    penaltyType?: string;
    hardBoundary?: boolean;
}
type PointResult = 'Ace' | 'Winner' | 'Serve Winner' | 'Forced Error' | 'Unforced Error' | 'Double Fault' | 'Penalty' | 'Unknown';
type StrokeType = 'Forehand' | 'Backhand' | 'Forehand Slice' | 'Backhand Slice' | 'Forehand Volley' | 'Backhand Volley' | 'Overhead Smash' | 'Backhand Overhead Smash' | 'Forehand Drop Shot' | 'Backhand Drop Shot' | 'Forehand Lob' | 'Backhand Lob' | 'Forehand Half-volley' | 'Backhand Half-volley' | 'Forehand Drive Volley' | 'Backhand Drive Volley' | 'Trick Shot' | 'Unknown Shot';
type ServeLocation = 'Wide' | 'Body' | 'T';
interface RallyShot {
    shotNumber: number;
    player: 0 | 1;
    stroke: StrokeType;
    direction?: 1 | 2 | 3;
    depth?: 'shallow' | 'deep' | 'very deep';
    position?: 'baseline' | 'net' | 'approach';
    code?: string;
}
interface MatchUpState {
    score: Score;
    matchUpStatus: MatchUpStatus;
    winningSide?: number;
}
type MatchUpStatus = 'TO_BE_PLAYED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED' | 'ABANDONED' | 'DEFAULTED' | 'RETIRED' | 'WALKOVER';
type MatchUpType = 'SINGLES' | 'DOUBLES' | 'TEAM';
type ParticipantType = 'INDIVIDUAL' | 'PAIR' | 'TEAM';
type ParticipantRole = 'COMPETITOR' | 'ALTERNATE' | 'SEED';
type ParticipantStatus = 'ACTIVE' | 'INACTIVE' | 'WITHDRAWN';
interface CreateMatchUpOptions {
    matchUpId?: string;
    matchUpFormat: string;
    participants?: Participant[];
    isDoubles?: boolean;
    matchUpType?: MatchUpType;
}
interface AddPointOptions {
    winner?: 0 | 1;
    server?: 0 | 1;
    winningSide?: 1 | 2;
    serverSideNumber?: 1 | 2;
    serverParticipantId?: string;
    scoreValue?: number;
    timestamp?: string;
    rallyLength?: number;
    result?: PointResult;
    penaltyType?: string;
    wrongSide?: boolean;
    wrongServer?: boolean;
    penaltyPoint?: boolean;
}
interface GetScoreboardOptions {
    perspective?: number;
}
interface ValidationResult {
    isValid: boolean;
    errors: string[];
    warnings?: string[];
}
interface FormatStructure {
    bestOf?: number;
    exactly?: number;
    aggregate?: boolean;
    matchRoot?: string;
    matchMods?: string[];
    setFormat?: SetFormatStructure;
    finalSetFormat?: SetFormatStructure;
    gameFormat?: GameFormatStructure;
    matchUpConstraint?: MatchUpConstraintStructure;
    simplified?: boolean;
}
interface MatchUpConstraintStructure {
    timed?: boolean;
    minutes?: number;
}
interface SetFormatStructure {
    setTo?: number;
    tiebreakAt?: number | string;
    tiebreakFormat?: TiebreakFormatStructure;
    noTiebreak?: boolean;
    NoAD?: boolean;
    winBy?: number;
    tiebreakSet?: TiebreakFormatStructure;
    timed?: boolean;
    minutes?: number;
    based?: string;
    modifier?: string;
    outs?: number;
    gameFormat?: GameFormatStructure;
}
interface TiebreakFormatStructure {
    tiebreakTo?: number;
    modifier?: string;
    NoAD?: boolean;
}
interface GameFormatStructure {
    type?: 'CONSECUTIVE' | 'TRADITIONAL';
    count?: number;
    deuceAfter?: number;
    NoAD?: boolean;
}
interface EndSegmentOptions {
    setNumber?: number;
    timestamp?: string;
    reason?: 'time' | 'mercy' | 'manual';
}
interface InitialScoreOptions {
    sets: Array<{
        side1Score: number;
        side2Score: number;
        side1TiebreakScore?: number;
        side2TiebreakScore?: number;
        winningSide?: number;
    }>;
    currentSetScore?: {
        side1Score: number;
        side2Score: number;
    };
    currentGameScore?: {
        side1Points: number;
        side2Points: number;
    };
    server?: 0 | 1;
}
interface AddSetOptions {
    side1Score: number;
    side2Score: number;
    side1TiebreakScore?: number;
    side2TiebreakScore?: number;
    winningSide?: 1 | 2;
    timestamp?: string;
}
interface AddGameOptions {
    winner: 0 | 1;
    tiebreakScore?: [number, number];
    timestamp?: string;
}
interface PointSituation {
    isBreakPoint: boolean;
    isGamePoint: boolean;
    isSetPoint: boolean;
    isMatchPoint: boolean;
    isGoldenPoint: boolean;
    isTiebreak: boolean;
    server?: 0 | 1;
}
interface ScoreResult {
    sets: SetScore[];
    scoreString: string;
    games?: number[];
    points?: number[];
    pointDisplay?: [string, string];
    situation?: PointSituation;
}
interface Statistics {
    totalPoints: number;
    pointsWon: number[];
    gamesWon: number[];
    setsWon: number[];
    aces?: number[];
    doubleFaults?: number[];
    breakPoints?: number[];
}
interface EpisodePoint {
    index: number;
    number: number;
    winner: 0 | 1;
    server?: 0 | 1;
    score?: string;
    result?: string;
}
interface EpisodeGame {
    index: number;
    isTiebreak: boolean;
    complete: boolean;
    winner?: 0 | 1;
}
interface EpisodeSet {
    index: number;
    complete: boolean;
    winner?: 0 | 1;
}
interface EpisodeNeeded {
    pointsToGame?: [number, number];
    pointsToSet?: [number, number];
    pointsToMatch?: [number, number];
    gamesToSet?: [number, number];
    isBreakpoint?: boolean;
}
interface Episode {
    action: 'addPoint';
    point: EpisodePoint;
    game: EpisodeGame;
    set: EpisodeSet;
    needed: EpisodeNeeded;
    nextService: number;
    result?: string;
    complete: boolean;
}

declare function getScoreboard(matchUp: MatchUp, options?: GetScoreboardOptions): string;

interface GetScoreOptions {
    useBracketNotation?: boolean;
}
declare function getScore(matchUp: MatchUp, options?: GetScoreOptions): ScoreResult;

interface PointWithMetadata {
    winner?: 0 | 1;
    server?: 0 | 1;
    index?: number;
    set?: number;
    game?: number;
    result?: 'Ace' | 'Winner' | 'Serve Winner' | 'Unforced Error' | 'Forced Error' | 'Double Fault' | 'Net' | 'Out' | 'Penalty';
    stroke?: 'Forehand' | 'Backhand' | 'Volley' | 'Forehand Volley' | 'Backhand Volley' | 'Overhead' | 'Smash' | 'Drop Shot' | 'Lob' | 'Slice';
    hand?: 'Forehand' | 'Backhand' | 'Right' | 'Left';
    serve?: 1 | 2;
    location?: string;
    rally?: number;
    first_serve?: {
        error: string;
        serves: string[];
    };
    breakpoint?: boolean;
    gamepoint?: boolean;
    setpoint?: boolean;
    matchpoint?: boolean;
    tiebreak?: boolean;
    code?: string;
    timestamp?: number;
    [key: string]: any;
}
interface StatCounters$1 {
    players: Record<number, Record<string, PointWithMetadata[]>>;
    teams: Record<number, Record<string, PointWithMetadata[]>>;
}
interface CalculatedStat {
    category: string;
    teams: StatTeamValue[];
}
interface StatTeamValue {
    value: number;
    display: string;
    numerators?: string[];
}
interface StatisticsOptions {
    setFilter?: number;
    playerFilter?: number;
    includeStrokeBreakdown?: boolean;
    includeRallyStats?: boolean;
}
interface MatchStatistics {
    counters: StatCounters$1;
    calculated: CalculatedStat[];
    summary?: {
        totalPoints: number;
        bySet?: number[];
        byPlayer?: number[];
    };
}
interface StatObject {
    name: string;
    numerator: [number, number];
    denominator?: [number, number];
    pct?: [number, number];
    default?: 'numerator';
}

interface PointMultiplier {
    condition: {
        results?: string[];
        strokes?: string[];
        setTypes?: string[];
    };
    value: number;
}
declare function resolvePointValue(point: Partial<Point>, multipliers: PointMultiplier[]): number;

interface TimerProfile {
    shotClockSeconds?: number;
    segmentTimers?: {
        segmentType: string;
        minutes: number;
        direction?: string;
        stoppageTime?: boolean;
    }[];
    changeoverSeconds?: number;
    setBreakSeconds?: number;
}
interface TimeoutRules {
    count: number;
    per: string;
    durationSeconds?: number;
    maxPerSide?: number;
}
interface PenaltyBoxProfile {
    durationSeconds: number;
}
interface SubstitutionRules {
    allowed: boolean;
    maxPerMatchUp?: number;
    maxPerSegment?: number;
    allowedMatchUpTypes?: string[];
    timing?: string;
    minRosterSize?: number;
    maxRosterSize?: number;
}
interface PlayerRules {
    maxMinutesPerSegment?: number;
    matchUpTypes?: string[];
}
interface PenaltyProfile {
    sport?: string;
    penaltyTypes: {
        penaltyType: string;
        label: string;
        category?: string;
    }[];
    escalation?: {
        step: number;
        consequence: string;
    }[];
}
interface PointProfile {
    sport?: string;
    pointResults: {
        result: string;
        label: string;
        isError?: boolean;
        isServe?: boolean;
    }[];
    strokeTypes?: string[];
    serveLocations?: string[];
}
type ServerRule = 'ALTERNATE_GAMES' | 'WINNER_SERVES';
interface CompetitionFormat {
    competitionFormatId?: string;
    competitionFormatName?: string;
    matchUpFormat?: string;
    sport?: string;
    timerProfile?: TimerProfile;
    timeoutRules?: TimeoutRules;
    substitutionRules?: SubstitutionRules;
    playerRules?: PlayerRules;
    penaltyProfile?: PenaltyProfile;
    penaltyBoxProfile?: PenaltyBoxProfile;
    pointProfile?: PointProfile;
    pointMultipliers?: PointMultiplier[];
    serverRule?: ServerRule;
    notes?: string;
}
interface ScoringEventContext {
    state: MatchUp;
    score: ReturnType<typeof getScore>;
}
interface ScoringEventHandlers {
    onPoint?: (context: ScoringEventContext) => void;
    onUndo?: (context: ScoringEventContext) => void;
    onRedo?: (context: ScoringEventContext) => void;
    onReset?: (context: ScoringEventContext) => void;
    onGameComplete?: (context: ScoringEventContext & {
        gameWinner: 0 | 1;
    }) => void;
    onSetComplete?: (context: ScoringEventContext & {
        setWinner: 0 | 1;
    }) => void;
    onMatchComplete?: (context: ScoringEventContext & {
        matchWinner: 0 | 1;
    }) => void;
}
interface ScoringEngineOptions {
    competitionFormat?: CompetitionFormat;
    pointMultipliers?: PointMultiplier[];
    eventHandlers?: ScoringEventHandlers;
    matchUpFormat?: string;
    isDoubles?: boolean;
    matchUpId?: string;
}
interface ScoringEngineSupplementaryState {
    initialLineUps?: Record<string, TeamCompetitor[]>;
    redoStack?: ScoreEntry[];
}
declare class ScoringEngine {
    private readonly competitionFormat?;
    private initialLineUps?;
    private pointMultipliers;
    private cachedFormatStructure?;
    private eventHandlers?;
    private initialScore?;
    private redoStack;
    private matchUpFormat;
    private matchUpId?;
    private isDoubles;
    private state;
    constructor(options?: ScoringEngineOptions);
    setState(matchUp: MatchUp): void;
    getState(): MatchUp;
    addPoint(options: AddPointOptions): void;
    addSet(options: AddSetOptions): void;
    addGame(options: AddGameOptions): void;
    endSegment(options?: EndSegmentOptions): void;
    setInitialScore(options: InitialScoreOptions): void;
    undo(count?: number): boolean;
    redo(count?: number): boolean;
    canUndo(): boolean;
    canRedo(): boolean;
    getUndoDepth(): number;
    getRedoDepth(): number;
    getScore(): ReturnType<typeof getScore>;
    getScoreboard(options?: Parameters<typeof getScoreboard>[1]): string;
    getWinner(): number | undefined;
    isComplete(): boolean;
    getPointCount(): number;
    getFormat(): string;
    getStatistics(options?: StatisticsOptions): MatchStatistics;
    getStatObjects(options?: StatisticsOptions): StatObject[];
    getNextServer(): 0 | 1;
    setServer(side: 0 | 1, options?: {
        recordEntry?: boolean;
    }): void;
    getEpisodes(): Episode[];
    isNoAd(): boolean;
    getSetsToWin(): number;
    getTiebreakAt(): number | null;
    hasFinalSetTiebreak(): boolean;
    getFormatStructure(): FormatStructure | undefined;
    getInputMode(): 'points' | 'games' | 'sets' | 'mixed' | 'none';
    setLineUp(sideNumber: 1 | 2, lineUp: TeamCompetitor[]): void;
    substitute(options: {
        sideNumber: 1 | 2;
        outParticipantId: string;
        inParticipantId: string;
        timestamp?: string;
    }): void;
    getActivePlayers(): {
        side1: string[];
        side2: string[];
    };
    private hasLineUp;
    setPointMultipliers(multipliers: PointMultiplier[]): void;
    getPointMultipliers(): PointMultiplier[];
    getSupplementaryState(): ScoringEngineSupplementaryState;
    loadSupplementaryState(state: ScoringEngineSupplementaryState): void;
    getPenaltyProfile(): PenaltyProfile | undefined;
    getPointProfile(): PointProfile | undefined;
    getTimerProfile(): TimerProfile | undefined;
    getTimeoutRules(): TimeoutRules | undefined;
    getPenaltyBoxProfile(): PenaltyBoxProfile | undefined;
    getSubstitutionRules(): SubstitutionRules | undefined;
    getPlayerRules(): PlayerRules | undefined;
    setEventHandlers(handlers: ScoringEventHandlers | undefined): void;
    getEventHandlers(): ScoringEventHandlers | undefined;
    decoratePoint(pointIndex: number, metadata: Record<string, any>): void;
    markHardBoundary(options: {
        setIndex: number;
        gameIndex: number;
    }): void;
    editPoint(pointIndex: number, newData: Partial<AddPointOptions>, options?: {
        recalculate?: boolean;
    }): void;
    removePoint(pointIndex: number, options?: {
        recalculate?: boolean;
    }): void;
    reset(): void;
    private ensureHistory;
    private buildEventContext;
    private cacheFormatStructure;
    private getInitialLineUps;
    private applyAddSet;
    private applyAddGame;
    private applySubstitution;
    private applyEndSegment;
    private checkSetCompletion;
    private checkMatchCompletion;
    private rebuildFromEntries;
    private prepareRebuildState;
    private replaySetServerEntry;
    private rebuildState;
    private applyInitialScore;
}

type SetMatchUpDailyLimitsArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    tournamentId: string;
    dailyLimits: any;
};
declare function setMatchUpDailyLimits(params: SetMatchUpDailyLimitsArgs): ResultType;

type AddPracticeRegistrationArgs = {
    tournamentRecord: Tournament;
    courtId: string;
    date: string;
    bookingId: string;
    participantId: string;
    startTime: string;
    endTime: string;
    notes?: string;
    disableNotice?: boolean;
};
type AddPracticeRegistrationResult = ResultType & {
    registration?: PracticeRegistration;
    conflicts?: ConflictReport;
};
declare function addPracticeRegistration(params: AddPracticeRegistrationArgs): AddPracticeRegistrationResult;

declare function allTournamentMatchUps(params?: GetMatchUpsArgs): ResultType & {
    matchUps?: HydratedMatchUp[];
};

declare function attachConsolationStructures(params: any): ResultType & {
    addedStructureIds?: string[];
};
declare function attachPlayoffStructures(params: any): ResultType & {
    addedStructureIds?: string[];
};
type AttachStructuresArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    matchUpModifications?: any[];
    structures: Structure[];
    links?: DrawLink[];
    itemType?: string;
    event?: Event$1;
};
declare function attachStructures({ itemType, matchUpModifications, tournamentRecord, drawDefinition, structures, links, event, }: AttachStructuresArgs): ResultType & {
    addedStructureIds?: string[];
};

declare function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }: {
    tournamentRecord: any;
    outcomes: any;
}): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
    publishedEventIds?: undefined;
    eventIdPublishedDrawIdsMap?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
    publishedEventIds?: undefined;
    eventIdPublishedDrawIdsMap?: undefined;
} | {
    publishedEventIds: any;
    eventIdPublishedDrawIdsMap: any;
    error?: undefined;
    info?: undefined;
};

type CreateOfficialRecordArgs = {
    officialRecordId?: string;
    personId: string;
    organisationId?: string;
    extensions?: any[];
};
declare function createOfficialRecord({ officialRecordId, personId, organisationId, extensions, }: CreateOfficialRecordArgs): {
    error?: any;
    officialRecord?: OfficialRecord;
    success?: boolean;
};

declare function deleteFlightAndFlightDraw({ autoPublish, tournamentRecord, auditData, drawId, event, force }: {
    autoPublish?: boolean | undefined;
    tournamentRecord: any;
    auditData: any;
    drawId: any;
    event: any;
    force: any;
}): ResultType | {
    error: any;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};

type GetCompetitionFormatArgs = {
    tournamentRecord: Tournament;
    drawDefinition?: DrawDefinition;
    structureId?: string;
    matchUpId?: string;
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
declare function getCompetitionFormat(params: GetCompetitionFormatArgs): {
    structureDefaultCompetitionFormat?: competitionFormat;
    drawDefaultCompetitionFormat?: competitionFormat;
    eventDefaultCompetitionFormat?: competitionFormat;
    competitionFormat?: competitionFormat;
    error?: any;
    success?: boolean;
};

type GetEvaluationTemplateArgs = {
    officialRecord?: OfficialRecord;
    policyName?: string;
    evaluationPolicy?: EvaluationPolicy;
};
declare function getEvaluationTemplate({ officialRecord, policyName, evaluationPolicy, }: GetEvaluationTemplateArgs): {
    error?: any;
    success?: boolean;
    fields?: EvaluationFormField[];
    evaluationPolicy?: EvaluationPolicy;
};

type GetMatchUpScheduleDetailsArgs = {
    scheduleVisibilityFilters?: ScheduleVisibilityFilters;
    scheduleTiming?: ScheduleTiming;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    matchUpType?: EventTypeUnion;
    afterRecoveryTimes?: boolean;
    usePublishState?: boolean;
    matchUp: HydratedMatchUp;
    matchUpFormat?: string;
    publishStatus?: any;
    event?: Event$1;
};
declare function getMatchUpScheduleDetails(params: GetMatchUpScheduleDetailsArgs): {
    error: {
        message: string;
        code: string;
    };
    schedule?: undefined;
    endDate?: undefined;
} | {
    schedule: any;
    endDate: string | undefined;
    error?: undefined;
};

type GetParticipantIdFinishingPositionsArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    byeAdvancements?: boolean;
    event?: Event$1;
};
declare function getParticipantIdFinishingPositions({ byeAdvancements, tournamentRecord, drawDefinition, event, }: GetParticipantIdFinishingPositionsArgs): any;

type PracticeRegistrationRecord = {
    registration: PracticeRegistration;
    courtId: string;
    venueId: string;
    date: string;
    bookingId: string;
    bookingStartTime?: string;
    bookingEndTime?: string;
};
type RegistrationFilter = {
    courtId?: string;
    date?: string;
    participantId?: string;
    includeCancelled?: boolean;
};
type GetPracticeRegistrationsArgs = {
    tournamentRecord: Tournament;
} & RegistrationFilter;
declare function getPracticeRegistrations(params: GetPracticeRegistrationsArgs): {
    registrations: PracticeRegistrationRecord[];
};

declare function modifyTournamentRecord(params: any): any;

type RemovePolicyArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    tournamentId?: string;
    policyType: string;
    event?: Event$1;
};
declare function removePolicy(params: RemovePolicyArgs): (ResultType & {
    valid?: boolean;
}) | {
    success: boolean;
    error?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
};

declare function setOrderOfFinish(params: any): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type GenderValidityCheckArgs = {
    referenceGender?: GenderUnion;
    matchUpType?: string;
    gender?: GenderUnion;
};
declare function tieFormatGenderValidityCheck(params: GenderValidityCheckArgs): ResultType;

type UpdateTeamLineUpArgs = {
    drawDefinition: DrawDefinition;
    participantId: string;
    tieFormat: TieFormat;
    drawId?: string;
    lineUp: LineUp;
};
declare function updateTeamLineUp({ drawDefinition, participantId, tieFormat, lineUp }: UpdateTeamLineUpArgs): {
    success?: boolean;
    error?: ErrorType;
};

type ValidateCollectionDefinitionArgs = {
    collectionDefinition: CollectionDefinition;
    referenceGender?: GenderUnion;
    referenceCategory?: Category;
    checkCollectionIds?: boolean;
    eventType?: EventTypeUnion;
    checkCategory?: boolean;
    checkGender?: boolean;
    event?: Event$1;
};
declare function validateCollectionDefinition({ checkCategory, collectionDefinition, checkCollectionIds, checkGender, referenceCategory, referenceGender, event, }: ValidateCollectionDefinitionArgs): ResultType;

type AddEvaluationPolicyArgs = {
    officialRecord: OfficialRecord;
    evaluationPolicy: EvaluationPolicy;
};
declare function addEvaluationPolicy({ officialRecord, evaluationPolicy, }: AddEvaluationPolicyArgs): {
    error?: any;
    evaluationPolicy?: EvaluationPolicy;
    success?: boolean;
};

type AddMatchUpScheduledTimeArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    removePriorValues?: boolean;
    disableNotice?: boolean;
    scheduledTime?: string;
    matchUpId?: string;
    matchUp?: MatchUp$1;
};
declare function addMatchUpScheduledTime(params: AddMatchUpScheduledTimeArgs): any;

type AutoSeedingParams = {
    sortDescending: boolean;
    stage: StageTypeUnion;
    tournamentRecord: any;
    policyDefinitions: any;
    scaleAttributes: any;
    scaleSortMethod: any;
    drawDefinition: any;
    scaleName: string;
    drawSize: number;
    drawId: string;
    event: any;
};
declare function autoSeeding({ tournamentRecord, drawDefinition, policyDefinitions, scaleAttributes, scaleName, drawSize, drawId, event, stage, sortDescending, scaleSortMethod, }: AutoSeedingParams): {
    stageEntries?: Entry[];
    seedsCount?: number;
    entries?: Entry[];
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
    scaleItemsWithParticipantIds?: undefined;
} | {
    scaleItemsWithParticipantIds: {
        participantId: string;
        scaleItems: any[];
    }[] | undefined;
    error?: undefined;
};

type DeleteParticipantsArgs = {
    addIndividualParticipantsToEvents?: boolean;
    tournamentRecord: Tournament;
    participantIds: string[];
};
declare function deleteParticipants(params: DeleteParticipantsArgs): {
    participantsRemovedCount?: number;
    success?: boolean;
    error?: ErrorType;
};

declare function generateEventWithDraw(params: any): any;

type GetAllStructureMatchUps = {
    scheduleVisibilityFilters?: ScheduleVisibilityFilters;
    tournamentAppliedPolicies?: PolicyDefinitions;
    participantsProfile?: ParticipantsProfile;
    tournamentParticipants?: Participant$1[];
    policyDefinitions?: PolicyDefinitions;
    seedAssignments?: SeedAssignment[];
    provisionalPositioning?: boolean;
    context?: {
        [key: string]: any;
    };
    contextContent?: ContextContent;
    contextFilters?: MatchUpFilters;
    matchUpFilters?: MatchUpFilters;
    participantMap?: ParticipantMap;
    scheduleTiming?: ScheduleTiming;
    hydrateParticipants?: boolean;
    drawDefinition?: DrawDefinition;
    contextProfile?: ContextProfile;
    tournamentRecord?: Tournament;
    afterRecoveryTimes?: boolean;
    useParticipantMap?: boolean;
    usePublishState?: boolean;
    exitProfiles?: ExitProfiles;
    matchUpsMap?: MatchUpsMap;
    structure?: Structure;
    publishStatus?: any;
    inContext?: boolean;
    event?: Event$1;
};
declare function getAllStructureMatchUps(params: GetAllStructureMatchUps): {
    collectionPositionMatchUps: {};
    error: {
        message: string;
        code: string;
    };
    roundMatchUps: {};
    matchUps: never[];
    isRoundRobin?: undefined;
    roundProfile?: undefined;
    matchUpsMap?: undefined;
} | {
    collectionPositionMatchUps: {};
    roundMatchUps: {};
    matchUps: never[];
    error?: undefined;
    isRoundRobin?: undefined;
    roundProfile?: undefined;
    matchUpsMap?: undefined;
} | {
    collectionPositionMatchUps: {};
    roundMatchUps: {};
    isRoundRobin: boolean;
    roundProfile: RoundProfile | undefined;
    matchUpsMap: MatchUpsMap;
    matchUps: any;
    error?: undefined;
};

type GetEvaluationSummaryArgs = {
    officialRecord: OfficialRecord;
    policyName?: string;
    approvedOnly?: boolean;
};
interface EvaluationSummary {
    evaluationCount: number;
    averageRating: number;
    latestRating?: number;
    latestDate?: string;
    sectionAverages?: {
        sectionId: string;
        sectionName: string;
        average: number;
    }[];
    meetsThreshold?: boolean;
}
declare function getEvaluationSummary({ officialRecord, policyName, approvedOnly }: GetEvaluationSummaryArgs): {
    error?: any;
    success?: boolean;
    summary?: EvaluationSummary;
};

type GetMatchUpDailyLimitsArgs = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    tournamentId?: string;
};
declare function getMatchUpDailyLimits({ tournamentRecords, tournamentId }: GetMatchUpDailyLimitsArgs): ResultType & {
    matchUpDailyLimits?: any;
};

type GetPairedParticipantArgs = {
    tournamentParticipants?: any[];
    tournamentRecord?: Tournament;
    participantIds: string[];
};
declare function getPairedParticipant({ tournamentParticipants, tournamentRecord, participantIds, }: GetPairedParticipantArgs): {
    duplicatedPairParticipants?: any[];
    participant?: Participant$1;
    error?: ErrorType;
    success?: boolean;
};

type GetPositionAssignmentsArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    structure?: Structure;
    structureId?: string;
    stage?: string;
};
declare function getPositionAssignments({ tournamentRecord, drawDefinition, stage, structureId, structure, }: GetPositionAssignmentsArgs): {
    error: {
        message: string;
        code: string;
    };
    positionAssignments?: undefined;
    structureId?: undefined;
} | {
    positionAssignments: PositionAssignment[];
    structureId: string | undefined;
    error: ErrorType | undefined;
};

declare function getTournamentPersons({ tournamentRecord, participantFilters }: {
    tournamentRecord: any;
    participantFilters: any;
}): {
    error: {
        message: string;
        code: string;
    };
    tournamentPersons?: undefined;
} | {
    tournamentPersons: unknown[];
    error?: undefined;
};

type ModifyCertificationArgs = {
    officialRecord: OfficialRecord;
    certificationId: string;
    updates: Partial<Pick<OfficialCertification, 'certificationLevel' | 'validFrom' | 'validUntil' | 'documentReferences' | 'notes' | 'extensions'>>;
};
declare function modifyCertification({ officialRecord, certificationId, updates, }: ModifyCertificationArgs): {
    error?: any;
    certification?: OfficialCertification;
    success?: boolean;
};

interface ParticipantScaleItemArgs {
    scaleAttributes: ScaleAttributes;
    requireTimeStamp?: boolean;
    participant: Participant$1;
}
declare function participantScaleItem({ requireTimeStamp, scaleAttributes, participant, }: ParticipantScaleItemArgs): ResultType & {
    scaleItem?: ScaleItem;
};

type RemoveCertificationArgs = {
    officialRecord: OfficialRecord;
    certificationId: string;
};
declare function removeCertification({ officialRecord, certificationId }: RemoveCertificationArgs): any;

type RemoveCollectionGroupArgs = {
    updateInProgressMatchUps?: boolean;
    collectionGroupNumber: number;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    tieFormatName?: string;
    structureId: string;
    matchUpId: string;
    matchUp?: MatchUp$1;
    eventId?: string;
    event?: Event$1;
};
declare function removeCollectionGroup({ updateInProgressMatchUps, collectionGroupNumber, tournamentRecord, drawDefinition, tieFormatName, structureId, matchUpId, matchUp, eventId, event, }: RemoveCollectionGroupArgs): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

declare function setTournamentStatus({ tournamentRecord, status }: {
    tournamentRecord: any;
    status: any;
}): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};

declare function toStatObjects(stats: MatchStatistics): StatObject[];

declare function unPublishParticipants(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type AddExtensionArgs$1 = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    participantId?: string;
    creationTime?: boolean;
    extension: Extension;
    event?: Event$1;
};
declare function addTournamentExtension(params: AddExtensionArgs$1): {
    success?: boolean;
    error?: ErrorType;
};
declare function addDrawDefinitionExtension(params: AddExtensionArgs$1): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};
declare function addEventExtension(params: AddExtensionArgs$1): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};
declare function addParticipantExtension(params?: any): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};
declare function removeTournamentExtension(params: any): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
};
declare function removeDrawDefinitionExtension(params: any): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
} | {
    error: {
        message: string;
        code: string;
    };
};
declare function removeEventExtension(params: any): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
} | {
    error: {
        message: string;
        code: string;
    };
};
declare function removeParticipantExtension(params?: any): {
    success?: boolean;
    error?: ErrorType;
    info?: any;
} | {
    error: {
        message: string;
        code: string;
    };
};

declare function addDrawEntries({ suppressDuplicateEntries, autoEntryPositions, entryStageSequence, ignoreStageSpace, participantIds, drawDefinition, entryStatus, roundTarget, entryStage, extension, drawId, event, }: {
    suppressDuplicateEntries?: boolean | undefined;
    autoEntryPositions?: boolean | undefined;
    entryStageSequence: any;
    ignoreStageSpace: any;
    participantIds: any;
    drawDefinition: any;
    entryStatus: any;
    roundTarget: any;
    entryStage: any;
    extension: any;
    drawId: any;
    event: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type StructureActionsArgs = {
    drawDefinition: DrawDefinition;
    structureId: string;
};
type StructureQueryArgs = {
    drawDefinition: DrawDefinition;
    structure?: Structure;
    structureId?: string;
};
declare function isCompletedStructure(params: StructureQueryArgs): boolean;
declare function allPlayoffPositionsFilled(params: StructureActionsArgs): boolean | {
    error: {
        message: string;
        code: string;
    };
};

declare function bulkMatchUpStatusUpdate(params: any): ResultType | {
    success?: boolean;
    error?: ErrorType;
    info?: string;
} | {
    error: {
        message: string;
        code: string;
    };
} | {
    error: {
        message: string;
        code: string;
    };
    info: {
        outcomes: any;
    };
};

declare function completeDrawMatchUps(params: any): {
    completeRoundRobinPlayoffs?: boolean;
    completedCount?: number;
    success?: boolean;
    error?: ErrorType;
};

type DeleteAdHocMatchUpsArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    removeUnAssigned?: boolean;
    removeIncomplete?: boolean;
    removeCompleted?: boolean;
    roundNumbers?: number[];
    matchUpIds?: string[];
    structureId?: string;
    event?: Event$1;
};
declare function deleteAdHocMatchUps(params: DeleteAdHocMatchUpsArgs): ResultType & {
    deletedMatchUpsCount?: number;
};

type FilterParticipantsArgs = {
    participantFilters: ParticipantFilters;
    participants: HydratedParticipant[];
    tournamentRecord: Tournament;
};
declare function filterParticipants({ participantFilters, tournamentRecord, participants, }: FilterParticipantsArgs): HydratedParticipant[];

declare function generateParticipants(params: any): {
    participants?: any[];
    error?: ErrorType;
};

type CompetitionMatchUpsArgs = {
    scheduleVisibilityFilters?: ScheduleVisibilityFilters;
    participantsProfile?: ParticipantsProfile;
    tournamentRecords: TournamentRecords;
    policyDefinitions?: PolicyDefinitions;
    matchUpFilters?: MatchUpFilters;
    contextFilters?: MatchUpFilters;
    hydrateParticipants?: boolean;
    afterRecoveryTimes?: boolean;
    useParticipantMap?: boolean;
    usePublishState?: boolean;
    nextMatchUps?: boolean;
    inContext?: boolean;
};
declare function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, useParticipantMap, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs): ResultType & {
    mappedParticipants?: {
        [key: string]: HydratedParticipant;
    };
    abandonedMatchUps?: HydratedMatchUp[];
    completedMatchUps?: HydratedMatchUp[];
    upcomingMatchUps?: HydratedMatchUp[];
    pendingMatchUps?: HydratedMatchUp[];
    byeMatchUps?: HydratedMatchUp[];
    groupInfo?: GroupInfo;
};

type GetEntriesAndSeedsCountArgs = {
    policyDefinitions: PolicyDefinitions;
    drawDefinition: DrawDefinition;
    stage: StageTypeUnion;
    drawSize?: number;
    drawId?: string;
    event: Event$1;
};
declare function getEntriesAndSeedsCount({ policyDefinitions, drawDefinition, drawSize, drawId, event, stage, }: GetEntriesAndSeedsCountArgs): {
    stageEntries?: Entry[];
    seedsCount?: number;
    entries?: Entry[];
    error?: ErrorType;
};

type GetMatchUpDependenciesArgs = {
    includeParticipantDependencies?: boolean;
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    matchUps?: HydratedMatchUp[];
    matchUpIds?: string[];
    drawIds?: string[];
};
declare function getMatchUpDependencies(params: GetMatchUpDependenciesArgs): {
    sourceMatchUpIds?: {
        [key: string]: any[];
    };
    matchUps?: HydratedMatchUp[];
    positionDependencies?: any;
    matchUpDependencies?: any;
    error?: ErrorType;
    success?: boolean;
};

type StatCounters = {
    participantName: string;
    competitorIds: string[];
    participantId: string;
    matchUpStatuses: {
        [key: string]: number;
    };
    competitiveness: {
        [key: string]: Tally;
    };
    competitiveRatio?: number;
    decisiveRatio?: number;
    routineRatio?: number;
    tiebreaksRatio?: number;
    matchUpsRatio?: number;
    pointsRatio?: number;
    gamesRatio?: number;
    setsRatio?: number;
    tiebreaksRank?: number;
    matchUpsRank?: number;
    pointsRank?: number;
    gamesRank?: number;
    setsRank?: number;
    tiebreaks: Tally;
    matchUps: Tally;
    points: Tally;
    games: Tally;
    sets: Tally;
};
type GetTeamStatistics = {
    withCompetitiveProfiles?: boolean;
    opponentParticipantId?: string;
    withIndividualStats?: boolean;
    tournamentRecord: Tournament;
    matchUps?: HydratedMatchUp[];
    teamParticipantId?: string;
    withScaleValues?: boolean;
    tallyPolicy?: any;
};
type TeamStatsResults = {
    allParticipantStats?: StatCounters[];
    relevantMatchUps: HydratedMatchUp[];
    participatingTeamsCount?: number;
    opponentStats?: StatCounters;
    teamStats?: StatCounters;
    success: boolean;
};
declare function getParticipantStats({ withCompetitiveProfiles, opponentParticipantId, withIndividualStats, teamParticipantId, tournamentRecord, withScaleValues, tallyPolicy, matchUps, }: GetTeamStatistics): ResultType | TeamStatsResults;

type GetTournamentPointAwardsArgs = {
    participantFilters?: ParticipantFilters;
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    level?: number;
};
declare function getTournamentPointAwards({ participantFilters, policyDefinitions, tournamentRecord, level, }: GetTournamentPointAwardsArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    pointAwards: any[];
};

declare function mergeParticipants({ participants: incomingParticipants, tournamentRecord, arraysToMerge }: {
    participants?: never[] | undefined;
    tournamentRecord: any;
    arraysToMerge: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    modifiedParticipantsCount: number;
    newParticipantsCount: number;
    error?: undefined;
};

type ModifyDrawNameArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    flightProfile: FlightProfile;
    drawName: string;
    drawId: string;
    event: Event$1;
};
declare function modifyDrawName({ tournamentRecord, drawDefinition, flightProfile, drawName, drawId, event, }: ModifyDrawNameArgs): ResultType & {
    flight?: Flight;
};

declare function modifyParticipant(params: any): any;

declare function removeMatchUpOutcome({ tournamentRecord, drawId, matchUpId, event, drawDefinition }: {
    tournamentRecord: any;
    drawId: any;
    matchUpId: any;
    event: any;
    drawDefinition: any;
}): ResultType | {
    success?: boolean;
    error?: ErrorType;
    info?: string;
} | {
    error: {
        message: string;
        code: string;
    };
};

type RemoveRoundMatchUpsArgs = {
    removeCompletedMatchUps?: boolean;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    structureId: string;
    roundNumber: number;
    event: Event$1;
};
declare function removeRoundMatchUps({ removeCompletedMatchUps, tournamentRecord, drawDefinition, structureId, roundNumber, event, }: RemoveRoundMatchUpsArgs): ResultType & {
    deletedMatchUpsCount?: number;
    roundRemoved?: boolean;
};

type SetTournamentDatesArgs = {
    tournamentRecord: Tournament;
    weekdays?: WeekdayUnion[];
    activeDates?: string[];
    startDate?: string;
    endDate?: string;
};
declare function setTournamentDates(params: SetTournamentDatesArgs): ResultType & {
    unscheduledMatchUpIds?: string[];
    datesRemoved?: string[];
    datesAdded?: string[];
};
declare function setTournamentStartDate({ tournamentRecord, startDate }: {
    tournamentRecord: any;
    startDate: any;
}): (ResultType & {
    unscheduledMatchUpIds?: string[];
    datesRemoved?: string[];
    datesAdded?: string[];
}) | {
    error: {
        message: string;
        code: string;
    };
};
declare function setTournamentEndDate({ tournamentRecord, endDate }: {
    tournamentRecord: any;
    endDate: any;
}): (ResultType & {
    unscheduledMatchUpIds?: string[];
    datesRemoved?: string[];
    datesAdded?: string[];
}) | {
    error: {
        message: string;
        code: string;
    };
};

type WizardParticipant = {
    participantId: string;
    rating: number;
    category?: string;
    gender?: string;
};
type ConsolationAppetite = 'NONE' | 'LIGHT' | 'FULL';
type WizardConstraints = {
    consolationAppetite?: ConsolationAppetite;
    allowCollapsedCategories?: boolean;
    voluntaryConsolation?: boolean;
    targetMatchesPerPlayer?: number;
    targetCompetitivePct?: number;
    allowMixedGender?: boolean;
    matchUpFormat?: string;
    hoursPerDay?: number;
    avgMinutes?: number;
    courts: number;
    days: number;
};
type WizardGovernance = {
    allowedMatchUpFormats?: string[];
    allowedDrawTypes?: string[];
};
type DistributionBin = {
    binStart: number;
    binEnd: number;
    count: number;
};
type DistributionGap = {
    start: number;
    end: number;
    size: number;
};
type RatingDistributionStats = {
    histogram: DistributionBin[];
    gaps: DistributionGap[];
    stddev: number;
    median: number;
    count: number;
    mean: number;
    iqr: number;
    min: number;
    max: number;
};
type FlightingStrategyType = 'STAGGERED_SINGLE' | 'NATURAL_CLUSTER' | 'EQUAL_COUNT' | 'EQUAL_BAND';
type WizardFlight = {
    participantIds: string[];
    ratings: number[];
    category?: string;
    gender?: string;
    label: string;
};
type FlightingStrategy = {
    type: FlightingStrategyType;
    flights: WizardFlight[];
    variant?: string;
};
type StructureKind = 'FIRST_ROUND_LOSER_CONSOLATION' | 'FIRST_MATCH_LOSER_CONSOLATION' | 'ROUND_ROBIN_WITH_PLAYOFF' | 'DOUBLE_ELIMINATION' | 'SINGLE_ELIMINATION' | 'ROUND_ROBIN' | 'DRAW_MATIC' | 'LUCKY_DRAW' | 'ADAPTIVE' | 'COMPASS' | 'FEED_IN' | 'SWISS';
type StructureRecommendation = {
    withdrawalRiskFactor: number;
    minMatchesPerPlayer: number;
    kind: StructureKind;
    totalMatches: number;
    voluntaryConsolation?: boolean;
    groupSize?: number;
    variantId?: string;
    rounds?: number;
};
type FlightStructure = {
    predictedBands: {
        competitive: number;
        decisive: number;
        routine: number;
    };
    structure: StructureRecommendation;
    flight: WizardFlight;
};
type PlanWarning = 'MIXED_GENDER_VARIANT' | 'COLLAPSED_CATEGORY' | 'WITHDRAWAL_RISK' | 'OVER_CAPACITY' | 'BELOW_FLOOR';
type RankedPlanAggregate = {
    minMatchesPerPlayer: number;
    courtHoursAvailable: number;
    courtHoursRequired: number;
    courtUtilization: number;
    totalMatches: number;
    competitive: number;
    decisive: number;
    routine: number;
};
type RankedPlan = {
    flightStructures: FlightStructure[];
    aggregate: RankedPlanAggregate;
    strategy: FlightingStrategyType;
    warnings: PlanWarning[];
    variant?: string;
    score: number;
    rank: number;
};
type RejectedStrategy = {
    strategy: FlightingStrategyType;
    reason: string;
};

type SuggestFormatPlansArgs = {
    predictionModel?: PredictionModel;
    tournamentRecord?: Tournament;
    participants: WizardParticipant[];
    governance?: WizardGovernance;
    constraints: WizardConstraints;
};
type SuggestFormatPlansResult = {
    rejected?: RejectedStrategy[];
    distribution: RatingDistributionStats;
    plans: RankedPlan[];
    error?: ErrorType;
};
declare function suggestFormatPlans({ predictionModel, tournamentRecord, participants, governance, constraints, }: SuggestFormatPlansArgs): SuggestFormatPlansResult;

declare function unPublishOrderOfPlay(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

declare function addPersonOtherId({ tournamentRecord, participantId, organisationId, personId, }: {
    tournamentRecord: any;
    participantId: string;
    organisationId: string;
    personId: string;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
};

type AggreateTieFormatsArgs = {
    tournamentRecord: Tournament;
};
declare function aggregateTieFormats({ tournamentRecord, }: AggreateTieFormatsArgs): ResultType & {
    addedCount?: number;
};

type ApplyLineUps = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    lineUps: TeamCompetitor$1[];
    matchUpId: string;
    event: Event$1;
};
declare function applyLineUps(params: ApplyLineUps): any;

type CalculateMatchUpMarginArgs = {
    matchUp: MatchUp$1;
};
type CalculateMatchUpMarginResult = {
    margin?: number;
    setRatio?: number;
    gameRatio?: number;
    pointRatio?: number;
    setsWonByLoser?: number;
    setsWonByWinner?: number;
    gameDifferential?: number;
    success?: boolean;
    error?: ErrorType;
};
declare function calculateMatchUpMargin({ matchUp }: CalculateMatchUpMarginArgs): CalculateMatchUpMarginResult;

declare function checkMatchUpIsComplete({ matchUp }: {
    matchUp: any;
}): any;

type GetAggregateTeamResultsArgs = {
    finishingPositionRangeBounsPoints?: {
        [key: string]: number;
    };
    tournamentRecord: Tournament;
};
declare function getAggregateTeamResults(params: GetAggregateTeamResultsArgs): (ResultType & {
    valid?: boolean;
}) | {
    individualResults: {};
    teamResults: {};
    success: boolean;
};

type getPredictiveAccuracyArgs = {
    exclusionRule?: {
        valueAccessor: string;
        range: [number, number];
    };
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    matchUps?: HydratedMatchUp[];
    singlesForDoubles?: boolean;
    valueAccessor?: string;
    excludeMargin?: number;
    zoneDoubling?: boolean;
    matchUpType: EventTypeUnion;
    zoneMargin?: number;
    ascending?: boolean;
    scaleName: string;
    eventId?: string;
    zonePct?: number;
    drawId?: string;
    event?: Event$1;
};
declare function getPredictiveAccuracy(params: getPredictiveAccuracyArgs): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
    context?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: {
        matchUpType: EventTypeUnion;
    };
    context?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    context: {
        matchUps: HydratedMatchUp[];
    };
    info?: undefined;
} | {
    relevantMatchUps: HydratedMatchUp[];
    zoneDistribution: any;
    zoneData: {
        competitiveness: any;
        valuesGap: number;
        score: Score$1 | undefined;
    }[];
    accuracy: any;
    nonZone: number;
    success: boolean;
    error?: undefined;
    info?: undefined;
    context?: undefined;
};

type GetSchedulingProfileArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
};
declare function getSchedulingProfile({ tournamentRecords, tournamentRecord }: GetSchedulingProfileArgs): {
    schedulingProfile?: any;
    modifications?: number;
    error?: ErrorType;
    issues?: string[];
};
type SetSchedulingProfileArgs = {
    tournamentRecords: TournamentRecords;
    tournamentRecord?: Tournament;
    schedulingProfile?: any[];
};
declare function setSchedulingProfile({ tournamentRecords, tournamentRecord, schedulingProfile, }: SetSchedulingProfileArgs): any;

declare function publishParticipants(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type RemoveCourtGridBookingArgs = {
    tournamentRecord: Tournament;
    disableNotice?: boolean;
    scheduledDate: string;
    courtOrder: number;
    courtId: string;
};
declare function removeCourtGridBooking(params: RemoveCourtGridBookingArgs): ResultType & {
    booking?: any;
};

type ResetAdHocMatchUps = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    removeAssignments?: boolean;
    roundNumbers?: number[];
    matchUpIds?: string[];
    structureId?: string;
    event: Event$1;
};
declare function resetAdHocMatchUps(params: ResetAdHocMatchUps): any;

declare function setTournamentName({ tournamentRecord, promotionalName, tournamentName, formalName }: {
    tournamentRecord: any;
    promotionalName: any;
    tournamentName: any;
    formalName: any;
}): ResultType & {
    valid?: boolean;
};
declare function setTournamentNotes({ tournamentRecord, notes }: {
    tournamentRecord: any;
    notes: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
};
declare function setTournamentLocalTimeZone({ tournamentRecord, localTimeZone }: {
    tournamentRecord: any;
    localTimeZone: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
};
declare function setTournamentTier({ tournamentRecord, tournamentTier }: {
    tournamentRecord: any;
    tournamentTier: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: string;
};
declare function setRegistrationProfile({ tournamentRecord, registrationProfile }: {
    tournamentRecord: any;
    registrationProfile: any;
}): ResultType & {
    valid?: boolean;
};
declare function setTournamentCategories({ tournamentRecord, categories }: {
    tournamentRecord: any;
    categories: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    referenced: string[];
};

declare function tournamentMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult;

declare function validateSchedulingProfile({ tournamentRecords, schedulingProfile }: {
    tournamentRecords: any;
    schedulingProfile: any;
}): any;

type AddCertificationArgs = {
    officialRecord: OfficialRecord;
    certificationId?: string;
    personId?: string;
    organisationId: string;
    certificationFamily: string;
    certificationLevel?: string;
    status?: string;
    validFrom?: string;
    validUntil?: string;
    documentReferences?: any[];
    notes?: string;
    extensions?: any[];
};
declare function addCertification({ officialRecord, certificationId, organisationId, certificationFamily, certificationLevel, status, validFrom, validUntil, documentReferences, notes, extensions, }: AddCertificationArgs): {
    error?: any;
    certification?: OfficialCertification;
    success?: boolean;
};

declare function addCollectionGroup({ updateInProgressMatchUps, tournamentRecord, groupDefinition, drawDefinition, collectionIds, tieFormatName, structureId, matchUpId, matchUp, eventId, event, }: {
    updateInProgressMatchUps?: boolean | undefined;
    tournamentRecord: any;
    groupDefinition: any;
    drawDefinition: any;
    collectionIds: any;
    tieFormatName: any;
    structureId: any;
    matchUpId: any;
    matchUp: any;
    eventId: any;
    event: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};

type AddParticipantsType = {
    allowDuplicateParticipantIdPairs?: boolean;
    returnParticipants?: boolean;
    participants?: Participant$1[];
    tournamentRecord: Tournament;
};
declare function addParticipants({ allowDuplicateParticipantIdPairs, returnParticipants, tournamentRecord, participants, }: AddParticipantsType): any;

declare function analyzeTournament({ tournamentRecord }: {
    tournamentRecord: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    analysis: any;
    success: boolean;
    error?: undefined;
};

declare function calculateMatchStatistics(_matchUp: MatchUp, points: PointWithMetadata[], options?: StatisticsOptions): MatchStatistics;
declare function enrichPointHistory(rawPoints: any[]): PointWithMetadata[];
declare function getQuickStats(points: PointWithMetadata[], options?: StatisticsOptions): {
    aces: [number, number];
    doubleFaults: [number, number];
    winners: [number, number];
    unforcedErrors: [number, number];
    totalPoints: [number, number];
};

declare function courtGridRows({ courtPrefix, minRowsCount, courtsData, scheduledDate }: {
    courtPrefix?: string | undefined;
    minRowsCount: any;
    courtsData: any;
    scheduledDate: any;
}): {
    error: {
        message: string;
        code: string;
    };
    courtPrefix?: undefined;
    rows?: undefined;
} | {
    courtPrefix: string;
    rows: any[];
    error?: undefined;
};

type DeleteDrawDefinitionArgs = {
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    eventDataParams?: any;
    autoPublish?: boolean;
    drawIds?: string[];
    auditData?: any;
    eventId?: string;
    force?: boolean;
    event?: Event$1;
};
declare function deleteDrawDefinitions(params: DeleteDrawDefinitionArgs): ResultType | {
    error: any;
};

type GetAppliedPoliciesArgs = {
    onlySpecifiedPolicyTypes?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    policyTypes?: string[];
    structure?: Structure;
    event?: Event$1;
};
declare function getAppliedPolicies({ onlySpecifiedPolicyTypes, policyTypes, tournamentRecord, drawDefinition, structure, event, }: GetAppliedPoliciesArgs): {
    appliedPolicies?: PolicyDefinitions;
    error?: ErrorType;
};
type GetPolicyDefinitionsArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    policyTypes?: string[];
    structure?: Structure;
    event?: Event$1;
};
declare function getPolicyDefinitions({ policyTypes, tournamentRecord, drawDefinition, structure, event, }: GetPolicyDefinitionsArgs): {
    policyDefinitions?: PolicyDefinitions;
    error?: ErrorType;
    info?: string;
};

type GetMatchUpFormatArgs = {
    tournamentRecord: Tournament;
    drawDefinition?: DrawDefinition;
    structureId?: string;
    matchUpId?: string;
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
declare function getMatchUpFormat(params: GetMatchUpFormatArgs): any;

type GetRoundsArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    excludeScheduleDateProfileRounds?: string;
    inContextMatchUps?: HydratedMatchUp[];
    excludeScheduledRounds?: boolean;
    excludeCompletedRounds?: boolean;
    context?: {
        [key: string]: any;
    };
    matchUpFilters?: MatchUpFilters;
    tournamentRecord?: Tournament;
    withSplitRounds?: boolean;
    schedulingProfile?: any;
    scheduleDate?: string;
    withRoundId?: boolean;
    venueId?: string;
};
declare function getRounds({ excludeScheduleDateProfileRounds, excludeScheduledRounds, excludeCompletedRounds, inContextMatchUps, tournamentRecords, schedulingProfile, tournamentRecord, withSplitRounds, matchUpFilters, scheduleDate, withRoundId, venueId, context, }: GetRoundsArgs): {
    error: {
        message: string;
        code: string;
    };
    inContextMatchUps: HydratedMatchUp[];
} | {
    error: {
        message: string;
        code: string;
    };
    inContextMatchUps?: undefined;
} | {
    rounds: any[];
    excludedRounds: any[];
    success: boolean;
    error?: undefined;
    inContextMatchUps?: undefined;
};

declare function getTournamentInfo(params?: {
    withStructureDetails?: boolean;
    tournamentRecord: Tournament;
    withMatchUpStats?: boolean;
    usePublishState?: boolean;
    withVenueData?: boolean;
}): {
    tournamentInfo?: any;
    eventInfo?: any[];
    error?: ErrorType;
};

declare function hydrateTournamentRecord(params: any): {
    error: {
        message: string;
        code: string;
    };
    tournamentRecord?: undefined;
} | {
    tournamentRecord: any;
    error?: undefined;
};

declare function keyValueScore(params: any): {
    updated: any;
    info: any;
    scoreString?: undefined;
    sets?: undefined;
    winningSide?: undefined;
    matchUpStatus?: undefined;
} | {
    updated: any;
    scoreString: any;
    sets: any;
    winningSide: any;
    matchUpStatus: any;
    info: any;
};

type ModifyEvaluationArgs = {
    officialRecord: OfficialRecord;
    evaluationId: string;
    updates: Partial<Pick<OfficialEvaluation, 'overallRating' | 'comments' | 'documentReference' | 'tournamentId' | 'tournamentName' | 'matchUpId' | 'policyName' | 'extensions'> & {
        scores?: EvaluationScore[];
    }>;
};
declare function modifyEvaluation({ officialRecord, evaluationId, updates }: ModifyEvaluationArgs): {
    error?: any;
    evaluation?: OfficialEvaluation;
    success?: boolean;
};

declare function publishOrderOfPlay(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type GetOfficialRecordArgs = {
    officialRecord: OfficialRecord;
};
declare function queryOfficialRecord({ officialRecord }: GetOfficialRecordArgs): {
    error?: any;
    success?: boolean;
    officialRecord?: OfficialRecord;
};

declare function refreshEventDrawOrder({ tournamentRecord, event }: {
    tournamentRecord: any;
    event: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};

type RemoveEvaluationArgs = {
    officialRecord: OfficialRecord;
    evaluationId: string;
};
declare function removeEvaluation({ officialRecord, evaluationId }: RemoveEvaluationArgs): any;

type RemoveSuspensionArgs = {
    officialRecord: OfficialRecord;
    suspensionId: string;
};
declare function removeSuspension({ officialRecord, suspensionId }: RemoveSuspensionArgs): any;

declare function stringify(matchUpFormatObject: any, preserveRedundant?: boolean): string | undefined;

type AddAdHocMatchUpsParams = {
    suppressNotifications?: boolean;
    tournamentRecord: any;
    structureId?: string;
    drawDefinition: any;
    matchUps: any[];
    event: any;
};
declare function addAdHocMatchUps(params: AddAdHocMatchUpsParams): ResultType;

type AddParticipantType = {
    allowDuplicateParticipantIdPairs?: boolean;
    tournamentRecords?: TournamentRecords;
    tournamentRecord: Tournament;
    activeTournamentId?: string;
    returnParticipant?: boolean;
    disableNotice?: boolean;
    pairOverride?: boolean;
    tournamentId?: string;
    participant: any;
};
declare function addParticipant(params: AddParticipantType): any;

declare function allEventMatchUps(params: GetMatchUpsArgs): {
    error: {
        message: string;
        code: string;
    };
    matchUps?: undefined;
    groupInfo?: undefined;
} | {
    matchUps: HydratedMatchUp[];
    groupInfo: any;
    error?: undefined;
};

type CalculateWinCriteriaArgs = {
    collectionGroups?: {
        groupValue?: number;
        groupNumber?: number;
    }[];
    collectionDefinitions?: CollectionDefinition[];
};
declare function calculateWinCriteria({ collectionDefinitions, collectionGroups, }: CalculateWinCriteriaArgs): ResultType & {
    aggregateValue?: boolean;
    valueGoal?: number;
};

type GetVenuesAndCourtsArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    convertExtensions?: boolean;
    ignoreDisabled?: boolean;
    tournamentId?: string;
    venueIds?: string[];
    dates?: string[];
};
declare function getVenuesAndCourts(params: GetVenuesAndCourtsArgs): ResultType & {
    venues?: HydratedVenue[];
    courts?: HydratedCourt[];
};
type GetCompeitionVenuesArgs = {
    tournamentRecords: TournamentRecords;
    requireCourts?: boolean;
    dates?: string[];
};
declare function getCompetitionVenues({ tournamentRecords, requireCourts, dates }: GetCompeitionVenuesArgs): {
    venueIds?: string[];
    error?: ErrorType;
    venues?: Venue[];
};

type GetEventRankingPointsArgs = {
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    policyName?: string;
    eventId: string;
    level?: number;
};
declare function getEventRankingPoints({ policyDefinitions, tournamentRecord, policyName, eventId, level, }: GetEventRankingPointsArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    eventAwards: any[];
    eventName: string | undefined;
    eventType: EventTypeUnion | undefined;
    isDoubles: boolean;
    error?: undefined;
};

declare function getHomeParticipantId(params: ScheduledMatchUpArgs): any;

declare function getMatchUpContextIds({ matchUps, matchUpId }: {
    matchUps: any;
    matchUpId: any;
}): {
    error: {
        message: string;
        code: string;
    };
    matchUpId?: undefined;
    drawId?: undefined;
    eventId?: undefined;
    structureId?: undefined;
    tournamentId?: undefined;
} | {
    matchUpId: any;
    drawId: any;
    eventId: any;
    structureId: any;
    tournamentId: any;
    error?: undefined;
};

type MutationLockEntry = MutationLock & {
    drawId?: string;
    eventId?: string;
    venueId?: string;
};
type GetMutationLocksArgs = {
    tournamentRecord: Tournament;
    scope?: MutationLockScope;
};
declare function getMutationLocks(params: GetMutationLocksArgs): {
    success?: boolean;
    error?: ErrorType;
    mutationLocks?: MutationLockEntry[];
};

type GetParticipantsArgs = {
    withIndividualParticipants?: boolean | {
        [key: string]: any;
    };
    participantFilters?: ParticipantFilters;
    scheduleAnalysis?: ScheduleAnalysis;
    policyDefinitions?: PolicyDefinitions;
    withPotentialMatchUps?: boolean;
    contextFilters?: MatchUpFilters;
    matchUpFilters?: MatchUpFilters;
    returnParticipantMap?: boolean;
    contextProfile?: ContextProfile;
    tournamentRecord: Tournament;
    withRankingProfile?: boolean;
    convertExtensions?: boolean;
    withScheduleItems?: boolean;
    withSignInStatus?: boolean;
    withTeamMatchUps?: boolean;
    withScaleValues?: boolean;
    usePublishState?: boolean;
    returnMatchUps?: boolean;
    withStatistics?: boolean;
    withOpponents?: boolean;
    withMatchUps?: boolean;
    internalUse?: boolean;
    withSeeding?: boolean;
    withEvents?: boolean;
    withDraws?: boolean;
    withISO2?: boolean;
    withIOC?: boolean;
};
declare function getParticipants(params: GetParticipantsArgs): {
    eventsPublishStatuses?: {
        [key: string]: any;
    };
    participantIdsWithConflicts?: string[];
    participants?: HydratedParticipant[];
    missingParticipantIds?: string[];
    participantMap?: ParticipantMap;
    matchUps?: HydratedMatchUp[];
    derivedEventInfo?: any;
    derivedDrawInfo?: any;
    mappedMatchUps?: any;
    error?: ErrorType;
    success?: boolean;
};

type GetSeedingThresholdsArgs = {
    roundRobinGroupsCount?: number;
    participantsCount: number;
};
declare function getSeedingThresholds({ roundRobinGroupsCount, participantsCount, }: GetSeedingThresholdsArgs): ResultType & {
    seedingThresholds?: any;
    success?: boolean;
};

type GetSeedsCountArgs = {
    policyDefinitions?: PolicyDefinitions;
    requireParticipantCount?: boolean;
    drawSizeProgression?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    participantsCount?: number;
    participantCount?: number;
    drawSize?: any;
    event?: Event$1;
};
declare function getSeedsCount(params: GetSeedsCountArgs): ResultType & {
    seedsCount?: number;
};

interface ValidateMatchUpOptions {
    matchUp: MatchUp;
    expectedScore?: {
        sets?: Array<{
            side1Score?: number;
            side2Score?: number;
            side1TiebreakScore?: number;
            side2TiebreakScore?: number;
        }>;
        scoreString?: string;
    };
}
interface ValidationDetails {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    actual: {
        sets: SetScore[];
        scoreString: string;
    };
    expected: {
        sets?: any[];
        scoreString?: string;
    };
    pointsProcessed: number;
    pointsRejected: number;
}
declare function validateMatchUp(options: ValidateMatchUpOptions): ValidationDetails;
declare function getSetScoreString(set: SetScore): string;
declare function validateSet(options: {
    points: Array<{
        winner: number;
        server?: number;
    }>;
    matchUpFormat: string;
    expectedGames: [number, number];
    expectedTiebreak?: [number, number];
}): ValidationDetails;

declare function getTeamLineUp({ drawDefinition, participantId }: {
    drawDefinition: any;
    participantId: any;
}): {
    error: {
        message: string;
        code: string;
    };
    lineUp?: undefined;
} | {
    lineUp: any;
    error?: undefined;
};

declare function getTournamentIds({ tournamentRecords }: {
    tournamentRecords: any;
}): {
    success: boolean;
    tournamentIds: string[];
};

type SetType = 'standard' | 'tiebreakOnly' | 'timed' | 'matchTiebreak';

declare function inferServeSide(matchUp: MatchUp, formatStructure: FormatStructure, setType: SetType): 'deuce' | 'ad' | undefined;

type ModifyEntriesStatusArgs = {
    drawDefinition?: DrawDefinition;
    autoEntryPositions?: boolean;
    tournamentRecord: Tournament;
    entryStatus?: EntryStatusUnion;
    ignoreAssignment?: boolean;
    entryStage?: StageTypeUnion;
    participantIds: string[];
    extension?: Extension;
    eventSync?: boolean;
    drawId: string;
    stage?: StageTypeUnion;
    event?: Event$1;
};
declare function modifyEntriesStatus({ autoEntryPositions, ignoreAssignment, tournamentRecord, drawDefinition, participantIds, entryStatus, entryStage, extension, eventSync, drawId, stage, event, }: ModifyEntriesStatusArgs): ResultType | {
    error: {
        message: string;
        code: string;
    };
    method: string;
    participantIds: any;
} | {
    error: {
        message: string;
        code: string;
    };
    method?: undefined;
    participantIds?: undefined;
};

type AddCourtGridBookingArgs = {
    tournamentRecord: Tournament;
    disableNotice?: boolean;
    bookingType: string;
    courtOrder: number;
    scheduledDate: string;
    courtId: string;
    rowCount?: number;
    notes?: string;
};
declare function addCourtGridBooking(params: AddCourtGridBookingArgs): ResultType & {
    booking?: any;
};

type AddEventEntryPairsArgs = {
    allowDuplicateParticipantIdPairs?: boolean;
    participantIdPairs?: string[][];
    entryStatus?: EntryStatusUnion;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    entryStage?: StageTypeUnion;
    enforceCategory?: boolean;
    uuids?: string[];
    event: Event$1;
};
declare function addEventEntryPairs(params: AddEventEntryPairsArgs): any;

declare function allDrawMatchUps(params: GetMatchUpsArgs): {
    groupInfo: any;
    context?: {
        [key: string]: any;
    };
    stack?: string | string[];
    errors?: string[];
    error?: ErrorType;
    success?: boolean;
    valid?: boolean;
    info?: any;
    matchUps?: HydratedMatchUp[];
    matchUpsMap?: MatchUpsMap;
};

declare const POINTS_AUTHORITIES: readonly ["ATP", "WTA", "ITF", "ITF_JUNIOR", "ITF_WHEELCHAIR", "TENNIS_EUROPE", "USTA", "LTA", "FFT", "DTB", "PPA", "BWF", "UTR", "UNSPECIFIED"];
type PointsAuthority = (typeof POINTS_AUTHORITIES)[number];
declare const pointsAuthorityConstants: {
    readonly ATP: "ATP";
    readonly WTA: "WTA";
    readonly ITF: "ITF";
    readonly ITF_JUNIOR: "ITF_JUNIOR";
    readonly ITF_WHEELCHAIR: "ITF_WHEELCHAIR";
    readonly TENNIS_EUROPE: "TENNIS_EUROPE";
    readonly USTA: "USTA";
    readonly LTA: "LTA";
    readonly FFT: "FFT";
    readonly DTB: "DTB";
    readonly PPA: "PPA";
    readonly BWF: "BWF";
    readonly UTR: "UTR";
    readonly UNSPECIFIED: "UNSPECIFIED";
    readonly POINTS_AUTHORITIES: readonly ["ATP", "WTA", "ITF", "ITF_JUNIOR", "ITF_WHEELCHAIR", "TENNIS_EUROPE", "USTA", "LTA", "FFT", "DTB", "PPA", "BWF", "UTR", "UNSPECIFIED"];
};

interface RankingPolicy {
    policyName?: string;
    policyVersion?: string;
    pointsAuthority?: PointsAuthority;
    validDateRange?: DateRange;
    awardProfiles: AwardProfile[];
    qualityWinProfiles?: QualityWinProfile[];
    aggregationRules?: AggregationRules$2;
    requireWinForPoints?: boolean;
    requireWinFirstRound?: boolean;
    doublesAttribution?: DoublesAttribution;
    categoryResolution?: 'eventCategory' | 'participantPrimary';
    tierToLevel?: Record<string, Record<string, number>>;
    pointPoolModel?: PointPoolModel;
    derivedRankings?: DerivedRanking[];
}
type PointPoolModel = 'per-category' | 'shared';
interface CategoryScope {
    ageCategoryCodes?: string[];
    genders?: string[];
    categoryNames?: string[];
    categoryTypes?: string[];
    ratingTypes?: string[];
    ballTypes?: string[];
    wheelchairClasses?: string[];
    subTypes?: string[];
}
interface AwardProfileScope {
    dateRanges?: DateRange[];
    eventTypes?: EventTypeUnion[];
    drawTypes?: string[];
    drawSizes?: number[];
    maxDrawSize?: number;
    stages?: string[];
    stageSequences?: number[];
    levels?: number[];
    maxLevel?: number;
    flights?: FlightConfig;
    maxFlightNumber?: number;
    participationOrder?: number;
    category?: CategoryScope;
    priority?: number;
}
interface AwardProfile extends AwardProfileScope {
    profileName?: string;
    pointsAuthority?: PointsAuthority;
    finishingPositionRanges?: Record<number, PositionValue>;
    finishingRound?: Record<number, {
        won?: PositionValue;
        lost?: PositionValue;
    }>;
    perWinPoints?: PerWinPointsDef | PerWinPointsDef[];
    pointsPerWin?: number | LevelKeyed<number>;
    finishingPositionPoints?: {
        participationOrders: number[];
    };
    maxCountableMatches?: number | LevelKeyed<number | undefined>;
    bonusPoints?: BonusPointDef[];
    requireWinForPoints?: boolean;
    requireWinFirstRound?: boolean;
}
type PositionValue = number | PositionValueObject | PositionValueObject[];
interface PositionValueObject {
    value?: number;
    level?: Record<number, number | FlightValues> | (number | FlightValues)[];
    flights?: number[];
    f?: number[];
    drawSize?: number;
    drawSizes?: number[];
    threshold?: boolean;
    requireWin?: boolean;
    won?: number | PositionValueObject;
    lost?: number | PositionValueObject;
}
interface FlightValues {
    flights?: number[];
    f?: number[];
}
interface PerWinPointsDef {
    participationOrders?: number[];
    value?: number;
    level?: Record<number, number | LineValues> | (number | LineValues)[];
    line?: number[];
    limit?: number;
}
interface LineValues {
    line?: number[];
    limit?: number;
    f?: number[];
}
interface BonusPointDef {
    finishingPositions: number[];
    value: number | LevelKeyed<number>;
}
interface QualityWinProfile {
    rankingRanges: QualityWinRange[];
    rankingScaleName: string;
    rankingEventType?: string;
    rankingSnapshot?: 'tournamentStart' | 'matchDate' | 'latestAvailable';
    unrankedOpponentBehavior?: 'noBonus' | 'useDefaultRank';
    defaultRank?: number;
    levels?: number[];
    eventTypes?: EventTypeUnion[];
    drawTypes?: string[];
    stages?: string[];
    dateRanges?: DateRange[];
    category?: CategoryScope;
    maxBonusPerTournament?: number;
    includeWalkovers?: boolean;
}
interface QualityWinRange {
    rankRange: [number, number];
    value: number;
}
interface AggregationRules$2 {
    countingBuckets?: CountingBucket$2[];
    bestOfCount?: number;
    rollingPeriodDays?: number;
    decayFunction?: 'none' | 'linear' | 'stepped';
    decaySteps?: {
        afterDays: number;
        multiplier: number;
    }[];
    separateByGender?: boolean;
    perCategory?: boolean;
    minCountableResults?: number;
    maxResultsPerLevel?: Record<number, number>;
    doublesAttribution?: DoublesAttribution;
    tiebreakCriteria?: TiebreakCriterion[];
    categoryAggregation?: CategoryAggregationRule[];
}
interface CategoryAggregationRule {
    ruleName?: string;
    source: CategoryScope;
    target: CategoryScope;
    multiplier?: number;
    rerateTo?: {
        profileName: string;
    };
    requireParticipationInTarget?: boolean;
    minResultsFromTarget?: number;
    eligibleSourceWindow?: {
        olderBy?: number;
        youngerBy?: number;
    };
    retentionMonthsAfterAging?: number;
    maxCarriedResults?: number;
    subjectToBucketLimits?: boolean;
    carryComponents?: PointComponent[];
    excludedSourceFilters?: SourceFilter[];
}
interface SourceFilter {
    levels?: number[];
    drawTypes?: string[];
    eventTiers?: string[];
    ageEligibility?: 'agingUpToTarget' | 'agingDownFromSource';
}
interface DerivedRanking {
    category: CategoryScope;
    derivedFrom: CategoryScope;
    filter: DerivedFilter;
}
interface DerivedFilter {
    excludePlayersAgingUp?: boolean;
    ageRange?: {
        min?: number;
        max?: number;
    };
    additionalScope?: CategoryScope;
}
interface CountingBucket$2 {
    bucketName?: string;
    eventTypes?: EventTypeUnion[];
    pointComponents?: PointComponent[];
    bestOfCount?: number;
    maxResultsPerLevel?: Record<number, number>;
    minResults?: number;
    levels?: number[];
    mandatoryRules?: MandatoryRule[];
}
interface MandatoryRule {
    ruleName?: string;
    levels: number[];
    bestOfCount?: number;
}
type PointComponent = 'positionPoints' | 'perWinPoints' | 'bonusPoints' | 'qualityWinPoints';
type DoublesAttribution = 'fullToEach' | 'splitEven' | 'teamOnly';
type TiebreakCriterion = 'headToHead' | 'mostWins' | 'highestSingleResult' | 'mostCountingResults' | 'rating';
interface PointAward$2 {
    participantId: string;
    personId?: string;
    tournamentId?: string;
    eventId?: string;
    drawId: string;
    structureId?: string;
    eventType: string;
    drawType?: string;
    stage?: string;
    stageSequence?: number;
    category?: {
        ageCategoryCode?: string;
        categoryName?: string;
        ratingType?: string;
        gender?: string;
    };
    points: number;
    positionPoints: number;
    perWinPoints: number;
    qualityWinPoints: number;
    bonusPoints: number;
    linePoints?: number;
    collectionPosition?: number;
    winCount: number;
    rangeAccessor: string | number;
    startDate?: string;
    endDate?: string;
    level?: number;
    profileName?: string;
    pointsAuthority?: PointsAuthority;
}
interface RankingListEntry$1 {
    rank: number;
    participantId: string;
    personId?: string;
    totalPoints: number;
    countingResults: number;
    bucketTotals?: Record<string, number>;
    tournamentResults: PointAward$2[];
    tiebreakValues?: Record<TiebreakCriterion, number>;
    meetsMinimum: boolean;
}
interface DateRange {
    startDate?: string;
    endDate?: string;
}
interface FlightConfig {
    flightNumbers?: number[];
    pct?: Record<number, number>;
}
type LevelKeyed<T> = {
    level: Record<number, T> | T[];
};

type PointAward$1 = Record<string, any>;
type CountingBucket$1 = {
    bucketName: string;
    eventTypes?: string[];
    pointComponents: string[];
    bestOfCount: number;
    maxResultsPerLevel?: Record<number, number>;
    mandatoryRules?: MandatoryRule[];
};
type AggregationRules$1 = {
    rollingPeriodDays?: number;
    separateByGender?: boolean;
    perCategory?: boolean;
    countingBuckets?: CountingBucket$1[];
    tiebreakCriteria?: TiebreakCriterion[];
    minCountableResults?: number;
    maxResultsPerLevel?: Record<number, number>;
    bestOfCount?: number;
    doublesAttribution?: DoublesAttribution;
    categoryAggregation?: CategoryAggregationRule[];
};
type CategoryFilter = {
    ageCategoryCodes?: string[];
    genders?: string[];
    eventTypes?: string[];
};
type RankingListEntry = {
    personId: string;
    totalPoints: number;
    rank: number;
    meetsMinimum: boolean;
    countingResults: PointAward$1[];
    droppedResults: PointAward$1[];
    bucketBreakdown?: {
        bucketName: string;
        countingResults: PointAward$1[];
        droppedResults: PointAward$1[];
        bucketTotal: number;
    }[];
};
type GenerateRankingListArgs = {
    pointAwards: PointAward$1[];
    aggregationRules?: AggregationRules$1;
    categoryFilter?: CategoryFilter;
    asOfDate?: string;
    pointPoolModel?: PointPoolModel;
};
declare function generateRankingList({ pointAwards, aggregationRules, categoryFilter, asOfDate, pointPoolModel, }: GenerateRankingListArgs): RankingListEntry[];

interface ParticipantContext {
    ageAtDate?: (personId: string, asOfDate?: string) => number | undefined;
    isAgingUpAtPeriodEnd?: (personId: string) => boolean;
}
type ApplyDerivedRankingsArgs = {
    entries: RankingListEntry[];
    filter: DerivedFilter;
    asOfDate?: string;
    participantContext?: ParticipantContext;
};
declare function applyDerivedRankings({ entries, filter, asOfDate, participantContext, }: ApplyDerivedRankingsArgs): RankingListEntry[];

type AssignOfficialArgs = {
    officialRecord: OfficialRecord;
    assignmentId?: string;
    tournamentId: string;
    roleSubtype: string;
    assignedDate?: string;
    startDate?: string;
    endDate?: string;
    assignedBy?: string;
    notes?: string;
    extensions?: any[];
};
declare function assignOfficial({ officialRecord, assignmentId, tournamentId, roleSubtype, assignedDate, startDate, endDate, assignedBy, notes, extensions, }: AssignOfficialArgs): {
    error?: any;
    assignment?: OfficialAssignment;
    success?: boolean;
};

type AssignSeedPositionsArgs = {
    provisionalPositioning?: boolean;
    useExistingSeedLimit?: boolean;
    seedingProfile?: SeedingProfile;
    assignments: SeedAssignment[];
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    structureId: string;
    drawId: string;
    event: Event;
};
declare function assignSeedPositions(params: AssignSeedPositionsArgs): ResultType | {
    modifications?: number;
    success?: boolean;
};

declare function attachFlightProfile({ deleteExisting, event, flightProfile }: {
    deleteExisting: any;
    event: any;
    flightProfile: any;
}): ResultType | {
    success: boolean;
    flightProfile: any;
};

interface PointsToDecoration {
    pointsToGame: [number, number];
    pointsToSet: [number, number];
    pointsToMatch: [number, number];
    gamesToSet: [number, number];
    isBreakpoint: boolean;
}
declare function calculatePointsTo(matchUp: MatchUp, formatStructure: FormatStructure, setType: SetType, activeSetFormat: SetFormatStructure | undefined, server: 0 | 1 | undefined): PointsToDecoration | undefined;

declare function deduceMatchUpFormat(scoreString: string): string;

type ReportColumn = {
    key: string;
    title: string;
    type?: 'string' | 'number' | 'boolean' | 'date';
    width?: number;
};
type ReportDefinition = {
    reportId: string;
    name: string;
    description: string;
    category: string;
    source?: 'factory' | 'server';
};
type ReportResult = {
    reportId: string;
    generatedAt: string;
    parameters?: Record<string, any>;
    columns: ReportColumn[];
    rows: Record<string, any>[];
    summary?: Record<string, any>;
};
type ReportAvailability = ReportDefinition & {
    computableNow: boolean;
};
type ReportContext = {
    tournamentRecord: any;
    participantMap?: Record<string, any>;
    matchUps?: any[];
    venues?: any[];
};

type GetAvailableReportsArgs = {
    tournamentRecord: Tournament;
};
declare function getAvailableReports({ tournamentRecord, }: GetAvailableReportsArgs): {
    availableReports: ReportAvailability[];
} | {
    error: any;
};

type ParseArgs = {
    consideredDate?: string;
    category?: Category;
};
declare function getCategoryAgeDetails(params: ParseArgs): any;

declare function getEventPublishStatus({ event, status }: {
    event: any;
    status?: string | undefined;
}): any;

declare function getMaxEntryPosition(params: any): number;

type PointAward = Record<string, any>;
type CountingBucket = {
    bucketName: string;
    eventTypes?: string[];
    pointComponents: string[];
    bestOfCount: number;
    maxResultsPerLevel?: Record<number, number>;
    mandatoryRules?: MandatoryRule[];
};
type AggregationRules = {
    countingBuckets?: CountingBucket[];
    maxResultsPerLevel?: Record<number, number>;
    bestOfCount?: number;
};
type BucketBreakdown = {
    bucketName: string;
    countingResults: PointAward[];
    droppedResults: PointAward[];
    bucketTotal: number;
};
type GetParticipantPointsArgs = {
    pointAwards: PointAward[];
    personId: string;
    aggregationRules?: AggregationRules;
};
declare function getParticipantPoints({ pointAwards, personId, aggregationRules, }: GetParticipantPointsArgs): {
    buckets: BucketBreakdown[];
    totalPoints: number;
};

type ModifyEventEntriesArgs = {
    unpairedParticipantIds?: string[];
    participantIdPairs?: string[][];
    entryStatus?: EntryStatusUnion;
    tournamentRecord: Tournament;
    entryStage?: string;
    event: Event$1;
};
declare function modifyEventEntries({ entryStatus, unpairedParticipantIds, participantIdPairs, entryStage, tournamentRecord, event, }: ModifyEventEntriesArgs): any;

type RemoveEventEntriesArgs = {
    tournamentParticipants?: HydratedParticipant[];
    entryStatuses?: EntryStatusUnion[];
    tournamentRecord?: Tournament;
    autoEntryPositions?: boolean;
    participantIds: string[];
    stage?: StageTypeUnion;
    event: Event$1;
};
declare function removeEventEntries({ autoEntryPositions, participantIds, entryStatuses, stage, event, }: RemoveEventEntriesArgs): {
    participantIdsRemoved?: string[];
    success?: boolean;
    error?: ErrorType;
};

type RemoveExtensionResult = {
    success?: boolean;
    error?: ErrorType;
    info?: any;
};
declare function removeExtension(params?: {
    tournamentRecords?: TournamentRecords;
    element?: {
        extensions?: any[];
    };
    discover?: boolean;
    name?: string;
}): RemoveExtensionResult;

type AddEvaluationArgs = {
    officialRecord: OfficialRecord;
    evaluationId?: string;
    evaluatorPersonId: string;
    subjectPersonId?: string;
    tournamentId?: string;
    tournamentName?: string;
    matchUpId?: string;
    evaluationDate?: string;
    overallRating: number;
    policyName?: string;
    scores?: EvaluationScore[];
    comments?: string;
    documentReference?: any;
    extensions?: any[];
};
declare function addEvaluation({ officialRecord, evaluationId, evaluatorPersonId, subjectPersonId, tournamentId, tournamentName, matchUpId, evaluationDate, overallRating, policyName, scores, comments, documentReference, extensions, }: AddEvaluationArgs): {
    error?: any;
    evaluation?: OfficialEvaluation;
    success?: boolean;
};

type AddSuspensionArgs = {
    officialRecord: OfficialRecord;
    suspensionId?: string;
    organisationId?: string;
    suspensionType?: string;
    suspensionNotes?: string;
    suspendedFrom?: string;
    suspendedUntil?: string;
    extensions?: any[];
};
declare function addSuspension({ officialRecord, suspensionId, organisationId, suspensionType, suspensionNotes, suspendedFrom, suspendedUntil, extensions, }: AddSuspensionArgs): {
    error?: any;
    suspension?: OfficialSuspension;
    success?: boolean;
};

type BuildReportContextArgs = {
    tournamentRecord: Tournament;
};
declare function buildReportContext({ tournamentRecord }: BuildReportContextArgs): ReportContext | {
    error: any;
};

declare function checkScoreHasValue(params: any): boolean;

type CheckSetIsCompleteArgs = {
    matchUpScoringFormat?: any;
    ignoreTiebreak?: boolean;
    isDecidingSet?: boolean;
    isTiebreakSet?: boolean;
    matchUpFormat?: string;
    isTimedSet?: boolean;
    set: any;
};
declare function checkSetIsComplete({ ignoreTiebreak, matchUpScoringFormat, matchUpFormat, isTiebreakSet, isDecidingSet, isTimedSet, set, }: CheckSetIsCompleteArgs): boolean | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};

declare function generateOutcome(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    outcome: {
        score: {
            sets: never[];
            scoreStringSide1: string;
            side2ScoreString: string;
        };
        matchUpStatus: any;
    };
} | {
    outcome: {
        winningSide: any;
        matchUpStatus: any;
        score: {
            sets: any;
            scoreStringSide1: string | {
                error?: ErrorType;
                info?: ErrorType | string;
            };
            scoreStringSide2: string | {
                error?: ErrorType;
                info?: ErrorType | string;
            };
        } | undefined;
    };
};

declare function getDrawData(params: any): {
    structures?: any[];
    success?: boolean;
    error?: ErrorType;
    drawInfo?: any;
};

type GetEvaluationsArgs = {
    officialRecord: OfficialRecord;
    evaluatorPersonId?: string;
    status?: EvaluationStatus;
    tournamentId?: string;
    policyName?: string;
};
declare function getEvaluations({ officialRecord, evaluatorPersonId, status, tournamentId, policyName, }: GetEvaluationsArgs): {
    error?: any;
    success?: boolean;
    evaluations?: OfficialEvaluation[];
};

type GetPublishStateArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    eventIds?: string[];
    drawIds?: string[];
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
declare function getPublishState(params: GetPublishStateArgs): ResultType & {
    publishState?: any;
};

type QualityWin = {
    opponentParticipantId: string;
    opponentRank: number;
    matchUpId: string;
    points: number;
};
type GetQualityWinPointsArgs = {
    qualityWinProfiles: any[];
    wonMatchUpIds: string[];
    mappedMatchUps: Record<string, any>;
    participantId?: string;
    participantSideMap: Record<string, number>;
    tournamentParticipants: any[];
    tournamentStartDate?: string;
    level?: number;
};
declare function getQualityWinPoints({ qualityWinProfiles, wonMatchUpIds, mappedMatchUps, participantSideMap, tournamentParticipants, tournamentStartDate, level, }: GetQualityWinPointsArgs): {
    qualityWinPoints: number;
    qualityWins: QualityWin[];
};

type ScaleType = {
    scaleName: string;
    scaleDate: string;
    scaleValue: any;
};
type ScalesType = {
    [SINGLES_EVENT]?: ScaleType;
    [DOUBLES_EVENT]?: ScaleType;
    [TEAM_EVENT]?: ScaleType;
};
declare function getScaleValues(params: any): ResultType & {
    seedings?: ScalesType;
    rankings?: ScalesType;
    ratings?: ScalesType;
};

type GetTournamentPointsArgs = {
    participantFilters?: ParticipantFilters;
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord: Tournament;
    policyName?: string;
    level?: number;
};
declare function getTournamentPoints({ participantFilters, policyDefinitions, tournamentRecord, policyName, level, }: GetTournamentPointsArgs): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    participantsWithOutcomes: HydratedParticipant[] | undefined;
    personPoints: {};
    pairPoints: {};
    teamPoints: {};
    error?: undefined;
};

type ModifyTieFormatArgs = {
    considerations?: {
        collectionName?: boolean;
        collectionOrder?: boolean;
    };
    updateInProgressMatchUps?: boolean;
    tieFormatComparison?: boolean;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    modifiedTieFormat: TieFormat;
    structureId?: string;
    matchUpId?: string;
    eventId?: string;
    uuids?: string[];
    event?: Event$1;
};
declare function modifyTieFormat({ updateInProgressMatchUps, tieFormatComparison, modifiedTieFormat, tournamentRecord, considerations, drawDefinition, structureId, matchUpId, eventId, uuids, event, }: ModifyTieFormatArgs): ResultType | {
    success: boolean;
    processedTieFormat: any;
    modifications: any[];
};

type RemoveOnlineResourceArgs = {
    onlineResource: OnlineResource;
    drawDefinition?: DrawDefinition;
    tournamentRecord: Tournament;
    organisationId?: string;
    participantId?: string;
    personId?: string;
    courtId?: string;
    venueId?: string;
    event?: Event;
};
declare function removeOnlineResource(params: RemoveOnlineResourceArgs): ResultType;

declare function removeScaleValues({ tournamentRecord, scaleAttributes, drawDefinition, entryStatuses, drawId, event, stage, }: {
    tournamentRecord: any;
    scaleAttributes: any;
    drawDefinition: any;
    entryStatuses: any;
    drawId: any;
    event: any;
    stage: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};

declare function setEntryPosition({ tournamentRecord, drawDefinition, participantId, entryPosition, skipRefresh, event, }: {
    tournamentRecord: any;
    drawDefinition: any;
    participantId: any;
    entryPosition: any;
    skipRefresh: any;
    event: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    entryPosition: any;
};
declare function setEntryPositions({ tournamentRecord, entryPositions, drawDefinition, event }: {
    tournamentRecord: any;
    entryPositions: any;
    drawDefinition: any;
    event: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
    entryPosition: any;
} | {
    error: {
        message: string;
        code: string;
    };
};

declare function unPublishEvent({ removePriorValues, tournamentRecord, status, event }: {
    removePriorValues?: boolean | undefined;
    tournamentRecord: any;
    status?: string | undefined;
    event: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    success: boolean;
    eventId: any;
};

declare function updateDrawIdsOrder({ event, orderedDrawIdsMap }: {
    event: any;
    orderedDrawIdsMap: any;
}): {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};

type PlayoffGroupConfig = {
    structureOptions?: {
        groupSize?: number;
    };
    addNameBaseToAttributeName?: boolean;
    playoffStructureNameBase?: string;
    finishingPositionLimit?: number;
    finishingPositionNaming?: any;
    finishingPositions?: number[];
    playoffAttributes?: any;
    structureNameMap?: any;
    sequenceLimit?: number;
    structureName?: string;
    structureId?: string;
    remainder?: boolean;
    drawType?: string;
    bestOf?: number;
    rankBy?: string;
};
type ValidatePlayoffGroupsArgs = {
    playoffGroups: PlayoffGroupConfig[];
    groupCount: number;
    groupSize: number;
};
declare function validatePlayoffGroups({ playoffGroups, groupCount, groupSize, }: ValidatePlayoffGroupsArgs): ResultType & {
    valid?: boolean;
    consumptionMap?: {
        [finishingPosition: number]: number;
    };
    info?: string;
};

type DestroyPairEntryArgs = {
    removeGroupParticipant?: boolean;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    participantId: string;
    drawId?: string;
    event: Event$1;
};
declare function destroyPairEntry({ removeGroupParticipant, tournamentRecord, drawDefinition, participantId, drawId, event, }: DestroyPairEntryArgs): {
    success?: boolean;
    error?: ErrorType;
    participantRemoved?: boolean;
};
declare function destroyPairEntries(params: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    destroyedCount: number;
    error?: undefined;
} | {
    error: any[];
};

declare function eventMatchUps(params: GetMatchUpsArgs): GroupsMatchUpsResult;

interface MCPPoint {
    match_id: string;
    Pt: string;
    Set1: string;
    Set2: string;
    Gm1: string;
    Gm2: string;
    Pts: string;
    Svr: string;
    Ret: string;
    '1st': string;
    '2nd': string;
    PtWinner: string;
    isAce: string;
    isDouble: string;
    isUnforced: string;
    isForced: string;
    isRallyWinner: string;
    rallyCount: string;
    [key: string]: string;
}
interface MCPMatch {
    match_id: string;
    points: MCPPoint[];
}
interface ParsedMCPPoint {
    winner: 0 | 1;
    server: 0 | 1;
    result?: PointResult;
    stroke?: StrokeType;
    hand?: 'Forehand' | 'Backhand';
    serve?: 1 | 2;
    serveLocation?: ServeLocation;
    rally?: RallyShot[];
    rallyLength?: number;
    code?: string;
}
interface ShotParseResult {
    serves: string[];
    rally: string[];
    lets?: number;
    terminator?: string;
    result?: string;
    winner?: 'S' | 'R';
    error?: string;
    parse_notes?: string;
    first_serve?: {
        serves: string[];
        lets?: number;
        error?: string;
        parse_notes?: string;
    };
    serve?: 1 | 2;
    code?: string;
}
declare function shotSplitter(shotSequence: string): string[];
declare function analyzeSequence(shotSequence: string): ShotParseResult;
declare function pointParser(serves: [string, string]): ShotParseResult;
declare function shotParser(shotSequence: string, whichServe: 1 | 2): ShotParseResult;
declare function parseMCPPoint(mcpPoint: MCPPoint, serverIndex: 0 | 1): ParsedMCPPoint;
declare function parseCSV(csvContent: string): MCPPoint[];
declare function groupByMatch(points: MCPPoint[]): MCPMatch[];

interface MCPValidationOptions {
    csvData: string;
    matchId?: string;
    matchUpFormat?: string;
    validateScore?: boolean;
    debug?: boolean;
}
interface MCPValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
    matchesProcessed: number;
    pointsProcessed: number;
    matchUps: MatchUp[];
    totalAces: number;
    totalDoubleFaults: number;
    totalWinners: number;
    totalUnforcedErrors: number;
    totalForcedErrors: number;
}
interface MCPMatchResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
    matchUp: MatchUp;
    pointsProcessed: number;
    expectedScore?: string;
    actualScore: string;
    scoreMatches?: boolean;
    formatDeduced: boolean;
    aces: number;
    doubleFaults: number;
    winners: number;
    unforcedErrors: number;
    forcedErrors: number;
}
declare function validateMCPMatch(mcpMatch: MCPMatch, options?: {
    matchUpFormat?: string;
    validateScore?: boolean;
    debug?: boolean;
}): MCPMatchResult;
declare function mcpValidator(options: MCPValidationOptions): MCPValidationResult;
declare function exportMatchUpJSON(matchUp: MatchUp): string;

type FindMatchUpFormatTiming = {
    tournamentRecords: {
        [key: string]: Tournament;
    };
    defaultRecoveryMinutes?: number;
    defaultAverageMinutes?: number;
    matchUpFormat: string;
    categoryName?: string;
    categoryType?: string;
    tournamentId: string;
    eventType?: EventTypeUnion;
    eventId?: string;
};
declare function findMatchUpFormatTiming({ defaultRecoveryMinutes, defaultAverageMinutes, tournamentRecords, matchUpFormat, categoryName, categoryType, tournamentId, eventType, eventId, }: FindMatchUpFormatTiming): {
    error: {
        message: string;
        code: string;
    };
    recoveryMinutes?: undefined;
    averageMinutes?: undefined;
    typeChangeRecoveryMinutes?: undefined;
} | {
    recoveryMinutes: any;
    averageMinutes: any;
    typeChangeRecoveryMinutes: any;
    error?: undefined;
};

type GetEntryStatusReportsArgs = {
    tournamentRecord: Tournament;
};
declare function getEntryStatusReports({ tournamentRecord }: GetEntryStatusReportsArgs): {
    error: {
        message: string;
        code: string;
    };
    entryStatusReports?: undefined;
    participantEntryReports?: undefined;
    eventReports?: undefined;
    withDrawnParticipantIds?: undefined;
    tournamentEntryReport?: undefined;
} | {
    entryStatusReports: unknown[];
    participantEntryReports: unknown[];
    eventReports: unknown[];
    withDrawnParticipantIds: string[];
    tournamentEntryReport: {
        nonParticipatingEntriesCount: number;
        individualParticipantsCount: number;
        eventsCount: number;
        nonParticipatingParticipantIds: string[];
        drawDefinitionsCount: number;
        tournamentId: string;
    };
    error?: undefined;
};

declare function getEventStructures({ withStageGrouping, stageSequences, stageSequence, roundTarget, stages, event, stage, }: {
    withStageGrouping: any;
    stageSequences: any;
    stageSequence: any;
    roundTarget: any;
    stages: any;
    event: any;
    stage: any;
}): {
    error: {
        message: string;
        code: string;
    };
    structures?: undefined;
    stageStructures?: undefined;
} | {
    structures: Structure[];
    stageStructures: {};
    error?: undefined;
};
declare function getTournamentStructures({ withStageGrouping, tournamentRecord, stageSequences, stageSequence, roundTarget, stages, stage, }: {
    withStageGrouping: any;
    tournamentRecord: any;
    stageSequences: any;
    stageSequence: any;
    roundTarget: any;
    stages: any;
    stage: any;
}): {
    error: {
        message: string;
        code: string;
    };
    structures?: undefined;
    stageStructures?: undefined;
} | {
    structures: Structure[];
    stageStructures: {};
    error?: undefined;
};

declare function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }: {
    profileBands: any;
    tournamentRecord: any;
    matchUps: any;
}): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    competitiveBands: any;
    error?: undefined;
};

declare function getParticipantPaymentStatus({ tournamentRecord, participantId }: {
    tournamentRecord: any;
    participantId: any;
}): "WAIVED" | "REFUNDED" | "PARTIAL" | "UNPAID" | "PAID" | (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
} | undefined;

type GetRoundMatchUpsArgs = {
    matchUps?: MatchUp$1[];
    interpolate?: boolean;
};
type RoundMatchUpsResult = {
    roundMatchUps?: {
        [roundNumber: number]: HydratedMatchUp[];
    };
    hasNoRoundPositions?: boolean;
    roundsNotPowerOf2?: boolean;
    maxMatchUpsCount?: number;
    roundProfile?: RoundProfile;
    roundNumbers?: number[];
    error?: ErrorType;
};
declare function getRoundMatchUps({ matchUps, interpolate }: GetRoundMatchUpsArgs): RoundMatchUpsResult;

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

type GetTieFormatArgs = {
    tournamentRecord: Tournament;
    drawDefinition?: DrawDefinition;
    structure?: Structure;
    structureId?: string;
    matchUpId: string;
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
declare function getTieFormat({ tournamentRecord, drawDefinition, structureId, matchUpId, structure, eventId, drawId, event, }: GetTieFormatArgs): {
    structureDefaultTieFormat?: TieFormat;
    eventDefaultTieFormat?: TieFormat;
    drawDefaultTieFormat?: TieFormat;
    tieFormat?: TieFormat;
    structure?: Structure;
    error?: ErrorType;
    success?: boolean;
    matchUp?: MatchUp$1;
};

declare function isValidMatchUpFormat({ matchUpFormat }: {
    matchUpFormat: string;
}): boolean;

type ModifyCourtAvailabilityArgs = {
    venueMatchUps?: HydratedMatchUp[];
    dateAvailability: Availability[];
    tournamentRecord: Tournament;
    disableNotice?: boolean;
    courtId: string;
    force?: boolean;
};
declare function modifyCourtAvailability({ tournamentRecord, dateAvailability, disableNotice, venueMatchUps, courtId, force, }: ModifyCourtAvailabilityArgs): {
    error?: ErrorType;
    success?: boolean;
    totalMergeCount?: number;
    matchUpIds?: string[];
    info?: string;
};

type GameFormat = {
    type: 'CONSECUTIVE';
    count: number;
    deuceAfter?: number;
} | {
    type: 'TRADITIONAL';
    deuceAfter?: number;
};
type ParsedFormat = {
    matchRoot?: string;
    aggregate?: boolean;
    matchMods?: string[];
    finalSetFormat?: any;
    simplified?: boolean;
    exactly?: number;
    setFormat?: any;
    bestOf?: number;
    gameFormat?: GameFormat;
    matchUpConstraint?: {
        timed?: boolean;
        minutes?: number;
    };
};
declare function parse(matchUpFormatCode: string): ParsedFormat | undefined;

interface PBPValidationOptions {
    points: string;
    expectedScore?: string;
    matchUpFormat?: string;
    allowExtraPoints?: boolean;
    debug?: boolean;
}
interface PBPValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
    pointsProcessed: number;
    pointsRejected: string[];
    expectedScore?: string;
    actualScore: string;
    matchUpFormat: string;
    formatDeduced: boolean;
    sets: Array<{
        games: [number, number];
        tiebreak?: [number, number];
        scoreString: string;
    }>;
}
declare function pbpValidator(options: PBPValidationOptions): PBPValidationResult;

declare function promoteAlternate(params: any): ResultType | {
    error: {
        message: string;
        code: string;
    };
    invalidEntryStatus?: undefined;
    invalidStage?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidEntryStatus: any;
    invalidStage?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidStage: any;
    invalidEntryStatus?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidStageSequence: any;
    invalidEntryStatus?: undefined;
    invalidStage?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    participantIds: any;
} | {
    error: {
        message: string;
        code: string;
    };
    participantId: any;
};
declare function promoteAlternates({ tournamentRecord, drawDefinition, participantIds, stageSequence, stage, eventId, event, }: {
    tournamentRecord: any;
    drawDefinition: any;
    participantIds: any;
    stageSequence: any;
    stage?: string | undefined;
    eventId: any;
    event: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
    invalidEntryStatus?: undefined;
    invalidStage?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidEntryStatus: any;
    invalidStage?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidStage: any;
    invalidEntryStatus?: undefined;
    invalidStageSequence?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidStageSequence: any;
    invalidEntryStatus?: undefined;
    invalidStage?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    participantIds: any;
};

declare function removeOrphanedTieFormats({ event }: {
    event: Event$1;
}): void;

type ResetTieFormatArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    matchUpId: string;
    uuids?: string[];
    event?: Event$1;
};
declare function resetTieFormat(params: ResetTieFormatArgs): ResultType & {
    deletedMatchUpIds?: string[];
    newMatchUps?: MatchUp$1[];
    success?: boolean;
};

declare function validateSetScore(set: any, matchUpFormat?: string, isDecidingSet?: boolean, allowIncomplete?: boolean): {
    isValid: boolean;
    error?: string;
};
declare function validateMatchUpScore(sets: any[], matchUpFormat?: string, matchUpStatus?: string): {
    isValid: boolean;
    error?: string;
};

type AddEventEntriesArgs = {
    policyDefinitions?: PolicyDefinitions;
    suppressDuplicateEntries?: boolean;
    entryStatus?: EntryStatusUnion;
    drawDefinition?: DrawDefinition;
    autoEntryPositions?: boolean;
    tournamentRecord?: Tournament;
    entryStageSequence?: number;
    ignoreStageSpace?: boolean;
    entryStage?: StageTypeUnion;
    participantIds?: string[];
    extensions?: Extension[];
    enforceCategory?: boolean;
    enforceGender?: boolean;
    extension?: Extension;
    roundTarget?: number;
    drawId?: string;
    event: Event$1;
};
declare function addEventEntries(params: AddEventEntriesArgs): ResultType;

type AddExtensionArgs = {
    tournamentRecords?: TournamentRecords;
    activeTournamentId?: string;
    creationTime?: boolean;
    tournamentId?: string;
    extension: Extension;
    discover?: boolean;
    element?: any;
};
declare function addExtension(params?: AddExtensionArgs): {
    success?: boolean;
    error?: ErrorType;
};

declare function addPersons({ participantRole, tournamentRecord, persons }: {
    participantRole?: any;
    tournamentRecord: any;
    persons: any;
}): any;

declare function analyzeDraws({ tournamentRecord }: {
    tournamentRecord: any;
}): {
    error?: ErrorType;
    drawsAnalysis?: any;
    success?: boolean;
};

type CategoryCanContainArgs = {
    childCategory: Category;
    withDetails?: boolean;
    category: Category;
};
declare function categoryCanContain({ childCategory, withDetails, category }: CategoryCanContainArgs): any;

declare function drawMatchUps({ participants: tournamentParticipants, tournamentAppliedPolicies, scheduleVisibilityFilters, participantsProfile, afterRecoveryTimes, policyDefinitions, useParticipantMap, tournamentRecord, usePublishState, contextFilters, contextContent, matchUpFilters, participantMap, publishStatus, contextProfile, drawDefinition, nextMatchUps, tournamentId, inContext, context, event, }: GetMatchUpsArgs): {
    groupInfo: any;
    abandonedMatchUps?: HydratedMatchUp[];
    completedMatchUps?: HydratedMatchUp[];
    upcomingMatchUps?: HydratedMatchUp[];
    participants?: HydratedParticipant[];
    pendingMatchUps?: HydratedMatchUp[];
    byeMatchUps?: HydratedMatchUp[];
    matchUpsMap?: MatchUpsMap;
    matchUpsCount?: number;
    success?: boolean;
    error?: ErrorType;
};

declare function getAllowedMatchUpFormats({ tournamentRecord, categoryName, categoryType }: {
    tournamentRecord: any;
    categoryName: any;
    categoryType: any;
}): any;
declare function getAllowedDrawTypes({ tournamentRecord, categoryName, categoryType }: {
    tournamentRecord: any;
    categoryName: any;
    categoryType: any;
}): any;

declare function getEventProperties({ tournamentRecord, event }: {
    tournamentRecord: any;
    event: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    entryScaleAttributes: any;
    hasSeededParticipants: any;
    hasRankedParticipants: any;
    hasRatedParticipants: any;
};

declare function getParticipantSignInStatus({ tournamentRecord, participantId }: {
    tournamentRecord: any;
    participantId: any;
}): false | "SIGNED_IN" | (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
} | undefined;

declare function publishEventSeeding({ removePriorValues, stageSeedingScaleNames, seedingScaleNames, tournamentRecord, status, drawIds, event, }: {
    removePriorValues?: boolean | undefined;
    stageSeedingScaleNames: any;
    seedingScaleNames: any;
    tournamentRecord: any;
    status?: string | undefined;
    drawIds?: never[] | undefined;
    event: any;
}): ResultType & {
    valid?: boolean;
};
declare function unPublishEventSeeding({ removePriorValues, seedingScaleNames, tournamentRecord, status, drawIds, stages, event, }: {
    removePriorValues?: boolean | undefined;
    seedingScaleNames: any;
    tournamentRecord: any;
    status?: string | undefined;
    drawIds: any;
    stages: any;
    event: any;
}): ResultType & {
    valid?: boolean;
};

type ResetScoreCardArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    tiebreakReset?: boolean;
    matchUpStatus?: string;
    matchUpId: string;
    event?: Event$1;
};
declare function resetScorecard(params: ResetScoreCardArgs): ResultType;

type AddOnlineResourceArgs = {
    onlineResource: OnlineResource;
    drawDefinition?: DrawDefinition;
    tournamentRecord: Tournament;
    organisationId?: string;
    participantId?: string;
    personId?: string;
    courtId?: string;
    venueId?: string;
    event?: Event$1;
};
declare function addOnlineResource(params: AddOnlineResourceArgs): ResultType;

type PublicFindParticipantArgs = {
    tournamentRecords?: TournamentRecords;
    policyDefinitions?: PolicyDefinitions;
    tournamentRecord?: Tournament;
    contextProfile?: ContextProfile;
    participantId?: string;
    personId?: string;
};
declare function publicFindParticipant(params: PublicFindParticipantArgs): {
    participant?: HydratedParticipant;
    tournamentId?: string;
    error?: ErrorType;
    stack?: any;
};

type GetMatchUpsMapArgs = {
    drawDefinition?: DrawDefinition;
    structure?: Structure;
};
declare function getMatchUpsMap({ drawDefinition, structure }: GetMatchUpsMapArgs): MatchUpsMap;

type ScheduleDetails = {
    attributes: {
        [key: string]: boolean;
    };
    dates: string[];
};
type DisplayAttributes = {
    participantAttributes?: {
        [key: string]: any;
    };
    scheduleDetails?: ScheduleDetails[];
    [key: string]: any;
    theme?: string;
};
type DisplaySettings = {
    draws: {
        [key: string]: DisplayAttributes;
        default: DisplayAttributes;
    };
    [key: string]: any;
};
type SetEventDisplaySettings = {
    displaySettings: DisplaySettings;
    tournamentRecord: Tournament;
    removePriorValues?: boolean;
    eventId?: string;
    status?: string;
    event: Event$1;
};
declare function setEventDisplay({ removePriorValues, tournamentRecord, displaySettings, status, event, }: SetEventDisplaySettings): ResultType;

type SetSubOrderArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    drawPosition: number;
    structureId: string;
    subOrder: number;
    event?: Event$1;
};
declare function setSubOrder({ tournamentRecord, drawDefinition, drawPosition, structureId, subOrder, event, }: SetSubOrderArgs): ResultType;

type ValidateLineUpArgs = {
    tieFormat?: TieFormat;
    lineUp: LineUp;
};
declare function validateLineUp({ lineUp, tieFormat }: ValidateLineUpArgs): {
    valid: boolean;
    errors: string[];
    error: {
        message: string;
        code: string;
    } | undefined;
};

type AddTimeItemArgs = {
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    removePriorValues?: boolean;
    duplicateValues?: boolean;
    participantId?: string;
    creationTime?: boolean;
    timeItem: TimeItem;
    event?: Event$1;
    element: any;
};
declare function addTimeItem(params: AddTimeItemArgs): any;
type AddParticipantTimeItemArgs = {
    tournamentRecord: Tournament;
    removePriorValues?: boolean;
    duplicateValues?: boolean;
    creationTime?: boolean;
    participantId: string;
    timeItem: TimeItem;
};
declare function addParticipantTimeItem({ creationTime, removePriorValues, tournamentRecord, duplicateValues, participantId, timeItem, }: AddParticipantTimeItemArgs): any;
declare function addTournamentTimeItem(params: any): any;
declare function addEventTimeItem(params: any): any;

declare function analyzeMatchUp(params?: any): ResultType & {
    completedSetsHaveValidOutcomes?: boolean;
    validMatchUpWinningSide?: boolean;
    calculatedWinningSide?: number;
    isLastSetWithValues?: boolean;
    validMatchUpOutcome?: boolean;
    sideTiebreakScores?: number[];
    isCompletedMatchUp?: boolean;
    completedSetsCount?: number;
    isValidSideNumber?: boolean;
    matchUpScoringFormat?: any;
    hasExistingValue?: boolean;
    sidePointScores?: number[];
    sideGameScores?: number[];
    expectTimedSet?: boolean;
    isCompletedSet?: boolean;
    isExistingSet?: boolean;
    existingValue?: number;
    isActiveSet?: boolean;
    winningSide?: number;
};

type CheckValidEntriesArgs = {
    policyDefinitions?: PolicyDefinitions;
    appliedPolicies?: PolicyDefinitions;
    participantMap?: ParticipantMap;
    tournamentRecord?: Tournament;
    participants?: Participant$1[];
    consideredEntries?: Entry[];
    enforceGender?: boolean;
    event: Event$1;
};
declare function checkValidEntries({ consideredEntries, policyDefinitions, tournamentRecord, appliedPolicies, participantMap, enforceGender, participants, event, }: CheckValidEntriesArgs): {
    error: {
        message: string;
        code: string;
    };
    invalidParticipantIds?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    invalidParticipantIds: string[];
} | {
    valid: boolean;
    success: boolean;
    error?: undefined;
    invalidParticipantIds?: undefined;
};

declare function createMatchUp(options: CreateMatchUpOptions): MatchUp;

type GenerateReportArgs = {
    tournamentRecord: Tournament;
    reportId: string;
    parameters?: Record<string, any>;
};
declare function generateReport({ tournamentRecord, reportId }: GenerateReportArgs): ReportResult | {
    error: any;
};

declare function getAwardProfile(params: any): {
    awardProfile: any;
};

type GetFlightProfileArgs = {
    eventId?: string;
    event: Event$1;
};
declare function getFlightProfile({ event, eventId }: GetFlightProfileArgs): {
    error: {
        message: string;
        code: string;
    };
    flightProfile?: undefined;
} | {
    flightProfile: any;
    error?: undefined;
};

declare function getMatchUpType(params: {
    matchUp: {
        sides?: {
            participant?: {
                participantType?: string;
            };
        }[];
        matchUpType?: string;
    };
}): ResultType & {
    matchUpType?: string;
};

type GetScaledEntriesArgs = {
    scaleAttributes: ScaleAttributes;
    tournamentRecord: Tournament;
    sortDescending?: boolean;
    stageSequence?: number;
    scaleSortMethod?: any;
    entries?: Entry[];
    stage?: string;
    event?: Event$1;
};
declare function getScaledEntries({ sortDescending, tournamentRecord, scaleAttributes, scaleSortMethod, stageSequence, entries, event, stage, }: GetScaledEntriesArgs): {
    error?: ErrorType;
    scaledEntries?: any[];
};

declare function hasLuckyRounds({ structure, matchUps }: {
    structure?: Structure;
    matchUps?: MatchUp$1[];
}): boolean;

type IsAdHocArgs = {
    structure?: any;
};
declare function isAdHoc({ structure }: IsAdHocArgs): boolean;

declare function isEmbargoed(detail?: PublishingDetail): boolean;
declare function isVisiblyPublished(detail?: PublishingDetail): boolean;

declare function removeSeeding({ tournamentRecord, drawDefinition, entryStatuses, scaleName, drawId, event, stage }: {
    tournamentRecord: any;
    drawDefinition: any;
    entryStatuses: any;
    scaleName: any;
    drawId: any;
    event: any;
    stage: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    info: string;
};

type ValidateTieFormatArgs = {
    checkCollectionIds?: boolean;
    enforceCategory?: boolean;
    enforceGender?: boolean;
    gender?: GenderUnion;
    category?: Category;
    tieFormat?: any;
    event?: Event$1;
};
declare function validateTieFormat(params: ValidateTieFormatArgs): ResultType;

type DisableCourtsArgs = {
    tournamentRecords: any;
    tournamentId?: string;
    courtIds: string[];
    dates?: string[];
};
declare function disableCourts(params: DisableCourtsArgs): ResultType & {
    valid?: boolean;
};

type DisableVenuesArgs = {
    tournamentRecords: any;
    tournamentId?: string;
    venueIds: string[];
};
declare function disableVenues(params: DisableVenuesArgs): ResultType & {
    valid?: boolean;
};

declare function getAllDrawMatchUps(params: any): ResultType & {
    matchUps?: HydratedMatchUp[];
    matchUpsMap?: MatchUpsMap;
};

declare function getAllEventData({ tournamentRecord, policyDefinitions }: {
    tournamentRecord: any;
    policyDefinitions: any;
}): {
    error: {
        message: string;
        code: string;
    };
    allEventData?: undefined;
} | {
    allEventData: {
        tournamentInfo: any;
        venuesData: HydratedVenue[] | undefined;
        eventsData: any;
    };
    error?: undefined;
};

type GetAwardPointsArgs = {
    participantWon?: boolean;
    flightNumber?: number;
    drawSize: number;
    valueObj: any;
    flights?: any;
    level?: number;
};
declare function getAwardPoints({ participantWon, flightNumber, valueObj, drawSize, flights, level, }: GetAwardPointsArgs): {
    awardPoints: number;
    requireWin: any;
};

type SetComplementArgs = {
    lowValue?: string | number;
    tiebreakAt?: number;
    isSide1?: boolean;
    NoAD?: boolean;
    setTo: number;
    winBy?: number;
};
declare const getSetComplement: (params: SetComplementArgs) => number[] | false;
type TiebreakComplementArgs = {
    lowValue?: number | string;
    tiebreakNoAd?: boolean;
    tiebreakTo: number;
    isSide1?: boolean;
};
declare const getTiebreakComplement: (params: TiebreakComplementArgs) => number[] | false;

declare function setEventStartDate({ tournamentRecord, event, startDate }: {
    tournamentRecord: any;
    event: any;
    startDate: any;
}): ResultType | {
    error: {
        message: string;
        code: string;
    };
};
declare function setEventEndDate(params: any): (ResultType & {
    valid?: boolean;
}) | {
    error: {
        message: string;
        code: string;
    };
};
type SetEventDatesArgs = {
    tournamentRecord: Tournament;
    weekdays?: WeekdayUnion[];
    activeDates?: string[];
    startDate?: string;
    endDate?: string;
    event: Event$1;
};
declare function setEventDates(params: SetEventDatesArgs): ResultType;

declare function validateCategory({ category }: {
    category: any;
}): any;

declare function addNotes(params?: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};
declare function removeNotes(params?: any): {
    error: {
        message: string;
        code: string;
    };
} | {
    success: boolean;
    error?: undefined;
};

type AnalyzeScoreArgs = {
    existingMatchUpStatus?: string;
    matchUpStatus?: string;
    matchUpFormat?: string;
    winningSide?: number;
    score: Score$1;
};
declare function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: AnalyzeScoreArgs): {
    valid: boolean;
};

declare function enableCourts(params: any): ResultType & {
    valid?: boolean;
};

type EnableVenuesArgs = {
    tournamentRecords: TournamentRecords;
    enableAll?: boolean;
    venueIds: string[];
};
declare function enableVenues(params: EnableVenuesArgs): ResultType & {
    valid?: boolean;
};

type GetDrawDefinitionArgs = {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord?: Tournament;
    tournamentId?: string;
    drawId: string;
};
declare function publicFindDrawDefinition(params: GetDrawDefinitionArgs): {
    error: ErrorType;
    drawDefinition?: undefined;
} | {
    drawDefinition: any;
    error?: undefined;
};

type DeleteCourtArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    disableNotice?: boolean;
    courtId: string;
    force?: boolean;
};
declare function deleteCourt(params: DeleteCourtArgs): any;
type DeleteCourtsArgs = {
    tournamentRecord?: Tournament;
    courtIds: string[];
    force?: boolean;
};
declare function deleteCourts(params: DeleteCourtsArgs): {
    success?: boolean;
    error?: ErrorType;
};

declare function deleteEvents(params: any): ResultType & {
    valid?: boolean;
};

type DeleteVenueArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    venueId: string;
    force?: boolean;
};
declare function deleteVenue(params: DeleteVenueArgs): {
    success?: boolean;
    error?: ErrorType;
};
declare function deleteVenues({ tournamentRecord, venueIds, force }: {
    tournamentRecord: any;
    venueIds: any;
    force: any;
}): {
    success?: boolean;
    error?: ErrorType;
} | {
    error: {
        message: string;
        code: string;
    };
};

type GetCourtInfoArgs = {
    tournamentRecord: Tournament;
    internalUse?: boolean;
    courtId: string;
};
declare function getCourtInfo({ tournamentRecord, internalUse, courtId }: GetCourtInfoArgs): {
    error?: ErrorType;
    success?: boolean;
    courtInfo?: any;
};

declare function getEpisodes(matchUp: MatchUp): Episode[];

type GetVenueDataArgs = {
    tournamentRecord: Tournament;
    venueId: string;
};
declare function getVenueData(params: GetVenueDataArgs): {
    success?: boolean;
    error?: ErrorType;
    venueData?: any;
};

type GetVenueReportArgs = {
    tournamentRecords: TournamentRecords;
    ignoreDisabled?: boolean;
    tournamentId?: string;
    venueIds?: string[];
    dates?: string[];
};
declare function getVenuesReport({ ignoreDisabled, tournamentRecords, tournamentId, venueIds, dates, }: GetVenueReportArgs): (ResultType & {
    venues?: HydratedVenue[];
    courts?: HydratedCourt[];
}) | {
    error: {
        message: string;
        code: string;
    };
    dates: never;
    venueIds?: undefined;
    venuesReport?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    venueIds: never;
    dates?: undefined;
    venuesReport?: undefined;
} | {
    error: {
        message: string;
        code: string;
    };
    dates?: undefined;
    venueIds?: undefined;
    venuesReport?: undefined;
} | {
    venuesReport: {
        venueId: any;
        venueName: any;
        venueReport: {};
    }[] | undefined;
    error?: undefined;
    dates?: undefined;
    venueIds?: undefined;
};

type ModifyCourtArgs = {
    tournamentRecords?: TournamentRecords;
    venueMatchUps?: HydratedMatchUp[];
    tournamentRecord?: Tournament;
    disableNotice?: boolean;
    modifications: any;
    courtId: string;
    force?: boolean;
};
declare function modifyCourt(params: ModifyCourtArgs): (ResultType & {
    court?: HydratedCourt;
}) | {
    error: {
        message: string;
        code: string;
    };
} | undefined;

type ModifyEventArgs = {
    tournamentRecord: Tournament;
    eventUpdates: {
        eventType?: EventTypeUnion;
        gender?: GenderUnion;
        startDate?: string;
        endDate?: string;
        category?: Category;
        eventName?: string;
    };
    eventId: string;
    event: Event$1;
};
declare function modifyEvent(params: ModifyEventArgs): ResultType;

type ModifyVenueArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    modifications: any;
    venueId: string;
    force?: boolean;
};
declare function modifyVenue(params: ModifyVenueArgs): any;

type AddGoesToArgs = {
    inContextDrawMatchUps?: HydratedMatchUp[];
    drawDefinition: DrawDefinition;
    matchUpsMap?: MatchUpsMap;
};
declare function addGoesTo({ inContextDrawMatchUps, drawDefinition, matchUpsMap }: AddGoesToArgs): {
    error: {
        message: string;
        code: string;
    };
    inContextDrawMatchUps?: undefined;
    goesToMap?: undefined;
} | {
    inContextDrawMatchUps: HydratedMatchUp[] | undefined;
    goesToMap: {
        loserMatchUpIds: {};
        winnerMatchUpIds: {};
    };
    error?: undefined;
};

declare function analyzeSet(params: any): {
    [key: string]: any;
};

type GetEventDataArgs = {
    participantsProfile?: ParticipantsProfile;
    includePositionAssignments?: boolean;
    policyDefinitions?: PolicyDefinitions;
    allParticipantResults?: boolean;
    sortConfig?: StructureSortConfig;
    hydrateParticipants?: boolean;
    tournamentRecord: Tournament;
    usePublishState?: boolean;
    refreshResults?: boolean;
    pressureRating?: boolean;
    participantFilters?: any;
    contextProfile?: any;
    eventId?: string;
    status?: string;
    event?: Event$1;
};
declare function getEventData(params: GetEventDataArgs): {
    participants?: HydratedParticipant[];
    error?: ErrorType;
    success?: boolean;
    eventData?: any;
};

type GetTallyArgs = {
    positionAssignment?: any;
};
declare function getTally({ positionAssignment }: GetTallyArgs): {
    error: {
        message: string;
        code: string;
    };
    tally?: undefined;
} | {
    tally: any;
    error?: undefined;
};

declare function isComplete(matchUp: MatchUp): boolean;

type validateScoreTypes = {
    existingMatchUpStatus?: string;
    matchUpStatus?: string;
    matchUpFormat?: string;
    winningSide?: number;
    score: Score$1;
};
declare function validateScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }: validateScoreTypes): ResultType & {
    valid?: boolean;
};

type AddFlightArgs = {
    qualifyingPositions?: number;
    drawEntries?: Entry[];
    drawName?: string;
    drawId: string;
    stage?: string;
    event: Event$1;
};
declare function addFlight({ qualifyingPositions, drawEntries, drawName, drawId, event, stage, }: AddFlightArgs): {
    success?: boolean;
    error?: ErrorType;
};

interface AddPointConfig {
    pointMultipliers?: PointMultiplier[];
}
declare function addPoint(matchUp: MatchUp, options: AddPointOptions, config?: AddPointConfig): MatchUp;

declare function getWinner(matchUp: MatchUp): number | undefined;

declare function validMatchUp(matchUp: any): boolean;
declare function validMatchUps(matchUps: any): boolean;

type AddCourtArgs = {
    tournamentRecord: Tournament;
    disableNotice?: boolean;
    courtId?: string;
    venueId: string;
    court?: any;
};
declare function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court }: AddCourtArgs): any;
type ACArgs = AddCourtsArgs & {
    tournamentRecords?: {
        [key: string]: Tournament;
    };
    tournamentRecord?: Tournament;
    venueId: string;
};
declare function addCourts(params: ACArgs): (ResultType & {
    courts?: Court[];
}) | {
    error: {
        message: string;
        code: string;
    };
} | {
    courtIds: string[];
    success: boolean;
    error?: undefined;
};
type AddCourtsArgs = {
    dateAvailability?: Availability[];
    venueAbbreviationRoot?: string;
    tournamentRecord: Tournament;
    courtNameRoot?: string;
    courtNames?: string[];
    courtTimings?: any[];
    courtsCount?: number;
    courtIds?: string[];
    startTime?: string;
    endTime?: string;
    idPrefix?: string;
    venueId: string;
    dates: string[];
};

type AddEventArgs = {
    suppressNotifications?: boolean;
    tournamentRecord: Tournament;
    internalUse?: boolean;
    event: any;
};
declare function addEvent({ suppressNotifications, tournamentRecord, internalUse, event }: AddEventArgs): {
    context?: {
        [key: string]: any;
    };
    error?: ErrorType;
    event?: Event$1;
    info?: any;
};

declare function addVenue(params: any): any;

type FindVenueArgs = {
    tournamentRecords?: TournamentRecords;
    tournamentRecord?: Tournament;
    venueId: string;
};
declare function findVenue({ tournamentRecords, tournamentRecord, venueId }: FindVenueArgs): {
    success?: boolean;
    venue?: Venue;
    error?: ErrorType;
};
declare function publicFindVenue({ convertExtensions, ...params }: {
    [x: string]: any;
    convertExtensions: any;
}): any;

declare function getCourts({ tournamentRecord, venueId, venueIds }: {
    tournamentRecord: any;
    venueId: any;
    venueIds: any;
}): {
    error: {
        message: string;
        code: string;
    };
    courts?: undefined;
} | {
    courts: any;
    error?: undefined;
};

type RankingStat = {
    median: number;
    avg: number;
    max: number;
    min: number;
};
type EventScaleValues = {
    [key: string]: {
        ratingsStats: {
            [key: string]: RankingStat;
        };
        ratings: {
            [key: string]: number[];
        };
        ranking: {
            [key: string]: any;
        };
        draws: {
            [key: string]: {
                ratingsStats: {
                    [key: string]: RankingStat;
                };
                ratings: {
                    [key: string]: number[];
                };
                ranking: {
                    [key: string]: any;
                };
            };
        };
    };
};
type GetEventsArgs = {
    tournamentRecord: Tournament;
    withScaleValues?: boolean;
    scaleEventType?: EventTypeUnion;
    inContext?: boolean;
    eventIds?: string[];
    drawIds?: string[];
    context?: any;
};
declare function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContext, eventIds, drawIds, context, }: GetEventsArgs): ResultType & {
    eventScaleValues?: EventScaleValues;
    events?: Event$1[];
};

type ParseScoreArgs = {
    scoreString: string;
    tiebreakTo?: number;
    matchUpFormat?: string;
};
type ParsedSetString = {
    winningSide: number | undefined;
    side1TiebreakScore?: number;
    side2TiebreakScore?: number;
    side1Score?: number;
    side2Score?: number;
    setNumber: number;
    NoAD?: boolean;
    tiebreakSet?: boolean;
};
declare function parseScoreString({ tiebreakTo, scoreString, matchUpFormat }: ParseScoreArgs): ParsedSetString[];

declare function publicFindCourt(params: any): any;

type FindExtensionType = {
    tournamentRecords?: TournamentRecords;
    params?: {
        [key: string]: any;
    };
    discover?: boolean | string[];
    element?: any;
    name: string;
};
type ExtensionResult = ResultType & {
    extension?: Extension;
};
declare function findExtension({ discover, element, name, ...params }: FindExtensionType): ExtensionResult;

type GetDrawStructuresArgs = {
    sortConfig?: StructureSortConfig;
    drawDefinition?: DrawDefinition;
    withStageGrouping?: boolean;
    stageSequences?: string[];
    stageSequence?: number;
    roundTarget?: number;
    stages?: string[];
    stage?: string;
};
type FoundDrawStructure = {
    stageStructures: {
        [key: string]: Structure[];
    };
    structures: Structure[];
};
declare function getDrawStructures({ withStageGrouping, drawDefinition, stageSequences, stageSequence, roundTarget, sortConfig, stages, stage, }: GetDrawStructuresArgs): ResultType & FoundDrawStructure;

type GetEventArgs = {
    context: {
        [key: string]: any;
    };
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    event: Event$1;
};
declare function getEvent({ tournamentRecord, drawDefinition, context, event }: GetEventArgs): any;

type FilterMatchUpsArgs = MatchUpFilters & {
    matchUps: HydratedMatchUp[];
};
declare function filterMatchUps(params: FilterMatchUpsArgs): HydratedMatchUp[];

type TimeItemResult = {
    timeItem?: TimeItem;
    previousItems?: any;
    success?: boolean;
    code?: string;
    info?: any;
};
type TimeItemArgs = {
    returnPreviousValues?: boolean;
    tournamentRecord?: Tournament;
    drawDefinition?: DrawDefinition;
    itemSubTypes?: string[];
    participantId?: string;
    itemType: string;
    event?: Event$1;
    element: any;
};
declare function getTimeItem(params: TimeItemArgs): TimeItemResult & ResultType;
declare function getDrawDefinitionTimeItem({ returnPreviousValues, drawDefinition, itemSubTypes, itemType }: {
    returnPreviousValues: any;
    drawDefinition: any;
    itemSubTypes: any;
    itemType: any;
}): {
    error: {
        message: string;
        code: string;
    };
    timeItem?: undefined;
    previousItems?: undefined;
    info?: undefined;
} | {
    timeItem: TimeItem;
    previousItems: any;
    error?: undefined;
    info?: undefined;
} | {
    info: any;
    error?: undefined;
    timeItem?: undefined;
    previousItems?: undefined;
};
type GetEventTimeItemArgs = {
    returnPreviousValues?: boolean;
    itemSubTypes?: string[];
    itemType: string;
    event: Event$1;
};
declare function getEventTimeItem({ returnPreviousValues, itemSubTypes, itemType, event }: GetEventTimeItemArgs): {
    error: {
        message: string;
        code: string;
    };
    timeItem?: undefined;
    previousItems?: undefined;
    info?: undefined;
} | {
    timeItem: TimeItem;
    previousItems: any;
    error?: undefined;
    info?: undefined;
} | {
    info: any;
    error?: undefined;
    timeItem?: undefined;
    previousItems?: undefined;
};
type GetTournamentTimeItemArgs = {
    returnPreviousValues?: boolean;
    tournamentRecord: Tournament;
    itemSubTypes?: string[];
    itemType: string;
};
declare function getTournamentTimeItem({ returnPreviousValues, tournamentRecord, itemSubTypes, itemType, }: GetTournamentTimeItemArgs): {
    error: {
        message: string;
        code: string;
    };
    timeItem?: undefined;
    previousItems?: undefined;
    info?: undefined;
} | {
    timeItem: TimeItem;
    previousItems: any;
    error?: undefined;
    info?: undefined;
} | {
    info: any;
    error?: undefined;
    timeItem?: undefined;
    previousItems?: undefined;
};
declare function getParticipantTimeItem({ returnPreviousValues, tournamentRecord, participantId, itemSubTypes, itemType, }: {
    returnPreviousValues: any;
    tournamentRecord: any;
    participantId: any;
    itemSubTypes: any;
    itemType: any;
}): (ResultType & {
    valid?: boolean;
}) | {
    participant?: Participant$1;
    tournamentId?: string;
    error?: ErrorType;
} | {
    timeItem: TimeItem;
    previousItems: any;
};

type FindMatchUpType = {
    participantsProfile?: ParticipantsProfile;
    contextContent?: ContextContent;
    contextProfile?: ContextProfile;
    drawDefinition?: DrawDefinition;
    afterRecoveryTimes?: boolean;
    tournamentRecord: Tournament;
    nextMatchUps?: boolean;
    inContext?: boolean;
    matchUpId: string;
    eventId?: string;
    drawId?: string;
    event?: Event$1;
};
type FindMatchUpResult = {
    drawDefinition?: DrawDefinition;
    matchUp?: HydratedMatchUp;
    structure?: Structure;
    error?: ErrorType;
};
declare function publicFindMatchUp(params: FindMatchUpType): FindMatchUpResult;

type FindPolicyArgs = {
    drawDefinition?: DrawDefinition;
    tournamentRecord?: Tournament;
    structure?: Structure;
    policyType: string;
    event?: Event$1;
};
declare function findPolicy({ tournamentRecord, drawDefinition, policyType, structure, event }: FindPolicyArgs): {
    policy?: any;
    error?: ErrorType;
    info?: string;
};

declare function credits(): string;

interface MethodSignatures {
    addAdHocMatchUps: EngineMethod<typeof addAdHocMatchUps>;
    addCertification: EngineMethod<typeof addCertification>;
    addCertificationRequirement: EngineMethod<typeof addCertificationRequirement>;
    addCollectionDefinition: EngineMethod<typeof addCollectionDefinition>;
    addCollectionGroup: EngineMethod<typeof addCollectionGroup>;
    addCourt: EngineMethod<typeof addCourt>;
    addCourtGridBooking: EngineMethod<typeof addCourtGridBooking>;
    addCourts: EngineMethod<typeof addCourts>;
    addDrawDefinition: EngineMethod<typeof addDrawDefinition>;
    addDrawDefinitionExtension: EngineMethod<typeof addDrawDefinitionExtension>;
    addDrawDefinitionTimeItem: EngineMethod<typeof addDrawDefinitionTimeItem>;
    addDrawEntries: EngineMethod<typeof addDrawEntries>;
    addDynamicRatings: EngineMethod<typeof addDynamicRatings>;
    addEvaluation: EngineMethod<typeof addEvaluation>;
    addEvaluationPolicy: EngineMethod<typeof addEvaluationPolicy>;
    addEvent: EngineMethod<typeof addEvent>;
    addEventEntries: EngineMethod<typeof addEventEntries>;
    addEventEntryPairs: EngineMethod<typeof addEventEntryPairs>;
    addEventExtension: EngineMethod<typeof addEventExtension>;
    addEventTimeItem: EngineMethod<typeof addEventTimeItem>;
    addExtension: EngineMethod<typeof addExtension>;
    addFinishingRounds: EngineMethod<typeof addFinishingRounds>;
    addFlight: EngineMethod<typeof addFlight>;
    addGoesTo: EngineMethod<typeof addGoesTo>;
    addIndividualParticipantIds: EngineMethod<typeof addIndividualParticipantIds>;
    addLinkedConsolationStructure: EngineMethod<typeof addLinkedConsolationStructure>;
    addMatchUpCourtOrder: EngineMethod<typeof addMatchUpCourtOrder>;
    addMatchUpEndTime: EngineMethod<typeof addMatchUpEndTime>;
    addMatchUpOfficial: EngineMethod<typeof addMatchUpOfficial>;
    addMatchUpResumeTime: EngineMethod<typeof addMatchUpResumeTime>;
    addMatchUpScheduledDate: EngineMethod<typeof addMatchUpScheduledDate>;
    addMatchUpScheduledTime: EngineMethod<typeof addMatchUpScheduledTime>;
    addMatchUpScheduleItems: EngineMethod<typeof addMatchUpScheduleItems>;
    addMatchUpStartTime: EngineMethod<typeof addMatchUpStartTime>;
    addMatchUpStopTime: EngineMethod<typeof addMatchUpStopTime>;
    addMutationLock: EngineMethod<typeof addMutationLock>;
    addNotes: EngineMethod<typeof addNotes>;
    addOnlineResource: EngineMethod<typeof addOnlineResource>;
    addParticipant: EngineMethod<typeof addParticipant>;
    addParticipantExtension: EngineMethod<typeof addParticipantExtension>;
    addParticipants: EngineMethod<typeof addParticipants>;
    addParticipantTimeItem: EngineMethod<typeof addParticipantTimeItem>;
    addPenalty: EngineMethod<typeof addPenalty>;
    addPersonOtherId: EngineMethod<typeof addPersonOtherId>;
    addPersonRequests: EngineMethod<typeof addPersonRequests>;
    addPersons: EngineMethod<typeof addPersons>;
    addPlayoffStructures: EngineMethod<typeof addPlayoffStructures>;
    addPoint: EngineMethod<typeof addPoint>;
    addPracticeRegistration: EngineMethod<typeof addPracticeRegistration>;
    addQualifyingStructure: EngineMethod<typeof addQualifyingStructure>;
    addSchedulingProfileRound: EngineMethod<typeof addSchedulingProfileRound>;
    addSuspension: EngineMethod<typeof addSuspension>;
    addTimeItem: EngineMethod<typeof addTimeItem>;
    addTournamentExtension: EngineMethod<typeof addTournamentExtension>;
    addTournamentTimeItem: EngineMethod<typeof addTournamentTimeItem>;
    addVenue: EngineMethod<typeof addVenue>;
    addVoluntaryConsolationStructure: EngineMethod<typeof addVoluntaryConsolationStructure>;
    adHocPositionSwap: EngineMethod<typeof adHocPositionSwap>;
    aggregateTieFormats: EngineMethod<typeof aggregateTieFormats>;
    allCompetitionMatchUps: EngineMethod<typeof allCompetitionMatchUps>;
    allDrawMatchUps: EngineMethod<typeof allDrawMatchUps>;
    allEventMatchUps: EngineMethod<typeof allEventMatchUps>;
    allocateTeamMatchUpCourts: EngineMethod<typeof allocateTeamMatchUpCourts>;
    allPlayoffPositionsFilled: EngineMethod<typeof allPlayoffPositionsFilled>;
    allTournamentMatchUps: EngineMethod<typeof allTournamentMatchUps>;
    alternateDrawPositionAssignment: EngineMethod<typeof alternateDrawPositionAssignment>;
    analyzeDraws: EngineMethod<typeof analyzeDraws>;
    analyzeMatchUp: EngineMethod<typeof analyzeMatchUp>;
    analyzeScore: EngineMethod<typeof analyzeScore>;
    analyzeSequence: EngineMethod<typeof analyzeSequence>;
    analyzeSet: EngineMethod<typeof analyzeSet>;
    analyzeTournament: EngineMethod<typeof analyzeTournament>;
    anonymizeTournamentRecord: EngineMethod<typeof anonymizeTournamentRecord>;
    applyDerivedRankings: EngineMethod<typeof applyDerivedRankings>;
    applyLineUps: EngineMethod<typeof applyLineUps>;
    applyTournamentRankingPoints: EngineMethod<typeof applyTournamentRankingPoints>;
    assignDrawPosition: EngineMethod<typeof assignDrawPosition>;
    assignDrawPositionBye: EngineMethod<typeof assignDrawPositionBye>;
    assignMatchUpCourt: EngineMethod<typeof assignMatchUpCourt>;
    assignMatchUpSideParticipant: EngineMethod<typeof assignMatchUpSideParticipant>;
    assignMatchUpVenue: EngineMethod<typeof assignMatchUpVenue>;
    assignOfficial: EngineMethod<typeof assignOfficial>;
    assignSeedPositions: EngineMethod<typeof assignSeedPositions>;
    assignTieMatchUpParticipantId: EngineMethod<typeof assignTieMatchUpParticipantId>;
    attachConsolationStructures: EngineMethod<typeof attachConsolationStructures>;
    attachFlightProfile: EngineMethod<typeof attachFlightProfile>;
    attachPlayoffStructures: EngineMethod<typeof attachPlayoffStructures>;
    attachPolicies: EngineMethod<typeof attachPolicies>;
    attachQualifyingStructure: EngineMethod<typeof attachQualifyingStructure>;
    attachStructures: EngineMethod<typeof attachStructures>;
    automatedPlayoffPositioning: EngineMethod<typeof automatedPlayoffPositioning>;
    automatedPositioning: EngineMethod<typeof automatedPositioning>;
    autoSeeding: EngineMethod<typeof autoSeeding>;
    buildDrawHierarchy: EngineMethod<typeof buildDrawHierarchy>;
    buildReportContext: EngineMethod<typeof buildReportContext>;
    bulkMatchUpStatusUpdate: EngineMethod<typeof bulkMatchUpStatusUpdate>;
    bulkRescheduleMatchUps: EngineMethod<typeof bulkRescheduleMatchUps>;
    bulkScheduleMatchUps: EngineMethod<typeof bulkScheduleMatchUps>;
    bulkScheduleTournamentMatchUps: EngineMethod<typeof bulkScheduleTournamentMatchUps>;
    bulkUpdateCourtAssignments: EngineMethod<typeof bulkUpdateCourtAssignments>;
    bulkUpdatePublishedEventIds: EngineMethod<typeof bulkUpdatePublishedEventIds>;
    calculateMatchStatistics: EngineMethod<typeof calculateMatchStatistics>;
    calculateMatchUpMargin: EngineMethod<typeof calculateMatchUpMargin>;
    calculatePointsTo: EngineMethod<typeof calculatePointsTo>;
    calculateScheduleTimes: EngineMethod<typeof calculateScheduleTimes>;
    calculateWinCriteria: EngineMethod<typeof calculateWinCriteria>;
    categoryCanContain: EngineMethod<typeof categoryCanContain>;
    checkInParticipant: EngineMethod<typeof checkInParticipant>;
    checkMatchUpIsComplete: EngineMethod<typeof checkMatchUpIsComplete>;
    checkOutParticipant: EngineMethod<typeof checkOutParticipant>;
    checkScoreHasValue: EngineMethod<typeof checkScoreHasValue>;
    checkSetIsComplete: EngineMethod<typeof checkSetIsComplete>;
    checkValidEntries: EngineMethod<typeof checkValidEntries>;
    cleanExpiredMutationLocks: EngineMethod<typeof cleanExpiredMutationLocks>;
    clearMatchUpSchedule: EngineMethod<typeof clearMatchUpSchedule>;
    clearScheduledMatchUps: EngineMethod<typeof clearScheduledMatchUps>;
    compareTieFormats: EngineMethod<typeof compareTieFormats>;
    competitionScheduleMatchUps: EngineMethod<typeof competitionScheduleMatchUps>;
    completeDrawMatchUps: EngineMethod<typeof completeDrawMatchUps>;
    copyTournamentRecord: EngineMethod<typeof copyTournamentRecord>;
    courtGridRows: EngineMethod<typeof courtGridRows>;
    createGroupParticipant: EngineMethod<typeof createGroupParticipant>;
    createMatchUp: EngineMethod<typeof createMatchUp>;
    createOfficialRecord: EngineMethod<typeof createOfficialRecord>;
    createTeamsFromParticipantAttributes: EngineMethod<typeof createTeamsFromParticipantAttributes>;
    createTournamentRecord: EngineMethod<typeof createTournamentRecord>;
    credits: EngineMethod<typeof credits>;
    deduceMatchUpFormat: EngineMethod<typeof deduceMatchUpFormat>;
    deleteAdHocMatchUps: EngineMethod<typeof deleteAdHocMatchUps>;
    deleteCourt: EngineMethod<typeof deleteCourt>;
    deleteCourts: EngineMethod<typeof deleteCourts>;
    deleteDrawDefinitions: EngineMethod<typeof deleteDrawDefinitions>;
    deleteEvents: EngineMethod<typeof deleteEvents>;
    deleteFlightAndFlightDraw: EngineMethod<typeof deleteFlightAndFlightDraw>;
    deleteFlightProfileAndFlightDraws: EngineMethod<typeof deleteFlightProfileAndFlightDraws>;
    deleteParticipants: EngineMethod<typeof deleteParticipants>;
    deleteVenue: EngineMethod<typeof deleteVenue>;
    deleteVenues: EngineMethod<typeof deleteVenues>;
    destroyPairEntries: EngineMethod<typeof destroyPairEntries>;
    destroyPairEntry: EngineMethod<typeof destroyPairEntry>;
    disableCourts: EngineMethod<typeof disableCourts>;
    disableTieAutoCalc: EngineMethod<typeof disableTieAutoCalc>;
    disableVenues: EngineMethod<typeof disableVenues>;
    drawMatchUps: EngineMethod<typeof drawMatchUps>;
    drawMatic: EngineMethod<typeof drawMatic>;
    enableCourts: EngineMethod<typeof enableCourts>;
    enableTieAutoCalc: EngineMethod<typeof enableTieAutoCalc>;
    enableVenues: EngineMethod<typeof enableVenues>;
    enrichPointHistory: EngineMethod<typeof enrichPointHistory>;
    eventMatchUps: EngineMethod<typeof eventMatchUps>;
    exportMatchUpJSON: EngineMethod<typeof exportMatchUpJSON>;
    filterMatchUps: EngineMethod<typeof filterMatchUps>;
    filterParticipants: EngineMethod<typeof filterParticipants>;
    findDrawDefinition: EngineMethod<typeof publicFindDrawDefinition>;
    findExtension: EngineMethod<typeof findExtension>;
    findMatchUp: EngineMethod<typeof publicFindMatchUp>;
    findMatchUpFormatTiming: EngineMethod<typeof findMatchUpFormatTiming>;
    findParticipant: EngineMethod<typeof publicFindParticipant>;
    findPolicy: EngineMethod<typeof findPolicy>;
    findVenue: EngineMethod<typeof findVenue>;
    generateAdHocMatchUps: EngineMethod<typeof generateAdHocMatchUps>;
    generateAdHocRounds: EngineMethod<typeof generateAdHocRounds>;
    generateAndPopulatePlayoffStructures: EngineMethod<typeof generateAndPopulatePlayoffStructures>;
    generateBookings: EngineMethod<typeof generateBookings>;
    generateConsolationStructure: EngineMethod<typeof generateConsolationStructure>;
    generateCourts: EngineMethod<typeof generateCourts>;
    generateDrawDefinition: EngineMethod<typeof generateDrawDefinition>;
    generateDrawMaticRound: EngineMethod<typeof generateDrawMaticRound>;
    generateDrawStructuresAndLinks: EngineMethod<typeof generateDrawStructuresAndLinks>;
    generateDrawTypeAndModifyDrawDefinition: EngineMethod<typeof generateDrawTypeAndModifyDrawDefinition>;
    generateEventsFromTieFormat: EngineMethod<typeof generateEventsFromTieFormat>;
    generateEventWithDraw: EngineMethod<typeof generateEventWithDraw>;
    generateFlightProfile: EngineMethod<typeof generateFlightProfile>;
    generateLineUps: EngineMethod<typeof generateLineUps>;
    generateOutcome: EngineMethod<typeof generateOutcome>;
    generateOutcomeFromScoreString: EngineMethod<typeof generateOutcomeFromScoreString>;
    generateParticipants: EngineMethod<typeof generateParticipants>;
    generateQualifyingStructure: EngineMethod<typeof generateQualifyingStructure>;
    generateRankingList: EngineMethod<typeof generateRankingList>;
    generateReport: EngineMethod<typeof generateReport>;
    generateScoreString: EngineMethod<typeof generateScoreString>;
    generateSeedingScaleItems: EngineMethod<typeof generateSeedingScaleItems>;
    generateStatCrew: EngineMethod<typeof generateStatCrew>;
    generateSwissRound: EngineMethod<typeof generateSwissRound>;
    generateTieMatchUpScore: EngineMethod<typeof generateTieMatchUpScore>;
    generateTournamentRecord: EngineMethod<typeof generateTournamentRecord>;
    generateVirtualCourts: EngineMethod<typeof generateVirtualCourts>;
    generateVoluntaryConsolation: EngineMethod<typeof generateVoluntaryConsolation>;
    getAggregateTeamResults: EngineMethod<typeof getAggregateTeamResults>;
    getAllDrawMatchUps: EngineMethod<typeof getAllDrawMatchUps>;
    getAllEventData: EngineMethod<typeof getAllEventData>;
    getAllowedDrawTypes: EngineMethod<typeof getAllowedDrawTypes>;
    getAllowedMatchUpFormats: EngineMethod<typeof getAllowedMatchUpFormats>;
    getAllStructureMatchUps: EngineMethod<typeof getAllStructureMatchUps>;
    getApplicableAwardProfileLevels: EngineMethod<typeof getApplicableAwardProfileLevels>;
    getAppliedPolicies: EngineMethod<typeof getAppliedPolicies>;
    getAssignedParticipantIds: EngineMethod<typeof getAssignedParticipantIds>;
    getAvailableMatchUpsCount: EngineMethod<typeof getAvailableMatchUpsCount>;
    getAvailablePlayoffProfiles: EngineMethod<typeof getAvailablePlayoffProfiles>;
    getAvailableReports: EngineMethod<typeof getAvailableReports>;
    getAwardPoints: EngineMethod<typeof getAwardPoints>;
    getAwardProfile: EngineMethod<typeof getAwardProfile>;
    getCategoryAgeDetails: EngineMethod<typeof getCategoryAgeDetails>;
    getCheckedInParticipantIds: EngineMethod<typeof getCheckedInParticipantIds>;
    getCompetitionDateRange: EngineMethod<typeof getCompetitionDateRange>;
    getCompetitionFormat: EngineMethod<typeof getCompetitionFormat>;
    getCompetitionLeaderboard: EngineMethod<typeof getCompetitionLeaderboard>;
    getCompetitionMatchUps: EngineMethod<typeof getCompetitionMatchUps>;
    getCompetitionParticipants: EngineMethod<typeof getCompetitionParticipants>;
    getCompetitionParticipantState: EngineMethod<typeof getCompetitionParticipantState>;
    getCompetitionPenalties: EngineMethod<typeof getCompetitionPenalties>;
    getCompetitionPolicy: EngineMethod<typeof getCompetitionPolicy>;
    getCompetitionState: EngineMethod<typeof getCompetitionState>;
    getCompetitionVenues: EngineMethod<typeof getCompetitionVenues>;
    getCourtInfo: EngineMethod<typeof getCourtInfo>;
    getCourts: EngineMethod<typeof getCourts>;
    getDraftState: EngineMethod<typeof getDraftState>;
    getDrawData: EngineMethod<typeof getDrawData>;
    getDrawDefinitionTimeItem: EngineMethod<typeof getDrawDefinitionTimeItem>;
    getDrawParticipantRepresentativeIds: EngineMethod<typeof getDrawParticipantRepresentativeIds>;
    getDrawStructures: EngineMethod<typeof getDrawStructures>;
    getDrawTypeCoercion: EngineMethod<typeof getDrawTypeCoercion>;
    getEligibleVoluntaryConsolationParticipants: EngineMethod<typeof getEligibleVoluntaryConsolationParticipants>;
    getEntriesAndSeedsCount: EngineMethod<typeof getEntriesAndSeedsCount>;
    getEntryStatusReports: EngineMethod<typeof getEntryStatusReports>;
    getEpisodes: EngineMethod<typeof getEpisodes>;
    getEvaluations: EngineMethod<typeof getEvaluations>;
    getEvaluationSummary: EngineMethod<typeof getEvaluationSummary>;
    getEvaluationTemplate: EngineMethod<typeof getEvaluationTemplate>;
    getEvent: EngineMethod<typeof getEvent>;
    getEventData: EngineMethod<typeof getEventData>;
    getEventMatchUpFormatTiming: EngineMethod<typeof getEventMatchUpFormatTiming>;
    getEventProperties: EngineMethod<typeof getEventProperties>;
    getEventPublishStatus: EngineMethod<typeof getEventPublishStatus>;
    getEventRankingPoints: EngineMethod<typeof getEventRankingPoints>;
    getEvents: EngineMethod<typeof getEvents>;
    getEventStructures: EngineMethod<typeof getEventStructures>;
    getEventTimeItem: EngineMethod<typeof getEventTimeItem>;
    getFlightProfile: EngineMethod<typeof getFlightProfile>;
    getHomeParticipantId: EngineMethod<typeof getHomeParticipantId>;
    getLinkedTournamentIds: EngineMethod<typeof getLinkedTournamentIds>;
    getLuckyDrawRoundStatus: EngineMethod<typeof getLuckyDrawRoundStatus>;
    getMatchUpCompetitiveProfile: EngineMethod<typeof getMatchUpCompetitiveProfile>;
    getMatchUpContextIds: EngineMethod<typeof getMatchUpContextIds>;
    getMatchUpDailyLimits: EngineMethod<typeof getMatchUpDailyLimits>;
    getMatchUpDailyLimitsUpdate: EngineMethod<typeof getMatchUpDailyLimitsUpdate>;
    getMatchUpDependencies: EngineMethod<typeof getMatchUpDependencies>;
    getMatchUpFormat: EngineMethod<typeof getMatchUpFormat>;
    getMatchUpFormatTiming: EngineMethod<typeof getMatchUpFormatTiming>;
    getMatchUpFormatTimingUpdate: EngineMethod<typeof getMatchUpFormatTimingUpdate>;
    getMatchUpScheduleDetails: EngineMethod<typeof getMatchUpScheduleDetails>;
    getMatchUpsMap: EngineMethod<typeof getMatchUpsMap>;
    getMatchUpsStats: EngineMethod<typeof getMatchUpsStats>;
    getMatchUpsToSchedule: EngineMethod<typeof getMatchUpsToSchedule>;
    getMatchUpType: EngineMethod<typeof getMatchUpType>;
    getMaxEntryPosition: EngineMethod<typeof getMaxEntryPosition>;
    getModifiedMatchUpFormatTiming: EngineMethod<typeof getModifiedMatchUpFormatTiming>;
    getMutationLocks: EngineMethod<typeof getMutationLocks>;
    getOfficialAssignments: EngineMethod<typeof getOfficialAssignments>;
    getOfficialCertifications: EngineMethod<typeof getOfficialCertifications>;
    getOfficialEligibility: EngineMethod<typeof getOfficialEligibility>;
    getPairedParticipant: EngineMethod<typeof getPairedParticipant>;
    getParticipantEventDetails: EngineMethod<typeof getParticipantEventDetails>;
    getParticipantIdFinishingPositions: EngineMethod<typeof getParticipantIdFinishingPositions>;
    getParticipantMembership: EngineMethod<typeof getParticipantMembership>;
    getParticipantPaymentStatus: EngineMethod<typeof getParticipantPaymentStatus>;
    getParticipantPoints: EngineMethod<typeof getParticipantPoints>;
    getParticipantResults: EngineMethod<typeof getParticipantResults>;
    getParticipants: EngineMethod<typeof getParticipants>;
    getParticipantScaleItem: EngineMethod<typeof getParticipantScaleItem>;
    getParticipantSchedules: EngineMethod<typeof getParticipantSchedules>;
    getParticipantSignInStatus: EngineMethod<typeof getParticipantSignInStatus>;
    getParticipantStats: EngineMethod<typeof getParticipantStats>;
    getParticipantTimeItem: EngineMethod<typeof getParticipantTimeItem>;
    getPersonRequests: EngineMethod<typeof getPersonRequests>;
    getPolicyDefinitions: EngineMethod<typeof getPolicyDefinitions>;
    getPositionAssignments: EngineMethod<typeof getPositionAssignments>;
    getPositionsPlayedOff: EngineMethod<typeof getPositionsPlayedOff>;
    getPracticeRegistrations: EngineMethod<typeof getPracticeRegistrations>;
    getPredictiveAccuracy: EngineMethod<typeof getPredictiveAccuracy>;
    getProfileRounds: EngineMethod<typeof getProfileRounds>;
    getPublishState: EngineMethod<typeof getPublishState>;
    getQualityWinPoints: EngineMethod<typeof getQualityWinPoints>;
    getQuickStats: EngineMethod<typeof getQuickStats>;
    getRandomQualifierList: EngineMethod<typeof getRandomQualifierList>;
    getRegistrationProfile: EngineMethod<typeof getRegistrationProfile>;
    getRoundMatchUps: EngineMethod<typeof getRoundMatchUps>;
    getRounds: EngineMethod<typeof getRounds>;
    getRoundVisibilityState: EngineMethod<typeof getRoundVisibilityState>;
    getScaledEntries: EngineMethod<typeof getScaledEntries>;
    getScaleValues: EngineMethod<typeof getScaleValues>;
    getScheduledRoundsDetails: EngineMethod<typeof getScheduledRoundsDetails>;
    getSchedulingProfile: EngineMethod<typeof getSchedulingProfile>;
    getSchedulingProfileIssues: EngineMethod<typeof getSchedulingProfileIssues>;
    getScore: EngineMethod<typeof getScore>;
    getScoreboard: EngineMethod<typeof getScoreboard>;
    getSeedingThresholds: EngineMethod<typeof getSeedingThresholds>;
    getSeedsCount: EngineMethod<typeof getSeedsCount>;
    getSetComplement: EngineMethod<typeof getSetComplement>;
    getSetScoreString: EngineMethod<typeof getSetScoreString>;
    getStructureReports: EngineMethod<typeof getStructureReports>;
    getStructureSeedAssignments: EngineMethod<typeof getStructureSeedAssignments>;
    getSwissChart: EngineMethod<typeof getSwissChart>;
    getSwissStandings: EngineMethod<typeof getSwissStandings>;
    getTally: EngineMethod<typeof getTally>;
    getTeamLineUp: EngineMethod<typeof getTeamLineUp>;
    getTiebreakComplement: EngineMethod<typeof getTiebreakComplement>;
    getTieFormat: EngineMethod<typeof getTieFormat>;
    getTimeItem: EngineMethod<typeof getTimeItem>;
    getTournamentIds: EngineMethod<typeof getTournamentIds>;
    getTournamentInfo: EngineMethod<typeof getTournamentInfo>;
    getTournamentPenalties: EngineMethod<typeof getTournamentPenalties>;
    getTournamentPersons: EngineMethod<typeof getTournamentPersons>;
    getTournamentPointAwards: EngineMethod<typeof getTournamentPointAwards>;
    getTournamentPoints: EngineMethod<typeof getTournamentPoints>;
    getTournamentPublishStatus: EngineMethod<typeof getTournamentPublishStatus>;
    getTournamentStructures: EngineMethod<typeof getTournamentStructures>;
    getTournamentTimeItem: EngineMethod<typeof getTournamentTimeItem>;
    getValidGroupSizes: EngineMethod<typeof getValidGroupSizes>;
    getVenueData: EngineMethod<typeof getVenueData>;
    getVenuesAndCourts: EngineMethod<typeof getVenuesAndCourts>;
    getVenuesReport: EngineMethod<typeof getVenuesReport>;
    getWinner: EngineMethod<typeof getWinner>;
    groupByMatch: EngineMethod<typeof groupByMatch>;
    hasLuckyRounds: EngineMethod<typeof hasLuckyRounds>;
    hydrateTournamentRecord: EngineMethod<typeof hydrateTournamentRecord>;
    inferServeSide: EngineMethod<typeof inferServeSide>;
    initializeCompetitionState: EngineMethod<typeof initializeCompetitionState>;
    initializeDraft: EngineMethod<typeof initializeDraft>;
    isAdHoc: EngineMethod<typeof isAdHoc>;
    isAggregateFormat: EngineMethod<typeof isAggregateFormat>;
    isComplete: EngineMethod<typeof isComplete>;
    isCompletedStructure: EngineMethod<typeof isCompletedStructure>;
    isEmbargoed: EngineMethod<typeof isEmbargoed>;
    isValid: EngineMethod<typeof isValidMatchUpFormat>;
    isValidForQualifying: EngineMethod<typeof isValidForQualifying>;
    isValidMatchUpFormat: EngineMethod<typeof isValidMatchUpFormat>;
    isVisiblyPublished: EngineMethod<typeof isVisiblyPublished>;
    keyValueScore: EngineMethod<typeof keyValueScore>;
    linkTournaments: EngineMethod<typeof linkTournaments>;
    luckyDrawAdvancement: EngineMethod<typeof luckyDrawAdvancement>;
    luckyLoserDrawPositionAssignment: EngineMethod<typeof luckyLoserDrawPositionAssignment>;
    matchUpActions: EngineMethod<typeof matchUpActions>;
    matchUpScheduleChange: EngineMethod<typeof matchUpScheduleChange>;
    mcpValidator: EngineMethod<typeof mcpValidator>;
    mergeParticipants: EngineMethod<typeof mergeParticipants>;
    migrateTournamentRecord: EngineMethod<typeof migrateTournamentRecord>;
    modifyCertification: EngineMethod<typeof modifyCertification>;
    modifyCollectionDefinition: EngineMethod<typeof modifyCollectionDefinition>;
    modifyCourt: EngineMethod<typeof modifyCourt>;
    modifyCourtAvailability: EngineMethod<typeof modifyCourtAvailability>;
    modifyDrawDefinition: EngineMethod<typeof modifyDrawDefinition>;
    modifyDrawName: EngineMethod<typeof modifyDrawName>;
    modifyEntriesStatus: EngineMethod<typeof modifyEntriesStatus>;
    modifyEvaluation: EngineMethod<typeof modifyEvaluation>;
    modifyEvent: EngineMethod<typeof modifyEvent>;
    modifyEventEntries: EngineMethod<typeof modifyEventEntries>;
    modifyEventMatchUpFormatTiming: EngineMethod<typeof modifyEventMatchUpFormatTiming>;
    modifyIndividualParticipantIds: EngineMethod<typeof modifyIndividualParticipantIds>;
    modifyMatchUpFormatTiming: EngineMethod<typeof modifyMatchUpFormatTiming>;
    modifyPairAssignment: EngineMethod<typeof modifyPairAssignment>;
    modifyParticipant: EngineMethod<typeof modifyParticipant>;
    modifyParticipantName: EngineMethod<typeof modifyParticipantName>;
    modifyParticipantOtherName: EngineMethod<typeof modifyParticipantOtherName>;
    modifyParticipantsPaymentStatus: EngineMethod<typeof modifyParticipantsPaymentStatus>;
    modifyParticipantsSignInStatus: EngineMethod<typeof modifyParticipantsSignInStatus>;
    modifyPenalty: EngineMethod<typeof modifyPenalty>;
    modifyPersonRequests: EngineMethod<typeof modifyPersonRequests>;
    modifySeedAssignment: EngineMethod<typeof modifySeedAssignment>;
    modifyTieFormat: EngineMethod<typeof modifyTieFormat>;
    modifyTournamentRecord: EngineMethod<typeof modifyTournamentRecord>;
    modifyVenue: EngineMethod<typeof modifyVenue>;
    orderCollectionDefinitions: EngineMethod<typeof orderCollectionDefinitions>;
    parse: EngineMethod<typeof parse>;
    parseCSV: EngineMethod<typeof parseCSV>;
    parseMatchUpFormat: EngineMethod<typeof parse>;
    parseMCPPoint: EngineMethod<typeof parseMCPPoint>;
    parseScoreString: EngineMethod<typeof parseScoreString>;
    participantScaleItem: EngineMethod<typeof participantScaleItem>;
    participantScheduledMatchUps: EngineMethod<typeof participantScheduledMatchUps>;
    pbpValidator: EngineMethod<typeof pbpValidator>;
    pointParser: EngineMethod<typeof pointParser>;
    positionActions: EngineMethod<typeof positionActions>;
    predictDrawCompetitiveBands: EngineMethod<typeof predictDrawCompetitiveBands>;
    predictMatchUpCompetitiveBands: EngineMethod<typeof predictMatchUpCompetitiveBands>;
    proAutoSchedule: EngineMethod<typeof proAutoSchedule>;
    processCompetitionMatchUp: EngineMethod<typeof processCompetitionMatchUp>;
    processCompetitionRound: EngineMethod<typeof processCompetitionRound>;
    proConflicts: EngineMethod<typeof proConflicts>;
    promoteAlternate: EngineMethod<typeof promoteAlternate>;
    promoteAlternates: EngineMethod<typeof promoteAlternates>;
    pruneDrawDefinition: EngineMethod<typeof pruneDrawDefinition>;
    publicFindCourt: EngineMethod<typeof publicFindCourt>;
    publicFindVenue: EngineMethod<typeof publicFindVenue>;
    publishEvent: EngineMethod<typeof publishEvent>;
    publishEventSeeding: EngineMethod<typeof publishEventSeeding>;
    publishOrderOfPlay: EngineMethod<typeof publishOrderOfPlay>;
    publishParticipants: EngineMethod<typeof publishParticipants>;
    qualifierDrawPositionAssignment: EngineMethod<typeof qualifierDrawPositionAssignment>;
    qualifierProgression: EngineMethod<typeof qualifierProgression>;
    queryOfficialRecord: EngineMethod<typeof queryOfficialRecord>;
    refreshEventDrawOrder: EngineMethod<typeof refreshEventDrawOrder>;
    regenerateParticipantNames: EngineMethod<typeof regenerateParticipantNames>;
    remapDrawDefinitionMatchUpIds: EngineMethod<typeof remapDrawDefinitionMatchUpIds>;
    removeCertification: EngineMethod<typeof removeCertification>;
    removeCollectionDefinition: EngineMethod<typeof removeCollectionDefinition>;
    removeCollectionGroup: EngineMethod<typeof removeCollectionGroup>;
    removeCourtGridBooking: EngineMethod<typeof removeCourtGridBooking>;
    removeDelegatedOutcome: EngineMethod<typeof removeDelegatedOutcome>;
    removeDrawDefinitionExtension: EngineMethod<typeof removeDrawDefinitionExtension>;
    removeDrawEntries: EngineMethod<typeof removeDrawEntries>;
    removeDrawPositionAssignment: EngineMethod<typeof removeDrawPositionAssignment>;
    removeEvaluation: EngineMethod<typeof removeEvaluation>;
    removeEventEntries: EngineMethod<typeof removeEventEntries>;
    removeEventExtension: EngineMethod<typeof removeEventExtension>;
    removeEventMatchUpFormatTiming: EngineMethod<typeof removeEventMatchUpFormatTiming>;
    removeExtension: EngineMethod<typeof removeExtension>;
    removeIndividualParticipantIds: EngineMethod<typeof removeIndividualParticipantIds>;
    removeMatchUpCourtAssignment: EngineMethod<typeof removeMatchUpCourtAssignment>;
    removeMatchUpOutcome: EngineMethod<typeof removeMatchUpOutcome>;
    removeMatchUpSideParticipant: EngineMethod<typeof removeMatchUpSideParticipant>;
    removeMutationLock: EngineMethod<typeof removeMutationLock>;
    removeNotes: EngineMethod<typeof removeNotes>;
    removeOfficialAssignment: EngineMethod<typeof removeOfficialAssignment>;
    removeOnlineResource: EngineMethod<typeof removeOnlineResource>;
    removeOrphanedTieFormats: EngineMethod<typeof removeOrphanedTieFormats>;
    removeParticipantExtension: EngineMethod<typeof removeParticipantExtension>;
    removeParticipantIdsFromAllTeams: EngineMethod<typeof removeParticipantIdsFromAllTeams>;
    removePenalty: EngineMethod<typeof removePenalty>;
    removePersonRequests: EngineMethod<typeof removePersonRequests>;
    removePolicy: EngineMethod<typeof removePolicy>;
    removePracticeRegistration: EngineMethod<typeof removePracticeRegistration>;
    removeRatings: EngineMethod<typeof removeRatings>;
    removeRoundMatchUps: EngineMethod<typeof removeRoundMatchUps>;
    removeScaleValues: EngineMethod<typeof removeScaleValues>;
    removeSeededParticipant: EngineMethod<typeof removeSeededParticipant>;
    removeSeeding: EngineMethod<typeof removeSeeding>;
    removeStageEntries: EngineMethod<typeof removeStageEntries>;
    removeStructure: EngineMethod<typeof removeStructure>;
    removeSuspension: EngineMethod<typeof removeSuspension>;
    removeTieMatchUpParticipantId: EngineMethod<typeof removeTieMatchUpParticipantId>;
    removeTournamentExtension: EngineMethod<typeof removeTournamentExtension>;
    renameStructures: EngineMethod<typeof renameStructures>;
    reorderUpcomingMatchUps: EngineMethod<typeof reorderUpcomingMatchUps>;
    replaceTieMatchUpParticipantId: EngineMethod<typeof replaceTieMatchUpParticipantId>;
    resetAdHocMatchUps: EngineMethod<typeof resetAdHocMatchUps>;
    resetCompetitionState: EngineMethod<typeof resetCompetitionState>;
    resetDrawDefinition: EngineMethod<typeof resetDrawDefinition>;
    resetMatchUpLineUps: EngineMethod<typeof resetMatchUpLineUps>;
    resetQualifyingStructure: EngineMethod<typeof resetQualifyingStructure>;
    resetScorecard: EngineMethod<typeof resetScorecard>;
    resetTieFormat: EngineMethod<typeof resetTieFormat>;
    resetVoluntaryConsolationStructure: EngineMethod<typeof resetVoluntaryConsolationStructure>;
    resolveDraftPositions: EngineMethod<typeof resolveDraftPositions>;
    resolvePointValue: EngineMethod<typeof resolvePointValue>;
    reverseScore: EngineMethod<typeof reverseScore>;
    scaledTeamAssignment: EngineMethod<typeof scaledTeamAssignment>;
    scheduleMatchUps: EngineMethod<typeof scheduleMatchUps>;
    scheduleProfileGrid: EngineMethod<typeof scheduleProfileGrid>;
    scheduleProfileRounds: EngineMethod<typeof scheduleProfileRounds>;
    ScoringEngine: EngineMethod<typeof ScoringEngine>;
    seedWithdrawalCascade: EngineMethod<typeof seedWithdrawalCascade>;
    setDelegatedOutcome: EngineMethod<typeof setDelegatedOutcome>;
    setDrawParticipantRepresentativeIds: EngineMethod<typeof setDrawParticipantRepresentativeIds>;
    setDrawPositionPreferences: EngineMethod<typeof setDrawPositionPreferences>;
    setEntryPosition: EngineMethod<typeof setEntryPosition>;
    setEntryPositions: EngineMethod<typeof setEntryPositions>;
    setEventDates: EngineMethod<typeof setEventDates>;
    setEventDisplay: EngineMethod<typeof setEventDisplay>;
    setEventEndDate: EngineMethod<typeof setEventEndDate>;
    setEventStartDate: EngineMethod<typeof setEventStartDate>;
    setMatchUpCalledAt: EngineMethod<typeof setMatchUpCalledAt>;
    setMatchUpDailyLimits: EngineMethod<typeof setMatchUpDailyLimits>;
    setMatchUpFormat: EngineMethod<typeof setMatchUpFormat>;
    setMatchUpHomeParticipantId: EngineMethod<typeof setMatchUpHomeParticipantId>;
    setMatchUpState: EngineMethod<typeof setMatchUpState>;
    setMatchUpStatus: EngineMethod<typeof setMatchUpStatus>;
    setOrderOfFinish: EngineMethod<typeof setOrderOfFinish>;
    setParticipantScaleItem: EngineMethod<typeof setParticipantScaleItem>;
    setParticipantScaleItems: EngineMethod<typeof setParticipantScaleItems>;
    setPositionAssignments: EngineMethod<typeof setPositionAssignments>;
    setPracticeDefaultCapacity: EngineMethod<typeof setPracticeDefaultCapacity>;
    setRegistrationProfile: EngineMethod<typeof setRegistrationProfile>;
    setSchedulingProfile: EngineMethod<typeof setSchedulingProfile>;
    setStructureOrder: EngineMethod<typeof setStructureOrder>;
    setSubOrder: EngineMethod<typeof setSubOrder>;
    setTournamentCategories: EngineMethod<typeof setTournamentCategories>;
    setTournamentDates: EngineMethod<typeof setTournamentDates>;
    setTournamentEndDate: EngineMethod<typeof setTournamentEndDate>;
    setTournamentLocalTimeZone: EngineMethod<typeof setTournamentLocalTimeZone>;
    setTournamentName: EngineMethod<typeof setTournamentName>;
    setTournamentNotes: EngineMethod<typeof setTournamentNotes>;
    setTournamentStartDate: EngineMethod<typeof setTournamentStartDate>;
    setTournamentStatus: EngineMethod<typeof setTournamentStatus>;
    setTournamentTier: EngineMethod<typeof setTournamentTier>;
    shiftAdHocRounds: EngineMethod<typeof shiftAdHocRounds>;
    shotParser: EngineMethod<typeof shotParser>;
    shotSplitter: EngineMethod<typeof shotSplitter>;
    stringify: EngineMethod<typeof stringify>;
    stringifyMatchUpFormat: EngineMethod<typeof stringify>;
    substituteParticipant: EngineMethod<typeof substituteParticipant>;
    suggestFormatPlans: EngineMethod<typeof suggestFormatPlans>;
    swapAdHocRounds: EngineMethod<typeof swapAdHocRounds>;
    swapDrawPositionAssignments: EngineMethod<typeof swapDrawPositionAssignments>;
    tallyParticipantResults: EngineMethod<typeof tallyParticipantResults>;
    tieFormatGenderValidityCheck: EngineMethod<typeof tieFormatGenderValidityCheck>;
    toggleParticipantCheckInState: EngineMethod<typeof toggleParticipantCheckInState>;
    toStatObjects: EngineMethod<typeof toStatObjects>;
    tournamentMatchUps: EngineMethod<typeof tournamentMatchUps>;
    transitionAssignmentStatus: EngineMethod<typeof transitionAssignmentStatus>;
    transitionCertificationStatus: EngineMethod<typeof transitionCertificationStatus>;
    transitionEvaluationStatus: EngineMethod<typeof transitionEvaluationStatus>;
    unlinkTournament: EngineMethod<typeof unlinkTournament>;
    unlinkTournaments: EngineMethod<typeof unlinkTournaments>;
    unPublishEvent: EngineMethod<typeof unPublishEvent>;
    unPublishEventSeeding: EngineMethod<typeof unPublishEventSeeding>;
    unPublishOrderOfPlay: EngineMethod<typeof unPublishOrderOfPlay>;
    unPublishParticipants: EngineMethod<typeof unPublishParticipants>;
    updateDrawIdsOrder: EngineMethod<typeof updateDrawIdsOrder>;
    updatePracticeRegistration: EngineMethod<typeof updatePracticeRegistration>;
    updateTeamLineUp: EngineMethod<typeof updateTeamLineUp>;
    updateTieMatchUpScore: EngineMethod<typeof updateTieMatchUpScore>;
    validateCategory: EngineMethod<typeof validateCategory>;
    validateCertification: EngineMethod<typeof validateCertification>;
    validateCollectionDefinition: EngineMethod<typeof validateCollectionDefinition>;
    validateLineUp: EngineMethod<typeof validateLineUp>;
    validateMatchUp: EngineMethod<typeof validateMatchUp>;
    validateMatchUpScore: EngineMethod<typeof validateMatchUpScore>;
    validateMCPMatch: EngineMethod<typeof validateMCPMatch>;
    validateOfficiatingStatusTransition: EngineMethod<typeof validateOfficiatingStatusTransition>;
    validatePlayoffGroups: EngineMethod<typeof validatePlayoffGroups>;
    validateSchedulingProfile: EngineMethod<typeof validateSchedulingProfile>;
    validateScore: EngineMethod<typeof validateScore>;
    validateSet: EngineMethod<typeof validateSet>;
    validateSetScore: EngineMethod<typeof validateSetScore>;
    validateTieFormat: EngineMethod<typeof validateTieFormat>;
    validMatchUp: EngineMethod<typeof validMatchUp>;
    validMatchUps: EngineMethod<typeof validMatchUps>;
    version: EngineMethod<typeof factoryVersion>;
    withdrawParticipantAtDrawPosition: EngineMethod<typeof withdrawParticipantAtDrawPosition>;
}

type FactoryEngine = {
    [key: string]: any;
};
type EngineHintKeys = {
    tournamentId?: string;
    eventId?: string;
    drawId?: string;
    matchUpId?: string;
    structureId?: string;
};
type EngineMethod<F> = F extends (firstParam: infer P, ...rest: infer R) => infer Ret ? [
    NonNullable<P>
] extends [object] ? (params?: Partial<NonNullable<P>> & EngineHintKeys, ...rest: R) => Ret : F : F;
type FacadeMethodNames = 'q' | 'on' | 'once' | 'off' | 'waitFor' | 'inspect' | 'build' | 'dryRun' | 'explain';
type FactoryEngineTyped = MethodSignatures & Record<Exclude<FactoryEngineMethod, keyof MethodSignatures | FacadeMethodNames>, (...args: any[]) => any> & {
    q: QueryFacade;
    on<T extends Topic>(topic: T, handler: (payload: TopicPayloadMap[T]) => void): Unsubscribe;
    once<T extends Topic>(topic: T, handler: (payload: TopicPayloadMap[T]) => void): Unsubscribe;
    off<T extends Topic>(topic: T, handler?: (payload: TopicPayloadMap[T]) => void): void;
    waitFor<T extends Topic>(topic: T, predicate?: (payload: TopicPayloadMap[T]) => boolean): Promise<TopicPayloadMap[T]>;
    inspect(): EngineInspection;
    build: BuildFacade;
    dryRun(directives: Directives): DryRunResult;
    explain(method: string, params?: Record<string, any>): ExplainResult;
};

type TournamentRecords = {
    [key: string]: Tournament;
};
type Directives = {
    pipe?: {
        [key: string]: boolean;
    };
    params?: {
        [key: string]: any;
    };
    method: string;
}[];
type CheckInOutParticipantArgs = {
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    matchUp?: HydratedMatchUp;
    participantId: string;
    matchUpId: string;
    event?: Event$1;
};
type ScheduleTimesResult = {
    scheduleTime: string;
};
type SeedBlock = {
    drawPositions: number[];
    seedNumbers: number[];
};
type SeedingProfile = {
    groupSeedingThreshold?: number;
    positioning?: string;
    nonRandom?: boolean;
};
type ScaleAttributes = {
    eventType?: EventTypeUnion;
    scaleName?: string;
    scaleType: string;
    accessor?: string;
};
type ScaleItem = {
    scaleDate?: string | Date;
    eventType?: EventTypeUnion;
    scaleName: string;
    scaleType: string;
    scaleValue: any;
};
type Flight = {
    manuallyAdded?: boolean;
    drawEntries: Entry[];
    flightNumber: number;
    drawName: string;
    drawId: string;
};
type FlightProfile = {
    scaleAttributes?: ScaleAttributes;
    splitMethod?: string;
    flights: Flight[];
};
type PolicyDefinitions = {
    [key in ValidPolicyTypes]?: {
        [key: string]: any;
    };
};
type QueueMethod = {
    params: {
        [key: string]: any;
    };
    method: string;
};
type RoundProfile = {
    [key: number]: {
        finishingPositionRange: MatchUpFinishingPositionRange;
        pairedDrawPositions: number[][];
        abbreviatedRoundName?: string;
        participantsCount?: number;
        drawPositions?: number[];
        inactiveRound?: boolean;
        feedRoundIndex?: number;
        inactiveCount?: number;
        finishingRound?: number;
        preFeedRound?: boolean;
        matchUpsCount: number;
        roundFactor?: number;
        feedRound?: boolean;
        roundIndex?: number;
        roundNumber: number;
        roundName?: string;
    };
};
type ParticipantFilters = {
    accessorValues?: {
        accessor: string;
        value: any;
    }[];
    participantRoleResponsibilities?: string[];
    participantRoles?: ParticipantRoleUnion[];
    participantTypes?: ParticipantTypeUnion[];
    signInStatus?: SignedInStatusUnion;
    positionedParticipants?: boolean;
    eventEntryStatuses?: string[];
    drawEntryStatuses?: string[];
    enableOrFiltering?: boolean;
    participantIds?: string[];
    genders?: GenderUnion;
    eventIds?: string[];
};
type StructureSortConfig = {
    deprioritizeCompleted?: boolean;
    mode?: {
        [key: string]: number;
    };
};
type PersonData = {
    participantExtensions?: Extension[];
    participantTimeItems?: TimeItem[];
    [key: string]: any;
};
type AddressProps = {
    postalCodesCount?: number;
    citiesCount?: number;
    statesCount?: number;
    [key: string]: any;
};
type TeamKey = {
    participantAttribute?: string;
    addParticipants?: boolean;
    personAttribute?: string;
    teamNames?: string[];
    accessor?: string;
    uuids?: string[];
};
type ScheduleAnalysis = boolean | {
    scheduledMinutesDifference: number;
};
type ParticipantsProfile = {
    participantType?: ParticipantTypeUnion;
    scaledParticipantsCount?: number;
    rankingRange?: [number, number];
    nationalityCodesCount?: number;
    scaleAllParticipants?: boolean;
    personExtensions?: Extension[];
    valuesInstanceLimit?: number;
    addressProps?: AddressProps;
    convertExtensions?: boolean;
    participantsCount?: number;
    addParticipants?: boolean;
    withScaleValues?: boolean;
    personAttribute?: string;
    consideredDate?: string;
    withGroupings?: boolean;
    personData?: PersonData;
    personIds?: string[];
    inContext?: boolean;
    category?: Category;
    withISO2?: boolean;
    withIOC?: boolean;
    teamKey?: TeamKey;
    idPrefix?: string;
    uuids?: string[];
    sex?: SexUnion;
    usePublishState?: boolean;
    withStatistics?: boolean;
    withOpponents?: boolean;
    withMatchUps?: boolean;
    withSeeding?: boolean;
    withEvents?: boolean;
    withDraws?: boolean;
    participantFilters?: ParticipantFilters;
    scheduleAnalysis?: ScheduleAnalysis;
    policyDefinitions?: PolicyDefinitions;
};
type ScheduleVisibilityFilters = {
    visibilityThreshold: string;
    eventIds?: string[];
    drawIds?: string[];
};
type ContextContent = {
    policies?: PolicyDefinitions;
};
type ContextProfile = {
    withCompetitiveness?: boolean;
    withScaleValues?: boolean;
    inferGender?: boolean;
    exclude?: string[];
};
type Counters = {
    walkoverWins: number;
    defaultWins: number;
    walkovers: number;
    defaults: number;
    losses: number;
    wins: number;
};
type ScheduleConflict = {
    priorScheduledMatchUpId: string;
    matchUpIdWithConflict: string;
};
type LineParticipation = {
    collectionPosition: number;
    collectionId?: string;
    won: boolean;
};
type StructureParticipation = {
    lineParticipation?: LineParticipation[];
    rankingStage: StageTypeUnion;
    walkoverWinCount: number;
    defaultWinCount: number;
    stageSequence: number;
    structureId: string;
    winCount: number;
    drawId: string;
};
type MappedParticipant = {
    structureParticipation: {
        [key: string]: StructureParticipation;
    } | StructureParticipation[];
    potentialMatchUps: {
        tournamentId: string;
        matchUpId: string;
        eventId: string;
        drawId: string;
    }[];
    scheduleConflicts: {
        [key: string]: ScheduleConflict;
    };
    scheduleItems: any[];
    participant: HydratedParticipant & {
        groupParticipantIds: string[];
        pairParticipantIds: string[];
        teamParticipantIds: string[];
        groups: {
            participantRoleResponsibilities?: string[];
            participantOtherName?: string;
            participantName: string;
            participantId: string;
        }[];
        teams: {
            participantRoleResponsibilities?: string[];
            participantOtherName?: string;
            participantName: string;
            participantId: string;
            teamId: string;
        }[];
    };
    statistics: {
        [key: string]: any;
    } | any[];
    opponents: {
        [key: string]: any;
    } | any[];
    pairIdMap: {
        [key: string]: any;
    } | any[];
    matchUps: {
        [key: string]: any;
    } | any[];
    events: {
        [key: string]: any;
    } | any[];
    draws: {
        [key: string]: any;
    } | any[];
    counters: Counters & {
        [DOUBLES_EVENT]: Counters;
        [SINGLES_EVENT]: Counters;
        [TEAM_EVENT]: Counters;
    };
};
type ParticipantMap = {
    [key: string]: MappedParticipant;
};
type GetMatchUpsArgs = {
    scheduleVisibilityFilters?: ScheduleVisibilityFilters;
    tournamentAppliedPolicies?: PolicyDefinitions;
    participantsProfile?: ParticipantsProfile;
    participants?: HydratedParticipant[];
    policyDefinitions?: PolicyDefinitions;
    context?: {
        [key: string]: any;
    };
    contextFilters?: MatchUpFilters;
    matchUpFilters?: MatchUpFilters;
    contextContent?: ContextContent;
    participantMap?: ParticipantMap;
    hydrateParticipants?: boolean;
    tournamentRecord?: Tournament;
    contextProfile?: ContextProfile;
    drawDefinition?: DrawDefinition;
    afterRecoveryTimes?: boolean;
    useParticipantMap?: boolean;
    usePublishState?: boolean;
    nextMatchUps?: boolean;
    tournamentId?: string;
    publishStatus?: any;
    inContext?: boolean;
    event?: Event$1;
};
type GroupInfo = {
    [key: string]: {
        participantName: string;
        participantId: string;
    };
};
type GroupsMatchUpsResult = {
    abandonedMatchUps?: HydratedMatchUp[];
    completedMatchUps?: HydratedMatchUp[];
    upcomingMatchUps?: HydratedMatchUp[];
    participants?: HydratedParticipant[];
    pendingMatchUps?: HydratedMatchUp[];
    byeMatchUps?: HydratedMatchUp[];
    matchUpsMap?: MatchUpsMap;
    matchUpsCount?: number;
    groupInfo?: GroupInfo;
    success?: boolean;
    error?: ErrorType;
};
type ExitProfiles = {
    [key: string]: string[];
};
type MinutesMapping = {
    categoryNames: string[];
    minutes: any;
};
type ScheduleTiming = {
    matchUpRecoveryTimes: {
        [key: string]: {
            recoveryTiming: MinutesMapping[];
            matchUpFormatCodes: string[];
        };
    }[];
    matchUpAverageTimes: {
        [key: string]: {
            [key: string]: {
                averageTiming: MinutesMapping[];
                matchUpFormatCodes: string[];
            };
        };
    }[];
};
type Substitution = {
    previousParticipantId: string;
    substitutionOrder: number;
    participantId: string;
};
type PlayoffAttributes = {
    [key: string | number]: {
        name: string;
        abbreviation: string;
    };
};
type WithPlayoffsArgs = {
    roundProfiles?: {
        [key: number]: number;
    }[];
    playoffAttributes?: PlayoffAttributes;
    playoffStructureNameBase?: string;
    addNameBaseToAttributeName?: boolean;
    finishingPositionNaming?: any;
    finishingPositionLimit?: number;
    playoffPositions?: number[];
    roundOffsetLimit?: number;
    exitProfileLimit?: boolean;
    roundNumbers?: number[];
    roundPlayoffs?: {
        [roundNumber: number]: WithPlayoffsArgs;
    };
};
type LineUp = TeamCompetitor$1[];
type StructureProfile = {
    distanceFromMain?: number;
    drawSources: string[];
    drawTargets: string[];
    progeny?: string[];
    sources: string[];
    targets: string[];
    rootStage?: string;
    stage?: string;
};
type IdCollections = {
    groupParticipants: string[];
    pairParticipants: string[];
    teamParticipants: string[];
};
type Request$1 = {
    requestType: string;
    requestId: string;
    startTime: string;
    endTime: string;
    date: string;
};
type PersonRequests = {
    [key: string]: Request$1[];
};
type AddScheduleAttributeArgs = {
    tournamentRecord?: Tournament;
    drawDefinition: DrawDefinition;
    removePriorValues?: boolean;
    disableNotice?: boolean;
    matchUpId: string;
    event?: Event$1;
};
type MatchUpFilters = {
    matchUpStatuses?: MatchUpStatusUnion[];
    excludeMatchUpStatuses?: string[];
    hasParticipantsCount?: number;
    isCollectionMatchUp?: boolean;
    matchUpFormats?: string[];
    roundPositions?: number[];
    hasWinningSide?: boolean;
    collectionIds?: string[];
    roundNumbers?: number[];
    isMatchUpTie?: boolean;
    matchUpFormat?: string;
    matchUpIds?: string[];
    roundNames?: string[];
    processContext?: boolean;
    stageSequences?: string[];
    scheduledDates?: string[];
    participantIds?: string[];
    stages?: StageTypeUnion[];
    tournamentIds?: string[];
    matchUpTypes?: string[];
    structureIds?: string[];
    scheduledDate?: string;
    readyToScore?: boolean;
    courtIds?: string[];
    eventIds?: string[];
    venueIds?: string[];
    drawIds?: string[];
    filterMatchUpTypes?: boolean;
    filterMatchUpIds?: boolean;
};
type GenerateDrawDefinitionArgs = {
    automated?: boolean | {
        seedsOnly: boolean;
    };
    playoffAttributes?: PlayoffAttributes;
    policyDefinitions?: PolicyDefinitions;
    appliedPolicies?: PolicyDefinitions;
    voluntaryConsolation?: {
        structureAbbreviation?: string;
        structureName?: string;
        structureId?: string;
    };
    enforceMinimumDrawSize?: boolean;
    ignoreAllowedDrawTypes?: boolean;
    qualifyingPlaceholder?: boolean;
    considerEventEntries?: boolean;
    seedingProfile?: SeedingProfile;
    hydrateCollections?: boolean;
    tournamentRecord: Tournament;
    matchUpType?: EventTypeUnion;
    hydrateRoundNames?: boolean;
    drawTypeCoercion?: boolean;
    ignoreStageSpace?: boolean;
    qualifyingProfiles?: any[];
    drawMatic?: DrawMaticArgs;
    qualifyingOnly?: boolean;
    drawType?: DrawTypeUnion;
    enforceGender?: boolean;
    processCodes?: string[];
    matchUpFormat?: string;
    structureName?: string;
    tieFormatName?: string;
    tieFormat?: TieFormat;
    withPlayoffs?: WithPlayoffsArgs;
    drawEntries?: Entry[];
    roundsCount?: number;
    seedsCount?: number;
    placeByes?: boolean;
    drawName?: string;
    drawSize?: number;
    idPrefix?: string;
    isMock?: boolean;
    random?: () => number;
    targetMatchUpIds?: TargetMatchUpId[];
    uuids?: string[];
    drawId?: string;
    event: Event$1;
};
type TargetMatchUpId = {
    matchUpId: string;
    roundNumber: number;
    roundPosition: number;
    stage?: string;
    stageSequence?: number;
    exitProfile?: string;
    structureId?: string;
};
type DrawMaticArgs = {
    adHocRatings?: {
        [key: string]: number;
    };
    restrictRoundsCount?: boolean;
    restrictEntryStatus?: boolean;
    tournamentRecord: Tournament;
    drawDefinition: DrawDefinition;
    enableDoubleRobin?: boolean;
    generateMatchUps?: boolean;
    eventType?: EventTypeUnion;
    salted?: number | boolean;
    participantIds?: string[];
    updateParticipantRatings?: boolean;
    dynamicRatings?: boolean;
    convertToELO?: boolean;
    refreshDynamic?: boolean;
    encounterValue?: number;
    sameTeamValue?: number;
    scaleAccessor?: string;
    maxIterations?: number;
    matchUpIds?: string[];
    structure?: Structure;
    roundsCount?: number;
    structureId?: string;
    random?: () => number;
    scaleName?: string;
    idPrefix?: string;
    isMock?: boolean;
    event: Event$1;
};
type ResultType = {
    context?: {
        [key: string]: any;
    };
    stack?: string | string[];
    errors?: string[];
    error?: ErrorType;
    success?: boolean;
    valid?: boolean;
    info?: any;
};
type MappedMatchUps = {
    [key: string]: {
        matchUps: HydratedMatchUp[] | MatchUp$1[] | undefined;
        itemStructureIds: string[];
        structureName?: string;
    };
};
type MatchUpsMap = {
    mappedMatchUps: MappedMatchUps;
    drawMatchUps: MatchUp$1[];
};
type Tally = [number, number];
type ScheduledMatchUpArgs = {
    visibilityThreshold?: string;
    timeStamp?: string;
    schedule?: any;
    matchUp: any;
};

declare function linkTournaments({ tournamentRecords }: {
    tournamentRecords: TournamentRecords;
}): ResultType;
type UnlinkTournamentsArgs = {
    tournamentRecords: TournamentRecords;
};
declare function unlinkTournaments({ tournamentRecords }: UnlinkTournamentsArgs): ResultType;
type UnlinkTournamentArgs = {
    tournamentRecords: TournamentRecords;
    tournamentId: string;
};
declare function unlinkTournament({ tournamentRecords, tournamentId }: UnlinkTournamentArgs): ResultType;

declare const mutate$g_initializeCompetitionState: typeof initializeCompetitionState;
declare const mutate$g_linkTournaments: typeof linkTournaments;
declare const mutate$g_processCompetitionMatchUp: typeof processCompetitionMatchUp;
declare const mutate$g_processCompetitionRound: typeof processCompetitionRound;
declare const mutate$g_resetCompetitionState: typeof resetCompetitionState;
declare const mutate$g_unlinkTournament: typeof unlinkTournament;
declare const mutate$g_unlinkTournaments: typeof unlinkTournaments;
declare namespace mutate$g {
  export {
    mutate$g_initializeCompetitionState as initializeCompetitionState,
    mutate$g_linkTournaments as linkTournaments,
    mutate$g_processCompetitionMatchUp as processCompetitionMatchUp,
    mutate$g_processCompetitionRound as processCompetitionRound,
    mutate$g_resetCompetitionState as resetCompetitionState,
    mutate$g_unlinkTournament as unlinkTournament,
    mutate$g_unlinkTournaments as unlinkTournaments,
  };
}

declare const query$f_getCompetitionLeaderboard: typeof getCompetitionLeaderboard;
declare const query$f_getCompetitionParticipantState: typeof getCompetitionParticipantState;
declare const query$f_getCompetitionPolicy: typeof getCompetitionPolicy;
declare const query$f_getCompetitionState: typeof getCompetitionState;
declare const query$f_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const query$f_getTournamentIds: typeof getTournamentIds;
declare namespace query$f {
  export {
    query$f_getCompetitionLeaderboard as getCompetitionLeaderboard,
    query$f_getCompetitionParticipantState as getCompetitionParticipantState,
    query$f_getCompetitionPolicy as getCompetitionPolicy,
    query$f_getCompetitionState as getCompetitionState,
    query$f_getLinkedTournamentIds as getLinkedTournamentIds,
    query$f_getTournamentIds as getTournamentIds,
  };
}

declare const index$q_getCompetitionLeaderboard: typeof getCompetitionLeaderboard;
declare const index$q_getCompetitionParticipantState: typeof getCompetitionParticipantState;
declare const index$q_getCompetitionPolicy: typeof getCompetitionPolicy;
declare const index$q_getCompetitionState: typeof getCompetitionState;
declare const index$q_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const index$q_getTournamentIds: typeof getTournamentIds;
declare const index$q_initializeCompetitionState: typeof initializeCompetitionState;
declare const index$q_linkTournaments: typeof linkTournaments;
declare const index$q_processCompetitionMatchUp: typeof processCompetitionMatchUp;
declare const index$q_processCompetitionRound: typeof processCompetitionRound;
declare const index$q_resetCompetitionState: typeof resetCompetitionState;
declare const index$q_unlinkTournament: typeof unlinkTournament;
declare const index$q_unlinkTournaments: typeof unlinkTournaments;
declare namespace index$q {
  export {
    index$q_getCompetitionLeaderboard as getCompetitionLeaderboard,
    index$q_getCompetitionParticipantState as getCompetitionParticipantState,
    index$q_getCompetitionPolicy as getCompetitionPolicy,
    index$q_getCompetitionState as getCompetitionState,
    index$q_getLinkedTournamentIds as getLinkedTournamentIds,
    index$q_getTournamentIds as getTournamentIds,
    index$q_initializeCompetitionState as initializeCompetitionState,
    index$q_linkTournaments as linkTournaments,
    mutate$g as mutate,
    index$q_processCompetitionMatchUp as processCompetitionMatchUp,
    index$q_processCompetitionRound as processCompetitionRound,
    query$f as query,
    index$q_resetCompetitionState as resetCompetitionState,
    index$q_unlinkTournament as unlinkTournament,
    index$q_unlinkTournaments as unlinkTournaments,
  };
}

declare const mutate$f_adHocPositionSwap: typeof adHocPositionSwap;
declare const mutate$f_addAdHocMatchUps: typeof addAdHocMatchUps;
declare const mutate$f_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem;
declare const mutate$f_addLinkedConsolationStructure: typeof addLinkedConsolationStructure;
declare const mutate$f_addPlayoffStructures: typeof addPlayoffStructures;
declare const mutate$f_addQualifyingStructure: typeof addQualifyingStructure;
declare const mutate$f_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure;
declare const mutate$f_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment;
declare const mutate$f_assignDrawPosition: typeof assignDrawPosition;
declare const mutate$f_assignDrawPositionBye: typeof assignDrawPositionBye;
declare const mutate$f_attachConsolationStructures: typeof attachConsolationStructures;
declare const mutate$f_attachPlayoffStructures: typeof attachPlayoffStructures;
declare const mutate$f_attachQualifyingStructure: typeof attachQualifyingStructure;
declare const mutate$f_attachStructures: typeof attachStructures;
declare const mutate$f_automatedPlayoffPositioning: typeof automatedPlayoffPositioning;
declare const mutate$f_automatedPositioning: typeof automatedPositioning;
declare const mutate$f_deleteAdHocMatchUps: typeof deleteAdHocMatchUps;
declare const mutate$f_initializeDraft: typeof initializeDraft;
declare const mutate$f_luckyDrawAdvancement: typeof luckyDrawAdvancement;
declare const mutate$f_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment;
declare const mutate$f_modifyDrawDefinition: typeof modifyDrawDefinition;
declare const mutate$f_modifyDrawName: typeof modifyDrawName;
declare const mutate$f_modifySeedAssignment: typeof modifySeedAssignment;
declare const mutate$f_pruneDrawDefinition: typeof pruneDrawDefinition;
declare const mutate$f_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment;
declare const mutate$f_qualifierProgression: typeof qualifierProgression;
declare const mutate$f_remapDrawDefinitionMatchUpIds: typeof remapDrawDefinitionMatchUpIds;
declare const mutate$f_removeDrawPositionAssignment: typeof removeDrawPositionAssignment;
declare const mutate$f_removeRoundMatchUps: typeof removeRoundMatchUps;
declare const mutate$f_removeSeededParticipant: typeof removeSeededParticipant;
declare const mutate$f_removeStructure: typeof removeStructure;
declare const mutate$f_renameStructures: typeof renameStructures;
declare const mutate$f_resetDrawDefinition: typeof resetDrawDefinition;
declare const mutate$f_resetQualifyingStructure: typeof resetQualifyingStructure;
declare const mutate$f_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure;
declare const mutate$f_resolveDraftPositions: typeof resolveDraftPositions;
declare const mutate$f_seedWithdrawalCascade: typeof seedWithdrawalCascade;
declare const mutate$f_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds;
declare const mutate$f_setDrawPositionPreferences: typeof setDrawPositionPreferences;
declare const mutate$f_setPositionAssignments: typeof setPositionAssignments;
declare const mutate$f_setStructureOrder: typeof setStructureOrder;
declare const mutate$f_setSubOrder: typeof setSubOrder;
declare const mutate$f_shiftAdHocRounds: typeof shiftAdHocRounds;
declare const mutate$f_swapAdHocRounds: typeof swapAdHocRounds;
declare const mutate$f_swapDrawPositionAssignments: typeof swapDrawPositionAssignments;
declare const mutate$f_updateTeamLineUp: typeof updateTeamLineUp;
declare const mutate$f_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition;
declare namespace mutate$f {
  export {
    mutate$f_adHocPositionSwap as adHocPositionSwap,
    mutate$f_addAdHocMatchUps as addAdHocMatchUps,
    mutate$f_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem,
    mutate$f_addLinkedConsolationStructure as addLinkedConsolationStructure,
    mutate$f_addPlayoffStructures as addPlayoffStructures,
    mutate$f_addQualifyingStructure as addQualifyingStructure,
    mutate$f_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure,
    mutate$f_alternateDrawPositionAssignment as alternateDrawPositionAssignment,
    mutate$f_assignDrawPosition as assignDrawPosition,
    mutate$f_assignDrawPositionBye as assignDrawPositionBye,
    mutate$f_attachConsolationStructures as attachConsolationStructures,
    mutate$f_attachPlayoffStructures as attachPlayoffStructures,
    mutate$f_attachQualifyingStructure as attachQualifyingStructure,
    mutate$f_attachStructures as attachStructures,
    mutate$f_automatedPlayoffPositioning as automatedPlayoffPositioning,
    mutate$f_automatedPositioning as automatedPositioning,
    mutate$f_deleteAdHocMatchUps as deleteAdHocMatchUps,
    mutate$f_initializeDraft as initializeDraft,
    mutate$f_luckyDrawAdvancement as luckyDrawAdvancement,
    mutate$f_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment,
    mutate$f_modifyDrawDefinition as modifyDrawDefinition,
    mutate$f_modifyDrawName as modifyDrawName,
    mutate$f_modifySeedAssignment as modifySeedAssignment,
    mutate$f_pruneDrawDefinition as pruneDrawDefinition,
    mutate$f_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment,
    mutate$f_qualifierProgression as qualifierProgression,
    mutate$f_remapDrawDefinitionMatchUpIds as remapDrawDefinitionMatchUpIds,
    mutate$f_removeDrawPositionAssignment as removeDrawPositionAssignment,
    mutate$f_removeRoundMatchUps as removeRoundMatchUps,
    mutate$f_removeSeededParticipant as removeSeededParticipant,
    mutate$f_removeStructure as removeStructure,
    mutate$f_renameStructures as renameStructures,
    mutate$f_resetDrawDefinition as resetDrawDefinition,
    mutate$f_resetQualifyingStructure as resetQualifyingStructure,
    mutate$f_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure,
    mutate$f_resolveDraftPositions as resolveDraftPositions,
    mutate$f_seedWithdrawalCascade as seedWithdrawalCascade,
    mutate$f_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds,
    mutate$f_setDrawPositionPreferences as setDrawPositionPreferences,
    mutate$f_setPositionAssignments as setPositionAssignments,
    mutate$f_setStructureOrder as setStructureOrder,
    mutate$f_setSubOrder as setSubOrder,
    mutate$f_shiftAdHocRounds as shiftAdHocRounds,
    mutate$f_swapAdHocRounds as swapAdHocRounds,
    mutate$f_swapDrawPositionAssignments as swapDrawPositionAssignments,
    mutate$f_updateTeamLineUp as updateTeamLineUp,
    mutate$f_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition,
  };
}

declare const query$e_addGoesTo: typeof addGoesTo;
declare const query$e_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const query$e_checkValidEntries: typeof checkValidEntries;
declare const query$e_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const query$e_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const query$e_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const query$e_getDraftState: typeof getDraftState;
declare const query$e_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const query$e_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const query$e_getDrawStructures: typeof getDrawStructures;
declare const query$e_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const query$e_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const query$e_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus;
declare const query$e_getMatchUpsMap: typeof getMatchUpsMap;
declare const query$e_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const query$e_getPositionAssignments: typeof getPositionAssignments;
declare const query$e_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const query$e_getRandomQualifierList: typeof getRandomQualifierList;
declare const query$e_getSeedingThresholds: typeof getSeedingThresholds;
declare const query$e_getSeedsCount: typeof getSeedsCount;
declare const query$e_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const query$e_getSwissChart: typeof getSwissChart;
declare const query$e_getSwissStandings: typeof getSwissStandings;
declare const query$e_getTally: typeof getTally;
declare const query$e_getTeamLineUp: typeof getTeamLineUp;
declare const query$e_getValidGroupSizes: typeof getValidGroupSizes;
declare const query$e_hasLuckyRounds: typeof hasLuckyRounds;
declare const query$e_isAdHoc: typeof isAdHoc;
declare const query$e_isCompletedStructure: typeof isCompletedStructure;
declare const query$e_isValidForQualifying: typeof isValidForQualifying;
declare const query$e_positionActions: typeof positionActions;
declare const query$e_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands;
declare const query$e_validatePlayoffGroups: typeof validatePlayoffGroups;
declare namespace query$e {
  export {
    query$e_addGoesTo as addGoesTo,
    query$e_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
    query$e_checkValidEntries as checkValidEntries,
    publicFindDrawDefinition as findDrawDefinition,
    query$e_getAssignedParticipantIds as getAssignedParticipantIds,
    query$e_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
    query$e_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
    query$e_getDraftState as getDraftState,
    query$e_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
    query$e_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
    query$e_getDrawStructures as getDrawStructures,
    query$e_getDrawTypeCoercion as getDrawTypeCoercion,
    query$e_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
    query$e_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus,
    query$e_getMatchUpsMap as getMatchUpsMap,
    query$e_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
    query$e_getPositionAssignments as getPositionAssignments,
    query$e_getPositionsPlayedOff as getPositionsPlayedOff,
    query$e_getRandomQualifierList as getRandomQualifierList,
    query$e_getSeedingThresholds as getSeedingThresholds,
    query$e_getSeedsCount as getSeedsCount,
    query$e_getStructureSeedAssignments as getStructureSeedAssignments,
    query$e_getSwissChart as getSwissChart,
    query$e_getSwissStandings as getSwissStandings,
    query$e_getTally as getTally,
    query$e_getTeamLineUp as getTeamLineUp,
    query$e_getValidGroupSizes as getValidGroupSizes,
    query$e_hasLuckyRounds as hasLuckyRounds,
    query$e_isAdHoc as isAdHoc,
    query$e_isCompletedStructure as isCompletedStructure,
    query$e_isValidForQualifying as isValidForQualifying,
    query$e_positionActions as positionActions,
    query$e_predictDrawCompetitiveBands as predictDrawCompetitiveBands,
    query$e_validatePlayoffGroups as validatePlayoffGroups,
  };
}

declare const index$p_adHocPositionSwap: typeof adHocPositionSwap;
declare const index$p_addAdHocMatchUps: typeof addAdHocMatchUps;
declare const index$p_addDrawDefinitionTimeItem: typeof addDrawDefinitionTimeItem;
declare const index$p_addFinishingRounds: typeof addFinishingRounds;
declare const index$p_addGoesTo: typeof addGoesTo;
declare const index$p_addLinkedConsolationStructure: typeof addLinkedConsolationStructure;
declare const index$p_addPlayoffStructures: typeof addPlayoffStructures;
declare const index$p_addQualifyingStructure: typeof addQualifyingStructure;
declare const index$p_addVoluntaryConsolationStructure: typeof addVoluntaryConsolationStructure;
declare const index$p_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const index$p_alternateDrawPositionAssignment: typeof alternateDrawPositionAssignment;
declare const index$p_assignDrawPosition: typeof assignDrawPosition;
declare const index$p_assignDrawPositionBye: typeof assignDrawPositionBye;
declare const index$p_attachConsolationStructures: typeof attachConsolationStructures;
declare const index$p_attachPlayoffStructures: typeof attachPlayoffStructures;
declare const index$p_attachQualifyingStructure: typeof attachQualifyingStructure;
declare const index$p_attachStructures: typeof attachStructures;
declare const index$p_autoSeeding: typeof autoSeeding;
declare const index$p_automatedPlayoffPositioning: typeof automatedPlayoffPositioning;
declare const index$p_automatedPositioning: typeof automatedPositioning;
declare const index$p_buildDrawHierarchy: typeof buildDrawHierarchy;
declare const index$p_checkValidEntries: typeof checkValidEntries;
declare const index$p_deleteAdHocMatchUps: typeof deleteAdHocMatchUps;
declare const index$p_drawMatic: typeof drawMatic;
declare const index$p_generateAdHocMatchUps: typeof generateAdHocMatchUps;
declare const index$p_generateAdHocRounds: typeof generateAdHocRounds;
declare const index$p_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures;
declare const index$p_generateConsolationStructure: typeof generateConsolationStructure;
declare const index$p_generateDrawDefinition: typeof generateDrawDefinition;
declare const index$p_generateDrawMaticRound: typeof generateDrawMaticRound;
declare const index$p_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks;
declare const index$p_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition;
declare const index$p_generateQualifyingStructure: typeof generateQualifyingStructure;
declare const index$p_generateSwissRound: typeof generateSwissRound;
declare const index$p_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
declare const index$p_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const index$p_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const index$p_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const index$p_getDraftState: typeof getDraftState;
declare const index$p_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const index$p_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const index$p_getDrawStructures: typeof getDrawStructures;
declare const index$p_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const index$p_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const index$p_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus;
declare const index$p_getMatchUpsMap: typeof getMatchUpsMap;
declare const index$p_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const index$p_getPositionAssignments: typeof getPositionAssignments;
declare const index$p_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const index$p_getRandomQualifierList: typeof getRandomQualifierList;
declare const index$p_getSeedingThresholds: typeof getSeedingThresholds;
declare const index$p_getSeedsCount: typeof getSeedsCount;
declare const index$p_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const index$p_getSwissChart: typeof getSwissChart;
declare const index$p_getSwissStandings: typeof getSwissStandings;
declare const index$p_getTally: typeof getTally;
declare const index$p_getTeamLineUp: typeof getTeamLineUp;
declare const index$p_getValidGroupSizes: typeof getValidGroupSizes;
declare const index$p_hasLuckyRounds: typeof hasLuckyRounds;
declare const index$p_initializeDraft: typeof initializeDraft;
declare const index$p_isAdHoc: typeof isAdHoc;
declare const index$p_isCompletedStructure: typeof isCompletedStructure;
declare const index$p_isValidForQualifying: typeof isValidForQualifying;
declare const index$p_luckyDrawAdvancement: typeof luckyDrawAdvancement;
declare const index$p_luckyLoserDrawPositionAssignment: typeof luckyLoserDrawPositionAssignment;
declare const index$p_modifyDrawDefinition: typeof modifyDrawDefinition;
declare const index$p_modifyDrawName: typeof modifyDrawName;
declare const index$p_modifySeedAssignment: typeof modifySeedAssignment;
declare const index$p_positionActions: typeof positionActions;
declare const index$p_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands;
declare const index$p_pruneDrawDefinition: typeof pruneDrawDefinition;
declare const index$p_qualifierDrawPositionAssignment: typeof qualifierDrawPositionAssignment;
declare const index$p_qualifierProgression: typeof qualifierProgression;
declare const index$p_remapDrawDefinitionMatchUpIds: typeof remapDrawDefinitionMatchUpIds;
declare const index$p_removeDrawPositionAssignment: typeof removeDrawPositionAssignment;
declare const index$p_removeRoundMatchUps: typeof removeRoundMatchUps;
declare const index$p_removeSeededParticipant: typeof removeSeededParticipant;
declare const index$p_removeStructure: typeof removeStructure;
declare const index$p_renameStructures: typeof renameStructures;
declare const index$p_resetDrawDefinition: typeof resetDrawDefinition;
declare const index$p_resetQualifyingStructure: typeof resetQualifyingStructure;
declare const index$p_resetVoluntaryConsolationStructure: typeof resetVoluntaryConsolationStructure;
declare const index$p_resolveDraftPositions: typeof resolveDraftPositions;
declare const index$p_seedWithdrawalCascade: typeof seedWithdrawalCascade;
declare const index$p_setDrawParticipantRepresentativeIds: typeof setDrawParticipantRepresentativeIds;
declare const index$p_setDrawPositionPreferences: typeof setDrawPositionPreferences;
declare const index$p_setPositionAssignments: typeof setPositionAssignments;
declare const index$p_setStructureOrder: typeof setStructureOrder;
declare const index$p_setSubOrder: typeof setSubOrder;
declare const index$p_shiftAdHocRounds: typeof shiftAdHocRounds;
declare const index$p_swapAdHocRounds: typeof swapAdHocRounds;
declare const index$p_swapDrawPositionAssignments: typeof swapDrawPositionAssignments;
declare const index$p_updateTeamLineUp: typeof updateTeamLineUp;
declare const index$p_validatePlayoffGroups: typeof validatePlayoffGroups;
declare const index$p_withdrawParticipantAtDrawPosition: typeof withdrawParticipantAtDrawPosition;
declare namespace index$p {
  export {
    index$p_adHocPositionSwap as adHocPositionSwap,
    index$p_addAdHocMatchUps as addAdHocMatchUps,
    index$p_addDrawDefinitionTimeItem as addDrawDefinitionTimeItem,
    index$p_addFinishingRounds as addFinishingRounds,
    index$p_addGoesTo as addGoesTo,
    index$p_addLinkedConsolationStructure as addLinkedConsolationStructure,
    index$p_addPlayoffStructures as addPlayoffStructures,
    index$p_addQualifyingStructure as addQualifyingStructure,
    index$p_addVoluntaryConsolationStructure as addVoluntaryConsolationStructure,
    index$p_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
    index$p_alternateDrawPositionAssignment as alternateDrawPositionAssignment,
    index$p_assignDrawPosition as assignDrawPosition,
    index$p_assignDrawPositionBye as assignDrawPositionBye,
    index$p_attachConsolationStructures as attachConsolationStructures,
    index$p_attachPlayoffStructures as attachPlayoffStructures,
    index$p_attachQualifyingStructure as attachQualifyingStructure,
    index$p_attachStructures as attachStructures,
    index$p_autoSeeding as autoSeeding,
    index$p_automatedPlayoffPositioning as automatedPlayoffPositioning,
    index$p_automatedPositioning as automatedPositioning,
    index$p_buildDrawHierarchy as buildDrawHierarchy,
    index$p_checkValidEntries as checkValidEntries,
    index$p_deleteAdHocMatchUps as deleteAdHocMatchUps,
    index$p_drawMatic as drawMatic,
    publicFindDrawDefinition as findDrawDefinition,
    index$p_generateAdHocMatchUps as generateAdHocMatchUps,
    index$p_generateAdHocRounds as generateAdHocRounds,
    index$p_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures,
    index$p_generateConsolationStructure as generateConsolationStructure,
    index$p_generateDrawDefinition as generateDrawDefinition,
    index$p_generateDrawMaticRound as generateDrawMaticRound,
    index$p_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks,
    index$p_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition,
    index$p_generateQualifyingStructure as generateQualifyingStructure,
    index$p_generateSwissRound as generateSwissRound,
    index$p_generateVoluntaryConsolation as generateVoluntaryConsolation,
    index$p_getAssignedParticipantIds as getAssignedParticipantIds,
    index$p_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
    index$p_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
    index$p_getDraftState as getDraftState,
    index$p_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
    index$p_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
    index$p_getDrawStructures as getDrawStructures,
    index$p_getDrawTypeCoercion as getDrawTypeCoercion,
    index$p_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
    index$p_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus,
    index$p_getMatchUpsMap as getMatchUpsMap,
    index$p_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
    index$p_getPositionAssignments as getPositionAssignments,
    index$p_getPositionsPlayedOff as getPositionsPlayedOff,
    index$p_getRandomQualifierList as getRandomQualifierList,
    index$p_getSeedingThresholds as getSeedingThresholds,
    index$p_getSeedsCount as getSeedsCount,
    index$p_getStructureSeedAssignments as getStructureSeedAssignments,
    index$p_getSwissChart as getSwissChart,
    index$p_getSwissStandings as getSwissStandings,
    index$p_getTally as getTally,
    index$p_getTeamLineUp as getTeamLineUp,
    index$p_getValidGroupSizes as getValidGroupSizes,
    index$p_hasLuckyRounds as hasLuckyRounds,
    index$p_initializeDraft as initializeDraft,
    index$p_isAdHoc as isAdHoc,
    index$p_isCompletedStructure as isCompletedStructure,
    index$p_isValidForQualifying as isValidForQualifying,
    index$p_luckyDrawAdvancement as luckyDrawAdvancement,
    index$p_luckyLoserDrawPositionAssignment as luckyLoserDrawPositionAssignment,
    index$p_modifyDrawDefinition as modifyDrawDefinition,
    index$p_modifyDrawName as modifyDrawName,
    index$p_modifySeedAssignment as modifySeedAssignment,
    mutate$f as mutate,
    index$p_positionActions as positionActions,
    index$p_predictDrawCompetitiveBands as predictDrawCompetitiveBands,
    index$p_pruneDrawDefinition as pruneDrawDefinition,
    index$p_qualifierDrawPositionAssignment as qualifierDrawPositionAssignment,
    index$p_qualifierProgression as qualifierProgression,
    query$e as query,
    index$p_remapDrawDefinitionMatchUpIds as remapDrawDefinitionMatchUpIds,
    index$p_removeDrawPositionAssignment as removeDrawPositionAssignment,
    index$p_removeRoundMatchUps as removeRoundMatchUps,
    index$p_removeSeededParticipant as removeSeededParticipant,
    index$p_removeStructure as removeStructure,
    index$p_renameStructures as renameStructures,
    index$p_resetDrawDefinition as resetDrawDefinition,
    index$p_resetQualifyingStructure as resetQualifyingStructure,
    index$p_resetVoluntaryConsolationStructure as resetVoluntaryConsolationStructure,
    index$p_resolveDraftPositions as resolveDraftPositions,
    index$p_seedWithdrawalCascade as seedWithdrawalCascade,
    index$p_setDrawParticipantRepresentativeIds as setDrawParticipantRepresentativeIds,
    index$p_setDrawPositionPreferences as setDrawPositionPreferences,
    index$p_setPositionAssignments as setPositionAssignments,
    index$p_setStructureOrder as setStructureOrder,
    index$p_setSubOrder as setSubOrder,
    index$p_shiftAdHocRounds as shiftAdHocRounds,
    index$p_swapAdHocRounds as swapAdHocRounds,
    index$p_swapDrawPositionAssignments as swapDrawPositionAssignments,
    index$p_updateTeamLineUp as updateTeamLineUp,
    index$p_validatePlayoffGroups as validatePlayoffGroups,
    index$p_withdrawParticipantAtDrawPosition as withdrawParticipantAtDrawPosition,
  };
}

declare const mutate$e_addDrawEntries: typeof addDrawEntries;
declare const mutate$e_addEventEntries: typeof addEventEntries;
declare const mutate$e_addEventEntryPairs: typeof addEventEntryPairs;
declare const mutate$e_destroyPairEntries: typeof destroyPairEntries;
declare const mutate$e_destroyPairEntry: typeof destroyPairEntry;
declare const mutate$e_modifyEntriesStatus: typeof modifyEntriesStatus;
declare const mutate$e_modifyEventEntries: typeof modifyEventEntries;
declare const mutate$e_promoteAlternate: typeof promoteAlternate;
declare const mutate$e_promoteAlternates: typeof promoteAlternates;
declare const mutate$e_removeDrawEntries: typeof removeDrawEntries;
declare const mutate$e_removeEventEntries: typeof removeEventEntries;
declare const mutate$e_removeStageEntries: typeof removeStageEntries;
declare const mutate$e_setEntryPosition: typeof setEntryPosition;
declare const mutate$e_setEntryPositions: typeof setEntryPositions;
declare namespace mutate$e {
  export {
    mutate$e_addDrawEntries as addDrawEntries,
    mutate$e_addEventEntries as addEventEntries,
    mutate$e_addEventEntryPairs as addEventEntryPairs,
    mutate$e_destroyPairEntries as destroyPairEntries,
    mutate$e_destroyPairEntry as destroyPairEntry,
    mutate$e_modifyEntriesStatus as modifyEntriesStatus,
    mutate$e_modifyEventEntries as modifyEventEntries,
    mutate$e_promoteAlternate as promoteAlternate,
    mutate$e_promoteAlternates as promoteAlternates,
    mutate$e_removeDrawEntries as removeDrawEntries,
    mutate$e_removeEventEntries as removeEventEntries,
    mutate$e_removeStageEntries as removeStageEntries,
    mutate$e_setEntryPosition as setEntryPosition,
    mutate$e_setEntryPositions as setEntryPositions,
  };
}

declare const query$d_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const query$d_getMaxEntryPosition: typeof getMaxEntryPosition;
declare namespace query$d {
  export {
    query$d_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
    query$d_getMaxEntryPosition as getMaxEntryPosition,
  };
}

declare const index$o_addDrawEntries: typeof addDrawEntries;
declare const index$o_addEventEntries: typeof addEventEntries;
declare const index$o_addEventEntryPairs: typeof addEventEntryPairs;
declare const index$o_destroyPairEntries: typeof destroyPairEntries;
declare const index$o_destroyPairEntry: typeof destroyPairEntry;
declare const index$o_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const index$o_getMaxEntryPosition: typeof getMaxEntryPosition;
declare const index$o_modifyEntriesStatus: typeof modifyEntriesStatus;
declare const index$o_modifyEventEntries: typeof modifyEventEntries;
declare const index$o_promoteAlternate: typeof promoteAlternate;
declare const index$o_promoteAlternates: typeof promoteAlternates;
declare const index$o_removeDrawEntries: typeof removeDrawEntries;
declare const index$o_removeEventEntries: typeof removeEventEntries;
declare const index$o_removeStageEntries: typeof removeStageEntries;
declare const index$o_setEntryPosition: typeof setEntryPosition;
declare const index$o_setEntryPositions: typeof setEntryPositions;
declare namespace index$o {
  export {
    index$o_addDrawEntries as addDrawEntries,
    index$o_addEventEntries as addEventEntries,
    index$o_addEventEntryPairs as addEventEntryPairs,
    index$o_destroyPairEntries as destroyPairEntries,
    index$o_destroyPairEntry as destroyPairEntry,
    index$o_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
    index$o_getMaxEntryPosition as getMaxEntryPosition,
    index$o_modifyEntriesStatus as modifyEntriesStatus,
    index$o_modifyEventEntries as modifyEventEntries,
    mutate$e as mutate,
    index$o_promoteAlternate as promoteAlternate,
    index$o_promoteAlternates as promoteAlternates,
    query$d as query,
    index$o_removeDrawEntries as removeDrawEntries,
    index$o_removeEventEntries as removeEventEntries,
    index$o_removeStageEntries as removeStageEntries,
    index$o_setEntryPosition as setEntryPosition,
    index$o_setEntryPositions as setEntryPositions,
  };
}

declare const generate$4_generateEventsFromTieFormat: typeof generateEventsFromTieFormat;
declare namespace generate$4 {
  export {
    generate$4_generateEventsFromTieFormat as generateEventsFromTieFormat,
  };
}

declare const mutate$d_addDrawDefinition: typeof addDrawDefinition;
declare const mutate$d_addEvent: typeof addEvent;
declare const mutate$d_addFlight: typeof addFlight;
declare const mutate$d_assignSeedPositions: typeof assignSeedPositions;
declare const mutate$d_attachFlightProfile: typeof attachFlightProfile;
declare const mutate$d_deleteDrawDefinitions: typeof deleteDrawDefinitions;
declare const mutate$d_deleteEvents: typeof deleteEvents;
declare const mutate$d_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw;
declare const mutate$d_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws;
declare const mutate$d_modifyEvent: typeof modifyEvent;
declare const mutate$d_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming;
declare const mutate$d_modifyPairAssignment: typeof modifyPairAssignment;
declare const mutate$d_refreshEventDrawOrder: typeof refreshEventDrawOrder;
declare const mutate$d_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const mutate$d_removeScaleValues: typeof removeScaleValues;
declare const mutate$d_removeSeeding: typeof removeSeeding;
declare const mutate$d_setEventDates: typeof setEventDates;
declare const mutate$d_setEventDisplay: typeof setEventDisplay;
declare const mutate$d_setEventEndDate: typeof setEventEndDate;
declare const mutate$d_setEventStartDate: typeof setEventStartDate;
declare const mutate$d_updateDrawIdsOrder: typeof updateDrawIdsOrder;
declare const mutate$d_validateCategory: typeof validateCategory;
declare namespace mutate$d {
  export {
    mutate$d_addDrawDefinition as addDrawDefinition,
    mutate$d_addEvent as addEvent,
    mutate$d_addFlight as addFlight,
    mutate$d_assignSeedPositions as assignSeedPositions,
    mutate$d_attachFlightProfile as attachFlightProfile,
    mutate$d_deleteDrawDefinitions as deleteDrawDefinitions,
    mutate$d_deleteEvents as deleteEvents,
    mutate$d_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw,
    mutate$d_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws,
    mutate$d_modifyEvent as modifyEvent,
    mutate$d_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming,
    mutate$d_modifyPairAssignment as modifyPairAssignment,
    mutate$d_refreshEventDrawOrder as refreshEventDrawOrder,
    mutate$d_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
    mutate$d_removeScaleValues as removeScaleValues,
    mutate$d_removeSeeding as removeSeeding,
    mutate$d_setEventDates as setEventDates,
    mutate$d_setEventDisplay as setEventDisplay,
    mutate$d_setEventEndDate as setEventEndDate,
    mutate$d_setEventStartDate as setEventStartDate,
    mutate$d_updateDrawIdsOrder as updateDrawIdsOrder,
    mutate$d_validateCategory as validateCategory,
  };
}

declare const query$c_categoryCanContain: typeof categoryCanContain;
declare const query$c_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const query$c_getEvent: typeof getEvent;
declare const query$c_getEventProperties: typeof getEventProperties;
declare const query$c_getEventStructures: typeof getEventStructures;
declare const query$c_getEventTimeItem: typeof getEventTimeItem;
declare const query$c_getEvents: typeof getEvents;
declare const query$c_getFlightProfile: typeof getFlightProfile;
declare const query$c_getScaledEntries: typeof getScaledEntries;
declare namespace query$c {
  export {
    query$c_categoryCanContain as categoryCanContain,
    query$c_getCategoryAgeDetails as getCategoryAgeDetails,
    query$c_getEvent as getEvent,
    query$c_getEventProperties as getEventProperties,
    query$c_getEventStructures as getEventStructures,
    query$c_getEventTimeItem as getEventTimeItem,
    query$c_getEvents as getEvents,
    query$c_getFlightProfile as getFlightProfile,
    query$c_getScaledEntries as getScaledEntries,
  };
}

declare const index$n_addDrawDefinition: typeof addDrawDefinition;
declare const index$n_addEvent: typeof addEvent;
declare const index$n_addFlight: typeof addFlight;
declare const index$n_assignSeedPositions: typeof assignSeedPositions;
declare const index$n_attachFlightProfile: typeof attachFlightProfile;
declare const index$n_categoryCanContain: typeof categoryCanContain;
declare const index$n_deleteDrawDefinitions: typeof deleteDrawDefinitions;
declare const index$n_deleteEvents: typeof deleteEvents;
declare const index$n_deleteFlightAndFlightDraw: typeof deleteFlightAndFlightDraw;
declare const index$n_deleteFlightProfileAndFlightDraws: typeof deleteFlightProfileAndFlightDraws;
declare const index$n_generateEventsFromTieFormat: typeof generateEventsFromTieFormat;
declare const index$n_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const index$n_getEvent: typeof getEvent;
declare const index$n_getEventProperties: typeof getEventProperties;
declare const index$n_getEventStructures: typeof getEventStructures;
declare const index$n_getEventTimeItem: typeof getEventTimeItem;
declare const index$n_getEvents: typeof getEvents;
declare const index$n_getFlightProfile: typeof getFlightProfile;
declare const index$n_getScaledEntries: typeof getScaledEntries;
declare const index$n_modifyEvent: typeof modifyEvent;
declare const index$n_modifyEventMatchUpFormatTiming: typeof modifyEventMatchUpFormatTiming;
declare const index$n_modifyPairAssignment: typeof modifyPairAssignment;
declare const index$n_refreshEventDrawOrder: typeof refreshEventDrawOrder;
declare const index$n_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const index$n_removeScaleValues: typeof removeScaleValues;
declare const index$n_removeSeeding: typeof removeSeeding;
declare const index$n_setEventDates: typeof setEventDates;
declare const index$n_setEventDisplay: typeof setEventDisplay;
declare const index$n_setEventEndDate: typeof setEventEndDate;
declare const index$n_setEventStartDate: typeof setEventStartDate;
declare const index$n_updateDrawIdsOrder: typeof updateDrawIdsOrder;
declare const index$n_validateCategory: typeof validateCategory;
declare namespace index$n {
  export {
    index$n_addDrawDefinition as addDrawDefinition,
    index$n_addEvent as addEvent,
    index$n_addFlight as addFlight,
    index$n_assignSeedPositions as assignSeedPositions,
    index$n_attachFlightProfile as attachFlightProfile,
    index$n_categoryCanContain as categoryCanContain,
    index$n_deleteDrawDefinitions as deleteDrawDefinitions,
    index$n_deleteEvents as deleteEvents,
    index$n_deleteFlightAndFlightDraw as deleteFlightAndFlightDraw,
    index$n_deleteFlightProfileAndFlightDraws as deleteFlightProfileAndFlightDraws,
    generate$4 as generate,
    index$n_generateEventsFromTieFormat as generateEventsFromTieFormat,
    index$n_getCategoryAgeDetails as getCategoryAgeDetails,
    index$n_getEvent as getEvent,
    index$n_getEventProperties as getEventProperties,
    index$n_getEventStructures as getEventStructures,
    index$n_getEventTimeItem as getEventTimeItem,
    index$n_getEvents as getEvents,
    index$n_getFlightProfile as getFlightProfile,
    index$n_getScaledEntries as getScaledEntries,
    index$n_modifyEvent as modifyEvent,
    index$n_modifyEventMatchUpFormatTiming as modifyEventMatchUpFormatTiming,
    index$n_modifyPairAssignment as modifyPairAssignment,
    mutate$d as mutate,
    query$c as query,
    index$n_refreshEventDrawOrder as refreshEventDrawOrder,
    index$n_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
    index$n_removeScaleValues as removeScaleValues,
    index$n_removeSeeding as removeSeeding,
    index$n_setEventDates as setEventDates,
    index$n_setEventDisplay as setEventDisplay,
    index$n_setEventEndDate as setEventEndDate,
    index$n_setEventStartDate as setEventStartDate,
    index$n_updateDrawIdsOrder as updateDrawIdsOrder,
    index$n_validateCategory as validateCategory,
  };
}

declare function getRoundRobinGroupMatchUps({ drawPositions }: {
    drawPositions: any;
}): {
    error: {
        message: string;
        code: string;
    };
    groupMatchUps?: undefined;
    uniqueMatchUpGroupings?: undefined;
} | {
    groupMatchUps: never[];
    uniqueMatchUpGroupings: any[];
    error?: undefined;
};
declare function drawPositionsHash(drawPositions?: never[]): string;
declare function groupRounds({ groupSize, drawPositionOffset }: {
    groupSize: any;
    drawPositionOffset: any;
}): any[];
declare function determineRoundNumber({ rounds, hash }: {
    rounds: any;
    hash: any;
}): any;
declare const roundRobinGroups: {
    getRoundRobinGroupMatchUps: typeof getRoundRobinGroupMatchUps;
    determineRoundNumber: typeof determineRoundNumber;
    drawPositionsHash: typeof drawPositionsHash;
    groupRounds: typeof groupRounds;
};

type GetCourtsAvailableAtPeriodStartArgs = {
    averageMatchUpMinutes: number;
    includeBookingTypes?: boolean;
    periodStart: string;
    courts: any[];
    date: string;
};
declare function getCourtsAvailableAtPeriodStart(params: GetCourtsAvailableAtPeriodStartArgs): ResultType & {
    availableToScheduleCount?: number;
};

declare function getScheduleTimes(params: any): ResultType & {
    scheduleTimes?: ScheduleTimesResult[];
    totalMatchUps?: number;
    timingProfile?: any;
};

type GenerateTimeSlotsArgs = {
    includeBookingTypes?: string[];
    courtDate: any;
};
declare function generateTimeSlots(params: GenerateTimeSlotsArgs): ResultType & {
    timeSlots?: any[];
};

type CourtGeneratorArgs = {
    startTime?: string;
    endTime?: string;
    count?: number;
    date?: string;
};
declare function courtGenerator(params?: CourtGeneratorArgs): {
    dateAvailability: {
        date: string | undefined;
        startTime: string;
        endTime: string;
    }[];
}[];

declare const garman: {
    getCourtsAvailableAtPeriodStart: typeof getCourtsAvailableAtPeriodStart;
    generateTimeSlots: typeof generateTimeSlots;
    getScheduleTimes: typeof getScheduleTimes;
    courtGenerator: typeof courtGenerator;
};

declare const garman$1_garman: typeof garman;
declare namespace garman$1 {
  export {
    garman as default,
    garman$1_garman as garman,
  };
}

declare const index$m_drawMatic: typeof drawMatic;
declare const index$m_generateAdHocMatchUps: typeof generateAdHocMatchUps;
declare const index$m_generateAdHocRounds: typeof generateAdHocRounds;
declare const index$m_generateAndPopulatePlayoffStructures: typeof generateAndPopulatePlayoffStructures;
declare const index$m_generateCourts: typeof generateCourts;
declare const index$m_generateDrawDefinition: typeof generateDrawDefinition;
declare const index$m_generateDrawMaticRound: typeof generateDrawMaticRound;
declare const index$m_generateDrawStructuresAndLinks: typeof generateDrawStructuresAndLinks;
declare const index$m_generateDrawTypeAndModifyDrawDefinition: typeof generateDrawTypeAndModifyDrawDefinition;
declare const index$m_generateFlightProfile: typeof generateFlightProfile;
declare const index$m_generateLineUps: typeof generateLineUps;
declare const index$m_generateQualifyingStructure: typeof generateQualifyingStructure;
declare const index$m_generateSeedingScaleItems: typeof generateSeedingScaleItems;
declare const index$m_generateStatCrew: typeof generateStatCrew;
declare const index$m_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
declare const index$m_roundRobinGroups: typeof roundRobinGroups;
declare namespace index$m {
  export {
    index$m_drawMatic as drawMatic,
    garman$1 as garman,
    index$m_generateAdHocMatchUps as generateAdHocMatchUps,
    index$m_generateAdHocRounds as generateAdHocRounds,
    index$m_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures,
    index$m_generateCourts as generateCourts,
    index$m_generateDrawDefinition as generateDrawDefinition,
    index$m_generateDrawMaticRound as generateDrawMaticRound,
    index$m_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks,
    index$m_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition,
    index$m_generateFlightProfile as generateFlightProfile,
    index$m_generateLineUps as generateLineUps,
    index$m_generateQualifyingStructure as generateQualifyingStructure,
    index$m_generateSeedingScaleItems as generateSeedingScaleItems,
    index$m_generateStatCrew as generateStatCrew,
    index$m_generateVoluntaryConsolation as generateVoluntaryConsolation,
    index$m_roundRobinGroups as roundRobinGroups,
  };
}

declare const index$l_isAggregateFormat: typeof isAggregateFormat;
declare const index$l_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$l_parse: typeof parse;
declare const index$l_stringify: typeof stringify;
declare namespace index$l {
  export {
    index$l_isAggregateFormat as isAggregateFormat,
    isValidMatchUpFormat as isValid,
    index$l_isValidMatchUpFormat as isValidMatchUpFormat,
    index$l_parse as parse,
    index$l_stringify as stringify,
  };
}

declare const mutate$c_applyLineUps: typeof applyLineUps;
declare const mutate$c_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant;
declare const mutate$c_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId;
declare const mutate$c_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate;
declare const mutate$c_checkInParticipant: typeof checkInParticipant;
declare const mutate$c_checkOutParticipant: typeof checkOutParticipant;
declare const mutate$c_disableTieAutoCalc: typeof disableTieAutoCalc;
declare const mutate$c_enableTieAutoCalc: typeof enableTieAutoCalc;
declare const mutate$c_removeDelegatedOutcome: typeof removeDelegatedOutcome;
declare const mutate$c_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant;
declare const mutate$c_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId;
declare const mutate$c_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId;
declare const mutate$c_resetAdHocMatchUps: typeof resetAdHocMatchUps;
declare const mutate$c_resetMatchUpLineUps: typeof resetMatchUpLineUps;
declare const mutate$c_resetScorecard: typeof resetScorecard;
declare const mutate$c_resetTieFormat: typeof resetTieFormat;
declare const mutate$c_setDelegatedOutcome: typeof setDelegatedOutcome;
declare const mutate$c_setMatchUpFormat: typeof setMatchUpFormat;
declare const mutate$c_setMatchUpState: typeof setMatchUpState;
declare const mutate$c_setMatchUpStatus: typeof setMatchUpStatus;
declare const mutate$c_setOrderOfFinish: typeof setOrderOfFinish;
declare const mutate$c_substituteParticipant: typeof substituteParticipant;
declare const mutate$c_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const mutate$c_updateTieMatchUpScore: typeof updateTieMatchUpScore;
declare namespace mutate$c {
  export {
    mutate$c_applyLineUps as applyLineUps,
    mutate$c_assignMatchUpSideParticipant as assignMatchUpSideParticipant,
    mutate$c_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId,
    mutate$c_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate,
    mutate$c_checkInParticipant as checkInParticipant,
    mutate$c_checkOutParticipant as checkOutParticipant,
    mutate$c_disableTieAutoCalc as disableTieAutoCalc,
    mutate$c_enableTieAutoCalc as enableTieAutoCalc,
    publicFindMatchUp as findMatchUp,
    mutate$c_removeDelegatedOutcome as removeDelegatedOutcome,
    mutate$c_removeMatchUpSideParticipant as removeMatchUpSideParticipant,
    mutate$c_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId,
    mutate$c_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId,
    mutate$c_resetAdHocMatchUps as resetAdHocMatchUps,
    mutate$c_resetMatchUpLineUps as resetMatchUpLineUps,
    mutate$c_resetScorecard as resetScorecard,
    mutate$c_resetTieFormat as resetTieFormat,
    mutate$c_setDelegatedOutcome as setDelegatedOutcome,
    mutate$c_setMatchUpFormat as setMatchUpFormat,
    mutate$c_setMatchUpState as setMatchUpState,
    mutate$c_setMatchUpStatus as setMatchUpStatus,
    mutate$c_setOrderOfFinish as setOrderOfFinish,
    mutate$c_substituteParticipant as substituteParticipant,
    mutate$c_toggleParticipantCheckInState as toggleParticipantCheckInState,
    mutate$c_updateTieMatchUpScore as updateTieMatchUpScore,
  };
}

declare const query$b_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const query$b_allDrawMatchUps: typeof allDrawMatchUps;
declare const query$b_allEventMatchUps: typeof allEventMatchUps;
declare const query$b_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const query$b_analyzeMatchUp: typeof analyzeMatchUp;
declare const query$b_calculateMatchUpMargin: typeof calculateMatchUpMargin;
declare const query$b_calculateWinCriteria: typeof calculateWinCriteria;
declare const query$b_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const query$b_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const query$b_drawMatchUps: typeof drawMatchUps;
declare const query$b_eventMatchUps: typeof eventMatchUps;
declare const query$b_filterMatchUps: typeof filterMatchUps;
declare const query$b_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const query$b_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const query$b_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const query$b_getCompetitionFormat: typeof getCompetitionFormat;
declare const query$b_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const query$b_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const query$b_getHomeParticipantId: typeof getHomeParticipantId;
declare const query$b_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const query$b_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const query$b_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const query$b_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const query$b_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const query$b_getMatchUpFormat: typeof getMatchUpFormat;
declare const query$b_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const query$b_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const query$b_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const query$b_getMatchUpType: typeof getMatchUpType;
declare const query$b_getMatchUpsStats: typeof getMatchUpsStats;
declare const query$b_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const query$b_getParticipantResults: typeof getParticipantResults;
declare const query$b_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const query$b_getRoundMatchUps: typeof getRoundMatchUps;
declare const query$b_getRounds: typeof getRounds;
declare const query$b_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const query$b_matchUpActions: typeof matchUpActions;
declare const query$b_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const query$b_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands;
declare const query$b_tallyParticipantResults: typeof tallyParticipantResults;
declare const query$b_tournamentMatchUps: typeof tournamentMatchUps;
declare const query$b_validMatchUp: typeof validMatchUp;
declare const query$b_validMatchUps: typeof validMatchUps;
declare namespace query$b {
  export {
    query$b_allCompetitionMatchUps as allCompetitionMatchUps,
    query$b_allDrawMatchUps as allDrawMatchUps,
    query$b_allEventMatchUps as allEventMatchUps,
    query$b_allTournamentMatchUps as allTournamentMatchUps,
    query$b_analyzeMatchUp as analyzeMatchUp,
    query$b_calculateMatchUpMargin as calculateMatchUpMargin,
    query$b_calculateWinCriteria as calculateWinCriteria,
    query$b_checkMatchUpIsComplete as checkMatchUpIsComplete,
    query$b_competitionScheduleMatchUps as competitionScheduleMatchUps,
    query$b_drawMatchUps as drawMatchUps,
    query$b_eventMatchUps as eventMatchUps,
    query$b_filterMatchUps as filterMatchUps,
    query$b_getAllDrawMatchUps as getAllDrawMatchUps,
    query$b_getAllStructureMatchUps as getAllStructureMatchUps,
    query$b_getCheckedInParticipantIds as getCheckedInParticipantIds,
    query$b_getCompetitionFormat as getCompetitionFormat,
    query$b_getCompetitionMatchUps as getCompetitionMatchUps,
    query$b_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
    query$b_getHomeParticipantId as getHomeParticipantId,
    query$b_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
    query$b_getMatchUpContextIds as getMatchUpContextIds,
    query$b_getMatchUpDailyLimits as getMatchUpDailyLimits,
    query$b_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
    query$b_getMatchUpDependencies as getMatchUpDependencies,
    query$b_getMatchUpFormat as getMatchUpFormat,
    query$b_getMatchUpFormatTiming as getMatchUpFormatTiming,
    query$b_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
    query$b_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
    query$b_getMatchUpType as getMatchUpType,
    query$b_getMatchUpsStats as getMatchUpsStats,
    query$b_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
    query$b_getParticipantResults as getParticipantResults,
    query$b_getPredictiveAccuracy as getPredictiveAccuracy,
    query$b_getRoundMatchUps as getRoundMatchUps,
    query$b_getRounds as getRounds,
    query$b_isValidMatchUpFormat as isValidMatchUpFormat,
    query$b_matchUpActions as matchUpActions,
    query$b_participantScheduledMatchUps as participantScheduledMatchUps,
    query$b_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands,
    query$b_tallyParticipantResults as tallyParticipantResults,
    query$b_tournamentMatchUps as tournamentMatchUps,
    query$b_validMatchUp as validMatchUp,
    query$b_validMatchUps as validMatchUps,
  };
}

declare const index$k_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const index$k_allDrawMatchUps: typeof allDrawMatchUps;
declare const index$k_allEventMatchUps: typeof allEventMatchUps;
declare const index$k_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const index$k_analyzeMatchUp: typeof analyzeMatchUp;
declare const index$k_applyLineUps: typeof applyLineUps;
declare const index$k_assignMatchUpSideParticipant: typeof assignMatchUpSideParticipant;
declare const index$k_assignTieMatchUpParticipantId: typeof assignTieMatchUpParticipantId;
declare const index$k_bulkMatchUpStatusUpdate: typeof bulkMatchUpStatusUpdate;
declare const index$k_calculateMatchUpMargin: typeof calculateMatchUpMargin;
declare const index$k_calculateWinCriteria: typeof calculateWinCriteria;
declare const index$k_checkInParticipant: typeof checkInParticipant;
declare const index$k_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const index$k_checkOutParticipant: typeof checkOutParticipant;
declare const index$k_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const index$k_disableTieAutoCalc: typeof disableTieAutoCalc;
declare const index$k_drawMatchUps: typeof drawMatchUps;
declare const index$k_enableTieAutoCalc: typeof enableTieAutoCalc;
declare const index$k_eventMatchUps: typeof eventMatchUps;
declare const index$k_filterMatchUps: typeof filterMatchUps;
declare const index$k_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const index$k_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const index$k_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const index$k_getCompetitionFormat: typeof getCompetitionFormat;
declare const index$k_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const index$k_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const index$k_getHomeParticipantId: typeof getHomeParticipantId;
declare const index$k_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const index$k_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const index$k_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const index$k_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const index$k_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const index$k_getMatchUpFormat: typeof getMatchUpFormat;
declare const index$k_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const index$k_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const index$k_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const index$k_getMatchUpType: typeof getMatchUpType;
declare const index$k_getMatchUpsStats: typeof getMatchUpsStats;
declare const index$k_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const index$k_getParticipantResults: typeof getParticipantResults;
declare const index$k_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const index$k_getRoundMatchUps: typeof getRoundMatchUps;
declare const index$k_getRounds: typeof getRounds;
declare const index$k_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$k_matchUpActions: typeof matchUpActions;
declare const index$k_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const index$k_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands;
declare const index$k_removeDelegatedOutcome: typeof removeDelegatedOutcome;
declare const index$k_removeMatchUpSideParticipant: typeof removeMatchUpSideParticipant;
declare const index$k_removeTieMatchUpParticipantId: typeof removeTieMatchUpParticipantId;
declare const index$k_replaceTieMatchUpParticipantId: typeof replaceTieMatchUpParticipantId;
declare const index$k_resetAdHocMatchUps: typeof resetAdHocMatchUps;
declare const index$k_resetMatchUpLineUps: typeof resetMatchUpLineUps;
declare const index$k_resetScorecard: typeof resetScorecard;
declare const index$k_resetTieFormat: typeof resetTieFormat;
declare const index$k_setDelegatedOutcome: typeof setDelegatedOutcome;
declare const index$k_setMatchUpFormat: typeof setMatchUpFormat;
declare const index$k_setMatchUpState: typeof setMatchUpState;
declare const index$k_setMatchUpStatus: typeof setMatchUpStatus;
declare const index$k_setOrderOfFinish: typeof setOrderOfFinish;
declare const index$k_substituteParticipant: typeof substituteParticipant;
declare const index$k_tallyParticipantResults: typeof tallyParticipantResults;
declare const index$k_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const index$k_tournamentMatchUps: typeof tournamentMatchUps;
declare const index$k_updateTieMatchUpScore: typeof updateTieMatchUpScore;
declare const index$k_validMatchUp: typeof validMatchUp;
declare const index$k_validMatchUps: typeof validMatchUps;
declare namespace index$k {
  export {
    index$k_allCompetitionMatchUps as allCompetitionMatchUps,
    index$k_allDrawMatchUps as allDrawMatchUps,
    index$k_allEventMatchUps as allEventMatchUps,
    index$k_allTournamentMatchUps as allTournamentMatchUps,
    index$k_analyzeMatchUp as analyzeMatchUp,
    index$k_applyLineUps as applyLineUps,
    index$k_assignMatchUpSideParticipant as assignMatchUpSideParticipant,
    index$k_assignTieMatchUpParticipantId as assignTieMatchUpParticipantId,
    index$k_bulkMatchUpStatusUpdate as bulkMatchUpStatusUpdate,
    index$k_calculateMatchUpMargin as calculateMatchUpMargin,
    index$k_calculateWinCriteria as calculateWinCriteria,
    index$k_checkInParticipant as checkInParticipant,
    index$k_checkMatchUpIsComplete as checkMatchUpIsComplete,
    index$k_checkOutParticipant as checkOutParticipant,
    index$k_competitionScheduleMatchUps as competitionScheduleMatchUps,
    index$k_disableTieAutoCalc as disableTieAutoCalc,
    index$k_drawMatchUps as drawMatchUps,
    index$k_enableTieAutoCalc as enableTieAutoCalc,
    index$k_eventMatchUps as eventMatchUps,
    index$k_filterMatchUps as filterMatchUps,
    publicFindMatchUp as findMatchUp,
    index$k_getAllDrawMatchUps as getAllDrawMatchUps,
    index$k_getAllStructureMatchUps as getAllStructureMatchUps,
    index$k_getCheckedInParticipantIds as getCheckedInParticipantIds,
    index$k_getCompetitionFormat as getCompetitionFormat,
    index$k_getCompetitionMatchUps as getCompetitionMatchUps,
    index$k_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
    index$k_getHomeParticipantId as getHomeParticipantId,
    index$k_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
    index$k_getMatchUpContextIds as getMatchUpContextIds,
    index$k_getMatchUpDailyLimits as getMatchUpDailyLimits,
    index$k_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
    index$k_getMatchUpDependencies as getMatchUpDependencies,
    index$k_getMatchUpFormat as getMatchUpFormat,
    index$k_getMatchUpFormatTiming as getMatchUpFormatTiming,
    index$k_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
    index$k_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
    index$k_getMatchUpType as getMatchUpType,
    index$k_getMatchUpsStats as getMatchUpsStats,
    index$k_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
    index$k_getParticipantResults as getParticipantResults,
    index$k_getPredictiveAccuracy as getPredictiveAccuracy,
    index$k_getRoundMatchUps as getRoundMatchUps,
    index$k_getRounds as getRounds,
    index$k_isValidMatchUpFormat as isValidMatchUpFormat,
    index$k_matchUpActions as matchUpActions,
    mutate$c as mutate,
    index$k_participantScheduledMatchUps as participantScheduledMatchUps,
    index$k_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands,
    query$b as query,
    index$k_removeDelegatedOutcome as removeDelegatedOutcome,
    index$k_removeMatchUpSideParticipant as removeMatchUpSideParticipant,
    index$k_removeTieMatchUpParticipantId as removeTieMatchUpParticipantId,
    index$k_replaceTieMatchUpParticipantId as replaceTieMatchUpParticipantId,
    index$k_resetAdHocMatchUps as resetAdHocMatchUps,
    index$k_resetMatchUpLineUps as resetMatchUpLineUps,
    index$k_resetScorecard as resetScorecard,
    index$k_resetTieFormat as resetTieFormat,
    index$k_setDelegatedOutcome as setDelegatedOutcome,
    index$k_setMatchUpFormat as setMatchUpFormat,
    index$k_setMatchUpState as setMatchUpState,
    index$k_setMatchUpStatus as setMatchUpStatus,
    index$k_setOrderOfFinish as setOrderOfFinish,
    index$k_substituteParticipant as substituteParticipant,
    index$k_tallyParticipantResults as tallyParticipantResults,
    index$k_toggleParticipantCheckInState as toggleParticipantCheckInState,
    index$k_tournamentMatchUps as tournamentMatchUps,
    index$k_updateTieMatchUpScore as updateTieMatchUpScore,
    index$k_validMatchUp as validMatchUp,
    index$k_validMatchUps as validMatchUps,
  };
}

declare const generate$3_generateEventWithDraw: typeof generateEventWithDraw;
declare const generate$3_generateOutcome: typeof generateOutcome;
declare const generate$3_generateOutcomeFromScoreString: typeof generateOutcomeFromScoreString;
declare const generate$3_generateParticipants: typeof generateParticipants;
declare const generate$3_generateTournamentRecord: typeof generateTournamentRecord;
declare namespace generate$3 {
  export {
    generate$3_generateEventWithDraw as generateEventWithDraw,
    generate$3_generateOutcome as generateOutcome,
    generate$3_generateOutcomeFromScoreString as generateOutcomeFromScoreString,
    generate$3_generateParticipants as generateParticipants,
    generate$3_generateTournamentRecord as generateTournamentRecord,
  };
}

declare const mutate$b_anonymizeTournamentRecord: typeof anonymizeTournamentRecord;
declare const mutate$b_completeDrawMatchUps: typeof completeDrawMatchUps;
declare const mutate$b_modifyTournamentRecord: typeof modifyTournamentRecord;
declare const mutate$b_removeMatchUpOutcome: typeof removeMatchUpOutcome;
declare namespace mutate$b {
  export {
    mutate$b_anonymizeTournamentRecord as anonymizeTournamentRecord,
    mutate$b_completeDrawMatchUps as completeDrawMatchUps,
    mutate$b_modifyTournamentRecord as modifyTournamentRecord,
    mutate$b_removeMatchUpOutcome as removeMatchUpOutcome,
  };
}

declare const index$j_anonymizeTournamentRecord: typeof anonymizeTournamentRecord;
declare const index$j_completeDrawMatchUps: typeof completeDrawMatchUps;
declare const index$j_generateEventWithDraw: typeof generateEventWithDraw;
declare const index$j_generateOutcome: typeof generateOutcome;
declare const index$j_generateOutcomeFromScoreString: typeof generateOutcomeFromScoreString;
declare const index$j_generateParticipants: typeof generateParticipants;
declare const index$j_generateTournamentRecord: typeof generateTournamentRecord;
declare const index$j_modifyTournamentRecord: typeof modifyTournamentRecord;
declare const index$j_removeMatchUpOutcome: typeof removeMatchUpOutcome;
declare namespace index$j {
  export {
    index$j_anonymizeTournamentRecord as anonymizeTournamentRecord,
    index$j_completeDrawMatchUps as completeDrawMatchUps,
    generate$3 as generate,
    index$j_generateEventWithDraw as generateEventWithDraw,
    index$j_generateOutcome as generateOutcome,
    index$j_generateOutcomeFromScoreString as generateOutcomeFromScoreString,
    index$j_generateParticipants as generateParticipants,
    index$j_generateTournamentRecord as generateTournamentRecord,
    index$j_modifyTournamentRecord as modifyTournamentRecord,
    mutate$b as mutate,
    index$j_removeMatchUpOutcome as removeMatchUpOutcome,
  };
}

declare const mutate$a_addDynamicRatings: typeof addDynamicRatings;
declare const mutate$a_addIndividualParticipantIds: typeof addIndividualParticipantIds;
declare const mutate$a_addParticipant: typeof addParticipant;
declare const mutate$a_addParticipants: typeof addParticipants;
declare const mutate$a_addPenalty: typeof addPenalty;
declare const mutate$a_addPersonOtherId: typeof addPersonOtherId;
declare const mutate$a_addPersonRequests: typeof addPersonRequests;
declare const mutate$a_addPersons: typeof addPersons;
declare const mutate$a_createGroupParticipant: typeof createGroupParticipant;
declare const mutate$a_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes;
declare const mutate$a_deleteParticipants: typeof deleteParticipants;
declare const mutate$a_mergeParticipants: typeof mergeParticipants;
declare const mutate$a_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds;
declare const mutate$a_modifyParticipant: typeof modifyParticipant;
declare const mutate$a_modifyParticipantName: typeof modifyParticipantName;
declare const mutate$a_modifyParticipantOtherName: typeof modifyParticipantOtherName;
declare const mutate$a_modifyParticipantsPaymentStatus: typeof modifyParticipantsPaymentStatus;
declare const mutate$a_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus;
declare const mutate$a_modifyPenalty: typeof modifyPenalty;
declare const mutate$a_modifyPersonRequests: typeof modifyPersonRequests;
declare const mutate$a_regenerateParticipantNames: typeof regenerateParticipantNames;
declare const mutate$a_removeIndividualParticipantIds: typeof removeIndividualParticipantIds;
declare const mutate$a_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams;
declare const mutate$a_removePenalty: typeof removePenalty;
declare const mutate$a_removePersonRequests: typeof removePersonRequests;
declare const mutate$a_removeRatings: typeof removeRatings;
declare const mutate$a_scaledTeamAssignment: typeof scaledTeamAssignment;
declare const mutate$a_setParticipantScaleItem: typeof setParticipantScaleItem;
declare const mutate$a_setParticipantScaleItems: typeof setParticipantScaleItems;
declare namespace mutate$a {
  export {
    mutate$a_addDynamicRatings as addDynamicRatings,
    mutate$a_addIndividualParticipantIds as addIndividualParticipantIds,
    mutate$a_addParticipant as addParticipant,
    mutate$a_addParticipants as addParticipants,
    mutate$a_addPenalty as addPenalty,
    mutate$a_addPersonOtherId as addPersonOtherId,
    mutate$a_addPersonRequests as addPersonRequests,
    mutate$a_addPersons as addPersons,
    mutate$a_createGroupParticipant as createGroupParticipant,
    mutate$a_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes,
    mutate$a_deleteParticipants as deleteParticipants,
    publicFindParticipant as findParticipant,
    mutate$a_mergeParticipants as mergeParticipants,
    mutate$a_modifyIndividualParticipantIds as modifyIndividualParticipantIds,
    mutate$a_modifyParticipant as modifyParticipant,
    mutate$a_modifyParticipantName as modifyParticipantName,
    mutate$a_modifyParticipantOtherName as modifyParticipantOtherName,
    mutate$a_modifyParticipantsPaymentStatus as modifyParticipantsPaymentStatus,
    mutate$a_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus,
    mutate$a_modifyPenalty as modifyPenalty,
    mutate$a_modifyPersonRequests as modifyPersonRequests,
    mutate$a_regenerateParticipantNames as regenerateParticipantNames,
    mutate$a_removeIndividualParticipantIds as removeIndividualParticipantIds,
    mutate$a_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams,
    mutate$a_removePenalty as removePenalty,
    mutate$a_removePersonRequests as removePersonRequests,
    mutate$a_removeRatings as removeRatings,
    mutate$a_scaledTeamAssignment as scaledTeamAssignment,
    mutate$a_setParticipantScaleItem as setParticipantScaleItem,
    mutate$a_setParticipantScaleItems as setParticipantScaleItems,
  };
}

declare const query$a_filterParticipants: typeof filterParticipants;
declare const query$a_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const query$a_getPairedParticipant: typeof getPairedParticipant;
declare const query$a_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const query$a_getParticipantMembership: typeof getParticipantMembership;
declare const query$a_getParticipantPaymentStatus: typeof getParticipantPaymentStatus;
declare const query$a_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const query$a_getParticipantSchedules: typeof getParticipantSchedules;
declare const query$a_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const query$a_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const query$a_getParticipants: typeof getParticipants;
declare const query$a_getScaleValues: typeof getScaleValues;
declare const query$a_participantScaleItem: typeof participantScaleItem;
declare const query$a_validateLineUp: typeof validateLineUp;
declare namespace query$a {
  export {
    query$a_filterParticipants as filterParticipants,
    query$a_getCompetitionParticipants as getCompetitionParticipants,
    query$a_getPairedParticipant as getPairedParticipant,
    query$a_getParticipantEventDetails as getParticipantEventDetails,
    query$a_getParticipantMembership as getParticipantMembership,
    query$a_getParticipantPaymentStatus as getParticipantPaymentStatus,
    query$a_getParticipantScaleItem as getParticipantScaleItem,
    query$a_getParticipantSchedules as getParticipantSchedules,
    query$a_getParticipantSignInStatus as getParticipantSignInStatus,
    query$a_getParticipantTimeItem as getParticipantTimeItem,
    query$a_getParticipants as getParticipants,
    query$a_getScaleValues as getScaleValues,
    query$a_participantScaleItem as participantScaleItem,
    query$a_validateLineUp as validateLineUp,
  };
}

declare const index$i_addDynamicRatings: typeof addDynamicRatings;
declare const index$i_addIndividualParticipantIds: typeof addIndividualParticipantIds;
declare const index$i_addParticipant: typeof addParticipant;
declare const index$i_addParticipants: typeof addParticipants;
declare const index$i_addPenalty: typeof addPenalty;
declare const index$i_addPersonOtherId: typeof addPersonOtherId;
declare const index$i_addPersonRequests: typeof addPersonRequests;
declare const index$i_addPersons: typeof addPersons;
declare const index$i_createGroupParticipant: typeof createGroupParticipant;
declare const index$i_createTeamsFromParticipantAttributes: typeof createTeamsFromParticipantAttributes;
declare const index$i_deleteParticipants: typeof deleteParticipants;
declare const index$i_filterParticipants: typeof filterParticipants;
declare const index$i_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const index$i_getPairedParticipant: typeof getPairedParticipant;
declare const index$i_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const index$i_getParticipantMembership: typeof getParticipantMembership;
declare const index$i_getParticipantPaymentStatus: typeof getParticipantPaymentStatus;
declare const index$i_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const index$i_getParticipantSchedules: typeof getParticipantSchedules;
declare const index$i_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const index$i_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const index$i_getParticipants: typeof getParticipants;
declare const index$i_getScaleValues: typeof getScaleValues;
declare const index$i_mergeParticipants: typeof mergeParticipants;
declare const index$i_modifyIndividualParticipantIds: typeof modifyIndividualParticipantIds;
declare const index$i_modifyParticipant: typeof modifyParticipant;
declare const index$i_modifyParticipantName: typeof modifyParticipantName;
declare const index$i_modifyParticipantOtherName: typeof modifyParticipantOtherName;
declare const index$i_modifyParticipantsPaymentStatus: typeof modifyParticipantsPaymentStatus;
declare const index$i_modifyParticipantsSignInStatus: typeof modifyParticipantsSignInStatus;
declare const index$i_modifyPenalty: typeof modifyPenalty;
declare const index$i_modifyPersonRequests: typeof modifyPersonRequests;
declare const index$i_participantScaleItem: typeof participantScaleItem;
declare const index$i_regenerateParticipantNames: typeof regenerateParticipantNames;
declare const index$i_removeIndividualParticipantIds: typeof removeIndividualParticipantIds;
declare const index$i_removeParticipantIdsFromAllTeams: typeof removeParticipantIdsFromAllTeams;
declare const index$i_removePenalty: typeof removePenalty;
declare const index$i_removePersonRequests: typeof removePersonRequests;
declare const index$i_removeRatings: typeof removeRatings;
declare const index$i_scaledTeamAssignment: typeof scaledTeamAssignment;
declare const index$i_setParticipantScaleItem: typeof setParticipantScaleItem;
declare const index$i_setParticipantScaleItems: typeof setParticipantScaleItems;
declare const index$i_validateLineUp: typeof validateLineUp;
declare namespace index$i {
  export {
    index$i_addDynamicRatings as addDynamicRatings,
    index$i_addIndividualParticipantIds as addIndividualParticipantIds,
    index$i_addParticipant as addParticipant,
    index$i_addParticipants as addParticipants,
    index$i_addPenalty as addPenalty,
    index$i_addPersonOtherId as addPersonOtherId,
    index$i_addPersonRequests as addPersonRequests,
    index$i_addPersons as addPersons,
    index$i_createGroupParticipant as createGroupParticipant,
    index$i_createTeamsFromParticipantAttributes as createTeamsFromParticipantAttributes,
    index$i_deleteParticipants as deleteParticipants,
    index$i_filterParticipants as filterParticipants,
    publicFindParticipant as findParticipant,
    index$i_getCompetitionParticipants as getCompetitionParticipants,
    index$i_getPairedParticipant as getPairedParticipant,
    index$i_getParticipantEventDetails as getParticipantEventDetails,
    index$i_getParticipantMembership as getParticipantMembership,
    index$i_getParticipantPaymentStatus as getParticipantPaymentStatus,
    index$i_getParticipantScaleItem as getParticipantScaleItem,
    index$i_getParticipantSchedules as getParticipantSchedules,
    index$i_getParticipantSignInStatus as getParticipantSignInStatus,
    index$i_getParticipantTimeItem as getParticipantTimeItem,
    index$i_getParticipants as getParticipants,
    index$i_getScaleValues as getScaleValues,
    index$i_mergeParticipants as mergeParticipants,
    index$i_modifyIndividualParticipantIds as modifyIndividualParticipantIds,
    index$i_modifyParticipant as modifyParticipant,
    index$i_modifyParticipantName as modifyParticipantName,
    index$i_modifyParticipantOtherName as modifyParticipantOtherName,
    index$i_modifyParticipantsPaymentStatus as modifyParticipantsPaymentStatus,
    index$i_modifyParticipantsSignInStatus as modifyParticipantsSignInStatus,
    index$i_modifyPenalty as modifyPenalty,
    index$i_modifyPersonRequests as modifyPersonRequests,
    mutate$a as mutate,
    index$i_participantScaleItem as participantScaleItem,
    query$a as query,
    index$i_regenerateParticipantNames as regenerateParticipantNames,
    index$i_removeIndividualParticipantIds as removeIndividualParticipantIds,
    index$i_removeParticipantIdsFromAllTeams as removeParticipantIdsFromAllTeams,
    index$i_removePenalty as removePenalty,
    index$i_removePersonRequests as removePersonRequests,
    index$i_removeRatings as removeRatings,
    index$i_scaledTeamAssignment as scaledTeamAssignment,
    index$i_setParticipantScaleItem as setParticipantScaleItem,
    index$i_setParticipantScaleItems as setParticipantScaleItems,
    index$i_validateLineUp as validateLineUp,
  };
}

declare const mutate$9_attachPolicies: typeof attachPolicies;
declare const mutate$9_removePolicy: typeof removePolicy;
declare namespace mutate$9 {
  export {
    mutate$9_attachPolicies as attachPolicies,
    mutate$9_removePolicy as removePolicy,
  };
}

declare const query$9_findPolicy: typeof findPolicy;
declare const query$9_getAppliedPolicies: typeof getAppliedPolicies;
declare const query$9_getPolicyDefinitions: typeof getPolicyDefinitions;
declare namespace query$9 {
  export {
    query$9_findPolicy as findPolicy,
    query$9_getAppliedPolicies as getAppliedPolicies,
    query$9_getPolicyDefinitions as getPolicyDefinitions,
  };
}

declare const index$h_attachPolicies: typeof attachPolicies;
declare const index$h_findPolicy: typeof findPolicy;
declare const index$h_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$h_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$h_removePolicy: typeof removePolicy;
declare namespace index$h {
  export {
    index$h_attachPolicies as attachPolicies,
    index$h_findPolicy as findPolicy,
    index$h_getAppliedPolicies as getAppliedPolicies,
    index$h_getPolicyDefinitions as getPolicyDefinitions,
    mutate$9 as mutate,
    query$9 as query,
    index$h_removePolicy as removePolicy,
  };
}

declare const mutate$8_publishEvent: typeof publishEvent;
declare const mutate$8_publishEventSeeding: typeof publishEventSeeding;
declare const mutate$8_publishOrderOfPlay: typeof publishOrderOfPlay;
declare const mutate$8_publishParticipants: typeof publishParticipants;
declare const mutate$8_setEventDisplay: typeof setEventDisplay;
declare const mutate$8_unPublishEvent: typeof unPublishEvent;
declare const mutate$8_unPublishEventSeeding: typeof unPublishEventSeeding;
declare const mutate$8_unPublishOrderOfPlay: typeof unPublishOrderOfPlay;
declare const mutate$8_unPublishParticipants: typeof unPublishParticipants;
declare namespace mutate$8 {
  export {
    mutate$8_publishEvent as publishEvent,
    mutate$8_publishEventSeeding as publishEventSeeding,
    mutate$8_publishOrderOfPlay as publishOrderOfPlay,
    mutate$8_publishParticipants as publishParticipants,
    mutate$8_setEventDisplay as setEventDisplay,
    mutate$8_unPublishEvent as unPublishEvent,
    mutate$8_unPublishEventSeeding as unPublishEventSeeding,
    mutate$8_unPublishOrderOfPlay as unPublishOrderOfPlay,
    mutate$8_unPublishParticipants as unPublishParticipants,
  };
}

declare const query$8_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const query$8_getAllEventData: typeof getAllEventData;
declare const query$8_getCourtInfo: typeof getCourtInfo;
declare const query$8_getDrawData: typeof getDrawData;
declare const query$8_getEventData: typeof getEventData;
declare const query$8_getEventPublishStatus: typeof getEventPublishStatus;
declare const query$8_getPublishState: typeof getPublishState;
declare const query$8_getRoundVisibilityState: typeof getRoundVisibilityState;
declare const query$8_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const query$8_getVenueData: typeof getVenueData;
declare const query$8_isEmbargoed: typeof isEmbargoed;
declare const query$8_isVisiblyPublished: typeof isVisiblyPublished;
declare namespace query$8 {
  export {
    query$8_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
    query$8_getAllEventData as getAllEventData,
    query$8_getCourtInfo as getCourtInfo,
    query$8_getDrawData as getDrawData,
    query$8_getEventData as getEventData,
    query$8_getEventPublishStatus as getEventPublishStatus,
    query$8_getPublishState as getPublishState,
    query$8_getRoundVisibilityState as getRoundVisibilityState,
    query$8_getTournamentPublishStatus as getTournamentPublishStatus,
    query$8_getVenueData as getVenueData,
    query$8_isEmbargoed as isEmbargoed,
    query$8_isVisiblyPublished as isVisiblyPublished,
  };
}

declare const index$g_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const index$g_getAllEventData: typeof getAllEventData;
declare const index$g_getCourtInfo: typeof getCourtInfo;
declare const index$g_getDrawData: typeof getDrawData;
declare const index$g_getEventData: typeof getEventData;
declare const index$g_getEventPublishStatus: typeof getEventPublishStatus;
declare const index$g_getPublishState: typeof getPublishState;
declare const index$g_getRoundVisibilityState: typeof getRoundVisibilityState;
declare const index$g_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const index$g_getVenueData: typeof getVenueData;
declare const index$g_isEmbargoed: typeof isEmbargoed;
declare const index$g_isVisiblyPublished: typeof isVisiblyPublished;
declare const index$g_publishEvent: typeof publishEvent;
declare const index$g_publishEventSeeding: typeof publishEventSeeding;
declare const index$g_publishOrderOfPlay: typeof publishOrderOfPlay;
declare const index$g_publishParticipants: typeof publishParticipants;
declare const index$g_setEventDisplay: typeof setEventDisplay;
declare const index$g_unPublishEvent: typeof unPublishEvent;
declare const index$g_unPublishEventSeeding: typeof unPublishEventSeeding;
declare const index$g_unPublishOrderOfPlay: typeof unPublishOrderOfPlay;
declare const index$g_unPublishParticipants: typeof unPublishParticipants;
declare namespace index$g {
  export {
    index$g_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
    index$g_getAllEventData as getAllEventData,
    index$g_getCourtInfo as getCourtInfo,
    index$g_getDrawData as getDrawData,
    index$g_getEventData as getEventData,
    index$g_getEventPublishStatus as getEventPublishStatus,
    index$g_getPublishState as getPublishState,
    index$g_getRoundVisibilityState as getRoundVisibilityState,
    index$g_getTournamentPublishStatus as getTournamentPublishStatus,
    index$g_getVenueData as getVenueData,
    index$g_isEmbargoed as isEmbargoed,
    index$g_isVisiblyPublished as isVisiblyPublished,
    mutate$8 as mutate,
    index$g_publishEvent as publishEvent,
    index$g_publishEventSeeding as publishEventSeeding,
    index$g_publishOrderOfPlay as publishOrderOfPlay,
    index$g_publishParticipants as publishParticipants,
    query$8 as query,
    index$g_setEventDisplay as setEventDisplay,
    index$g_unPublishEvent as unPublishEvent,
    index$g_unPublishEventSeeding as unPublishEventSeeding,
    index$g_unPublishOrderOfPlay as unPublishOrderOfPlay,
    index$g_unPublishParticipants as unPublishParticipants,
  };
}

declare const query$7_analyzeDraws: typeof analyzeDraws;
declare const query$7_analyzeTournament: typeof analyzeTournament;
declare const query$7_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks;
declare const query$7_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const query$7_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const query$7_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const query$7_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels;
declare const query$7_getAppliedPolicies: typeof getAppliedPolicies;
declare const query$7_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const query$7_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const query$7_getEventRankingPoints: typeof getEventRankingPoints;
declare const query$7_getMutationLocks: typeof getMutationLocks;
declare const query$7_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const query$7_getRegistrationProfile: typeof getRegistrationProfile;
declare const query$7_getTournamentInfo: typeof getTournamentInfo;
declare const query$7_getTournamentPenalties: typeof getTournamentPenalties;
declare const query$7_getTournamentPersons: typeof getTournamentPersons;
declare const query$7_getTournamentPoints: typeof getTournamentPoints;
declare const query$7_getTournamentStructures: typeof getTournamentStructures;
declare const query$7_getTournamentTimeItem: typeof getTournamentTimeItem;
declare const query$7_suggestFormatPlans: typeof suggestFormatPlans;
declare namespace query$7 {
  export {
    query$7_analyzeDraws as analyzeDraws,
    query$7_analyzeTournament as analyzeTournament,
    query$7_cleanExpiredMutationLocks as cleanExpiredMutationLocks,
    query$7_getAggregateTeamResults as getAggregateTeamResults,
    query$7_getAllowedDrawTypes as getAllowedDrawTypes,
    query$7_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
    query$7_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels,
    query$7_getAppliedPolicies as getAppliedPolicies,
    query$7_getCompetitionDateRange as getCompetitionDateRange,
    query$7_getCompetitionPenalties as getCompetitionPenalties,
    query$7_getEventRankingPoints as getEventRankingPoints,
    query$7_getMutationLocks as getMutationLocks,
    query$7_getPolicyDefinitions as getPolicyDefinitions,
    query$7_getRegistrationProfile as getRegistrationProfile,
    query$7_getTournamentInfo as getTournamentInfo,
    query$7_getTournamentPenalties as getTournamentPenalties,
    query$7_getTournamentPersons as getTournamentPersons,
    query$7_getTournamentPoints as getTournamentPoints,
    query$7_getTournamentStructures as getTournamentStructures,
    query$7_getTournamentTimeItem as getTournamentTimeItem,
    query$7_suggestFormatPlans as suggestFormatPlans,
  };
}

declare const query$6_compareTieFormats: typeof compareTieFormats;
declare const query$6_getTieFormat: typeof getTieFormat;
declare const query$6_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const query$6_validateCollectionDefinition: typeof validateCollectionDefinition;
declare namespace query$6 {
  export {
    query$6_compareTieFormats as compareTieFormats,
    query$6_getTieFormat as getTieFormat,
    query$6_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
    query$6_validateCollectionDefinition as validateCollectionDefinition,
  };
}

declare const query$5_courtGridRows: typeof courtGridRows;
declare const query$5_findVenue: typeof findVenue;
declare const query$5_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const query$5_getPersonRequests: typeof getPersonRequests;
declare const query$5_getProfileRounds: typeof getProfileRounds;
declare const query$5_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const query$5_getSchedulingProfile: typeof getSchedulingProfile;
declare const query$5_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const query$5_publicFindCourt: typeof publicFindCourt;
declare namespace query$5 {
  export {
    query$5_courtGridRows as courtGridRows,
    query$5_findVenue as findVenue,
    query$5_getMatchUpsToSchedule as getMatchUpsToSchedule,
    query$5_getPersonRequests as getPersonRequests,
    query$5_getProfileRounds as getProfileRounds,
    query$5_getScheduledRoundsDetails as getScheduledRoundsDetails,
    query$5_getSchedulingProfile as getSchedulingProfile,
    query$5_getSchedulingProfileIssues as getSchedulingProfileIssues,
    query$5_publicFindCourt as publicFindCourt,
  };
}

declare const query$4_getCompetitionVenues: typeof getCompetitionVenues;
declare const query$4_getCourts: typeof getCourts;
declare const query$4_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const query$4_publicFindVenue: typeof publicFindVenue;
declare namespace query$4 {
  export {
    query$4_getCompetitionVenues as getCompetitionVenues,
    query$4_getCourts as getCourts,
    query$4_getVenuesAndCourts as getVenuesAndCourts,
    query$4_publicFindVenue as publicFindVenue,
  };
}

declare const index$f_addGoesTo: typeof addGoesTo;
declare const index$f_allCompetitionMatchUps: typeof allCompetitionMatchUps;
declare const index$f_allDrawMatchUps: typeof allDrawMatchUps;
declare const index$f_allEventMatchUps: typeof allEventMatchUps;
declare const index$f_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
declare const index$f_allTournamentMatchUps: typeof allTournamentMatchUps;
declare const index$f_analyzeDraws: typeof analyzeDraws;
declare const index$f_analyzeMatchUp: typeof analyzeMatchUp;
declare const index$f_analyzeTournament: typeof analyzeTournament;
declare const index$f_bulkUpdatePublishedEventIds: typeof bulkUpdatePublishedEventIds;
declare const index$f_calculateMatchUpMargin: typeof calculateMatchUpMargin;
declare const index$f_calculateWinCriteria: typeof calculateWinCriteria;
declare const index$f_categoryCanContain: typeof categoryCanContain;
declare const index$f_checkMatchUpIsComplete: typeof checkMatchUpIsComplete;
declare const index$f_checkValidEntries: typeof checkValidEntries;
declare const index$f_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks;
declare const index$f_compareTieFormats: typeof compareTieFormats;
declare const index$f_competitionScheduleMatchUps: typeof competitionScheduleMatchUps;
declare const index$f_courtGridRows: typeof courtGridRows;
declare const index$f_credits: typeof credits;
declare const index$f_drawMatchUps: typeof drawMatchUps;
declare const index$f_eventMatchUps: typeof eventMatchUps;
declare const index$f_filterMatchUps: typeof filterMatchUps;
declare const index$f_filterParticipants: typeof filterParticipants;
declare const index$f_findExtension: typeof findExtension;
declare const index$f_findVenue: typeof findVenue;
declare const index$f_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const index$f_getAllDrawMatchUps: typeof getAllDrawMatchUps;
declare const index$f_getAllEventData: typeof getAllEventData;
declare const index$f_getAllStructureMatchUps: typeof getAllStructureMatchUps;
declare const index$f_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const index$f_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const index$f_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels;
declare const index$f_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$f_getAssignedParticipantIds: typeof getAssignedParticipantIds;
declare const index$f_getAvailableMatchUpsCount: typeof getAvailableMatchUpsCount;
declare const index$f_getAvailablePlayoffProfiles: typeof getAvailablePlayoffProfiles;
declare const index$f_getCategoryAgeDetails: typeof getCategoryAgeDetails;
declare const index$f_getCheckedInParticipantIds: typeof getCheckedInParticipantIds;
declare const index$f_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const index$f_getCompetitionFormat: typeof getCompetitionFormat;
declare const index$f_getCompetitionLeaderboard: typeof getCompetitionLeaderboard;
declare const index$f_getCompetitionMatchUps: typeof getCompetitionMatchUps;
declare const index$f_getCompetitionParticipantState: typeof getCompetitionParticipantState;
declare const index$f_getCompetitionParticipants: typeof getCompetitionParticipants;
declare const index$f_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const index$f_getCompetitionPolicy: typeof getCompetitionPolicy;
declare const index$f_getCompetitionState: typeof getCompetitionState;
declare const index$f_getCompetitionVenues: typeof getCompetitionVenues;
declare const index$f_getCourtInfo: typeof getCourtInfo;
declare const index$f_getCourts: typeof getCourts;
declare const index$f_getDraftState: typeof getDraftState;
declare const index$f_getDrawData: typeof getDrawData;
declare const index$f_getDrawDefinitionTimeItem: typeof getDrawDefinitionTimeItem;
declare const index$f_getDrawParticipantRepresentativeIds: typeof getDrawParticipantRepresentativeIds;
declare const index$f_getDrawStructures: typeof getDrawStructures;
declare const index$f_getDrawTypeCoercion: typeof getDrawTypeCoercion;
declare const index$f_getEligibleVoluntaryConsolationParticipants: typeof getEligibleVoluntaryConsolationParticipants;
declare const index$f_getEntriesAndSeedsCount: typeof getEntriesAndSeedsCount;
declare const index$f_getEvent: typeof getEvent;
declare const index$f_getEventData: typeof getEventData;
declare const index$f_getEventMatchUpFormatTiming: typeof getEventMatchUpFormatTiming;
declare const index$f_getEventProperties: typeof getEventProperties;
declare const index$f_getEventPublishStatus: typeof getEventPublishStatus;
declare const index$f_getEventRankingPoints: typeof getEventRankingPoints;
declare const index$f_getEventStructures: typeof getEventStructures;
declare const index$f_getEventTimeItem: typeof getEventTimeItem;
declare const index$f_getEvents: typeof getEvents;
declare const index$f_getFlightProfile: typeof getFlightProfile;
declare const index$f_getHomeParticipantId: typeof getHomeParticipantId;
declare const index$f_getLinkedTournamentIds: typeof getLinkedTournamentIds;
declare const index$f_getLuckyDrawRoundStatus: typeof getLuckyDrawRoundStatus;
declare const index$f_getMatchUpCompetitiveProfile: typeof getMatchUpCompetitiveProfile;
declare const index$f_getMatchUpContextIds: typeof getMatchUpContextIds;
declare const index$f_getMatchUpDailyLimits: typeof getMatchUpDailyLimits;
declare const index$f_getMatchUpDailyLimitsUpdate: typeof getMatchUpDailyLimitsUpdate;
declare const index$f_getMatchUpDependencies: typeof getMatchUpDependencies;
declare const index$f_getMatchUpFormat: typeof getMatchUpFormat;
declare const index$f_getMatchUpFormatTiming: typeof getMatchUpFormatTiming;
declare const index$f_getMatchUpFormatTimingUpdate: typeof getMatchUpFormatTimingUpdate;
declare const index$f_getMatchUpScheduleDetails: typeof getMatchUpScheduleDetails;
declare const index$f_getMatchUpType: typeof getMatchUpType;
declare const index$f_getMatchUpsMap: typeof getMatchUpsMap;
declare const index$f_getMatchUpsStats: typeof getMatchUpsStats;
declare const index$f_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const index$f_getMaxEntryPosition: typeof getMaxEntryPosition;
declare const index$f_getModifiedMatchUpFormatTiming: typeof getModifiedMatchUpFormatTiming;
declare const index$f_getMutationLocks: typeof getMutationLocks;
declare const index$f_getPairedParticipant: typeof getPairedParticipant;
declare const index$f_getParticipantEventDetails: typeof getParticipantEventDetails;
declare const index$f_getParticipantIdFinishingPositions: typeof getParticipantIdFinishingPositions;
declare const index$f_getParticipantMembership: typeof getParticipantMembership;
declare const index$f_getParticipantPaymentStatus: typeof getParticipantPaymentStatus;
declare const index$f_getParticipantResults: typeof getParticipantResults;
declare const index$f_getParticipantScaleItem: typeof getParticipantScaleItem;
declare const index$f_getParticipantSchedules: typeof getParticipantSchedules;
declare const index$f_getParticipantSignInStatus: typeof getParticipantSignInStatus;
declare const index$f_getParticipantTimeItem: typeof getParticipantTimeItem;
declare const index$f_getParticipants: typeof getParticipants;
declare const index$f_getPersonRequests: typeof getPersonRequests;
declare const index$f_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$f_getPositionAssignments: typeof getPositionAssignments;
declare const index$f_getPositionsPlayedOff: typeof getPositionsPlayedOff;
declare const index$f_getPredictiveAccuracy: typeof getPredictiveAccuracy;
declare const index$f_getProfileRounds: typeof getProfileRounds;
declare const index$f_getPublishState: typeof getPublishState;
declare const index$f_getRandomQualifierList: typeof getRandomQualifierList;
declare const index$f_getRegistrationProfile: typeof getRegistrationProfile;
declare const index$f_getRoundMatchUps: typeof getRoundMatchUps;
declare const index$f_getRoundVisibilityState: typeof getRoundVisibilityState;
declare const index$f_getRounds: typeof getRounds;
declare const index$f_getScaleValues: typeof getScaleValues;
declare const index$f_getScaledEntries: typeof getScaledEntries;
declare const index$f_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const index$f_getSchedulingProfile: typeof getSchedulingProfile;
declare const index$f_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const index$f_getSeedingThresholds: typeof getSeedingThresholds;
declare const index$f_getSeedsCount: typeof getSeedsCount;
declare const index$f_getStructureSeedAssignments: typeof getStructureSeedAssignments;
declare const index$f_getSwissChart: typeof getSwissChart;
declare const index$f_getSwissStandings: typeof getSwissStandings;
declare const index$f_getTally: typeof getTally;
declare const index$f_getTeamLineUp: typeof getTeamLineUp;
declare const index$f_getTieFormat: typeof getTieFormat;
declare const index$f_getTimeItem: typeof getTimeItem;
declare const index$f_getTournamentIds: typeof getTournamentIds;
declare const index$f_getTournamentInfo: typeof getTournamentInfo;
declare const index$f_getTournamentPenalties: typeof getTournamentPenalties;
declare const index$f_getTournamentPersons: typeof getTournamentPersons;
declare const index$f_getTournamentPoints: typeof getTournamentPoints;
declare const index$f_getTournamentPublishStatus: typeof getTournamentPublishStatus;
declare const index$f_getTournamentStructures: typeof getTournamentStructures;
declare const index$f_getTournamentTimeItem: typeof getTournamentTimeItem;
declare const index$f_getValidGroupSizes: typeof getValidGroupSizes;
declare const index$f_getVenueData: typeof getVenueData;
declare const index$f_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const index$f_hasLuckyRounds: typeof hasLuckyRounds;
declare const index$f_isAdHoc: typeof isAdHoc;
declare const index$f_isCompletedStructure: typeof isCompletedStructure;
declare const index$f_isEmbargoed: typeof isEmbargoed;
declare const index$f_isValidForQualifying: typeof isValidForQualifying;
declare const index$f_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$f_isVisiblyPublished: typeof isVisiblyPublished;
declare const index$f_matchUpActions: typeof matchUpActions;
declare const index$f_participantScaleItem: typeof participantScaleItem;
declare const index$f_participantScheduledMatchUps: typeof participantScheduledMatchUps;
declare const index$f_positionActions: typeof positionActions;
declare const index$f_predictDrawCompetitiveBands: typeof predictDrawCompetitiveBands;
declare const index$f_predictMatchUpCompetitiveBands: typeof predictMatchUpCompetitiveBands;
declare const index$f_publicFindCourt: typeof publicFindCourt;
declare const index$f_publicFindVenue: typeof publicFindVenue;
declare const index$f_suggestFormatPlans: typeof suggestFormatPlans;
declare const index$f_tallyParticipantResults: typeof tallyParticipantResults;
declare const index$f_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const index$f_tournamentMatchUps: typeof tournamentMatchUps;
declare const index$f_validMatchUp: typeof validMatchUp;
declare const index$f_validMatchUps: typeof validMatchUps;
declare const index$f_validateCollectionDefinition: typeof validateCollectionDefinition;
declare const index$f_validateLineUp: typeof validateLineUp;
declare const index$f_validatePlayoffGroups: typeof validatePlayoffGroups;
declare namespace index$f {
  export {
    index$f_addGoesTo as addGoesTo,
    index$f_allCompetitionMatchUps as allCompetitionMatchUps,
    index$f_allDrawMatchUps as allDrawMatchUps,
    index$f_allEventMatchUps as allEventMatchUps,
    index$f_allPlayoffPositionsFilled as allPlayoffPositionsFilled,
    index$f_allTournamentMatchUps as allTournamentMatchUps,
    index$f_analyzeDraws as analyzeDraws,
    index$f_analyzeMatchUp as analyzeMatchUp,
    index$f_analyzeTournament as analyzeTournament,
    index$f_bulkUpdatePublishedEventIds as bulkUpdatePublishedEventIds,
    index$f_calculateMatchUpMargin as calculateMatchUpMargin,
    index$f_calculateWinCriteria as calculateWinCriteria,
    index$f_categoryCanContain as categoryCanContain,
    index$f_checkMatchUpIsComplete as checkMatchUpIsComplete,
    index$f_checkValidEntries as checkValidEntries,
    index$f_cleanExpiredMutationLocks as cleanExpiredMutationLocks,
    index$f_compareTieFormats as compareTieFormats,
    index$f_competitionScheduleMatchUps as competitionScheduleMatchUps,
    index$f_courtGridRows as courtGridRows,
    index$f_credits as credits,
    index$f_drawMatchUps as drawMatchUps,
    index$f_eventMatchUps as eventMatchUps,
    index$f_filterMatchUps as filterMatchUps,
    index$f_filterParticipants as filterParticipants,
    publicFindDrawDefinition as findDrawDefinition,
    index$f_findExtension as findExtension,
    index$f_findVenue as findVenue,
    index$f_getAggregateTeamResults as getAggregateTeamResults,
    index$f_getAllDrawMatchUps as getAllDrawMatchUps,
    index$f_getAllEventData as getAllEventData,
    index$f_getAllStructureMatchUps as getAllStructureMatchUps,
    index$f_getAllowedDrawTypes as getAllowedDrawTypes,
    index$f_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
    index$f_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels,
    index$f_getAppliedPolicies as getAppliedPolicies,
    index$f_getAssignedParticipantIds as getAssignedParticipantIds,
    index$f_getAvailableMatchUpsCount as getAvailableMatchUpsCount,
    index$f_getAvailablePlayoffProfiles as getAvailablePlayoffProfiles,
    index$f_getCategoryAgeDetails as getCategoryAgeDetails,
    index$f_getCheckedInParticipantIds as getCheckedInParticipantIds,
    index$f_getCompetitionDateRange as getCompetitionDateRange,
    index$f_getCompetitionFormat as getCompetitionFormat,
    index$f_getCompetitionLeaderboard as getCompetitionLeaderboard,
    index$f_getCompetitionMatchUps as getCompetitionMatchUps,
    index$f_getCompetitionParticipantState as getCompetitionParticipantState,
    index$f_getCompetitionParticipants as getCompetitionParticipants,
    index$f_getCompetitionPenalties as getCompetitionPenalties,
    index$f_getCompetitionPolicy as getCompetitionPolicy,
    index$f_getCompetitionState as getCompetitionState,
    index$f_getCompetitionVenues as getCompetitionVenues,
    index$f_getCourtInfo as getCourtInfo,
    index$f_getCourts as getCourts,
    index$f_getDraftState as getDraftState,
    index$f_getDrawData as getDrawData,
    index$f_getDrawDefinitionTimeItem as getDrawDefinitionTimeItem,
    index$f_getDrawParticipantRepresentativeIds as getDrawParticipantRepresentativeIds,
    index$f_getDrawStructures as getDrawStructures,
    index$f_getDrawTypeCoercion as getDrawTypeCoercion,
    index$f_getEligibleVoluntaryConsolationParticipants as getEligibleVoluntaryConsolationParticipants,
    index$f_getEntriesAndSeedsCount as getEntriesAndSeedsCount,
    index$f_getEvent as getEvent,
    index$f_getEventData as getEventData,
    index$f_getEventMatchUpFormatTiming as getEventMatchUpFormatTiming,
    index$f_getEventProperties as getEventProperties,
    index$f_getEventPublishStatus as getEventPublishStatus,
    index$f_getEventRankingPoints as getEventRankingPoints,
    index$f_getEventStructures as getEventStructures,
    index$f_getEventTimeItem as getEventTimeItem,
    index$f_getEvents as getEvents,
    index$f_getFlightProfile as getFlightProfile,
    index$f_getHomeParticipantId as getHomeParticipantId,
    index$f_getLinkedTournamentIds as getLinkedTournamentIds,
    index$f_getLuckyDrawRoundStatus as getLuckyDrawRoundStatus,
    index$f_getMatchUpCompetitiveProfile as getMatchUpCompetitiveProfile,
    index$f_getMatchUpContextIds as getMatchUpContextIds,
    index$f_getMatchUpDailyLimits as getMatchUpDailyLimits,
    index$f_getMatchUpDailyLimitsUpdate as getMatchUpDailyLimitsUpdate,
    index$f_getMatchUpDependencies as getMatchUpDependencies,
    index$f_getMatchUpFormat as getMatchUpFormat,
    index$f_getMatchUpFormatTiming as getMatchUpFormatTiming,
    index$f_getMatchUpFormatTimingUpdate as getMatchUpFormatTimingUpdate,
    index$f_getMatchUpScheduleDetails as getMatchUpScheduleDetails,
    index$f_getMatchUpType as getMatchUpType,
    index$f_getMatchUpsMap as getMatchUpsMap,
    index$f_getMatchUpsStats as getMatchUpsStats,
    index$f_getMatchUpsToSchedule as getMatchUpsToSchedule,
    index$f_getMaxEntryPosition as getMaxEntryPosition,
    index$f_getModifiedMatchUpFormatTiming as getModifiedMatchUpFormatTiming,
    index$f_getMutationLocks as getMutationLocks,
    index$f_getPairedParticipant as getPairedParticipant,
    index$f_getParticipantEventDetails as getParticipantEventDetails,
    index$f_getParticipantIdFinishingPositions as getParticipantIdFinishingPositions,
    index$f_getParticipantMembership as getParticipantMembership,
    index$f_getParticipantPaymentStatus as getParticipantPaymentStatus,
    index$f_getParticipantResults as getParticipantResults,
    index$f_getParticipantScaleItem as getParticipantScaleItem,
    index$f_getParticipantSchedules as getParticipantSchedules,
    index$f_getParticipantSignInStatus as getParticipantSignInStatus,
    index$f_getParticipantTimeItem as getParticipantTimeItem,
    index$f_getParticipants as getParticipants,
    index$f_getPersonRequests as getPersonRequests,
    index$f_getPolicyDefinitions as getPolicyDefinitions,
    index$f_getPositionAssignments as getPositionAssignments,
    index$f_getPositionsPlayedOff as getPositionsPlayedOff,
    index$f_getPredictiveAccuracy as getPredictiveAccuracy,
    index$f_getProfileRounds as getProfileRounds,
    index$f_getPublishState as getPublishState,
    index$f_getRandomQualifierList as getRandomQualifierList,
    index$f_getRegistrationProfile as getRegistrationProfile,
    index$f_getRoundMatchUps as getRoundMatchUps,
    index$f_getRoundVisibilityState as getRoundVisibilityState,
    index$f_getRounds as getRounds,
    index$f_getScaleValues as getScaleValues,
    index$f_getScaledEntries as getScaledEntries,
    index$f_getScheduledRoundsDetails as getScheduledRoundsDetails,
    index$f_getSchedulingProfile as getSchedulingProfile,
    index$f_getSchedulingProfileIssues as getSchedulingProfileIssues,
    index$f_getSeedingThresholds as getSeedingThresholds,
    index$f_getSeedsCount as getSeedsCount,
    index$f_getStructureSeedAssignments as getStructureSeedAssignments,
    index$f_getSwissChart as getSwissChart,
    index$f_getSwissStandings as getSwissStandings,
    index$f_getTally as getTally,
    index$f_getTeamLineUp as getTeamLineUp,
    index$f_getTieFormat as getTieFormat,
    index$f_getTimeItem as getTimeItem,
    index$f_getTournamentIds as getTournamentIds,
    index$f_getTournamentInfo as getTournamentInfo,
    index$f_getTournamentPenalties as getTournamentPenalties,
    index$f_getTournamentPersons as getTournamentPersons,
    index$f_getTournamentPoints as getTournamentPoints,
    index$f_getTournamentPublishStatus as getTournamentPublishStatus,
    index$f_getTournamentStructures as getTournamentStructures,
    index$f_getTournamentTimeItem as getTournamentTimeItem,
    index$f_getValidGroupSizes as getValidGroupSizes,
    index$f_getVenueData as getVenueData,
    index$f_getVenuesAndCourts as getVenuesAndCourts,
    index$f_hasLuckyRounds as hasLuckyRounds,
    index$f_isAdHoc as isAdHoc,
    index$f_isCompletedStructure as isCompletedStructure,
    index$f_isEmbargoed as isEmbargoed,
    index$f_isValidForQualifying as isValidForQualifying,
    index$f_isValidMatchUpFormat as isValidMatchUpFormat,
    index$f_isVisiblyPublished as isVisiblyPublished,
    index$f_matchUpActions as matchUpActions,
    index$f_participantScaleItem as participantScaleItem,
    index$f_participantScheduledMatchUps as participantScheduledMatchUps,
    index$f_positionActions as positionActions,
    index$f_predictDrawCompetitiveBands as predictDrawCompetitiveBands,
    index$f_predictMatchUpCompetitiveBands as predictMatchUpCompetitiveBands,
    index$f_publicFindCourt as publicFindCourt,
    index$f_publicFindVenue as publicFindVenue,
    index$f_suggestFormatPlans as suggestFormatPlans,
    index$f_tallyParticipantResults as tallyParticipantResults,
    index$f_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
    index$f_tournamentMatchUps as tournamentMatchUps,
    index$f_validMatchUp as validMatchUp,
    index$f_validMatchUps as validMatchUps,
    index$f_validateCollectionDefinition as validateCollectionDefinition,
    index$f_validateLineUp as validateLineUp,
    index$f_validatePlayoffGroups as validatePlayoffGroups,
  };
}

declare const query$3_applyDerivedRankings: typeof applyDerivedRankings;
declare const query$3_generateRankingList: typeof generateRankingList;
declare const query$3_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels;
declare const query$3_getAwardPoints: typeof getAwardPoints;
declare const query$3_getAwardProfile: typeof getAwardProfile;
declare const query$3_getEventRankingPoints: typeof getEventRankingPoints;
declare const query$3_getParticipantPoints: typeof getParticipantPoints;
declare const query$3_getQualityWinPoints: typeof getQualityWinPoints;
declare const query$3_getTournamentPointAwards: typeof getTournamentPointAwards;
declare const query$3_getTournamentPoints: typeof getTournamentPoints;
declare namespace query$3 {
  export {
    query$3_applyDerivedRankings as applyDerivedRankings,
    query$3_generateRankingList as generateRankingList,
    query$3_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels,
    query$3_getAwardPoints as getAwardPoints,
    query$3_getAwardProfile as getAwardProfile,
    query$3_getEventRankingPoints as getEventRankingPoints,
    query$3_getParticipantPoints as getParticipantPoints,
    query$3_getQualityWinPoints as getQualityWinPoints,
    query$3_getTournamentPointAwards as getTournamentPointAwards,
    query$3_getTournamentPoints as getTournamentPoints,
  };
}

declare const mutate$7_applyTournamentRankingPoints: typeof applyTournamentRankingPoints;
declare namespace mutate$7 {
  export {
    mutate$7_applyTournamentRankingPoints as applyTournamentRankingPoints,
  };
}

declare const index$e_applyDerivedRankings: typeof applyDerivedRankings;
declare const index$e_applyTournamentRankingPoints: typeof applyTournamentRankingPoints;
declare const index$e_generateRankingList: typeof generateRankingList;
declare const index$e_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels;
declare const index$e_getAwardPoints: typeof getAwardPoints;
declare const index$e_getAwardProfile: typeof getAwardProfile;
declare const index$e_getEventRankingPoints: typeof getEventRankingPoints;
declare const index$e_getParticipantPoints: typeof getParticipantPoints;
declare const index$e_getQualityWinPoints: typeof getQualityWinPoints;
declare const index$e_getTournamentPointAwards: typeof getTournamentPointAwards;
declare const index$e_getTournamentPoints: typeof getTournamentPoints;
declare namespace index$e {
  export {
    index$e_applyDerivedRankings as applyDerivedRankings,
    index$e_applyTournamentRankingPoints as applyTournamentRankingPoints,
    index$e_generateRankingList as generateRankingList,
    index$e_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels,
    index$e_getAwardPoints as getAwardPoints,
    index$e_getAwardProfile as getAwardProfile,
    index$e_getEventRankingPoints as getEventRankingPoints,
    index$e_getParticipantPoints as getParticipantPoints,
    index$e_getQualityWinPoints as getQualityWinPoints,
    index$e_getTournamentPointAwards as getTournamentPointAwards,
    index$e_getTournamentPoints as getTournamentPoints,
    mutate$7 as mutate,
    query$3 as query,
  };
}

declare const index$d_buildReportContext: typeof buildReportContext;
declare const index$d_generateReport: typeof generateReport;
declare const index$d_getAvailableReports: typeof getAvailableReports;
declare const index$d_getEntryStatusReports: typeof getEntryStatusReports;
declare const index$d_getParticipantStats: typeof getParticipantStats;
declare const index$d_getStructureReports: typeof getStructureReports;
declare const index$d_getVenuesReport: typeof getVenuesReport;
declare namespace index$d {
  export {
    index$d_buildReportContext as buildReportContext,
    index$d_generateReport as generateReport,
    index$d_getAvailableReports as getAvailableReports,
    index$d_getEntryStatusReports as getEntryStatusReports,
    index$d_getParticipantStats as getParticipantStats,
    index$d_getStructureReports as getStructureReports,
    index$d_getVenuesReport as getVenuesReport,
  };
}

declare const mutate$6_addCourtGridBooking: typeof addCourtGridBooking;
declare const mutate$6_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
declare const mutate$6_addMatchUpEndTime: typeof addMatchUpEndTime;
declare const mutate$6_addMatchUpOfficial: typeof addMatchUpOfficial;
declare const mutate$6_addMatchUpResumeTime: typeof addMatchUpResumeTime;
declare const mutate$6_addMatchUpScheduleItems: typeof addMatchUpScheduleItems;
declare const mutate$6_addMatchUpScheduledDate: typeof addMatchUpScheduledDate;
declare const mutate$6_addMatchUpScheduledTime: typeof addMatchUpScheduledTime;
declare const mutate$6_addMatchUpStartTime: typeof addMatchUpStartTime;
declare const mutate$6_addMatchUpStopTime: typeof addMatchUpStopTime;
declare const mutate$6_addSchedulingProfileRound: typeof addSchedulingProfileRound;
declare const mutate$6_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts;
declare const mutate$6_assignMatchUpCourt: typeof assignMatchUpCourt;
declare const mutate$6_assignMatchUpVenue: typeof assignMatchUpVenue;
declare const mutate$6_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps;
declare const mutate$6_bulkScheduleMatchUps: typeof bulkScheduleMatchUps;
declare const mutate$6_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps;
declare const mutate$6_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments;
declare const mutate$6_calculateScheduleTimes: typeof calculateScheduleTimes;
declare const mutate$6_clearMatchUpSchedule: typeof clearMatchUpSchedule;
declare const mutate$6_clearScheduledMatchUps: typeof clearScheduledMatchUps;
declare const mutate$6_findMatchUpFormatTiming: typeof findMatchUpFormatTiming;
declare const mutate$6_generateBookings: typeof generateBookings;
declare const mutate$6_generateVirtualCourts: typeof generateVirtualCourts;
declare const mutate$6_matchUpScheduleChange: typeof matchUpScheduleChange;
declare const mutate$6_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming;
declare const mutate$6_proAutoSchedule: typeof proAutoSchedule;
declare const mutate$6_proConflicts: typeof proConflicts;
declare const mutate$6_removeCourtGridBooking: typeof removeCourtGridBooking;
declare const mutate$6_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const mutate$6_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
declare const mutate$6_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
declare const mutate$6_scheduleMatchUps: typeof scheduleMatchUps;
declare const mutate$6_scheduleProfileGrid: typeof scheduleProfileGrid;
declare const mutate$6_scheduleProfileRounds: typeof scheduleProfileRounds;
declare const mutate$6_setMatchUpCalledAt: typeof setMatchUpCalledAt;
declare const mutate$6_setMatchUpDailyLimits: typeof setMatchUpDailyLimits;
declare const mutate$6_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId;
declare const mutate$6_setSchedulingProfile: typeof setSchedulingProfile;
declare const mutate$6_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const mutate$6_validateSchedulingProfile: typeof validateSchedulingProfile;
declare namespace mutate$6 {
  export {
    mutate$6_addCourtGridBooking as addCourtGridBooking,
    mutate$6_addMatchUpCourtOrder as addMatchUpCourtOrder,
    mutate$6_addMatchUpEndTime as addMatchUpEndTime,
    mutate$6_addMatchUpOfficial as addMatchUpOfficial,
    mutate$6_addMatchUpResumeTime as addMatchUpResumeTime,
    mutate$6_addMatchUpScheduleItems as addMatchUpScheduleItems,
    mutate$6_addMatchUpScheduledDate as addMatchUpScheduledDate,
    mutate$6_addMatchUpScheduledTime as addMatchUpScheduledTime,
    mutate$6_addMatchUpStartTime as addMatchUpStartTime,
    mutate$6_addMatchUpStopTime as addMatchUpStopTime,
    mutate$6_addSchedulingProfileRound as addSchedulingProfileRound,
    mutate$6_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts,
    mutate$6_assignMatchUpCourt as assignMatchUpCourt,
    mutate$6_assignMatchUpVenue as assignMatchUpVenue,
    mutate$6_bulkRescheduleMatchUps as bulkRescheduleMatchUps,
    mutate$6_bulkScheduleMatchUps as bulkScheduleMatchUps,
    mutate$6_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps,
    mutate$6_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments,
    mutate$6_calculateScheduleTimes as calculateScheduleTimes,
    mutate$6_clearMatchUpSchedule as clearMatchUpSchedule,
    mutate$6_clearScheduledMatchUps as clearScheduledMatchUps,
    mutate$6_findMatchUpFormatTiming as findMatchUpFormatTiming,
    mutate$6_generateBookings as generateBookings,
    mutate$6_generateVirtualCourts as generateVirtualCourts,
    mutate$6_matchUpScheduleChange as matchUpScheduleChange,
    mutate$6_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming,
    mutate$6_proAutoSchedule as proAutoSchedule,
    mutate$6_proConflicts as proConflicts,
    mutate$6_removeCourtGridBooking as removeCourtGridBooking,
    mutate$6_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
    mutate$6_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
    mutate$6_reorderUpcomingMatchUps as reorderUpcomingMatchUps,
    mutate$6_scheduleMatchUps as scheduleMatchUps,
    mutate$6_scheduleProfileGrid as scheduleProfileGrid,
    mutate$6_scheduleProfileRounds as scheduleProfileRounds,
    mutate$6_setMatchUpCalledAt as setMatchUpCalledAt,
    mutate$6_setMatchUpDailyLimits as setMatchUpDailyLimits,
    mutate$6_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId,
    mutate$6_setSchedulingProfile as setSchedulingProfile,
    mutate$6_toggleParticipantCheckInState as toggleParticipantCheckInState,
    mutate$6_validateSchedulingProfile as validateSchedulingProfile,
  };
}

declare const index$c_addCourtGridBooking: typeof addCourtGridBooking;
declare const index$c_addMatchUpCourtOrder: typeof addMatchUpCourtOrder;
declare const index$c_addMatchUpEndTime: typeof addMatchUpEndTime;
declare const index$c_addMatchUpOfficial: typeof addMatchUpOfficial;
declare const index$c_addMatchUpResumeTime: typeof addMatchUpResumeTime;
declare const index$c_addMatchUpScheduleItems: typeof addMatchUpScheduleItems;
declare const index$c_addMatchUpScheduledDate: typeof addMatchUpScheduledDate;
declare const index$c_addMatchUpScheduledTime: typeof addMatchUpScheduledTime;
declare const index$c_addMatchUpStartTime: typeof addMatchUpStartTime;
declare const index$c_addMatchUpStopTime: typeof addMatchUpStopTime;
declare const index$c_addSchedulingProfileRound: typeof addSchedulingProfileRound;
declare const index$c_allocateTeamMatchUpCourts: typeof allocateTeamMatchUpCourts;
declare const index$c_assignMatchUpCourt: typeof assignMatchUpCourt;
declare const index$c_assignMatchUpVenue: typeof assignMatchUpVenue;
declare const index$c_bulkRescheduleMatchUps: typeof bulkRescheduleMatchUps;
declare const index$c_bulkScheduleMatchUps: typeof bulkScheduleMatchUps;
declare const index$c_bulkScheduleTournamentMatchUps: typeof bulkScheduleTournamentMatchUps;
declare const index$c_bulkUpdateCourtAssignments: typeof bulkUpdateCourtAssignments;
declare const index$c_calculateScheduleTimes: typeof calculateScheduleTimes;
declare const index$c_clearMatchUpSchedule: typeof clearMatchUpSchedule;
declare const index$c_clearScheduledMatchUps: typeof clearScheduledMatchUps;
declare const index$c_courtGridRows: typeof courtGridRows;
declare const index$c_findMatchUpFormatTiming: typeof findMatchUpFormatTiming;
declare const index$c_findVenue: typeof findVenue;
declare const index$c_generateBookings: typeof generateBookings;
declare const index$c_generateVirtualCourts: typeof generateVirtualCourts;
declare const index$c_getMatchUpsToSchedule: typeof getMatchUpsToSchedule;
declare const index$c_getPersonRequests: typeof getPersonRequests;
declare const index$c_getProfileRounds: typeof getProfileRounds;
declare const index$c_getScheduledRoundsDetails: typeof getScheduledRoundsDetails;
declare const index$c_getSchedulingProfile: typeof getSchedulingProfile;
declare const index$c_getSchedulingProfileIssues: typeof getSchedulingProfileIssues;
declare const index$c_matchUpScheduleChange: typeof matchUpScheduleChange;
declare const index$c_modifyMatchUpFormatTiming: typeof modifyMatchUpFormatTiming;
declare const index$c_proAutoSchedule: typeof proAutoSchedule;
declare const index$c_proConflicts: typeof proConflicts;
declare const index$c_publicFindCourt: typeof publicFindCourt;
declare const index$c_removeCourtGridBooking: typeof removeCourtGridBooking;
declare const index$c_removeEventMatchUpFormatTiming: typeof removeEventMatchUpFormatTiming;
declare const index$c_removeMatchUpCourtAssignment: typeof removeMatchUpCourtAssignment;
declare const index$c_reorderUpcomingMatchUps: typeof reorderUpcomingMatchUps;
declare const index$c_scheduleMatchUps: typeof scheduleMatchUps;
declare const index$c_scheduleProfileGrid: typeof scheduleProfileGrid;
declare const index$c_scheduleProfileRounds: typeof scheduleProfileRounds;
declare const index$c_setMatchUpCalledAt: typeof setMatchUpCalledAt;
declare const index$c_setMatchUpDailyLimits: typeof setMatchUpDailyLimits;
declare const index$c_setMatchUpHomeParticipantId: typeof setMatchUpHomeParticipantId;
declare const index$c_setSchedulingProfile: typeof setSchedulingProfile;
declare const index$c_toggleParticipantCheckInState: typeof toggleParticipantCheckInState;
declare const index$c_validateSchedulingProfile: typeof validateSchedulingProfile;
declare namespace index$c {
  export {
    index$c_addCourtGridBooking as addCourtGridBooking,
    index$c_addMatchUpCourtOrder as addMatchUpCourtOrder,
    index$c_addMatchUpEndTime as addMatchUpEndTime,
    index$c_addMatchUpOfficial as addMatchUpOfficial,
    index$c_addMatchUpResumeTime as addMatchUpResumeTime,
    index$c_addMatchUpScheduleItems as addMatchUpScheduleItems,
    index$c_addMatchUpScheduledDate as addMatchUpScheduledDate,
    index$c_addMatchUpScheduledTime as addMatchUpScheduledTime,
    index$c_addMatchUpStartTime as addMatchUpStartTime,
    index$c_addMatchUpStopTime as addMatchUpStopTime,
    index$c_addSchedulingProfileRound as addSchedulingProfileRound,
    index$c_allocateTeamMatchUpCourts as allocateTeamMatchUpCourts,
    index$c_assignMatchUpCourt as assignMatchUpCourt,
    index$c_assignMatchUpVenue as assignMatchUpVenue,
    index$c_bulkRescheduleMatchUps as bulkRescheduleMatchUps,
    index$c_bulkScheduleMatchUps as bulkScheduleMatchUps,
    index$c_bulkScheduleTournamentMatchUps as bulkScheduleTournamentMatchUps,
    index$c_bulkUpdateCourtAssignments as bulkUpdateCourtAssignments,
    index$c_calculateScheduleTimes as calculateScheduleTimes,
    index$c_clearMatchUpSchedule as clearMatchUpSchedule,
    index$c_clearScheduledMatchUps as clearScheduledMatchUps,
    index$c_courtGridRows as courtGridRows,
    index$c_findMatchUpFormatTiming as findMatchUpFormatTiming,
    index$c_findVenue as findVenue,
    index$c_generateBookings as generateBookings,
    index$c_generateVirtualCourts as generateVirtualCourts,
    index$c_getMatchUpsToSchedule as getMatchUpsToSchedule,
    index$c_getPersonRequests as getPersonRequests,
    index$c_getProfileRounds as getProfileRounds,
    index$c_getScheduledRoundsDetails as getScheduledRoundsDetails,
    index$c_getSchedulingProfile as getSchedulingProfile,
    index$c_getSchedulingProfileIssues as getSchedulingProfileIssues,
    index$c_matchUpScheduleChange as matchUpScheduleChange,
    index$c_modifyMatchUpFormatTiming as modifyMatchUpFormatTiming,
    mutate$6 as mutate,
    index$c_proAutoSchedule as proAutoSchedule,
    index$c_proConflicts as proConflicts,
    index$c_publicFindCourt as publicFindCourt,
    query$5 as query,
    index$c_removeCourtGridBooking as removeCourtGridBooking,
    index$c_removeEventMatchUpFormatTiming as removeEventMatchUpFormatTiming,
    index$c_removeMatchUpCourtAssignment as removeMatchUpCourtAssignment,
    index$c_reorderUpcomingMatchUps as reorderUpcomingMatchUps,
    index$c_scheduleMatchUps as scheduleMatchUps,
    index$c_scheduleProfileGrid as scheduleProfileGrid,
    index$c_scheduleProfileRounds as scheduleProfileRounds,
    index$c_setMatchUpCalledAt as setMatchUpCalledAt,
    index$c_setMatchUpDailyLimits as setMatchUpDailyLimits,
    index$c_setMatchUpHomeParticipantId as setMatchUpHomeParticipantId,
    index$c_setSchedulingProfile as setSchedulingProfile,
    index$c_toggleParticipantCheckInState as toggleParticipantCheckInState,
    index$c_validateSchedulingProfile as validateSchedulingProfile,
  };
}

type generate$2_CompetitionFormat = CompetitionFormat;
type generate$2_PenaltyProfile = PenaltyProfile;
type generate$2_PlayerRules = PlayerRules;
type generate$2_PointProfile = PointProfile;
type generate$2_ScoringEngine = ScoringEngine;
declare const generate$2_ScoringEngine: typeof ScoringEngine;
type generate$2_ScoringEngineOptions = ScoringEngineOptions;
type generate$2_ScoringEngineSupplementaryState = ScoringEngineSupplementaryState;
type generate$2_ServerRule = ServerRule;
type generate$2_SubstitutionRules = SubstitutionRules;
type generate$2_TimeoutRules = TimeoutRules;
type generate$2_TimerProfile = TimerProfile;
declare const generate$2_generateScoreString: typeof generateScoreString;
declare const generate$2_generateTieMatchUpScore: typeof generateTieMatchUpScore;
declare const generate$2_reverseScore: typeof reverseScore;
declare namespace generate$2 {
  export { generate$2_ScoringEngine as ScoringEngine, generate$2_generateScoreString as generateScoreString, generate$2_generateTieMatchUpScore as generateTieMatchUpScore, generate$2_reverseScore as reverseScore };
  export type { generate$2_CompetitionFormat as CompetitionFormat, generate$2_PenaltyProfile as PenaltyProfile, generate$2_PlayerRules as PlayerRules, generate$2_PointProfile as PointProfile, generate$2_ScoringEngineOptions as ScoringEngineOptions, generate$2_ScoringEngineSupplementaryState as ScoringEngineSupplementaryState, generate$2_ServerRule as ServerRule, generate$2_SubstitutionRules as SubstitutionRules, generate$2_TimeoutRules as TimeoutRules, generate$2_TimerProfile as TimerProfile };
}

type mutate$5_AddPointConfig = AddPointConfig;
type mutate$5_PointMultiplier = PointMultiplier;
type mutate$5_PointsToDecoration = PointsToDecoration;
declare const mutate$5_addPoint: typeof addPoint;
declare const mutate$5_calculatePointsTo: typeof calculatePointsTo;
declare const mutate$5_createMatchUp: typeof createMatchUp;
declare const mutate$5_inferServeSide: typeof inferServeSide;
declare const mutate$5_resolvePointValue: typeof resolvePointValue;
declare namespace mutate$5 {
  export { mutate$5_addPoint as addPoint, mutate$5_calculatePointsTo as calculatePointsTo, mutate$5_createMatchUp as createMatchUp, mutate$5_inferServeSide as inferServeSide, mutate$5_resolvePointValue as resolvePointValue };
  export type { mutate$5_AddPointConfig as AddPointConfig, mutate$5_PointMultiplier as PointMultiplier, mutate$5_PointsToDecoration as PointsToDecoration };
}

declare const help_keyValueScore: typeof keyValueScore;
declare namespace help {
  export {
    help_keyValueScore as keyValueScore,
    parse as parseMatchUpFormat,
    stringify as stringifyMatchUpFormat,
  };
}

type query$2_CalculatedStat = CalculatedStat;
type query$2_GetScoreOptions = GetScoreOptions;
type query$2_MatchStatistics = MatchStatistics;
type query$2_StatObject = StatObject;
type query$2_StatisticsOptions = StatisticsOptions;
declare const query$2_analyzeScore: typeof analyzeScore;
declare const query$2_analyzeSet: typeof analyzeSet;
declare const query$2_calculateMatchStatistics: typeof calculateMatchStatistics;
declare const query$2_checkScoreHasValue: typeof checkScoreHasValue;
declare const query$2_checkSetIsComplete: typeof checkSetIsComplete;
declare const query$2_deduceMatchUpFormat: typeof deduceMatchUpFormat;
declare const query$2_enrichPointHistory: typeof enrichPointHistory;
declare const query$2_getEpisodes: typeof getEpisodes;
declare const query$2_getQuickStats: typeof getQuickStats;
declare const query$2_getScore: typeof getScore;
declare const query$2_getScoreboard: typeof getScoreboard;
declare const query$2_getSetComplement: typeof getSetComplement;
declare const query$2_getTiebreakComplement: typeof getTiebreakComplement;
declare const query$2_getWinner: typeof getWinner;
declare const query$2_isComplete: typeof isComplete;
declare const query$2_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const query$2_parseScoreString: typeof parseScoreString;
declare const query$2_toStatObjects: typeof toStatObjects;
declare const query$2_validateMatchUpScore: typeof validateMatchUpScore;
declare const query$2_validateScore: typeof validateScore;
declare const query$2_validateSetScore: typeof validateSetScore;
declare const query$2_validateTieFormat: typeof validateTieFormat;
declare namespace query$2 {
  export { query$2_analyzeScore as analyzeScore, query$2_analyzeSet as analyzeSet, query$2_calculateMatchStatistics as calculateMatchStatistics, query$2_checkScoreHasValue as checkScoreHasValue, query$2_checkSetIsComplete as checkSetIsComplete, query$2_deduceMatchUpFormat as deduceMatchUpFormat, query$2_enrichPointHistory as enrichPointHistory, query$2_getEpisodes as getEpisodes, query$2_getQuickStats as getQuickStats, query$2_getScore as getScore, query$2_getScoreboard as getScoreboard, query$2_getSetComplement as getSetComplement, query$2_getTiebreakComplement as getTiebreakComplement, query$2_getWinner as getWinner, query$2_isComplete as isComplete, query$2_isValidMatchUpFormat as isValidMatchUpFormat, query$2_parseScoreString as parseScoreString, query$2_toStatObjects as toStatObjects, query$2_validateMatchUpScore as validateMatchUpScore, query$2_validateScore as validateScore, query$2_validateSetScore as validateSetScore, query$2_validateTieFormat as validateTieFormat };
  export type { query$2_CalculatedStat as CalculatedStat, query$2_GetScoreOptions as GetScoreOptions, query$2_MatchStatistics as MatchStatistics, StatCounters$1 as StatCounters, query$2_StatObject as StatObject, query$2_StatisticsOptions as StatisticsOptions };
}

type index$b_AddGameOptions = AddGameOptions;
type index$b_AddPointConfig = AddPointConfig;
type index$b_AddPointOptions = AddPointOptions;
type index$b_AddSetOptions = AddSetOptions;
type index$b_CalculatedStat = CalculatedStat;
type index$b_CompetitionFormat = CompetitionFormat;
type index$b_CreateMatchUpOptions = CreateMatchUpOptions;
type index$b_EndSegmentOptions = EndSegmentOptions;
type index$b_Episode = Episode;
type index$b_EpisodeGame = EpisodeGame;
type index$b_EpisodeNeeded = EpisodeNeeded;
type index$b_EpisodePoint = EpisodePoint;
type index$b_EpisodeSet = EpisodeSet;
type index$b_FormatStructure = FormatStructure;
type index$b_GameFormatStructure = GameFormatStructure;
type index$b_GetScoreOptions = GetScoreOptions;
type index$b_GetScoreboardOptions = GetScoreboardOptions;
type index$b_InitialScoreOptions = InitialScoreOptions;
type index$b_MCPMatch = MCPMatch;
type index$b_MCPMatchResult = MCPMatchResult;
type index$b_MCPPoint = MCPPoint;
type index$b_MCPValidationOptions = MCPValidationOptions;
type index$b_MCPValidationResult = MCPValidationResult;
type index$b_MatchStatistics = MatchStatistics;
type index$b_MatchUpHistory = MatchUpHistory;
type index$b_MatchUpState = MatchUpState;
type index$b_PBPValidationOptions = PBPValidationOptions;
type index$b_PBPValidationResult = PBPValidationResult;
type index$b_ParsedMCPPoint = ParsedMCPPoint;
type index$b_PenaltyProfile = PenaltyProfile;
type index$b_PlayerRules = PlayerRules;
type index$b_PointMultiplier = PointMultiplier;
type index$b_PointProfile = PointProfile;
type index$b_PointResult = PointResult;
type index$b_PointSituation = PointSituation;
type index$b_PointsToDecoration = PointsToDecoration;
type index$b_RallyShot = RallyShot;
type index$b_ScoreEntry = ScoreEntry;
type index$b_ScoreResult = ScoreResult;
type index$b_ScoringEngine = ScoringEngine;
declare const index$b_ScoringEngine: typeof ScoringEngine;
type index$b_ScoringEngineOptions = ScoringEngineOptions;
type index$b_ScoringEngineSupplementaryState = ScoringEngineSupplementaryState;
type index$b_ServeLocation = ServeLocation;
type index$b_ServerRule = ServerRule;
type index$b_SetFormatStructure = SetFormatStructure;
type index$b_SetScore = SetScore;
type index$b_StatObject = StatObject;
type index$b_Statistics = Statistics;
type index$b_StatisticsOptions = StatisticsOptions;
type index$b_StrokeType = StrokeType;
type index$b_SubstitutionEvent = SubstitutionEvent;
type index$b_SubstitutionRules = SubstitutionRules;
type index$b_TiebreakFormatStructure = TiebreakFormatStructure;
type index$b_TimeoutRules = TimeoutRules;
type index$b_TimerProfile = TimerProfile;
type index$b_ValidateMatchUpOptions = ValidateMatchUpOptions;
type index$b_ValidationDetails = ValidationDetails;
type index$b_ValidationResult = ValidationResult;
declare const index$b_addPoint: typeof addPoint;
declare const index$b_analyzeScore: typeof analyzeScore;
declare const index$b_analyzeSequence: typeof analyzeSequence;
declare const index$b_analyzeSet: typeof analyzeSet;
declare const index$b_calculateMatchStatistics: typeof calculateMatchStatistics;
declare const index$b_calculatePointsTo: typeof calculatePointsTo;
declare const index$b_checkScoreHasValue: typeof checkScoreHasValue;
declare const index$b_checkSetIsComplete: typeof checkSetIsComplete;
declare const index$b_createMatchUp: typeof createMatchUp;
declare const index$b_deduceMatchUpFormat: typeof deduceMatchUpFormat;
declare const index$b_enrichPointHistory: typeof enrichPointHistory;
declare const index$b_exportMatchUpJSON: typeof exportMatchUpJSON;
declare const index$b_generateScoreString: typeof generateScoreString;
declare const index$b_generateTieMatchUpScore: typeof generateTieMatchUpScore;
declare const index$b_getEpisodes: typeof getEpisodes;
declare const index$b_getQuickStats: typeof getQuickStats;
declare const index$b_getScore: typeof getScore;
declare const index$b_getScoreboard: typeof getScoreboard;
declare const index$b_getSetComplement: typeof getSetComplement;
declare const index$b_getSetScoreString: typeof getSetScoreString;
declare const index$b_getTiebreakComplement: typeof getTiebreakComplement;
declare const index$b_getWinner: typeof getWinner;
declare const index$b_groupByMatch: typeof groupByMatch;
declare const index$b_inferServeSide: typeof inferServeSide;
declare const index$b_isComplete: typeof isComplete;
declare const index$b_isValidMatchUpFormat: typeof isValidMatchUpFormat;
declare const index$b_keyValueScore: typeof keyValueScore;
declare const index$b_mcpValidator: typeof mcpValidator;
declare const index$b_parseCSV: typeof parseCSV;
declare const index$b_parseMCPPoint: typeof parseMCPPoint;
declare const index$b_parseScoreString: typeof parseScoreString;
declare const index$b_pbpValidator: typeof pbpValidator;
declare const index$b_pointParser: typeof pointParser;
declare const index$b_resolvePointValue: typeof resolvePointValue;
declare const index$b_reverseScore: typeof reverseScore;
declare const index$b_shotParser: typeof shotParser;
declare const index$b_shotSplitter: typeof shotSplitter;
declare const index$b_toStatObjects: typeof toStatObjects;
declare const index$b_validateMCPMatch: typeof validateMCPMatch;
declare const index$b_validateMatchUp: typeof validateMatchUp;
declare const index$b_validateMatchUpScore: typeof validateMatchUpScore;
declare const index$b_validateScore: typeof validateScore;
declare const index$b_validateSet: typeof validateSet;
declare const index$b_validateSetScore: typeof validateSetScore;
declare const index$b_validateTieFormat: typeof validateTieFormat;
declare namespace index$b {
  export { index$b_ScoringEngine as ScoringEngine, index$b_addPoint as addPoint, index$b_analyzeScore as analyzeScore, index$b_analyzeSequence as analyzeSequence, index$b_analyzeSet as analyzeSet, index$b_calculateMatchStatistics as calculateMatchStatistics, index$b_calculatePointsTo as calculatePointsTo, index$b_checkScoreHasValue as checkScoreHasValue, index$b_checkSetIsComplete as checkSetIsComplete, index$b_createMatchUp as createMatchUp, index$b_deduceMatchUpFormat as deduceMatchUpFormat, index$b_enrichPointHistory as enrichPointHistory, index$b_exportMatchUpJSON as exportMatchUpJSON, generate$2 as generate, index$b_generateScoreString as generateScoreString, index$b_generateTieMatchUpScore as generateTieMatchUpScore, index$b_getEpisodes as getEpisodes, index$b_getQuickStats as getQuickStats, index$b_getScore as getScore, index$b_getScoreboard as getScoreboard, index$b_getSetComplement as getSetComplement, index$b_getSetScoreString as getSetScoreString, index$b_getTiebreakComplement as getTiebreakComplement, index$b_getWinner as getWinner, index$b_groupByMatch as groupByMatch, help as helpers, index$b_inferServeSide as inferServeSide, index$b_isComplete as isComplete, index$b_isValidMatchUpFormat as isValidMatchUpFormat, index$b_keyValueScore as keyValueScore, index$b_mcpValidator as mcpValidator, mutate$5 as mutate, index$b_parseCSV as parseCSV, index$b_parseMCPPoint as parseMCPPoint, parse as parseMatchUpFormat, index$b_parseScoreString as parseScoreString, index$b_pbpValidator as pbpValidator, index$b_pointParser as pointParser, query$2 as query, index$b_resolvePointValue as resolvePointValue, index$b_reverseScore as reverseScore, index$b_shotParser as shotParser, index$b_shotSplitter as shotSplitter, stringify as stringifyMatchUpFormat, index$b_toStatObjects as toStatObjects, index$b_validateMCPMatch as validateMCPMatch, index$b_validateMatchUp as validateMatchUp, index$b_validateMatchUpScore as validateMatchUpScore, index$b_validateScore as validateScore, index$b_validateSet as validateSet, index$b_validateSetScore as validateSetScore, index$b_validateTieFormat as validateTieFormat };
  export type { index$b_AddGameOptions as AddGameOptions, index$b_AddPointConfig as AddPointConfig, index$b_AddPointOptions as AddPointOptions, index$b_AddSetOptions as AddSetOptions, index$b_CalculatedStat as CalculatedStat, index$b_CompetitionFormat as CompetitionFormat, index$b_CreateMatchUpOptions as CreateMatchUpOptions, index$b_EndSegmentOptions as EndSegmentOptions, index$b_Episode as Episode, index$b_EpisodeGame as EpisodeGame, index$b_EpisodeNeeded as EpisodeNeeded, index$b_EpisodePoint as EpisodePoint, index$b_EpisodeSet as EpisodeSet, index$b_FormatStructure as FormatStructure, index$b_GameFormatStructure as GameFormatStructure, index$b_GetScoreOptions as GetScoreOptions, index$b_GetScoreboardOptions as GetScoreboardOptions, index$b_InitialScoreOptions as InitialScoreOptions, index$b_MCPMatch as MCPMatch, index$b_MCPMatchResult as MCPMatchResult, index$b_MCPPoint as MCPPoint, index$b_MCPValidationOptions as MCPValidationOptions, index$b_MCPValidationResult as MCPValidationResult, index$b_MatchStatistics as MatchStatistics, index$b_MatchUpHistory as MatchUpHistory, index$b_MatchUpState as MatchUpState, index$b_PBPValidationOptions as PBPValidationOptions, index$b_PBPValidationResult as PBPValidationResult, index$b_ParsedMCPPoint as ParsedMCPPoint, index$b_PenaltyProfile as PenaltyProfile, index$b_PlayerRules as PlayerRules, index$b_PointMultiplier as PointMultiplier, index$b_PointProfile as PointProfile, index$b_PointResult as PointResult, index$b_PointSituation as PointSituation, index$b_PointsToDecoration as PointsToDecoration, index$b_RallyShot as RallyShot, index$b_ScoreEntry as ScoreEntry, index$b_ScoreResult as ScoreResult, index$b_ScoringEngineOptions as ScoringEngineOptions, index$b_ScoringEngineSupplementaryState as ScoringEngineSupplementaryState, MatchUp as ScoringMatchUp, Point as ScoringPoint, Score as ScoringScore, index$b_ServeLocation as ServeLocation, index$b_ServerRule as ServerRule, index$b_SetFormatStructure as SetFormatStructure, index$b_SetScore as SetScore, StatCounters$1 as StatCounters, index$b_StatObject as StatObject, index$b_Statistics as Statistics, index$b_StatisticsOptions as StatisticsOptions, index$b_StrokeType as StrokeType, index$b_SubstitutionEvent as SubstitutionEvent, index$b_SubstitutionRules as SubstitutionRules, index$b_TiebreakFormatStructure as TiebreakFormatStructure, index$b_TimeoutRules as TimeoutRules, index$b_TimerProfile as TimerProfile, index$b_ValidateMatchUpOptions as ValidateMatchUpOptions, index$b_ValidationDetails as ValidationDetails, index$b_ValidationResult as ValidationResult };
}

declare const mutate$4_addCollectionDefinition: typeof addCollectionDefinition;
declare const mutate$4_addCollectionGroup: typeof addCollectionGroup;
declare const mutate$4_aggregateTieFormats: typeof aggregateTieFormats;
declare const mutate$4_modifyCollectionDefinition: typeof modifyCollectionDefinition;
declare const mutate$4_modifyTieFormat: typeof modifyTieFormat;
declare const mutate$4_orderCollectionDefinitions: typeof orderCollectionDefinitions;
declare const mutate$4_removeCollectionDefinition: typeof removeCollectionDefinition;
declare const mutate$4_removeCollectionGroup: typeof removeCollectionGroup;
declare const mutate$4_removeOrphanedTieFormats: typeof removeOrphanedTieFormats;
declare namespace mutate$4 {
  export {
    mutate$4_addCollectionDefinition as addCollectionDefinition,
    mutate$4_addCollectionGroup as addCollectionGroup,
    mutate$4_aggregateTieFormats as aggregateTieFormats,
    mutate$4_modifyCollectionDefinition as modifyCollectionDefinition,
    mutate$4_modifyTieFormat as modifyTieFormat,
    mutate$4_orderCollectionDefinitions as orderCollectionDefinitions,
    mutate$4_removeCollectionDefinition as removeCollectionDefinition,
    mutate$4_removeCollectionGroup as removeCollectionGroup,
    mutate$4_removeOrphanedTieFormats as removeOrphanedTieFormats,
  };
}

declare const index$a_addCollectionDefinition: typeof addCollectionDefinition;
declare const index$a_addCollectionGroup: typeof addCollectionGroup;
declare const index$a_aggregateTieFormats: typeof aggregateTieFormats;
declare const index$a_compareTieFormats: typeof compareTieFormats;
declare const index$a_getTieFormat: typeof getTieFormat;
declare const index$a_modifyCollectionDefinition: typeof modifyCollectionDefinition;
declare const index$a_modifyTieFormat: typeof modifyTieFormat;
declare const index$a_orderCollectionDefinitions: typeof orderCollectionDefinitions;
declare const index$a_removeCollectionDefinition: typeof removeCollectionDefinition;
declare const index$a_removeCollectionGroup: typeof removeCollectionGroup;
declare const index$a_removeOrphanedTieFormats: typeof removeOrphanedTieFormats;
declare const index$a_tieFormatGenderValidityCheck: typeof tieFormatGenderValidityCheck;
declare const index$a_validateCollectionDefinition: typeof validateCollectionDefinition;
declare namespace index$a {
  export {
    index$a_addCollectionDefinition as addCollectionDefinition,
    index$a_addCollectionGroup as addCollectionGroup,
    index$a_aggregateTieFormats as aggregateTieFormats,
    index$a_compareTieFormats as compareTieFormats,
    index$a_getTieFormat as getTieFormat,
    index$a_modifyCollectionDefinition as modifyCollectionDefinition,
    index$a_modifyTieFormat as modifyTieFormat,
    mutate$4 as mutate,
    index$a_orderCollectionDefinitions as orderCollectionDefinitions,
    query$6 as query,
    index$a_removeCollectionDefinition as removeCollectionDefinition,
    index$a_removeCollectionGroup as removeCollectionGroup,
    index$a_removeOrphanedTieFormats as removeOrphanedTieFormats,
    index$a_tieFormatGenderValidityCheck as tieFormatGenderValidityCheck,
    index$a_validateCollectionDefinition as validateCollectionDefinition,
  };
}

declare const generate$1_copyTournamentRecord: typeof copyTournamentRecord;
declare const generate$1_createTournamentRecord: typeof createTournamentRecord;
declare namespace generate$1 {
  export {
    generate$1_copyTournamentRecord as copyTournamentRecord,
    generate$1_createTournamentRecord as createTournamentRecord,
  };
}

declare const mutate$3_addDrawDefinitionExtension: typeof addDrawDefinitionExtension;
declare const mutate$3_addEventExtension: typeof addEventExtension;
declare const mutate$3_addEventTimeItem: typeof addEventTimeItem;
declare const mutate$3_addExtension: typeof addExtension;
declare const mutate$3_addMutationLock: typeof addMutationLock;
declare const mutate$3_addNotes: typeof addNotes;
declare const mutate$3_addOnlineResource: typeof addOnlineResource;
declare const mutate$3_addParticipantExtension: typeof addParticipantExtension;
declare const mutate$3_addParticipantTimeItem: typeof addParticipantTimeItem;
declare const mutate$3_addTimeItem: typeof addTimeItem;
declare const mutate$3_addTournamentExtension: typeof addTournamentExtension;
declare const mutate$3_addTournamentTimeItem: typeof addTournamentTimeItem;
declare const mutate$3_hydrateTournamentRecord: typeof hydrateTournamentRecord;
declare const mutate$3_migrateTournamentRecord: typeof migrateTournamentRecord;
declare const mutate$3_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension;
declare const mutate$3_removeEventExtension: typeof removeEventExtension;
declare const mutate$3_removeExtension: typeof removeExtension;
declare const mutate$3_removeMutationLock: typeof removeMutationLock;
declare const mutate$3_removeNotes: typeof removeNotes;
declare const mutate$3_removeOnlineResource: typeof removeOnlineResource;
declare const mutate$3_removeParticipantExtension: typeof removeParticipantExtension;
declare const mutate$3_removeTournamentExtension: typeof removeTournamentExtension;
declare const mutate$3_setRegistrationProfile: typeof setRegistrationProfile;
declare const mutate$3_setTournamentCategories: typeof setTournamentCategories;
declare const mutate$3_setTournamentDates: typeof setTournamentDates;
declare const mutate$3_setTournamentEndDate: typeof setTournamentEndDate;
declare const mutate$3_setTournamentLocalTimeZone: typeof setTournamentLocalTimeZone;
declare const mutate$3_setTournamentName: typeof setTournamentName;
declare const mutate$3_setTournamentNotes: typeof setTournamentNotes;
declare const mutate$3_setTournamentStartDate: typeof setTournamentStartDate;
declare const mutate$3_setTournamentStatus: typeof setTournamentStatus;
declare const mutate$3_setTournamentTier: typeof setTournamentTier;
declare namespace mutate$3 {
  export {
    mutate$3_addDrawDefinitionExtension as addDrawDefinitionExtension,
    mutate$3_addEventExtension as addEventExtension,
    mutate$3_addEventTimeItem as addEventTimeItem,
    mutate$3_addExtension as addExtension,
    mutate$3_addMutationLock as addMutationLock,
    mutate$3_addNotes as addNotes,
    mutate$3_addOnlineResource as addOnlineResource,
    mutate$3_addParticipantExtension as addParticipantExtension,
    mutate$3_addParticipantTimeItem as addParticipantTimeItem,
    mutate$3_addTimeItem as addTimeItem,
    mutate$3_addTournamentExtension as addTournamentExtension,
    mutate$3_addTournamentTimeItem as addTournamentTimeItem,
    mutate$3_hydrateTournamentRecord as hydrateTournamentRecord,
    mutate$3_migrateTournamentRecord as migrateTournamentRecord,
    mutate$3_removeDrawDefinitionExtension as removeDrawDefinitionExtension,
    mutate$3_removeEventExtension as removeEventExtension,
    mutate$3_removeExtension as removeExtension,
    mutate$3_removeMutationLock as removeMutationLock,
    mutate$3_removeNotes as removeNotes,
    mutate$3_removeOnlineResource as removeOnlineResource,
    mutate$3_removeParticipantExtension as removeParticipantExtension,
    mutate$3_removeTournamentExtension as removeTournamentExtension,
    mutate$3_setRegistrationProfile as setRegistrationProfile,
    mutate$3_setTournamentCategories as setTournamentCategories,
    mutate$3_setTournamentDates as setTournamentDates,
    mutate$3_setTournamentEndDate as setTournamentEndDate,
    mutate$3_setTournamentLocalTimeZone as setTournamentLocalTimeZone,
    mutate$3_setTournamentName as setTournamentName,
    mutate$3_setTournamentNotes as setTournamentNotes,
    mutate$3_setTournamentStartDate as setTournamentStartDate,
    mutate$3_setTournamentStatus as setTournamentStatus,
    mutate$3_setTournamentTier as setTournamentTier,
  };
}

declare const index$9_addDrawDefinitionExtension: typeof addDrawDefinitionExtension;
declare const index$9_addEventExtension: typeof addEventExtension;
declare const index$9_addEventTimeItem: typeof addEventTimeItem;
declare const index$9_addExtension: typeof addExtension;
declare const index$9_addMutationLock: typeof addMutationLock;
declare const index$9_addNotes: typeof addNotes;
declare const index$9_addOnlineResource: typeof addOnlineResource;
declare const index$9_addParticipantExtension: typeof addParticipantExtension;
declare const index$9_addParticipantTimeItem: typeof addParticipantTimeItem;
declare const index$9_addTimeItem: typeof addTimeItem;
declare const index$9_addTournamentExtension: typeof addTournamentExtension;
declare const index$9_addTournamentTimeItem: typeof addTournamentTimeItem;
declare const index$9_analyzeDraws: typeof analyzeDraws;
declare const index$9_analyzeTournament: typeof analyzeTournament;
declare const index$9_cleanExpiredMutationLocks: typeof cleanExpiredMutationLocks;
declare const index$9_copyTournamentRecord: typeof copyTournamentRecord;
declare const index$9_createTournamentRecord: typeof createTournamentRecord;
declare const index$9_getAggregateTeamResults: typeof getAggregateTeamResults;
declare const index$9_getAllowedDrawTypes: typeof getAllowedDrawTypes;
declare const index$9_getAllowedMatchUpFormats: typeof getAllowedMatchUpFormats;
declare const index$9_getApplicableAwardProfileLevels: typeof getApplicableAwardProfileLevels;
declare const index$9_getAppliedPolicies: typeof getAppliedPolicies;
declare const index$9_getCompetitionDateRange: typeof getCompetitionDateRange;
declare const index$9_getCompetitionPenalties: typeof getCompetitionPenalties;
declare const index$9_getEventRankingPoints: typeof getEventRankingPoints;
declare const index$9_getMutationLocks: typeof getMutationLocks;
declare const index$9_getPolicyDefinitions: typeof getPolicyDefinitions;
declare const index$9_getRegistrationProfile: typeof getRegistrationProfile;
declare const index$9_getTournamentInfo: typeof getTournamentInfo;
declare const index$9_getTournamentPenalties: typeof getTournamentPenalties;
declare const index$9_getTournamentPersons: typeof getTournamentPersons;
declare const index$9_getTournamentPoints: typeof getTournamentPoints;
declare const index$9_getTournamentStructures: typeof getTournamentStructures;
declare const index$9_getTournamentTimeItem: typeof getTournamentTimeItem;
declare const index$9_hydrateTournamentRecord: typeof hydrateTournamentRecord;
declare const index$9_migrateTournamentRecord: typeof migrateTournamentRecord;
declare const index$9_removeDrawDefinitionExtension: typeof removeDrawDefinitionExtension;
declare const index$9_removeEventExtension: typeof removeEventExtension;
declare const index$9_removeExtension: typeof removeExtension;
declare const index$9_removeMutationLock: typeof removeMutationLock;
declare const index$9_removeNotes: typeof removeNotes;
declare const index$9_removeOnlineResource: typeof removeOnlineResource;
declare const index$9_removeParticipantExtension: typeof removeParticipantExtension;
declare const index$9_removeTournamentExtension: typeof removeTournamentExtension;
declare const index$9_setRegistrationProfile: typeof setRegistrationProfile;
declare const index$9_setTournamentCategories: typeof setTournamentCategories;
declare const index$9_setTournamentDates: typeof setTournamentDates;
declare const index$9_setTournamentEndDate: typeof setTournamentEndDate;
declare const index$9_setTournamentLocalTimeZone: typeof setTournamentLocalTimeZone;
declare const index$9_setTournamentName: typeof setTournamentName;
declare const index$9_setTournamentNotes: typeof setTournamentNotes;
declare const index$9_setTournamentStartDate: typeof setTournamentStartDate;
declare const index$9_setTournamentStatus: typeof setTournamentStatus;
declare const index$9_setTournamentTier: typeof setTournamentTier;
declare const index$9_suggestFormatPlans: typeof suggestFormatPlans;
declare namespace index$9 {
  export {
    index$9_addDrawDefinitionExtension as addDrawDefinitionExtension,
    index$9_addEventExtension as addEventExtension,
    index$9_addEventTimeItem as addEventTimeItem,
    index$9_addExtension as addExtension,
    index$9_addMutationLock as addMutationLock,
    index$9_addNotes as addNotes,
    index$9_addOnlineResource as addOnlineResource,
    index$9_addParticipantExtension as addParticipantExtension,
    index$9_addParticipantTimeItem as addParticipantTimeItem,
    index$9_addTimeItem as addTimeItem,
    index$9_addTournamentExtension as addTournamentExtension,
    index$9_addTournamentTimeItem as addTournamentTimeItem,
    index$9_analyzeDraws as analyzeDraws,
    index$9_analyzeTournament as analyzeTournament,
    index$9_cleanExpiredMutationLocks as cleanExpiredMutationLocks,
    index$9_copyTournamentRecord as copyTournamentRecord,
    index$9_createTournamentRecord as createTournamentRecord,
    generate$1 as generate,
    index$9_getAggregateTeamResults as getAggregateTeamResults,
    index$9_getAllowedDrawTypes as getAllowedDrawTypes,
    index$9_getAllowedMatchUpFormats as getAllowedMatchUpFormats,
    index$9_getApplicableAwardProfileLevels as getApplicableAwardProfileLevels,
    index$9_getAppliedPolicies as getAppliedPolicies,
    index$9_getCompetitionDateRange as getCompetitionDateRange,
    index$9_getCompetitionPenalties as getCompetitionPenalties,
    index$9_getEventRankingPoints as getEventRankingPoints,
    index$9_getMutationLocks as getMutationLocks,
    index$9_getPolicyDefinitions as getPolicyDefinitions,
    index$9_getRegistrationProfile as getRegistrationProfile,
    index$9_getTournamentInfo as getTournamentInfo,
    index$9_getTournamentPenalties as getTournamentPenalties,
    index$9_getTournamentPersons as getTournamentPersons,
    index$9_getTournamentPoints as getTournamentPoints,
    index$9_getTournamentStructures as getTournamentStructures,
    index$9_getTournamentTimeItem as getTournamentTimeItem,
    index$9_hydrateTournamentRecord as hydrateTournamentRecord,
    index$9_migrateTournamentRecord as migrateTournamentRecord,
    mutate$3 as mutate,
    query$7 as query,
    index$9_removeDrawDefinitionExtension as removeDrawDefinitionExtension,
    index$9_removeEventExtension as removeEventExtension,
    index$9_removeExtension as removeExtension,
    index$9_removeMutationLock as removeMutationLock,
    index$9_removeNotes as removeNotes,
    index$9_removeOnlineResource as removeOnlineResource,
    index$9_removeParticipantExtension as removeParticipantExtension,
    index$9_removeTournamentExtension as removeTournamentExtension,
    index$9_setRegistrationProfile as setRegistrationProfile,
    index$9_setTournamentCategories as setTournamentCategories,
    index$9_setTournamentDates as setTournamentDates,
    index$9_setTournamentEndDate as setTournamentEndDate,
    index$9_setTournamentLocalTimeZone as setTournamentLocalTimeZone,
    index$9_setTournamentName as setTournamentName,
    index$9_setTournamentNotes as setTournamentNotes,
    index$9_setTournamentStartDate as setTournamentStartDate,
    index$9_setTournamentStatus as setTournamentStatus,
    index$9_setTournamentTier as setTournamentTier,
    index$9_suggestFormatPlans as suggestFormatPlans,
  };
}

type DayId = string;
type BlockId = string;
type VenueId = string;
type CourtId = string;
type TournamentId = string;
type TemplateId = string;
type RuleId = string;
declare const BLOCK_TYPES: {
    readonly MAINTENANCE: "MAINTENANCE";
    readonly PRACTICE: "PRACTICE";
    readonly RESERVED: "RESERVED";
    readonly BLOCKED: "BLOCKED";
    readonly CLOSED: "CLOSED";
    readonly SCHEDULED: "SCHEDULED";
    readonly SOFT_BLOCK: "SOFT_BLOCK";
    readonly HARD_BLOCK: "HARD_BLOCK";
    readonly LOCKED: "LOCKED";
    readonly AVAILABLE: "AVAILABLE";
    readonly UNSPECIFIED: "UNSPECIFIED";
};
type BlockType = 'MAINTENANCE' | 'PRACTICE' | 'RESERVED' | 'BLOCKED' | 'CLOSED' | 'SCHEDULED' | 'SOFT_BLOCK' | 'HARD_BLOCK' | 'LOCKED' | 'AVAILABLE' | 'UNSPECIFIED';
type BlockSource = 'USER' | 'TEMPLATE' | 'RULE' | 'SYSTEM';
type BlockHardness = 'HARD' | 'SOFT';
interface TimeRange {
    start: string;
    end: string;
}
interface CourtRef {
    tournamentId: TournamentId;
    venueId: VenueId;
    courtId: CourtId;
}
interface Block extends TimeRange {
    id: BlockId;
    court: CourtRef;
    type: BlockType;
    reason?: string;
    priority?: number;
    hardSoft?: BlockHardness;
    recurrenceKey?: string;
    source?: BlockSource;
    matchUpId?: string;
}
interface RailSegment extends TimeRange {
    status: BlockType;
    contributingBlocks: BlockId[];
}
interface CourtRail {
    court: CourtRef;
    segments: RailSegment[];
}
interface VenueDayTimeline {
    day: DayId;
    venueId: VenueId;
    rails: CourtRail[];
}
interface CourtSchedulingSummary {
    scheduledMinutes: number;
    availableMinutes: number;
    blockedMinutes: number;
}
interface CapacityPoint {
    time: string;
    courtsAvailable: number;
    courtsSoftBlocked: number;
    courtsHardBlocked: number;
}
interface CapacityCurve {
    day: DayId;
    points: CapacityPoint[];
}
interface Template {
    id: TemplateId;
    name: string;
    description?: string;
    operations: TemplateOperation[];
}
interface TemplateOperation {
    target: 'TOURNAMENT' | 'VENUE' | 'COURT_GROUP' | 'COURT';
    venueIds?: VenueId[];
    courtIds?: CourtId[];
    days?: DayId[];
    relativeTime?: {
        startOffsetMinutes: number;
        endOffsetMinutes: number;
    };
    absoluteTime?: TimeRange;
    blockType: BlockType;
    reason?: string;
    hardSoft?: BlockHardness;
}
interface Rule {
    id: RuleId;
    name: string;
    description?: string;
    evaluate: (ctx: EngineContext) => BlockMutation[];
}
type MutationKind = 'ADD_BLOCK' | 'UPDATE_BLOCK' | 'REMOVE_BLOCK';
interface BlockMutation {
    kind: MutationKind;
    block: Block;
    previousBlock?: Block;
}
interface MutationResult {
    applied: BlockMutation[];
    rejected: BlockMutation[];
    warnings: EngineWarning[];
    conflicts: EngineConflict[];
}
interface SimulationResult {
    previewRails: VenueDayTimeline[];
    capacityImpact?: CapacityCurve;
    conflicts: EngineConflict[];
}
type ConflictSeverity = 'INFO' | 'WARN' | 'ERROR';
interface EngineWarning {
    code: string;
    message: string;
    relatedBlocks?: BlockId[];
    relatedCourts?: CourtRef[];
}
interface EngineConflict {
    code: string;
    message: string;
    severity: ConflictSeverity;
    timeRange: TimeRange;
    courts: CourtRef[];
    relatedMatches?: string[];
}
interface EngineConfig {
    tournamentId: TournamentId;
    dayStartTime: string;
    dayEndTime: string;
    slotMinutes: number;
    granularityMinutes?: number;
    typePrecedence: BlockType[];
    conflictEvaluators?: ConflictEvaluator[];
}
interface ConflictEvaluator {
    id: string;
    description: string;
    evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
}
interface EngineContext {
    config: EngineConfig;
    tournamentRecord: any;
    blocksById: Map<BlockId, Block>;
    blocksByCourtDay: Map<string, BlockId[]>;
    templates: Map<TemplateId, Template>;
    rules: Map<RuleId, Rule>;
}
type EngineEventType = 'STATE_CHANGED' | 'BLOCKS_CHANGED' | 'CONFLICTS_CHANGED' | 'AVAILABILITY_CHANGED' | 'PLAN_CHANGED';
interface EngineEvent {
    type: EngineEventType;
    payload: any;
}
interface StateChangedEvent extends EngineEvent {
    type: 'STATE_CHANGED';
    payload: {
        reason: string;
    };
}
interface BlocksChangedEvent extends EngineEvent {
    type: 'BLOCKS_CHANGED';
    payload: {
        mutations: BlockMutation[];
    };
}
interface ConflictsChangedEvent extends EngineEvent {
    type: 'CONFLICTS_CHANGED';
    payload: {
        conflicts: EngineConflict[];
    };
}
interface ApplyBlockOptions {
    courts: CourtRef[];
    timeRange: TimeRange;
    type: BlockType;
    reason?: string;
    hardSoft?: BlockHardness;
    source?: BlockSource;
}
interface MoveBlockOptions {
    blockId: BlockId;
    newTimeRange: TimeRange;
    newCourt?: CourtRef;
}
interface ResizeBlockOptions {
    blockId: BlockId;
    newTimeRange: TimeRange;
}
interface ApplyTemplateOptions {
    templateId: TemplateId;
    scope?: {
        venues?: VenueId[];
        courts?: CourtRef[];
        days?: DayId[];
    };
}
interface CourtDayAvailability {
    startTime: string;
    endTime: string;
}
interface CourtMeta {
    ref: CourtRef;
    name: string;
    surface: string;
    indoor: boolean;
    hasLights: boolean;
    tags: string[];
    openTime?: string;
    closeTime?: string;
    closedDays?: string[];
    extendedProps?: Record<string, any>;
}
interface Edge {
    time: string;
    type: 'START' | 'END';
    blockId: BlockId;
}

declare function courtDayKey(court: CourtRef, day: string): string;
declare function courtKey(court: CourtRef): string;
declare function venueKey(tournamentId: string, venueId: string): string;
declare function venueDayKey(tournamentId: string, venueId: string, day: string): string;
declare function resolveVenueId(venue: {
    venueId?: string;
    venueName?: string;
}): string;
declare function resolveCourtId(court: {
    courtId?: string;
    courtName?: string;
}): string;
declare function clampToDayRange(block: Block, dayRange: TimeRange): Block | null;
declare function rangesOverlap(a: TimeRange, b: TimeRange): boolean;
declare function overlappingRange(a: TimeRange, b: TimeRange): TimeRange;
declare function diffMinutes(start: string, end: string): number;
declare function resolveStatus(contributingIds: BlockId[], blocksById: Map<BlockId, Block>, precedence: BlockType[]): BlockType;
declare function buildEdges(blocks: Block[]): Edge[];
declare function sortEdges(edges: Edge[]): Edge[];
declare function deriveRailSegments(blocks: Block[], dayRange: TimeRange, config: EngineConfig): RailSegment[];
declare function mergeAdjacentSegments(segments: RailSegment[]): RailSegment[];
declare function extractDay(isoDateTime: string): string;
declare function buildDayRange(day: string, config: EngineConfig): TimeRange;
declare function validateSegments(segments: RailSegment[]): boolean;

declare function generateCapacityCurve(day: DayId, timelines: VenueDayTimeline[]): CapacityCurve;
interface CapacityStats {
    peakAvailable: number;
    peakTime: string;
    minAvailable: number;
    minTime: string;
    avgAvailable: number;
    totalCourtHours: number;
    utilizationPercent: number;
    peakUnavailable?: number;
    peakUnavailableTime?: string;
    totalCourts?: number;
    totalAvailableHours?: number;
    totalUnavailableHours?: number;
    availablePercent?: number;
    avgBlockedHoursPerCourt?: number;
}
declare function calculateCapacityStats(curve: CapacityCurve): CapacityStats;
declare function filterCapacityCurve(curve: CapacityCurve, timeRange: {
    start: string;
    end: string;
}): CapacityCurve;
declare function sampleCapacityCurve(curve: CapacityCurve, intervalMinutes: number): CapacityCurve;
interface CapacityDiff {
    time: string;
    availableDelta: number;
    softBlockedDelta: number;
    hardBlockedDelta: number;
}
declare function compareCapacityCurves(baseline: CapacityCurve, modified: CapacityCurve): CapacityDiff[];

declare function intervalsOverlap(a: TimeRange, b: TimeRange): boolean;
declare function timeInsideBlock(time: number, block: Block): boolean;
declare function findBlocksContainingTime(time: number, blocks: Block[]): Block[];
declare function clampDragToCollisions(anchorTime: number, cursorTime: number, blocks: Block[]): {
    start: number;
    end: number;
    clamped: boolean;
    clampedBy?: Block;
    direction: 'forward' | 'backward';
};
declare function sortBlocksByStart(blocks: Block[]): void;

declare const courtOverlapEvaluator: {
    id: string;
    description: string;
    evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const matchWindowEvaluator: {
    id: string;
    description: string;
    evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const adjacentBlockEvaluator: {
    id: string;
    description: string;
    evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const lightingEvaluator: {
    id: string;
    description: string;
    evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const blockDurationEvaluator: {
    id: string;
    description: string;
    evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const dayBoundaryEvaluator: {
    id: string;
    description: string;
    evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const maintenanceWindowEvaluator: {
    id: string;
    description: string;
    evaluate: (_ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
};
declare const defaultEvaluators: {
    id: string;
    description: string;
    evaluate: (ctx: EngineContext, mutations: BlockMutation[]) => EngineConflict[];
}[];
declare class EvaluatorRegistry {
    private readonly evaluators;
    register(evaluator: any): void;
    unregister(evaluatorId: string): void;
    get(evaluatorId: string): any;
    getAll(): any[];
    clear(): void;
}
declare const createFollowByEvaluator: (_factoryAPI: any) => {
    id: string;
    description: string;
    evaluate: (_ctx: EngineContext, _mutations: BlockMutation[]) => EngineConflict[];
};
declare function groupConflictsBySeverity(conflicts: EngineConflict[]): {
    errors: EngineConflict[];
    warnings: EngineConflict[];
    info: EngineConflict[];
};
declare function getHighestSeverity(conflicts: EngineConflict[]): 'ERROR' | 'WARN' | 'INFO' | null;
declare function formatConflicts(conflicts: EngineConflict[]): string[];

declare function hhmmToMinutes(hhmm: string): number;
declare function minutesToHhmm(minutes: number): string;
declare function snapToGranularity(minutes: number, granularity: number, mode?: 'floor' | 'ceil' | 'round'): number;
declare function snapIsoToGranularity(iso: string, granularity: number, mode?: 'floor' | 'ceil' | 'round'): string;
declare function iterateDayTicks(startHhmm: string, endHhmm: string, granularity: number): Generator<string, void, undefined>;

interface PlanItem {
    planItemId: string;
    day: DayId;
    venueId: VenueId;
    eventId: string;
    drawId?: string;
    structureId?: string;
    roundNumber: number;
    roundSegment?: {
        segmentNumber: number;
        segmentsCount: number;
    };
    matchUpType?: string;
    notBeforeTime?: string;
    estimatedDurationMinutes?: number;
}
interface DayPlan {
    day: DayId;
    items: PlanItem[];
}
declare function computePlanItemId(item: Pick<PlanItem, 'day' | 'venueId' | 'eventId' | 'drawId' | 'roundNumber'>): string;

declare class AvailabilityEngine {
    private config;
    private tournamentRecord;
    private blocksById;
    private blocksByCourtDay;
    private courtDayAvailability;
    private venueDayAvailability;
    private templates;
    private rules;
    private plans;
    private readonly subscribers;
    private resolvedGranularity;
    private nextBlockId;
    init(tournamentRecord: any, config?: Partial<EngineConfig>): void;
    updateTournamentRecord(tournamentRecord: any): void;
    getConfig(): EngineConfig;
    getResolvedGranularityMinutes(): number;
    getCourtAvailability(court: CourtRef, day: DayId): CourtDayAvailability;
    setCourtAvailability(court: CourtRef, day: DayId, avail: CourtDayAvailability): void;
    setCourtAvailabilityAllDays(court: CourtRef, avail: CourtDayAvailability): void;
    setAllCourtsDefaultAvailability(avail: CourtDayAvailability): void;
    clearCourtAvailabilityForVenue(tournamentId: TournamentId, venueId: VenueId): void;
    getCourtAvailabilityKeys(court: CourtRef): string[];
    getVenueAvailability(tournamentId: TournamentId, venueId: VenueId, day?: DayId): CourtDayAvailability | null;
    setVenueDefaultAvailability(tournamentId: TournamentId, venueId: VenueId, avail: CourtDayAvailability): void;
    setVenueDayAvailability(tournamentId: TournamentId, venueId: VenueId, day: DayId, avail: CourtDayAvailability): void;
    getVisibleTimeRange(day: DayId, courtRefs?: CourtRef[]): {
        startTime: string;
        endTime: string;
    };
    getTournamentDays(): DayId[];
    getActiveDays(): DayId[];
    getDayTimeline(day: DayId): VenueDayTimeline[];
    getVenueTimeline(day: DayId, venueId: VenueId): VenueDayTimeline | null;
    getCourtRail(day: DayId, court: CourtRef): CourtRail | null;
    getCourtSchedulingSummary(court: CourtRef): CourtSchedulingSummary;
    getCapacityCurve(day: DayId): CapacityCurve;
    getDayBlocks(day: DayId): Block[];
    getAllBlocks(): Block[];
    getTemplates(): Template[];
    getTemplate(templateId: TemplateId): Template | null;
    getRules(): Rule[];
    getRule(ruleId: RuleId): Rule | null;
    addPlanItem(item: Omit<PlanItem, 'planItemId'>): PlanItem;
    removePlanItem(planItemId: string): boolean;
    updatePlanItem(planItemId: string, updates: Partial<Pick<PlanItem, 'notBeforeTime' | 'estimatedDurationMinutes' | 'matchUpType' | 'roundSegment'>>): PlanItem | null;
    movePlanItem(planItemId: string, newDay: DayId): PlanItem | null;
    getDayPlan(day: DayId): DayPlan | null;
    getAllPlans(): DayPlan[];
    applyBlock(opts: ApplyBlockOptions): MutationResult;
    moveBlock(opts: MoveBlockOptions): MutationResult;
    resizeBlock(opts: ResizeBlockOptions): MutationResult;
    removeBlock(blockId: BlockId): MutationResult;
    applyTemplate(opts: ApplyTemplateOptions): MutationResult;
    importScheduledMatchUps(matchUps: Array<{
        matchUpId: string;
        courtId: string;
        venueId: string;
        date: string;
        startTime: string;
        durationMinutes: number;
    }>): MutationResult;
    private timeToMinutes;
    simulateBlocks(mutations: BlockMutation[], day?: DayId): SimulationResult;
    subscribe(listener: (event: EngineEvent) => void): () => void;
    private emit;
    private applyMutations;
    private applyMutation;
    private indexBlock;
    private unindexBlock;
    private evaluateConflicts;
    private createContext;
    private createSnapshot;
    private static readonly BOOKING_TYPE_MAP;
    private loadBlocksFromTournamentRecord;
    private loadVenueAvailability;
    private loadCourtAvailability;
    private createBlockFromBooking;
    private getAllCourtsFromTournamentRecord;
    private getFirstAvailableDay;
    private generateBlockId;
    private clampToAvailability;
    listCourtMeta(): CourtMeta[];
    private getCourtMeta;
}

type ValidationPhase = 'PRECHECK' | 'INTEGRITY' | 'ORDERING' | 'CAPACITY';
type ValidationSeverity = 'ERROR' | 'WARN' | 'INFO';
interface FixAction {
    type: string;
    description: string;
    payload?: any;
}
interface RuleResult {
    ruleId: string;
    phase: ValidationPhase;
    severity: ValidationSeverity;
    message: string;
    context?: {
        day?: string;
        venueId?: string;
        planItemId?: string;
    };
    fixAction?: FixAction;
}
type IssueIndex = Map<string, RuleResult[]>;
interface ValidationPipelineResult {
    results: RuleResult[];
    issueIndex: IssueIndex;
}
interface ValidationPipelineParams {
    engine: AvailabilityEngine;
    day?: DayId;
    phases?: ValidationPhase[];
}
declare function runValidationPipeline(params: ValidationPipelineParams): ValidationPipelineResult;

interface TodsDateAvailability {
    date: string;
    startTime: string;
    endTime: string;
    venueId: string;
    courtIds?: string[];
}
interface TodsVenue {
    venueId?: string;
    venueName?: string;
    defaultStartTime?: string;
    defaultEndTime?: string;
    courts?: TodsCourt[];
    dateAvailability?: TodsDateAvailability[];
}
interface TodsCourt {
    courtId?: string;
    courtName?: string;
    surfaceType?: string;
    surfaceCategory?: string;
    courtDimensions?: string;
    indoor?: boolean;
    onlineResources?: any[];
}
interface SchedulingProfileRound {
    eventId: string;
    drawId?: string;
    roundNumber?: number;
    roundSegment?: string;
    matchUpType?: string;
}
interface SchedulingProfileItem {
    scheduleDate: string;
    venueIds: string[];
    rounds?: SchedulingProfileRound[];
}
type SchedulingProfile = SchedulingProfileItem[];
interface SchedulingSelection {
    scheduleDate: string;
    venueIds: string[];
    rounds: SchedulingProfileRound[];
}
interface BridgeConfig {
    courtToCourtId?: (courtRef: CourtRef) => string;
    isSchedulableStatus?: (status: BlockType) => boolean;
    aggregateByVenue?: boolean;
}
declare function railsToDateAvailability(timelines: VenueDayTimeline[], config?: BridgeConfig): TodsDateAvailability[];
declare function applyAvailabilityToTournamentRecord(params: {
    tournamentRecord: any;
    timelines: VenueDayTimeline[];
    config?: BridgeConfig;
    engine?: AvailabilityEngine;
}): any;
declare function buildSchedulingProfileFromUISelections(selections: SchedulingSelection[]): SchedulingProfile;
declare function todsAvailabilityToBlocks(params: {
    venue: TodsVenue;
    tournamentId: string;
    blockType?: BlockType;
}): Array<{
    court: CourtRef;
    start: string;
    end: string;
    type: BlockType;
}>;
declare function validateSchedulingProfileFormat(profile: SchedulingProfile): {
    valid: boolean;
    errors: string[];
};
declare function validateDateAvailability(entries: TodsDateAvailability[]): {
    valid: boolean;
    errors: string[];
};
declare function mergeOverlappingAvailability(entries: TodsDateAvailability[]): TodsDateAvailability[];
declare function calculateCourtHours(entries: TodsDateAvailability[]): number;

type index$8_ApplyBlockOptions = ApplyBlockOptions;
type index$8_ApplyTemplateOptions = ApplyTemplateOptions;
declare const index$8_BLOCK_TYPES: typeof BLOCK_TYPES;
type index$8_Block = Block;
type index$8_BlockHardness = BlockHardness;
type index$8_BlockId = BlockId;
type index$8_BlockMutation = BlockMutation;
type index$8_BlockSource = BlockSource;
type index$8_BlockType = BlockType;
type index$8_BlocksChangedEvent = BlocksChangedEvent;
type index$8_BridgeConfig = BridgeConfig;
type index$8_CapacityCurve = CapacityCurve;
type index$8_CapacityDiff = CapacityDiff;
type index$8_CapacityPoint = CapacityPoint;
type index$8_CapacityStats = CapacityStats;
type index$8_ConflictEvaluator = ConflictEvaluator;
type index$8_ConflictSeverity = ConflictSeverity;
type index$8_ConflictsChangedEvent = ConflictsChangedEvent;
type index$8_CourtDayAvailability = CourtDayAvailability;
type index$8_CourtId = CourtId;
type index$8_CourtMeta = CourtMeta;
type index$8_CourtRail = CourtRail;
type index$8_CourtRef = CourtRef;
type index$8_CourtSchedulingSummary = CourtSchedulingSummary;
type index$8_DayId = DayId;
type index$8_DayPlan = DayPlan;
type index$8_Edge = Edge;
type index$8_EngineConfig = EngineConfig;
type index$8_EngineConflict = EngineConflict;
type index$8_EngineContext = EngineContext;
type index$8_EngineEvent = EngineEvent;
type index$8_EngineEventType = EngineEventType;
type index$8_EngineWarning = EngineWarning;
type index$8_EvaluatorRegistry = EvaluatorRegistry;
declare const index$8_EvaluatorRegistry: typeof EvaluatorRegistry;
type index$8_FixAction = FixAction;
type index$8_IssueIndex = IssueIndex;
type index$8_MoveBlockOptions = MoveBlockOptions;
type index$8_MutationKind = MutationKind;
type index$8_MutationResult = MutationResult;
type index$8_PlanItem = PlanItem;
type index$8_RailSegment = RailSegment;
type index$8_ResizeBlockOptions = ResizeBlockOptions;
type index$8_Rule = Rule;
type index$8_RuleId = RuleId;
type index$8_RuleResult = RuleResult;
type index$8_SchedulingProfile = SchedulingProfile;
type index$8_SchedulingProfileItem = SchedulingProfileItem;
type index$8_SchedulingProfileRound = SchedulingProfileRound;
type index$8_SchedulingSelection = SchedulingSelection;
type index$8_SimulationResult = SimulationResult;
type index$8_StateChangedEvent = StateChangedEvent;
type index$8_Template = Template;
type index$8_TemplateId = TemplateId;
type index$8_TemplateOperation = TemplateOperation;
type index$8_TimeRange = TimeRange;
type index$8_TodsCourt = TodsCourt;
type index$8_TodsDateAvailability = TodsDateAvailability;
type index$8_TodsVenue = TodsVenue;
type index$8_TournamentId = TournamentId;
type index$8_ValidationPhase = ValidationPhase;
type index$8_ValidationPipelineParams = ValidationPipelineParams;
type index$8_ValidationPipelineResult = ValidationPipelineResult;
type index$8_ValidationSeverity = ValidationSeverity;
type index$8_VenueDayTimeline = VenueDayTimeline;
type index$8_VenueId = VenueId;
declare const index$8_adjacentBlockEvaluator: typeof adjacentBlockEvaluator;
declare const index$8_applyAvailabilityToTournamentRecord: typeof applyAvailabilityToTournamentRecord;
declare const index$8_blockDurationEvaluator: typeof blockDurationEvaluator;
declare const index$8_buildDayRange: typeof buildDayRange;
declare const index$8_buildEdges: typeof buildEdges;
declare const index$8_buildSchedulingProfileFromUISelections: typeof buildSchedulingProfileFromUISelections;
declare const index$8_calculateCapacityStats: typeof calculateCapacityStats;
declare const index$8_calculateCourtHours: typeof calculateCourtHours;
declare const index$8_clampDragToCollisions: typeof clampDragToCollisions;
declare const index$8_clampToDayRange: typeof clampToDayRange;
declare const index$8_compareCapacityCurves: typeof compareCapacityCurves;
declare const index$8_computePlanItemId: typeof computePlanItemId;
declare const index$8_courtDayKey: typeof courtDayKey;
declare const index$8_courtKey: typeof courtKey;
declare const index$8_courtOverlapEvaluator: typeof courtOverlapEvaluator;
declare const index$8_createFollowByEvaluator: typeof createFollowByEvaluator;
declare const index$8_dayBoundaryEvaluator: typeof dayBoundaryEvaluator;
declare const index$8_defaultEvaluators: typeof defaultEvaluators;
declare const index$8_deriveRailSegments: typeof deriveRailSegments;
declare const index$8_diffMinutes: typeof diffMinutes;
declare const index$8_extractDay: typeof extractDay;
declare const index$8_filterCapacityCurve: typeof filterCapacityCurve;
declare const index$8_findBlocksContainingTime: typeof findBlocksContainingTime;
declare const index$8_formatConflicts: typeof formatConflicts;
declare const index$8_generateCapacityCurve: typeof generateCapacityCurve;
declare const index$8_getHighestSeverity: typeof getHighestSeverity;
declare const index$8_groupConflictsBySeverity: typeof groupConflictsBySeverity;
declare const index$8_hhmmToMinutes: typeof hhmmToMinutes;
declare const index$8_intervalsOverlap: typeof intervalsOverlap;
declare const index$8_iterateDayTicks: typeof iterateDayTicks;
declare const index$8_lightingEvaluator: typeof lightingEvaluator;
declare const index$8_maintenanceWindowEvaluator: typeof maintenanceWindowEvaluator;
declare const index$8_matchWindowEvaluator: typeof matchWindowEvaluator;
declare const index$8_mergeAdjacentSegments: typeof mergeAdjacentSegments;
declare const index$8_mergeOverlappingAvailability: typeof mergeOverlappingAvailability;
declare const index$8_minutesToHhmm: typeof minutesToHhmm;
declare const index$8_overlappingRange: typeof overlappingRange;
declare const index$8_railsToDateAvailability: typeof railsToDateAvailability;
declare const index$8_rangesOverlap: typeof rangesOverlap;
declare const index$8_resolveCourtId: typeof resolveCourtId;
declare const index$8_resolveStatus: typeof resolveStatus;
declare const index$8_resolveVenueId: typeof resolveVenueId;
declare const index$8_runValidationPipeline: typeof runValidationPipeline;
declare const index$8_sampleCapacityCurve: typeof sampleCapacityCurve;
declare const index$8_snapIsoToGranularity: typeof snapIsoToGranularity;
declare const index$8_snapToGranularity: typeof snapToGranularity;
declare const index$8_sortBlocksByStart: typeof sortBlocksByStart;
declare const index$8_sortEdges: typeof sortEdges;
declare const index$8_timeInsideBlock: typeof timeInsideBlock;
declare const index$8_todsAvailabilityToBlocks: typeof todsAvailabilityToBlocks;
declare const index$8_validateDateAvailability: typeof validateDateAvailability;
declare const index$8_validateSchedulingProfileFormat: typeof validateSchedulingProfileFormat;
declare const index$8_validateSegments: typeof validateSegments;
declare const index$8_venueDayKey: typeof venueDayKey;
declare const index$8_venueKey: typeof venueKey;
declare namespace index$8 {
  export { index$8_BLOCK_TYPES as BLOCK_TYPES, index$8_EvaluatorRegistry as EvaluatorRegistry, index$8_adjacentBlockEvaluator as adjacentBlockEvaluator, index$8_applyAvailabilityToTournamentRecord as applyAvailabilityToTournamentRecord, index$8_blockDurationEvaluator as blockDurationEvaluator, index$8_buildDayRange as buildDayRange, index$8_buildEdges as buildEdges, index$8_buildSchedulingProfileFromUISelections as buildSchedulingProfileFromUISelections, index$8_calculateCapacityStats as calculateCapacityStats, index$8_calculateCourtHours as calculateCourtHours, index$8_clampDragToCollisions as clampDragToCollisions, index$8_clampToDayRange as clampToDayRange, index$8_compareCapacityCurves as compareCapacityCurves, index$8_computePlanItemId as computePlanItemId, index$8_courtDayKey as courtDayKey, index$8_courtKey as courtKey, index$8_courtOverlapEvaluator as courtOverlapEvaluator, index$8_createFollowByEvaluator as createFollowByEvaluator, index$8_dayBoundaryEvaluator as dayBoundaryEvaluator, index$8_defaultEvaluators as defaultEvaluators, index$8_deriveRailSegments as deriveRailSegments, index$8_diffMinutes as diffMinutes, index$8_extractDay as extractDay, index$8_filterCapacityCurve as filterCapacityCurve, index$8_findBlocksContainingTime as findBlocksContainingTime, index$8_formatConflicts as formatConflicts, index$8_generateCapacityCurve as generateCapacityCurve, index$8_getHighestSeverity as getHighestSeverity, index$8_groupConflictsBySeverity as groupConflictsBySeverity, index$8_hhmmToMinutes as hhmmToMinutes, index$8_intervalsOverlap as intervalsOverlap, index$8_iterateDayTicks as iterateDayTicks, index$8_lightingEvaluator as lightingEvaluator, index$8_maintenanceWindowEvaluator as maintenanceWindowEvaluator, index$8_matchWindowEvaluator as matchWindowEvaluator, index$8_mergeAdjacentSegments as mergeAdjacentSegments, index$8_mergeOverlappingAvailability as mergeOverlappingAvailability, index$8_minutesToHhmm as minutesToHhmm, index$8_overlappingRange as overlappingRange, index$8_railsToDateAvailability as railsToDateAvailability, index$8_rangesOverlap as rangesOverlap, index$8_resolveCourtId as resolveCourtId, index$8_resolveStatus as resolveStatus, index$8_resolveVenueId as resolveVenueId, index$8_runValidationPipeline as runValidationPipeline, index$8_sampleCapacityCurve as sampleCapacityCurve, index$8_snapIsoToGranularity as snapIsoToGranularity, index$8_snapToGranularity as snapToGranularity, index$8_sortBlocksByStart as sortBlocksByStart, index$8_sortEdges as sortEdges, index$8_timeInsideBlock as timeInsideBlock, index$8_todsAvailabilityToBlocks as todsAvailabilityToBlocks, index$8_validateDateAvailability as validateDateAvailability, index$8_validateSchedulingProfileFormat as validateSchedulingProfileFormat, index$8_validateSegments as validateSegments, index$8_venueDayKey as venueDayKey, index$8_venueKey as venueKey };
  export type { index$8_ApplyBlockOptions as ApplyBlockOptions, index$8_ApplyTemplateOptions as ApplyTemplateOptions, index$8_Block as Block, index$8_BlockHardness as BlockHardness, index$8_BlockId as BlockId, index$8_BlockMutation as BlockMutation, index$8_BlockSource as BlockSource, index$8_BlockType as BlockType, index$8_BlocksChangedEvent as BlocksChangedEvent, index$8_BridgeConfig as BridgeConfig, index$8_CapacityCurve as CapacityCurve, index$8_CapacityDiff as CapacityDiff, index$8_CapacityPoint as CapacityPoint, index$8_CapacityStats as CapacityStats, index$8_ConflictEvaluator as ConflictEvaluator, index$8_ConflictSeverity as ConflictSeverity, index$8_ConflictsChangedEvent as ConflictsChangedEvent, index$8_CourtDayAvailability as CourtDayAvailability, index$8_CourtId as CourtId, index$8_CourtMeta as CourtMeta, index$8_CourtRail as CourtRail, index$8_CourtRef as CourtRef, index$8_CourtSchedulingSummary as CourtSchedulingSummary, index$8_DayId as DayId, index$8_DayPlan as DayPlan, index$8_Edge as Edge, index$8_EngineConfig as EngineConfig, index$8_EngineConflict as EngineConflict, index$8_EngineContext as EngineContext, index$8_EngineEvent as EngineEvent, index$8_EngineEventType as EngineEventType, index$8_EngineWarning as EngineWarning, index$8_FixAction as FixAction, index$8_IssueIndex as IssueIndex, index$8_MoveBlockOptions as MoveBlockOptions, index$8_MutationKind as MutationKind, index$8_MutationResult as MutationResult, index$8_PlanItem as PlanItem, index$8_RailSegment as RailSegment, index$8_ResizeBlockOptions as ResizeBlockOptions, index$8_Rule as Rule, index$8_RuleId as RuleId, index$8_RuleResult as RuleResult, index$8_SchedulingProfile as SchedulingProfile, index$8_SchedulingProfileItem as SchedulingProfileItem, index$8_SchedulingProfileRound as SchedulingProfileRound, index$8_SchedulingSelection as SchedulingSelection, index$8_SimulationResult as SimulationResult, index$8_StateChangedEvent as StateChangedEvent, index$8_Template as Template, index$8_TemplateId as TemplateId, index$8_TemplateOperation as TemplateOperation, index$8_TimeRange as TimeRange, index$8_TodsCourt as TodsCourt, index$8_TodsDateAvailability as TodsDateAvailability, index$8_TodsVenue as TodsVenue, index$8_TournamentId as TournamentId, index$8_ValidationPhase as ValidationPhase, index$8_ValidationPipelineParams as ValidationPipelineParams, index$8_ValidationPipelineResult as ValidationPipelineResult, index$8_ValidationSeverity as ValidationSeverity, index$8_VenueDayTimeline as VenueDayTimeline, index$8_VenueId as VenueId };
}

declare const mutate$2_addCertification: typeof addCertification;
declare const mutate$2_addCertificationRequirement: typeof addCertificationRequirement;
declare const mutate$2_addEvaluation: typeof addEvaluation;
declare const mutate$2_addEvaluationPolicy: typeof addEvaluationPolicy;
declare const mutate$2_addSuspension: typeof addSuspension;
declare const mutate$2_assignOfficial: typeof assignOfficial;
declare const mutate$2_createOfficialRecord: typeof createOfficialRecord;
declare const mutate$2_modifyCertification: typeof modifyCertification;
declare const mutate$2_modifyEvaluation: typeof modifyEvaluation;
declare const mutate$2_removeCertification: typeof removeCertification;
declare const mutate$2_removeEvaluation: typeof removeEvaluation;
declare const mutate$2_removeOfficialAssignment: typeof removeOfficialAssignment;
declare const mutate$2_removeSuspension: typeof removeSuspension;
declare const mutate$2_transitionAssignmentStatus: typeof transitionAssignmentStatus;
declare const mutate$2_transitionCertificationStatus: typeof transitionCertificationStatus;
declare const mutate$2_transitionEvaluationStatus: typeof transitionEvaluationStatus;
declare namespace mutate$2 {
  export {
    mutate$2_addCertification as addCertification,
    mutate$2_addCertificationRequirement as addCertificationRequirement,
    mutate$2_addEvaluation as addEvaluation,
    mutate$2_addEvaluationPolicy as addEvaluationPolicy,
    mutate$2_addSuspension as addSuspension,
    mutate$2_assignOfficial as assignOfficial,
    mutate$2_createOfficialRecord as createOfficialRecord,
    mutate$2_modifyCertification as modifyCertification,
    mutate$2_modifyEvaluation as modifyEvaluation,
    mutate$2_removeCertification as removeCertification,
    mutate$2_removeEvaluation as removeEvaluation,
    mutate$2_removeOfficialAssignment as removeOfficialAssignment,
    mutate$2_removeSuspension as removeSuspension,
    mutate$2_transitionAssignmentStatus as transitionAssignmentStatus,
    mutate$2_transitionCertificationStatus as transitionCertificationStatus,
    mutate$2_transitionEvaluationStatus as transitionEvaluationStatus,
  };
}

declare const query$1_getEvaluationSummary: typeof getEvaluationSummary;
declare const query$1_getEvaluationTemplate: typeof getEvaluationTemplate;
declare const query$1_getEvaluations: typeof getEvaluations;
declare const query$1_getOfficialAssignments: typeof getOfficialAssignments;
declare const query$1_getOfficialCertifications: typeof getOfficialCertifications;
declare const query$1_getOfficialEligibility: typeof getOfficialEligibility;
declare const query$1_queryOfficialRecord: typeof queryOfficialRecord;
declare const query$1_validateCertification: typeof validateCertification;
declare const query$1_validateOfficiatingStatusTransition: typeof validateOfficiatingStatusTransition;
declare namespace query$1 {
  export {
    query$1_getEvaluationSummary as getEvaluationSummary,
    query$1_getEvaluationTemplate as getEvaluationTemplate,
    query$1_getEvaluations as getEvaluations,
    query$1_getOfficialAssignments as getOfficialAssignments,
    query$1_getOfficialCertifications as getOfficialCertifications,
    query$1_getOfficialEligibility as getOfficialEligibility,
    query$1_queryOfficialRecord as queryOfficialRecord,
    query$1_validateCertification as validateCertification,
    query$1_validateOfficiatingStatusTransition as validateOfficiatingStatusTransition,
  };
}

declare const index$7_addCertification: typeof addCertification;
declare const index$7_addCertificationRequirement: typeof addCertificationRequirement;
declare const index$7_addEvaluation: typeof addEvaluation;
declare const index$7_addEvaluationPolicy: typeof addEvaluationPolicy;
declare const index$7_addSuspension: typeof addSuspension;
declare const index$7_assignOfficial: typeof assignOfficial;
declare const index$7_createOfficialRecord: typeof createOfficialRecord;
declare const index$7_getEvaluationSummary: typeof getEvaluationSummary;
declare const index$7_getEvaluationTemplate: typeof getEvaluationTemplate;
declare const index$7_getEvaluations: typeof getEvaluations;
declare const index$7_getOfficialAssignments: typeof getOfficialAssignments;
declare const index$7_getOfficialCertifications: typeof getOfficialCertifications;
declare const index$7_getOfficialEligibility: typeof getOfficialEligibility;
declare const index$7_modifyCertification: typeof modifyCertification;
declare const index$7_modifyEvaluation: typeof modifyEvaluation;
declare const index$7_queryOfficialRecord: typeof queryOfficialRecord;
declare const index$7_removeCertification: typeof removeCertification;
declare const index$7_removeEvaluation: typeof removeEvaluation;
declare const index$7_removeOfficialAssignment: typeof removeOfficialAssignment;
declare const index$7_removeSuspension: typeof removeSuspension;
declare const index$7_transitionAssignmentStatus: typeof transitionAssignmentStatus;
declare const index$7_transitionCertificationStatus: typeof transitionCertificationStatus;
declare const index$7_transitionEvaluationStatus: typeof transitionEvaluationStatus;
declare const index$7_validateCertification: typeof validateCertification;
declare const index$7_validateOfficiatingStatusTransition: typeof validateOfficiatingStatusTransition;
declare namespace index$7 {
  export {
    index$7_addCertification as addCertification,
    index$7_addCertificationRequirement as addCertificationRequirement,
    index$7_addEvaluation as addEvaluation,
    index$7_addEvaluationPolicy as addEvaluationPolicy,
    index$7_addSuspension as addSuspension,
    index$7_assignOfficial as assignOfficial,
    index$7_createOfficialRecord as createOfficialRecord,
    index$7_getEvaluationSummary as getEvaluationSummary,
    index$7_getEvaluationTemplate as getEvaluationTemplate,
    index$7_getEvaluations as getEvaluations,
    index$7_getOfficialAssignments as getOfficialAssignments,
    index$7_getOfficialCertifications as getOfficialCertifications,
    index$7_getOfficialEligibility as getOfficialEligibility,
    index$7_modifyCertification as modifyCertification,
    index$7_modifyEvaluation as modifyEvaluation,
    mutate$2 as mutate,
    query$1 as query,
    index$7_queryOfficialRecord as queryOfficialRecord,
    index$7_removeCertification as removeCertification,
    index$7_removeEvaluation as removeEvaluation,
    index$7_removeOfficialAssignment as removeOfficialAssignment,
    index$7_removeSuspension as removeSuspension,
    index$7_transitionAssignmentStatus as transitionAssignmentStatus,
    index$7_transitionCertificationStatus as transitionCertificationStatus,
    index$7_transitionEvaluationStatus as transitionEvaluationStatus,
    index$7_validateCertification as validateCertification,
    index$7_validateOfficiatingStatusTransition as validateOfficiatingStatusTransition,
  };
}

declare const mutate$1_addPracticeRegistration: typeof addPracticeRegistration;
declare const mutate$1_removePracticeRegistration: typeof removePracticeRegistration;
declare const mutate$1_setPracticeDefaultCapacity: typeof setPracticeDefaultCapacity;
declare const mutate$1_updatePracticeRegistration: typeof updatePracticeRegistration;
declare namespace mutate$1 {
  export {
    mutate$1_addPracticeRegistration as addPracticeRegistration,
    mutate$1_removePracticeRegistration as removePracticeRegistration,
    mutate$1_setPracticeDefaultCapacity as setPracticeDefaultCapacity,
    mutate$1_updatePracticeRegistration as updatePracticeRegistration,
  };
}

declare const query_getPracticeRegistrations: typeof getPracticeRegistrations;
declare namespace query {
  export {
    query_getPracticeRegistrations as getPracticeRegistrations,
  };
}

declare const index$6_addPracticeRegistration: typeof addPracticeRegistration;
declare const index$6_getPracticeRegistrations: typeof getPracticeRegistrations;
declare const index$6_query: typeof query;
declare const index$6_removePracticeRegistration: typeof removePracticeRegistration;
declare const index$6_setPracticeDefaultCapacity: typeof setPracticeDefaultCapacity;
declare const index$6_updatePracticeRegistration: typeof updatePracticeRegistration;
declare namespace index$6 {
  export {
    index$6_addPracticeRegistration as addPracticeRegistration,
    index$6_getPracticeRegistrations as getPracticeRegistrations,
    mutate$1 as mutate,
    index$6_query as query,
    index$6_removePracticeRegistration as removePracticeRegistration,
    index$6_setPracticeDefaultCapacity as setPracticeDefaultCapacity,
    index$6_updatePracticeRegistration as updatePracticeRegistration,
  };
}

declare const generate_generateCourts: typeof generateCourts;
declare namespace generate {
  export {
    generate_generateCourts as generateCourts,
  };
}

declare const mutate_addCourt: typeof addCourt;
declare const mutate_addCourts: typeof addCourts;
declare const mutate_addVenue: typeof addVenue;
declare const mutate_deleteCourt: typeof deleteCourt;
declare const mutate_deleteCourts: typeof deleteCourts;
declare const mutate_deleteVenue: typeof deleteVenue;
declare const mutate_deleteVenues: typeof deleteVenues;
declare const mutate_disableCourts: typeof disableCourts;
declare const mutate_disableVenues: typeof disableVenues;
declare const mutate_enableCourts: typeof enableCourts;
declare const mutate_enableVenues: typeof enableVenues;
declare const mutate_modifyCourt: typeof modifyCourt;
declare const mutate_modifyCourtAvailability: typeof modifyCourtAvailability;
declare const mutate_modifyVenue: typeof modifyVenue;
declare namespace mutate {
  export {
    mutate_addCourt as addCourt,
    mutate_addCourts as addCourts,
    mutate_addVenue as addVenue,
    mutate_deleteCourt as deleteCourt,
    mutate_deleteCourts as deleteCourts,
    mutate_deleteVenue as deleteVenue,
    mutate_deleteVenues as deleteVenues,
    mutate_disableCourts as disableCourts,
    mutate_disableVenues as disableVenues,
    mutate_enableCourts as enableCourts,
    mutate_enableVenues as enableVenues,
    mutate_modifyCourt as modifyCourt,
    mutate_modifyCourtAvailability as modifyCourtAvailability,
    mutate_modifyVenue as modifyVenue,
  };
}

declare const index$5_addCourt: typeof addCourt;
declare const index$5_addCourts: typeof addCourts;
declare const index$5_addVenue: typeof addVenue;
declare const index$5_deleteCourt: typeof deleteCourt;
declare const index$5_deleteCourts: typeof deleteCourts;
declare const index$5_deleteVenue: typeof deleteVenue;
declare const index$5_deleteVenues: typeof deleteVenues;
declare const index$5_disableCourts: typeof disableCourts;
declare const index$5_disableVenues: typeof disableVenues;
declare const index$5_enableCourts: typeof enableCourts;
declare const index$5_enableVenues: typeof enableVenues;
declare const index$5_generate: typeof generate;
declare const index$5_generateCourts: typeof generateCourts;
declare const index$5_getCompetitionVenues: typeof getCompetitionVenues;
declare const index$5_getCourts: typeof getCourts;
declare const index$5_getVenuesAndCourts: typeof getVenuesAndCourts;
declare const index$5_modifyCourt: typeof modifyCourt;
declare const index$5_modifyCourtAvailability: typeof modifyCourtAvailability;
declare const index$5_modifyVenue: typeof modifyVenue;
declare const index$5_mutate: typeof mutate;
declare const index$5_publicFindVenue: typeof publicFindVenue;
declare namespace index$5 {
  export {
    index$5_addCourt as addCourt,
    index$5_addCourts as addCourts,
    index$5_addVenue as addVenue,
    index$5_deleteCourt as deleteCourt,
    index$5_deleteCourts as deleteCourts,
    index$5_deleteVenue as deleteVenue,
    index$5_deleteVenues as deleteVenues,
    index$5_disableCourts as disableCourts,
    index$5_disableVenues as disableVenues,
    index$5_enableCourts as enableCourts,
    index$5_enableVenues as enableVenues,
    index$5_generate as generate,
    index$5_generateCourts as generateCourts,
    index$5_getCompetitionVenues as getCompetitionVenues,
    index$5_getCourts as getCourts,
    index$5_getVenuesAndCourts as getVenuesAndCourts,
    index$5_modifyCourt as modifyCourt,
    index$5_modifyCourtAvailability as modifyCourtAvailability,
    index$5_modifyVenue as modifyVenue,
    index$5_mutate as mutate,
    index$5_publicFindVenue as publicFindVenue,
    query$4 as query,
  };
}

declare namespace index$4 {
  export {
    index$8 as availabilityGovernor,
    index$q as competitionGovernor,
    index$p as drawsGovernor,
    index$o as entriesGovernor,
    index$n as eventGovernor,
    index$m as generationGovernor,
    index$l as matchUpFormatGovernor,
    index$k as matchUpGovernor,
    index$j as mocksGovernor,
    index$7 as officiatingGovernor,
    index$i as participantGovernor,
    index$h as policyGovernor,
    index$6 as practiceGovernor,
    index$g as publishingGovernor,
    index$f as queryGovernor,
    index$e as rankingGovernor,
    index$d as reportGovernor,
    index$c as scheduleGovernor,
    index$b as scoreGovernor,
    index$a as tieFormatGovernor,
    index$9 as tournamentGovernor,
    index$5 as venueGovernor,
  };
}

declare function isPowerOf2(n?: any): boolean;
declare function nearestPowerOf2(val: any): number;
declare function isNumeric(value: any): boolean;
declare function isOdd(num: any): boolean | undefined;
declare function nextPowerOf2(n?: any): any;
declare function isConvertableInteger(n: any): boolean;

declare function visualizeScheduledMatchUps({ scheduledMatchUps, showGlobalLog }: {
    scheduledMatchUps: any;
    showGlobalLog: any;
}): void;

declare function createMap(objectArray: any, attribute: any): any;
declare const hasAttributeValues: (a: any) => (o: any) => boolean;
declare function undefinedToNull(obj: object, shallow?: boolean): any;
declare function generateHashCode(o: any): string | undefined;

declare function getIsoDateString(schedule: any): string | undefined;
declare function validTimeValue(value: any): boolean;
declare function DateHHMM(date: any): string;
declare function timeUTC(date?: any): number;
declare function formatDate(date?: any, separator?: string, format?: string): string;
declare function offsetDate(date: any): Date;
declare function offsetTime(date?: any): number;
declare function isDate(dateArg: any): boolean;
declare function generateDateRange(startDt?: any, endDt?: any): string[];
declare function isISODateString(dateString: any): boolean;
declare function isValidEmbargoDate(value: unknown): boolean;
declare function isTimeString(timeString: any): boolean;
declare function timeStringMinutes(timeString?: any): number;
declare function extractTime(dateString: any): string | undefined;
declare function extractDate(dateString: any): string;
declare function convertTime(value: any, time24?: any, keepDate?: any): string | undefined;
declare function addDays(date: any, days?: number): string;
declare function addWeek(date: any): string;
declare function getDateByWeek(week: any, year: any, dateFormat: any, sunday?: boolean): string;
declare function timeToDate(timeString: any, date?: string | undefined): Date;
declare function addMinutesToTimeString(timeString?: any, minutes?: any): string;
declare function sameDay(date1: any, date2: any): boolean;
declare const dateTime: {
    addDays: typeof addDays;
    addWeek: typeof addWeek;
    addMinutesToTimeString: typeof addMinutesToTimeString;
    convertTime: typeof convertTime;
    getIsoDateString: typeof getIsoDateString;
    getUTCdateString: (date?: any) => string;
    DateHHMM: typeof DateHHMM;
    extractDate: typeof extractDate;
    extractTime: typeof extractTime;
    formatDate: typeof formatDate;
    getDateByWeek: typeof getDateByWeek;
    isISODateString: typeof isISODateString;
    isValidEmbargoDate: typeof isValidEmbargoDate;
    isDate: typeof isDate;
    isTimeString: typeof isTimeString;
    offsetDate: typeof offsetDate;
    offsetTime: typeof offsetTime;
    sameDay: typeof sameDay;
    timeStringMinutes: typeof timeStringMinutes;
    timeToDate: typeof timeToDate;
    timeUTC: typeof timeUTC;
    validTimeValue: typeof validTimeValue;
    validDateString: RegExp;
    timeValidation: RegExp;
    dateValidation: RegExp;
};

declare function matchUpChronologicalSort(a: HydratedMatchUp, b: HydratedMatchUp): number;

declare function matchUpScheduleSort(a: any, b: any): number;

declare function structureSort(a: Structure | undefined, b: Structure | undefined, config?: any): number;

declare function matchUpSort(a: HydratedMatchUp, b: HydratedMatchUp): number;

declare function dehydrateMatchUps({ tournamentRecord }: {
    tournamentRecord: any;
}): {
    success?: boolean;
    error?: ErrorType;
};

declare const extractAttributes: (accessor: any) => (element: any) => any;

declare function definedAttributes(obj: object, ignoreFalse?: boolean, ignoreEmptyArrays?: boolean, shallow?: boolean): any;

declare function attributeFilter(params?: any): any;

declare function JSON2CSV(arrayOfJSON?: any, config?: any): any;
declare function flattenJSON(obj: any, keyJoiner?: string, path?: string[]): any;

declare function generateTimeCode(index?: number): string;

declare function makeDeepCopy(sourceObject: any, convertExtensions?: any, internalUse?: any, removeExtensions?: any, iteration?: number): any;

declare function constantToString(str: any): any;

declare function numericSort(a: any, b: any): number;

declare function UUIDS(count?: number, pre?: any, random?: () => number): string[];
declare function UUID(pre?: any, random?: () => number): string;

declare function isValidIANATimeZone(timeZone: string): boolean;
declare function getTimeZoneOffsetMinutes(timeZone: string, date?: Date): number;
declare function wallClockToUTC(date: string, time: string, timeZone: string): string | {
    error: typeof INVALID_TIME_ZONE;
};
declare function utcToWallClock(utcIso: string, timeZone: string): {
    date: string;
    time: string;
} | {
    error: typeof INVALID_TIME_ZONE;
};
declare function toEmbargoUTC(date: string, time: string, timeZone: string): string | {
    error: typeof INVALID_TIME_ZONE;
};
declare const timeZone: {
    isValidIANATimeZone: typeof isValidIANATimeZone;
    getTimeZoneOffsetMinutes: typeof getTimeZoneOffsetMinutes;
    wallClockToUTC: typeof wallClockToUTC;
    utcToWallClock: typeof utcToWallClock;
    toEmbargoUTC: typeof toEmbargoUTC;
};

declare function unique(arr: any): any[];
declare function noNulls(arr: any): any;
declare function shuffleArray(arr: any, random?: () => number): any[];
declare function instanceCount(values: any): {
    [key: number | string]: number;
};
declare function countValues(values: any): {
    [key: number]: string[];
};
declare function groupValues(obj: any): {};
declare function randomPop(array: any, random?: () => number): any;
declare function randomMember(arr: any, random?: () => number): any;
declare function generateRange(start: any, end: any): any[];
declare function intersection(a: any, b: any): any[];
declare function overlap(a: any, b: any): boolean;
declare function occurrences(val: any, arr: any): any;
declare function subSort(arr: any, i: any, n: any, sortFx: any): never[];
declare function chunkArray(arr: any, chunksize: any): any;
declare function chunkSizeProfile(arr: number[], [size, ...otherSizes]: number[]): any;
declare function allNumeric(arr: any): any;
declare function noNumeric(arr: any): any;
declare function chunkByNth(arr: any[], chunksCount: number, shuttle?: boolean): any;

declare const index$3_JSON2CSV: typeof JSON2CSV;
declare const index$3_UUID: typeof UUID;
declare const index$3_UUIDS: typeof UUIDS;
declare const index$3_allNumeric: typeof allNumeric;
declare const index$3_attributeFilter: typeof attributeFilter;
declare const index$3_chunkArray: typeof chunkArray;
declare const index$3_chunkByNth: typeof chunkByNth;
declare const index$3_chunkSizeProfile: typeof chunkSizeProfile;
declare const index$3_constantToString: typeof constantToString;
declare const index$3_countValues: typeof countValues;
declare const index$3_createMap: typeof createMap;
declare const index$3_dateTime: typeof dateTime;
declare const index$3_definedAttributes: typeof definedAttributes;
declare const index$3_dehydrateMatchUps: typeof dehydrateMatchUps;
declare const index$3_extractAttributes: typeof extractAttributes;
declare const index$3_flattenJSON: typeof flattenJSON;
declare const index$3_generateDateRange: typeof generateDateRange;
declare const index$3_generateHashCode: typeof generateHashCode;
declare const index$3_generateRange: typeof generateRange;
declare const index$3_generateTimeCode: typeof generateTimeCode;
declare const index$3_groupValues: typeof groupValues;
declare const index$3_hasAttributeValues: typeof hasAttributeValues;
declare const index$3_instanceCount: typeof instanceCount;
declare const index$3_intersection: typeof intersection;
declare const index$3_isConvertableInteger: typeof isConvertableInteger;
declare const index$3_isNumeric: typeof isNumeric;
declare const index$3_isOdd: typeof isOdd;
declare const index$3_isPowerOf2: typeof isPowerOf2;
declare const index$3_isValidEmbargoDate: typeof isValidEmbargoDate;
declare const index$3_makeDeepCopy: typeof makeDeepCopy;
declare const index$3_matchUpChronologicalSort: typeof matchUpChronologicalSort;
declare const index$3_matchUpScheduleSort: typeof matchUpScheduleSort;
declare const index$3_matchUpSort: typeof matchUpSort;
declare const index$3_nearestPowerOf2: typeof nearestPowerOf2;
declare const index$3_nextPowerOf2: typeof nextPowerOf2;
declare const index$3_noNulls: typeof noNulls;
declare const index$3_noNumeric: typeof noNumeric;
declare const index$3_numericSort: typeof numericSort;
declare const index$3_occurrences: typeof occurrences;
declare const index$3_overlap: typeof overlap;
declare const index$3_randomMember: typeof randomMember;
declare const index$3_randomPop: typeof randomPop;
declare const index$3_shuffleArray: typeof shuffleArray;
declare const index$3_structureSort: typeof structureSort;
declare const index$3_subSort: typeof subSort;
declare const index$3_timeZone: typeof timeZone;
declare const index$3_undefinedToNull: typeof undefinedToNull;
declare const index$3_unique: typeof unique;
declare const index$3_visualizeScheduledMatchUps: typeof visualizeScheduledMatchUps;
declare namespace index$3 {
  export {
    index$3_JSON2CSV as JSON2CSV,
    index$3_UUID as UUID,
    index$3_UUIDS as UUIDS,
    index$3_allNumeric as allNumeric,
    index$3_attributeFilter as attributeFilter,
    index$3_chunkArray as chunkArray,
    index$3_chunkByNth as chunkByNth,
    index$3_chunkSizeProfile as chunkSizeProfile,
    index$3_constantToString as constantToString,
    index$3_countValues as countValues,
    index$3_createMap as createMap,
    index$3_dateTime as dateTime,
    index$3_definedAttributes as definedAttributes,
    index$3_dehydrateMatchUps as dehydrateMatchUps,
    index$3_extractAttributes as extractAttributes,
    index$3_flattenJSON as flattenJSON,
    index$3_generateDateRange as generateDateRange,
    index$3_generateHashCode as generateHashCode,
    index$3_generateRange as generateRange,
    index$3_generateTimeCode as generateTimeCode,
    index$3_groupValues as groupValues,
    index$3_hasAttributeValues as hasAttributeValues,
    index$3_instanceCount as instanceCount,
    index$3_intersection as intersection,
    index$3_isConvertableInteger as isConvertableInteger,
    index$3_isNumeric as isNumeric,
    index$3_isOdd as isOdd,
    index$3_isPowerOf2 as isPowerOf2,
    index$3_isValidEmbargoDate as isValidEmbargoDate,
    index$3_makeDeepCopy as makeDeepCopy,
    index$3_matchUpChronologicalSort as matchUpChronologicalSort,
    index$3_matchUpScheduleSort as matchUpScheduleSort,
    index$3_matchUpSort as matchUpSort,
    index$3_nearestPowerOf2 as nearestPowerOf2,
    index$3_nextPowerOf2 as nextPowerOf2,
    index$3_noNulls as noNulls,
    index$3_noNumeric as noNumeric,
    index$3_numericSort as numericSort,
    index$3_occurrences as occurrences,
    index$3_overlap as overlap,
    index$3_randomMember as randomMember,
    index$3_randomPop as randomPop,
    index$3_shuffleArray as shuffleArray,
    index$3_structureSort as structureSort,
    index$3_subSort as subSort,
    index$3_timeZone as timeZone,
    index$3_undefinedToNull as undefinedToNull,
    index$3_unique as unique,
    index$3_visualizeScheduledMatchUps as visualizeScheduledMatchUps,
  };
}

declare const NATIVE = "native";
declare const LEGACY = "legacy";
declare const DUAL = "dual";
type SchemaWriteMode = typeof NATIVE | typeof DUAL | typeof LEGACY;

type Notice = {
    topic: string;
    payload: any;
    key?: string;
};
type DevContextType = {
    errors?: boolean | string[];
    params?: boolean | string[];
    result?: boolean | string[];
    exclude?: string[];
    [key: string]: any;
} | boolean;
type ImplemtationGlobalStateTypes = {
    tournamentRecords: TournamentRecords;
    subscriptions: {
        [key: string]: any;
    };
    methods: {
        [key: string]: any;
    };
    disableNotifications: boolean;
    tournamentId?: string;
    notices: Notice[];
    modified: boolean;
};
declare function setStateProvider(globalStateProvider?: {
    [key: string]: any;
}): {
    success: boolean;
};
declare function createInstanceState(): {
    error: unknown;
    success?: undefined;
} | {
    success: boolean;
    error?: undefined;
};
declare function getDevContext(contextCriteria?: {
    [key: string]: any;
}): DevContextType;
declare function timeKeeper(action?: string, timer?: string): any;
declare function setGlobalLog(loggingFx?: any): void;
declare function setDevContext(value?: DevContextType): void;
declare function setSchemaWriteMode(mode?: SchemaWriteMode): {
    success?: boolean;
    error?: ErrorType;
};
declare function getSchemaWriteMode(): SchemaWriteMode;
declare function writeNativeEnabled(): boolean;
declare function writeLegacyEnabled(): boolean;
declare function setSaveDrawDeletions(flag?: boolean): {
    success?: boolean;
    error?: ErrorType;
};
declare function getSaveDrawDeletions(): boolean;
declare function setAuditAuthorityServer(flag?: boolean): {
    success?: boolean;
    error?: ErrorType;
};
declare function getAuditAuthorityServer(): boolean;
declare function disableNotifications(): void;
declare function enableNotifications(): void;
type DeepCopyAttributes = {
    threshold?: number;
    stringify?: string[];
    ignore?: string[];
    toJSON?: string[];
};
declare function setDeepCopy(value: boolean, attributes: DeepCopyAttributes): void;
declare function deepCopyEnabled(): {
    threshold?: number;
    modulate?: any;
    stringify: string[];
    ignore: any;
    toJSON: string[];
    enabled: boolean;
};
declare function setGlobalSubscriptions(params: any): {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};
declare function setSubscriptions(params: any): any;
declare function setGlobalMethods(params?: {
    [key: string]: any;
}): {
    error: {
        message: string;
        code: string;
    };
    info: string;
} | {
    error: {
        message: string;
        code: string;
    };
    info?: undefined;
} | {
    success: boolean;
    error?: undefined;
    info?: undefined;
};
declare function setMethods(params?: {
    [key: string]: any;
}): any;
declare function cycleMutationStatus(): any;
declare function addNotice(notice: Notice): any;
type GetNoticesArgs = {
    topic: string;
};
declare function getMethods(): {
    [key: string]: any;
};
declare function getNotices(params: GetNoticesArgs): any[];
declare function getPayloads(params: GetNoticesArgs): any[];
type DeleteNoticeArgs = {
    topic?: string;
    key: string;
};
declare function deleteNotice({ key, topic }: DeleteNoticeArgs): any;
declare function deleteNotices(): any;
declare function getTopics(): any;
declare function hasTopic(topic: any): any;
type CallListenerArgs = {
    payloads: any[];
    notices?: any[];
    topic: string;
};
declare function callListener(payload: any): Promise<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_getAuditAuthorityServer: typeof getAuditAuthorityServer;
declare const globalState_getDevContext: typeof getDevContext;
declare const globalState_getMethods: typeof getMethods;
declare const globalState_getNotices: typeof getNotices;
declare const globalState_getPayloads: typeof getPayloads;
declare const globalState_getProvider: typeof getProvider;
declare const globalState_getSaveDrawDeletions: typeof getSaveDrawDeletions;
declare const globalState_getSchemaWriteMode: typeof getSchemaWriteMode;
declare const globalState_getTopics: typeof getTopics;
declare const globalState_getTournamentId: typeof getTournamentId;
declare const globalState_getTournamentRecord: typeof getTournamentRecord;
declare const globalState_getTournamentRecords: typeof getTournamentRecords;
declare const globalState_globalLog: typeof globalLog;
declare const globalState_handleCaughtError: typeof handleCaughtError;
declare const globalState_hasTopic: typeof hasTopic;
declare const globalState_removeTournamentRecord: typeof removeTournamentRecord;
declare const globalState_setAuditAuthorityServer: typeof setAuditAuthorityServer;
declare const globalState_setDeepCopy: typeof setDeepCopy;
declare const globalState_setDevContext: typeof setDevContext;
declare const globalState_setGlobalLog: typeof setGlobalLog;
declare const globalState_setGlobalMethods: typeof setGlobalMethods;
declare const globalState_setGlobalSubscriptions: typeof setGlobalSubscriptions;
declare const globalState_setMethods: typeof setMethods;
declare const globalState_setSaveDrawDeletions: typeof setSaveDrawDeletions;
declare const globalState_setSchemaWriteMode: typeof setSchemaWriteMode;
declare const globalState_setStateMethods: typeof setStateMethods;
declare const globalState_setStateProvider: typeof setStateProvider;
declare const globalState_setSubscriptions: typeof setSubscriptions;
declare const globalState_setTournamentId: typeof setTournamentId;
declare const globalState_setTournamentRecord: typeof setTournamentRecord;
declare const globalState_setTournamentRecords: typeof setTournamentRecords;
declare const globalState_timeKeeper: typeof timeKeeper;
declare const globalState_writeLegacyEnabled: typeof writeLegacyEnabled;
declare const globalState_writeNativeEnabled: typeof writeNativeEnabled;
declare namespace globalState {
  export { globalState_addNotice as addNotice, globalState_callListener as callListener, globalState_createInstanceState as createInstanceState, globalState_cycleMutationStatus as cycleMutationStatus, globalState_deepCopyEnabled as deepCopyEnabled, globalState_deleteNotice as deleteNotice, globalState_deleteNotices as deleteNotices, globalState_disableNotifications as disableNotifications, globalState_enableNotifications as enableNotifications, globalState_getAuditAuthorityServer as getAuditAuthorityServer, globalState_getDevContext as getDevContext, globalState_getMethods as getMethods, globalState_getNotices as getNotices, globalState_getPayloads as getPayloads, globalState_getProvider as getProvider, globalState_getSaveDrawDeletions as getSaveDrawDeletions, globalState_getSchemaWriteMode as getSchemaWriteMode, globalState_getTopics as getTopics, globalState_getTournamentId as getTournamentId, globalState_getTournamentRecord as getTournamentRecord, globalState_getTournamentRecords as getTournamentRecords, globalState_globalLog as globalLog, globalState_handleCaughtError as handleCaughtError, globalState_hasTopic as hasTopic, globalState_removeTournamentRecord as removeTournamentRecord, globalState_setAuditAuthorityServer as setAuditAuthorityServer, globalState_setDeepCopy as setDeepCopy, globalState_setDevContext as setDevContext, globalState_setGlobalLog as setGlobalLog, globalState_setGlobalMethods as setGlobalMethods, globalState_setGlobalSubscriptions as setGlobalSubscriptions, globalState_setMethods as setMethods, globalState_setSaveDrawDeletions as setSaveDrawDeletions, globalState_setSchemaWriteMode as setSchemaWriteMode, globalState_setStateMethods as setStateMethods, globalState_setStateProvider as setStateProvider, globalState_setSubscriptions as setSubscriptions, globalState_setTournamentId as setTournamentId, globalState_setTournamentRecord as setTournamentRecord, globalState_setTournamentRecords as setTournamentRecords, globalState_timeKeeper as timeKeeper, globalState_writeLegacyEnabled as writeLegacyEnabled, globalState_writeNativeEnabled as writeNativeEnabled };
  export type { globalState_CallListenerArgs as CallListenerArgs, globalState_DeepCopyAttributes as DeepCopyAttributes, globalState_DeleteNoticeArgs as DeleteNoticeArgs, globalState_DevContextType as DevContextType, globalState_GetNoticesArgs as GetNoticesArgs, globalState_HandleCaughtErrorArgs as HandleCaughtErrorArgs, globalState_ImplemtationGlobalStateTypes as ImplemtationGlobalStateTypes, globalState_Notice as Notice };
}

type PolicyDefinition = Record<string, any>;
type PolicyEntry = {
    policyType: string;
    definition: PolicyDefinition;
    version?: string;
    name: string;
};
type RegisterArgs = {
    definition: PolicyDefinition;
    policyType: string;
    version?: string;
    name: string;
};
declare function register({ policyType, name, version, definition }: RegisterArgs): void;
type LookupArgs = {
    policyType: string;
    version?: string;
    name: string;
};
declare function lookup({ policyType, name, version }: LookupArgs): PolicyDefinition | undefined;
type ListArgs = {
    policyType?: string;
};
declare function list({ policyType }?: ListArgs): PolicyEntry[];
type ClearArgs = {
    policyType?: string;
    name?: string;
};
declare function clear({ policyType, name }?: ClearArgs): void;
declare const policyRegistry: {
    register: typeof register;
    lookup: typeof lookup;
    list: typeof list;
    clear: typeof clear;
};

interface PolicyComposer {
    get(path: string): unknown;
    extend(other: Record<string, any>): PolicyComposer;
    set(path: string, value: unknown): PolicyComposer;
    merge(path: string, fragment: Record<string, any>): PolicyComposer;
    unset(path: string): PolicyComposer;
    from(args: {
        name: string;
        version?: string;
    }): PolicyComposer;
    build(): Record<string, any>;
    register(args: {
        name: string;
        version?: string;
    }): Record<string, any>;
}
declare function policyComposer(policyType?: string): PolicyComposer;

type FactoryErrorOptions = {
    cause?: unknown;
    methodName?: string;
    path?: string;
    context?: Record<string, any>;
    info?: string;
};
declare class FactoryError extends Error {
    readonly code: string;
    readonly methodName?: string;
    readonly path?: string;
    readonly context?: Record<string, any>;
    readonly info?: string;
    constructor(code: string, message: string, opts?: FactoryErrorOptions);
    get suggestions(): string[];
    toJSON(): {
        message: string;
        code: string;
        info?: string;
    };
}

declare class MissingTournamentRecordError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingTournamentRecordsError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingDrawDefinitionError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingEventError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingValueError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingSanctioningRecordError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MissingOfficialRecordError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class InvalidValuesError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class InvalidDateError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class ParticipantNotFoundError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class StructureNotFoundError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class MatchUpNotFoundError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}
declare class EventNotFoundError extends FactoryError {
    constructor(opts?: FactoryErrorOptions);
}

declare function constructFactoryError(code: string, message: string, opts?: FactoryErrorOptions): FactoryError;

type SuggestionFactory = (context?: Record<string, any>) => string[];
declare function registerSuggestions(code: string, factory: SuggestionFactory): void;
declare function getSuggestions(code: string, context?: Record<string, any>): string[];

type index$2_EventNotFoundError = EventNotFoundError;
declare const index$2_EventNotFoundError: typeof EventNotFoundError;
type index$2_FactoryError = FactoryError;
declare const index$2_FactoryError: typeof FactoryError;
type index$2_FactoryErrorOptions = FactoryErrorOptions;
type index$2_InvalidDateError = InvalidDateError;
declare const index$2_InvalidDateError: typeof InvalidDateError;
type index$2_InvalidValuesError = InvalidValuesError;
declare const index$2_InvalidValuesError: typeof InvalidValuesError;
type index$2_MatchUpNotFoundError = MatchUpNotFoundError;
declare const index$2_MatchUpNotFoundError: typeof MatchUpNotFoundError;
type index$2_MissingDrawDefinitionError = MissingDrawDefinitionError;
declare const index$2_MissingDrawDefinitionError: typeof MissingDrawDefinitionError;
type index$2_MissingEventError = MissingEventError;
declare const index$2_MissingEventError: typeof MissingEventError;
type index$2_MissingOfficialRecordError = MissingOfficialRecordError;
declare const index$2_MissingOfficialRecordError: typeof MissingOfficialRecordError;
type index$2_MissingSanctioningRecordError = MissingSanctioningRecordError;
declare const index$2_MissingSanctioningRecordError: typeof MissingSanctioningRecordError;
type index$2_MissingTournamentRecordError = MissingTournamentRecordError;
declare const index$2_MissingTournamentRecordError: typeof MissingTournamentRecordError;
type index$2_MissingTournamentRecordsError = MissingTournamentRecordsError;
declare const index$2_MissingTournamentRecordsError: typeof MissingTournamentRecordsError;
type index$2_MissingValueError = MissingValueError;
declare const index$2_MissingValueError: typeof MissingValueError;
type index$2_ParticipantNotFoundError = ParticipantNotFoundError;
declare const index$2_ParticipantNotFoundError: typeof ParticipantNotFoundError;
type index$2_StructureNotFoundError = StructureNotFoundError;
declare const index$2_StructureNotFoundError: typeof StructureNotFoundError;
declare const index$2_constructFactoryError: typeof constructFactoryError;
declare const index$2_getSuggestions: typeof getSuggestions;
declare const index$2_registerSuggestions: typeof registerSuggestions;
declare namespace index$2 {
  export { index$2_EventNotFoundError as EventNotFoundError, index$2_FactoryError as FactoryError, index$2_InvalidDateError as InvalidDateError, index$2_InvalidValuesError as InvalidValuesError, index$2_MatchUpNotFoundError as MatchUpNotFoundError, index$2_MissingDrawDefinitionError as MissingDrawDefinitionError, index$2_MissingEventError as MissingEventError, index$2_MissingOfficialRecordError as MissingOfficialRecordError, index$2_MissingSanctioningRecordError as MissingSanctioningRecordError, index$2_MissingTournamentRecordError as MissingTournamentRecordError, index$2_MissingTournamentRecordsError as MissingTournamentRecordsError, index$2_MissingValueError as MissingValueError, index$2_ParticipantNotFoundError as ParticipantNotFoundError, index$2_StructureNotFoundError as StructureNotFoundError, index$2_constructFactoryError as constructFactoryError, index$2_getSuggestions as getSuggestions, index$2_registerSuggestions as registerSuggestions };
  export type { index$2_FactoryErrorOptions as FactoryErrorOptions };
}

declare function asyncEngine(test?: boolean): FactoryEngine & {
    error?: any;
};

declare const syncEngine: FactoryEngine;

declare const askEngine: FactoryEngine;

declare const matchUpEngine: FactoryEngine;

declare const mocksEngine: FactoryEngine;

type index$1_ApplyBlockOptions = ApplyBlockOptions;
type index$1_ApplyTemplateOptions = ApplyTemplateOptions;
type index$1_AvailabilityEngine = AvailabilityEngine;
declare const index$1_AvailabilityEngine: typeof AvailabilityEngine;
declare const index$1_BLOCK_TYPES: typeof BLOCK_TYPES;
type index$1_Block = Block;
type index$1_BlockHardness = BlockHardness;
type index$1_BlockId = BlockId;
type index$1_BlockMutation = BlockMutation;
type index$1_BlockSource = BlockSource;
type index$1_BlockType = BlockType;
type index$1_BlocksChangedEvent = BlocksChangedEvent;
type index$1_BridgeConfig = BridgeConfig;
type index$1_CapacityCurve = CapacityCurve;
type index$1_CapacityDiff = CapacityDiff;
type index$1_CapacityPoint = CapacityPoint;
type index$1_CapacityStats = CapacityStats;
type index$1_ConflictEvaluator = ConflictEvaluator;
type index$1_ConflictSeverity = ConflictSeverity;
type index$1_ConflictsChangedEvent = ConflictsChangedEvent;
type index$1_CourtDayAvailability = CourtDayAvailability;
type index$1_CourtId = CourtId;
type index$1_CourtMeta = CourtMeta;
type index$1_CourtRail = CourtRail;
type index$1_CourtRef = CourtRef;
type index$1_CourtSchedulingSummary = CourtSchedulingSummary;
type index$1_DayId = DayId;
type index$1_DayPlan = DayPlan;
type index$1_Edge = Edge;
type index$1_EngineConfig = EngineConfig;
type index$1_EngineConflict = EngineConflict;
type index$1_EngineContext = EngineContext;
type index$1_EngineEvent = EngineEvent;
type index$1_EngineEventType = EngineEventType;
type index$1_EngineWarning = EngineWarning;
type index$1_EvaluatorRegistry = EvaluatorRegistry;
declare const index$1_EvaluatorRegistry: typeof EvaluatorRegistry;
type index$1_FixAction = FixAction;
type index$1_IssueIndex = IssueIndex;
type index$1_MoveBlockOptions = MoveBlockOptions;
type index$1_MutationKind = MutationKind;
type index$1_MutationResult = MutationResult;
type index$1_PlanItem = PlanItem;
type index$1_RailSegment = RailSegment;
type index$1_ResizeBlockOptions = ResizeBlockOptions;
type index$1_Rule = Rule;
type index$1_RuleId = RuleId;
type index$1_RuleResult = RuleResult;
type index$1_SchedulingProfile = SchedulingProfile;
type index$1_SchedulingProfileItem = SchedulingProfileItem;
type index$1_SchedulingProfileRound = SchedulingProfileRound;
type index$1_SchedulingSelection = SchedulingSelection;
type index$1_SimulationResult = SimulationResult;
type index$1_StateChangedEvent = StateChangedEvent;
type index$1_Template = Template;
type index$1_TemplateId = TemplateId;
type index$1_TemplateOperation = TemplateOperation;
type index$1_TimeRange = TimeRange;
type index$1_TodsCourt = TodsCourt;
type index$1_TodsDateAvailability = TodsDateAvailability;
type index$1_TodsVenue = TodsVenue;
type index$1_TournamentId = TournamentId;
type index$1_ValidationPhase = ValidationPhase;
type index$1_ValidationPipelineParams = ValidationPipelineParams;
type index$1_ValidationPipelineResult = ValidationPipelineResult;
type index$1_ValidationSeverity = ValidationSeverity;
type index$1_VenueDayTimeline = VenueDayTimeline;
type index$1_VenueId = VenueId;
declare const index$1_adjacentBlockEvaluator: typeof adjacentBlockEvaluator;
declare const index$1_applyAvailabilityToTournamentRecord: typeof applyAvailabilityToTournamentRecord;
declare const index$1_blockDurationEvaluator: typeof blockDurationEvaluator;
declare const index$1_buildDayRange: typeof buildDayRange;
declare const index$1_buildEdges: typeof buildEdges;
declare const index$1_buildSchedulingProfileFromUISelections: typeof buildSchedulingProfileFromUISelections;
declare const index$1_calculateCapacityStats: typeof calculateCapacityStats;
declare const index$1_calculateCourtHours: typeof calculateCourtHours;
declare const index$1_clampDragToCollisions: typeof clampDragToCollisions;
declare const index$1_clampToDayRange: typeof clampToDayRange;
declare const index$1_compareCapacityCurves: typeof compareCapacityCurves;
declare const index$1_computePlanItemId: typeof computePlanItemId;
declare const index$1_courtDayKey: typeof courtDayKey;
declare const index$1_courtKey: typeof courtKey;
declare const index$1_courtOverlapEvaluator: typeof courtOverlapEvaluator;
declare const index$1_createFollowByEvaluator: typeof createFollowByEvaluator;
declare const index$1_dayBoundaryEvaluator: typeof dayBoundaryEvaluator;
declare const index$1_defaultEvaluators: typeof defaultEvaluators;
declare const index$1_deriveRailSegments: typeof deriveRailSegments;
declare const index$1_diffMinutes: typeof diffMinutes;
declare const index$1_extractDay: typeof extractDay;
declare const index$1_filterCapacityCurve: typeof filterCapacityCurve;
declare const index$1_findBlocksContainingTime: typeof findBlocksContainingTime;
declare const index$1_formatConflicts: typeof formatConflicts;
declare const index$1_generateCapacityCurve: typeof generateCapacityCurve;
declare const index$1_getHighestSeverity: typeof getHighestSeverity;
declare const index$1_groupConflictsBySeverity: typeof groupConflictsBySeverity;
declare const index$1_hhmmToMinutes: typeof hhmmToMinutes;
declare const index$1_intervalsOverlap: typeof intervalsOverlap;
declare const index$1_iterateDayTicks: typeof iterateDayTicks;
declare const index$1_lightingEvaluator: typeof lightingEvaluator;
declare const index$1_maintenanceWindowEvaluator: typeof maintenanceWindowEvaluator;
declare const index$1_matchWindowEvaluator: typeof matchWindowEvaluator;
declare const index$1_mergeAdjacentSegments: typeof mergeAdjacentSegments;
declare const index$1_mergeOverlappingAvailability: typeof mergeOverlappingAvailability;
declare const index$1_minutesToHhmm: typeof minutesToHhmm;
declare const index$1_overlappingRange: typeof overlappingRange;
declare const index$1_railsToDateAvailability: typeof railsToDateAvailability;
declare const index$1_rangesOverlap: typeof rangesOverlap;
declare const index$1_resolveCourtId: typeof resolveCourtId;
declare const index$1_resolveStatus: typeof resolveStatus;
declare const index$1_resolveVenueId: typeof resolveVenueId;
declare const index$1_runValidationPipeline: typeof runValidationPipeline;
declare const index$1_sampleCapacityCurve: typeof sampleCapacityCurve;
declare const index$1_snapIsoToGranularity: typeof snapIsoToGranularity;
declare const index$1_snapToGranularity: typeof snapToGranularity;
declare const index$1_sortBlocksByStart: typeof sortBlocksByStart;
declare const index$1_sortEdges: typeof sortEdges;
declare const index$1_timeInsideBlock: typeof timeInsideBlock;
declare const index$1_todsAvailabilityToBlocks: typeof todsAvailabilityToBlocks;
declare const index$1_validateDateAvailability: typeof validateDateAvailability;
declare const index$1_validateSchedulingProfileFormat: typeof validateSchedulingProfileFormat;
declare const index$1_validateSegments: typeof validateSegments;
declare const index$1_venueDayKey: typeof venueDayKey;
declare const index$1_venueKey: typeof venueKey;
declare namespace index$1 {
  export { index$1_AvailabilityEngine as AvailabilityEngine, index$1_BLOCK_TYPES as BLOCK_TYPES, index$1_EvaluatorRegistry as EvaluatorRegistry, index$1_adjacentBlockEvaluator as adjacentBlockEvaluator, index$1_applyAvailabilityToTournamentRecord as applyAvailabilityToTournamentRecord, index$1_blockDurationEvaluator as blockDurationEvaluator, index$1_buildDayRange as buildDayRange, index$1_buildEdges as buildEdges, index$1_buildSchedulingProfileFromUISelections as buildSchedulingProfileFromUISelections, index$1_calculateCapacityStats as calculateCapacityStats, index$1_calculateCourtHours as calculateCourtHours, index$1_clampDragToCollisions as clampDragToCollisions, index$1_clampToDayRange as clampToDayRange, index$1_compareCapacityCurves as compareCapacityCurves, index$1_computePlanItemId as computePlanItemId, index$1_courtDayKey as courtDayKey, index$1_courtKey as courtKey, index$1_courtOverlapEvaluator as courtOverlapEvaluator, index$1_createFollowByEvaluator as createFollowByEvaluator, index$1_dayBoundaryEvaluator as dayBoundaryEvaluator, index$1_defaultEvaluators as defaultEvaluators, index$1_deriveRailSegments as deriveRailSegments, index$1_diffMinutes as diffMinutes, index$1_extractDay as extractDay, index$1_filterCapacityCurve as filterCapacityCurve, index$1_findBlocksContainingTime as findBlocksContainingTime, index$1_formatConflicts as formatConflicts, index$1_generateCapacityCurve as generateCapacityCurve, index$1_getHighestSeverity as getHighestSeverity, index$1_groupConflictsBySeverity as groupConflictsBySeverity, index$1_hhmmToMinutes as hhmmToMinutes, index$1_intervalsOverlap as intervalsOverlap, index$1_iterateDayTicks as iterateDayTicks, index$1_lightingEvaluator as lightingEvaluator, index$1_maintenanceWindowEvaluator as maintenanceWindowEvaluator, index$1_matchWindowEvaluator as matchWindowEvaluator, index$1_mergeAdjacentSegments as mergeAdjacentSegments, index$1_mergeOverlappingAvailability as mergeOverlappingAvailability, index$1_minutesToHhmm as minutesToHhmm, index$1_overlappingRange as overlappingRange, index$1_railsToDateAvailability as railsToDateAvailability, index$1_rangesOverlap as rangesOverlap, index$1_resolveCourtId as resolveCourtId, index$1_resolveStatus as resolveStatus, index$1_resolveVenueId as resolveVenueId, index$1_runValidationPipeline as runValidationPipeline, index$1_sampleCapacityCurve as sampleCapacityCurve, index$1_snapIsoToGranularity as snapIsoToGranularity, index$1_snapToGranularity as snapToGranularity, index$1_sortBlocksByStart as sortBlocksByStart, index$1_sortEdges as sortEdges, index$1_timeInsideBlock as timeInsideBlock, index$1_todsAvailabilityToBlocks as todsAvailabilityToBlocks, index$1_validateDateAvailability as validateDateAvailability, index$1_validateSchedulingProfileFormat as validateSchedulingProfileFormat, index$1_validateSegments as validateSegments, index$1_venueDayKey as venueDayKey, index$1_venueKey as venueKey };
  export type { index$1_ApplyBlockOptions as ApplyBlockOptions, index$1_ApplyTemplateOptions as ApplyTemplateOptions, index$1_Block as Block, index$1_BlockHardness as BlockHardness, index$1_BlockId as BlockId, index$1_BlockMutation as BlockMutation, index$1_BlockSource as BlockSource, index$1_BlockType as BlockType, index$1_BlocksChangedEvent as BlocksChangedEvent, index$1_BridgeConfig as BridgeConfig, index$1_CapacityCurve as CapacityCurve, index$1_CapacityDiff as CapacityDiff, index$1_CapacityPoint as CapacityPoint, index$1_CapacityStats as CapacityStats, index$1_ConflictEvaluator as ConflictEvaluator, index$1_ConflictSeverity as ConflictSeverity, index$1_ConflictsChangedEvent as ConflictsChangedEvent, index$1_CourtDayAvailability as CourtDayAvailability, index$1_CourtId as CourtId, index$1_CourtMeta as CourtMeta, index$1_CourtRail as CourtRail, index$1_CourtRef as CourtRef, index$1_CourtSchedulingSummary as CourtSchedulingSummary, index$1_DayId as DayId, index$1_DayPlan as DayPlan, index$1_Edge as Edge, index$1_EngineConfig as EngineConfig, index$1_EngineConflict as EngineConflict, index$1_EngineContext as EngineContext, index$1_EngineEvent as EngineEvent, index$1_EngineEventType as EngineEventType, index$1_EngineWarning as EngineWarning, index$1_FixAction as FixAction, index$1_IssueIndex as IssueIndex, index$1_MoveBlockOptions as MoveBlockOptions, index$1_MutationKind as MutationKind, index$1_MutationResult as MutationResult, index$1_PlanItem as PlanItem, index$1_RailSegment as RailSegment, index$1_ResizeBlockOptions as ResizeBlockOptions, index$1_Rule as Rule, index$1_RuleId as RuleId, index$1_RuleResult as RuleResult, index$1_SchedulingProfile as SchedulingProfile, index$1_SchedulingProfileItem as SchedulingProfileItem, index$1_SchedulingProfileRound as SchedulingProfileRound, index$1_SchedulingSelection as SchedulingSelection, index$1_SimulationResult as SimulationResult, index$1_StateChangedEvent as StateChangedEvent, index$1_Template as Template, index$1_TemplateId as TemplateId, index$1_TemplateOperation as TemplateOperation, index$1_TimeRange as TimeRange, index$1_TodsCourt as TodsCourt, index$1_TodsDateAvailability as TodsDateAvailability, index$1_TodsVenue as TodsVenue, index$1_TournamentId as TournamentId, index$1_ValidationPhase as ValidationPhase, index$1_ValidationPipelineParams as ValidationPipelineParams, index$1_ValidationPipelineResult as ValidationPipelineResult, index$1_ValidationSeverity as ValidationSeverity, index$1_VenueDayTimeline as VenueDayTimeline, index$1_VenueId as VenueId };
}

type CalendarConflict = {
    type: 'PROXIMITY' | 'SAME_WEEK' | 'BLACKOUT' | 'MAX_EVENTS_PER_WEEK';
    severity: 'error' | 'warning';
    message: string;
    conflictingEvent?: CalendarEvent;
};

type ValidationIssue = {
    field: string;
    message: string;
    severity: 'error' | 'warning';
};

declare const sanctioningEngine: {
    version: () => string;
    reset: () => {
        success: boolean;
    };
    getState: () => {
        sanctioningRecords: any;
        success: boolean;
    };
    setState: (records: SanctioningRecords) => {
        success: boolean;
    };
    setSanctioningRecord: (record: SanctioningRecord) => {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    removeSanctioningRecord: (sanctioningId: string) => {
        error: ErrorType;
        context: {
            sanctioningId: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    setActiveSanctioningId: (sanctioningId?: string) => {
        error: ErrorType;
        context: {
            sanctioningId: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    getActiveSanctioningId: () => string | undefined;
    createSanctioningRecord: (params: any) => {
        error?: any;
        sanctioningRecord?: SanctioningRecord;
        success?: boolean;
    };
    updateProposal: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            status?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            status: SanctioningStatus;
            message?: undefined;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    addEventProposal: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            status?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            status: SanctioningStatus;
            message?: undefined;
        };
    } | {
        eventProposalId: string | undefined;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    removeEventProposal: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            status?: undefined;
            eventProposalId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            status: SanctioningStatus;
            message?: undefined;
            eventProposalId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            eventProposalId: string;
            message?: undefined;
            status?: undefined;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    updateEventProposal: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            status?: undefined;
            eventProposalId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            status: SanctioningStatus;
            message?: undefined;
            eventProposalId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            eventProposalId: string;
            message?: undefined;
            status?: undefined;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    submitApplication: (params: any) => {
        error: ErrorType;
        context: {
            fromStatus: SanctioningStatus;
            message: string;
            toStatus?: undefined;
            validTargets?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            fromStatus: SanctioningStatus;
            toStatus: SanctioningStatus;
            validTargets: SanctioningStatus[];
            message?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            guard: TransitionGuardType;
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
    } | {
        error: ErrorType;
    };
    reviewApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    approveApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    conditionallyApprove: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    };
    meetCondition: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            conditionId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            conditionId: string;
            message?: undefined;
        };
    } | {
        allConditionsMet: boolean;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    rejectApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    withdrawApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    requestModification: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    requestEndorsement: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    endorseApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    declineEndorsement: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    addReviewNote: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        noteId: string;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    activateFromSanctioning: (params: any) => {
        error: ErrorType;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        tournamentRecord: Tournament;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    proposeAmendment: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            status?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            status: SanctioningStatus;
            message?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            message: string | undefined;
            status?: undefined;
        };
    } | {
        amendmentId: string;
        severity: AmendmentSeverity;
        autoApproved: boolean;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    reviewAmendment: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
            amendmentId?: undefined;
        };
    } | {
        error: ErrorType;
        context: {
            amendmentId: string;
            message?: undefined;
        };
    } | {
        approved: boolean;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    transitionToPostEvent: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    submitComplianceItem: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    verifyComplianceItem: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        allCompliant: boolean;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    waiveComplianceItem: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    flagComplianceIssues: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    closeApplication: (params: any) => {
        error: ErrorType;
    } | {
        success: boolean;
        error?: undefined;
    };
    checkComplianceDeadlines: (params: any) => {
        error: ErrorType;
    } | {
        overdueCount: number;
        success: boolean;
        error?: undefined;
    };
    getSanctioningRecord: (params?: any) => {
        error: ErrorType;
    } | {
        sanctioningRecord: any;
        success: boolean;
        error?: undefined;
    };
    getAvailableTransitions: (params?: any) => {
        error?: any;
        success?: boolean;
        availableTransitions?: SanctioningStatus[];
    };
    getStatusHistory: (params?: any) => {
        error?: any;
        success?: boolean;
        statusHistory?: StatusTransition[];
    };
    getCompleteness: (params?: any) => {
        error: ErrorType;
    } | {
        completeness: {
            score: number;
            totalFields: number;
            completedFields: number;
            missingFields: string[];
        };
        success: boolean;
        error?: undefined;
    };
    getEligibleTiers: (params: any) => {
        error: ErrorType;
    } | {
        tierEligibilities: {
            tierName: string;
            tierLevel: number;
            eligible: boolean;
            reasons: string[];
        }[];
        eligibleTiers: {
            tierName: string;
            tierLevel: number;
            eligible: boolean;
            reasons: string[];
        }[];
        success: boolean;
        error?: undefined;
    };
    validateProposal: (params: any) => {
        error: ErrorType;
    } | {
        valid: boolean;
        issues: ValidationIssue[];
        errors: ValidationIssue[];
        warnings: ValidationIssue[];
        success: boolean;
        error?: undefined;
    };
    getCalendarConflicts: (params: any) => {
        error: ErrorType;
        context?: undefined;
    } | {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        conflicts: CalendarConflict[];
        errors: CalendarConflict[];
        warnings: CalendarConflict[];
        hasConflicts: boolean;
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    executionQueue: (directives: SanctioningDirectives, rollbackOnError?: boolean) => any;
};

declare const officiatingEngine: {
    version: () => string;
    reset: () => {
        success: boolean;
    };
    getState: () => {
        officialRecords: any;
        success: boolean;
    };
    setState: (records: OfficialRecords) => {
        success: boolean;
    };
    setOfficialRecord: (record: OfficialRecord) => {
        error: {
            message: string;
            code: string;
        };
        context: {
            message: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    removeOfficialRecord: (officialRecordId: string) => {
        error: ErrorType;
        context: {
            officialRecordId: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    setActiveOfficialRecordId: (officialRecordId?: string) => {
        error: ErrorType;
        context: {
            officialRecordId: string;
        };
    } | {
        success: boolean;
        error?: undefined;
        context?: undefined;
    };
    getActiveOfficialRecordId: () => string | undefined;
    createOfficialRecord: (params: any) => {
        error?: any;
        officialRecord?: OfficialRecord;
        success?: boolean;
    };
    addCertification: (params: any) => {
        error?: any;
        certification?: OfficialCertification;
        success?: boolean;
    };
    modifyCertification: (params: any) => {
        error?: any;
        certification?: OfficialCertification;
        success?: boolean;
    };
    removeCertification: (params: any) => any;
    transitionCertificationStatus: (params: any) => {
        error?: any;
        certification?: OfficialCertification;
        success?: boolean;
    };
    addEvaluation: (params: any) => {
        error?: any;
        evaluation?: OfficialEvaluation;
        success?: boolean;
    };
    modifyEvaluation: (params: any) => {
        error?: any;
        evaluation?: OfficialEvaluation;
        success?: boolean;
    };
    removeEvaluation: (params: any) => any;
    transitionEvaluationStatus: (params: any) => {
        error?: any;
        evaluation?: OfficialEvaluation;
        success?: boolean;
    };
    assignOfficial: (params: any) => {
        error?: any;
        assignment?: OfficialAssignment;
        success?: boolean;
    };
    removeOfficialAssignment: (params: any) => any;
    transitionAssignmentStatus: (params: any) => {
        error?: any;
        assignment?: OfficialAssignment;
        success?: boolean;
    };
    addCertificationRequirement: (params: any) => {
        error?: any;
        certificationRequirement?: CertificationRequirement;
        success?: boolean;
    };
    addSuspension: (params: any) => {
        error?: any;
        suspension?: OfficialSuspension;
        success?: boolean;
    };
    removeSuspension: (params: any) => any;
    addEvaluationPolicy: (params: any) => {
        error?: any;
        evaluationPolicy?: EvaluationPolicy;
        success?: boolean;
    };
    getOfficialRecord: (params?: any) => {
        error?: any;
        success?: boolean;
        officialRecord?: OfficialRecord;
    };
    getOfficialCertifications: (params?: any) => {
        error?: any;
        success?: boolean;
        certifications?: OfficialCertification[];
    };
    validateCertification: (params: any) => {
        error?: any;
        success?: boolean;
        valid?: boolean;
        certification?: OfficialCertification;
        reasons?: string[];
    };
    getEvaluations: (params?: any) => {
        error?: any;
        success?: boolean;
        evaluations?: OfficialEvaluation[];
    };
    getEvaluationSummary: (params?: any) => {
        error?: any;
        success?: boolean;
        summary?: EvaluationSummary;
    };
    getOfficialEligibility: (params: any) => {
        error?: any;
        success?: boolean;
        eligible?: boolean;
        reasons?: string[];
    };
    getOfficialAssignments: (params?: any) => {
        error?: any;
        success?: boolean;
        assignments?: OfficialAssignment[];
    };
    getEvaluationTemplate: (params: any) => {
        error?: any;
        success?: boolean;
        fields?: EvaluationFormField[];
        evaluationPolicy?: EvaluationPolicy;
    };
    executionQueue: (directives: OfficiatingDirectives, rollbackOnError?: boolean) => any;
};

declare const competitionEngine: FactoryEngineTyped;
declare const tournamentEngine: FactoryEngineTyped;
declare const competitionEngineUntyped: FactoryEngine;
declare const tournamentEngineUntyped: FactoryEngine;

declare const competitionEngineAsync: FactoryEngine & {
    error?: any;
};
declare const tournamentEngineAsync: FactoryEngine & {
    error?: any;
};

declare function countryToFlag(isoCode: string): string;
declare function flagIOC(ioc: string): string;

declare const fixtures: {
    competitionFormats: {
        INTENNSE_STANDARD: {
            competitionFormatName: string;
            matchUpFormat: string;
            sport: string;
            timerProfile: {
                shotClockSeconds: number;
                segmentTimers: {
                    segmentType: string;
                    direction: string;
                    minutes: number;
                }[];
                changeoverSeconds: number;
                setBreakSeconds: number;
            };
            timeoutRules: {
                count: number;
                per: string;
                durationSeconds: number;
                maxPerSide: number;
            };
            substitutionRules: {
                allowed: boolean;
                allowedMatchUpTypes: string[];
                timing: string;
            };
            playerRules: {
                maxMinutesPerSegment: number;
                matchUpTypes: string[];
            };
            penaltyBoxProfile: {
                durationSeconds: number;
            };
            penaltyProfile: {
                sport: string;
                penaltyTypes: {
                    penaltyType: string;
                    label: string;
                    category: string;
                }[];
                escalation: {
                    step: number;
                    consequence: string;
                }[];
            };
            pointProfile: {
                sport: string;
                pointResults: ({
                    result: string;
                    label: string;
                    isServe: boolean;
                    isError?: undefined;
                } | {
                    result: string;
                    label: string;
                    isServe?: undefined;
                    isError?: undefined;
                } | {
                    result: string;
                    label: string;
                    isError: boolean;
                    isServe?: undefined;
                } | {
                    result: string;
                    label: string;
                    isServe: boolean;
                    isError: boolean;
                })[];
            };
            pointMultipliers: {
                condition: {
                    results: string[];
                };
                value: number;
            }[];
        };
        TENNIS_STANDARD: {
            competitionFormatName: string;
            matchUpFormat: string;
            sport: string;
            timerProfile: {
                changeoverSeconds: number;
                setBreakSeconds: number;
            };
            timeoutRules: {
                count: number;
                per: string;
            };
            substitutionRules: {
                allowed: boolean;
            };
            penaltyProfile: {
                sport: string;
                penaltyTypes: {
                    penaltyType: string;
                    label: string;
                    category: string;
                }[];
                escalation: {
                    step: number;
                    consequence: string;
                }[];
            };
            pointProfile: {
                sport: string;
                pointResults: ({
                    result: string;
                    label: string;
                    isServe: boolean;
                    isError?: undefined;
                } | {
                    result: string;
                    label: string;
                    isServe?: undefined;
                    isError?: undefined;
                } | {
                    result: string;
                    label: string;
                    isError: boolean;
                    isServe?: undefined;
                } | {
                    result: string;
                    label: string;
                    isServe: boolean;
                    isError: boolean;
                })[];
            };
            pointMultipliers: never[];
        };
    };
    ratingsParameters: {
        ELO: {
            defaultInitialization: number;
            decimalsCount: number;
            range: number[];
            ascending: boolean;
        };
        NTRP: {
            accessors: string[];
            attributes: {
                ustaRatingType: string;
            };
            accessor: string;
            defaultInitialization: number;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        UTR: {
            defaultInitialization: number;
            accessors: string[];
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        WTN: {
            attributes: {
                confidence: {
                    generator: boolean;
                    range: number[];
                };
            };
            accessors: string[];
            defaultInitialization: number;
            accessor: string;
            ascending: boolean;
            decimalsCount: number;
            range: number[];
        };
        DUPR: {
            defaultInitialization: number;
            accessors: string[];
            accessor: string;
            attributes: {
                reliabilityScore: {
                    generator: boolean;
                    range: number[];
                };
            };
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        UTR_P: {
            defaultInitialization: number;
            accessors: string[];
            accessor: string;
            attributes: {
                verified: {
                    type: string;
                };
                provisional: {
                    type: string;
                };
            };
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        UTPR: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
            deprecated: boolean;
        };
        PSA: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
            attributes: {
                tournaments: {
                    generator: boolean;
                    range: number[];
                };
                divisor: {
                    generator: boolean;
                    range: number[];
                };
            };
        };
        SQUASH_LEVELS: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        US_SQUASH: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        USATT: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        ITTF: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        USAR: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
        };
        BWF: {
            defaultInitialization: number;
            accessor: string;
            decimalsCount: number;
            ascending: boolean;
            range: number[];
            attributes: {
                tournaments: {
                    generator: boolean;
                    range: number[];
                };
            };
        };
    };
    matchUpFormats: {
        FORMAT_STANDARD: string;
        FORMAT_STANDARD_NOAD: string;
        FORMAT_ATP_DOUBLES: string;
        FORMAT_SHORT_SETS: string;
        FORMAT_FAST4: string;
        FORMAT_GRAND_SLAM: string;
        FORMAT_ONE_SET: string;
        FORMAT_MATCH_TIEBREAK: string;
        FORMAT_SET3_TB7: string;
        FORMAT_PRO_SET: string;
        FORMAT_COLLEGE_PRO_SET: string;
        TIMED20: string;
    };
    countryToFlag: typeof countryToFlag;
    tieFormats: {
        COLLEGE_D3: {
            collectionDefinitions: {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        COLLEGE_DEFAULT: {
            collectionDefinitions: ({
                collectionName: string;
                collectionValue: number;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue?: undefined;
            } | {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
                collectionValue?: undefined;
            })[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        COLLEGE_JUCO: {
            collectionDefinitions: {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        DOMINANT_DUO: {
            collectionDefinitions: {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        DOMINANT_DUO_MIXED: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        LAVER_CUP: {
            collectionDefinitions: {
                collectionGroupNumber: number;
                matchUpType: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpValue: number;
            }[];
            collectionGroups: {
                groupNumber: number;
                groupName: string;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        TEAM_DOUBLES_3_AGGREGATION: {
            collectionDefinitions: {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                scoreValue: number;
            }[];
            tieFormatName: string;
            unrestrictedSelections: boolean;
            winCriteria: {
                aggregateValue: boolean;
            };
        };
        USTA_BREWER_CUP: {
            collectionDefinitions: ({
                category: {
                    ageCategoryCode: string;
                };
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
                collectionGroupNumber?: undefined;
            } | {
                category: {
                    ageCategoryCode: string;
                };
                collectionName: string;
                collectionGroupNumber: number;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            })[];
            collectionGroups: {
                groupNumber: number;
                groupName: string;
                groupValue: number;
                winCriteria: {
                    valueGoal: number;
                };
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_OZAKI_CUP: {
            winCriteria: {
                valueGoal: number;
            };
            tieFormatName: string;
            collectionDefinitions: {
                category: {
                    ageCategoryCode: string;
                };
                matchUpFormat: string;
                collectionName: string;
                matchUpType: string;
                matchUpCount: number;
                matchUpValue: number;
                gender: string;
            }[];
        };
        USTA_COLLEGE: {
            collectionDefinitions: ({
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                collectionValue: number;
                matchUpValue?: undefined;
            } | {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
                collectionValue?: undefined;
            })[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_GOLD_TEAM_CHALLENGE: {
            collectionDefinitions: {
                collectionName: string;
                matchUpFormat: string;
                matchUpType: string;
                matchUpCount: number;
                matchUpValue: number;
                gender: string;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_INTERSECTIONAL: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_LEVEL_1: {
            collectionDefinitions: {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_SECTION_BATTLE: {
            collectionDefinitions: ({
                category: {
                    ageCategoryCode: string;
                };
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
                processCodes?: undefined;
            } | {
                collectionName: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
                processCodes: string[];
                category?: undefined;
            })[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_SOUTHERN_LEVEL_5: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
        USTA_TOC: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                scoreValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                aggregateValue: boolean;
            };
        };
        USTA_WTT_ITT: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                scoreValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                aggregateValue: boolean;
            };
        };
        USTA_ZONAL: {
            collectionDefinitions: {
                collectionName: string;
                gender: string;
                matchUpCount: number;
                matchUpFormat: string;
                matchUpType: string;
                matchUpValue: number;
            }[];
            tieFormatName: string;
            winCriteria: {
                valueGoal: number;
            };
        };
    };
    countries: ({
        ioc: string;
        iso2: string;
        iso: string;
        label: string;
        phone: string;
        suggested?: undefined;
    } | {
        ioc: string;
        iso2: string;
        iso: string;
        label: string;
        phone: string;
        suggested: boolean;
    })[];
    policies: {
        POLICY_AVOIDANCE_COUNTRY: {
            avoidance: {
                roundsToSeparate: undefined;
                policyName: string;
                policyAttributes: {
                    key: string;
                }[];
            };
        };
        POLICY_COMPETITION_STANDARD: {
            competition: {
                policyName: string;
                ratingPolicy: {
                    baselineRating: {
                        source: "SCALE";
                        frozenDuringEvent: true;
                    };
                    dynamicFormRating: {
                        enabled: true;
                        initializeFrom: "BASELINE";
                        kFactor: number;
                        logisticScale: number;
                    };
                };
                pairingPolicy: {
                    method: "DRAW_MATIC";
                    ratingSource: "DYNAMIC_FORM";
                    avoidRepeatOpponents: true;
                    sameTeamValue: number;
                };
                victoryPolicy: {
                    primaryRanking: "WINS";
                    tiebreakOrder: ("DYNAMIC_FORM_RATING" | "HEAD_TO_HEAD" | "POINT_DIFFERENTIAL")[];
                };
                processingGranularity: "PER_ROUND";
            };
        };
        POLICY_COMPETITION_PRESSURE: {
            competition: {
                policyName: string;
                ratingPolicy: {
                    baselineRating: {
                        source: "SCALE";
                        frozenDuringEvent: true;
                    };
                    dynamicFormRating: {
                        enabled: true;
                        initializeFrom: "BASELINE";
                        kFactor: number;
                        logisticScale: number;
                    };
                    pressureRating: {
                        enabled: true;
                        expectationSource: "BASELINE_ONLY";
                        actualOutputMethod: "POINT_SHARE";
                        weights: {
                            pointShare: number;
                            pointDifferential: number;
                            contextFactor: number;
                        };
                    };
                };
                pairingPolicy: {
                    method: "DRAW_MATIC";
                    ratingSource: "DYNAMIC_FORM";
                    avoidRepeatOpponents: true;
                    sameTeamValue: number;
                };
                victoryPolicy: {
                    primaryRanking: "PRESSURE_RATING";
                    tiebreakOrder: ("HEAD_TO_HEAD_PRESSURE" | "POINT_DIFFERENTIAL" | "STRENGTH_OF_OPPOSITION")[];
                };
                processingGranularity: "PER_MATCHUP";
            };
        };
        POLICY_COMPETITION_SWISS: {
            competition: {
                policyName: string;
                ratingPolicy: {
                    baselineRating: {
                        source: "SCALE";
                        frozenDuringEvent: true;
                    };
                    dynamicFormRating: {
                        enabled: true;
                        initializeFrom: "BASELINE";
                        kFactor: number;
                        logisticScale: number;
                    };
                    pressureRating: {
                        enabled: true;
                        expectationSource: "BASELINE_ONLY";
                        actualOutputMethod: "POINT_SHARE";
                        weights: {
                            pointShare: number;
                        };
                    };
                };
                pairingPolicy: {
                    method: "SWISS";
                    ratingSource: "DYNAMIC_FORM";
                    avoidRepeatOpponents: true;
                };
                victoryPolicy: {
                    primaryRanking: "WINS";
                    tiebreakOrder: ("PRESSURE_RATING" | "HEAD_TO_HEAD" | "BUCHHOLZ" | "SONNEBORN_BERGER")[];
                };
                processingGranularity: "PER_ROUND";
            };
        };
        POLICY_POSITION_ACTIONS_DEFAULT: {
            positionActions: {
                policyName: string;
                enabledStructures: ({
                    stages: string[];
                    stageSequences: number[];
                    enabledActions: never[];
                    disabledActions: never[];
                } | {
                    stages: never[];
                    stageSequences: never[];
                    enabledActions: string[];
                    disabledActions: never[];
                })[];
                disbledStructures: never[];
                otherFlightEntries: boolean;
                activePositionOverrides: never[];
            };
        };
        POLICY_POSITION_ACTIONS_DISABLED: {
            positionActions: {
                policyName: string;
                enabledStructures: boolean;
            };
        };
        POLICY_POSITION_ACTIONS_NO_MOVEMENT: {
            positionActions: {
                policyName: string;
                enabledStructures: {
                    stages: never[];
                    stageSequences: never[];
                    enabledActions: string[];
                    disabledActions: never[];
                }[];
            };
        };
        POLICY_POSITION_ACTIONS_UNRESTRICTED: {
            positionActions: {
                policyName: string;
                enabledStructures: never[];
                otherFlightEntries: boolean;
                disableRoundRestrictions: boolean;
                activePositionOverrides: string[];
            };
        };
        POLICY_PRIVACY_DEFAULT: {
            participant: {
                policyName: string;
                participant: {
                    contacts: boolean;
                    individualParticipants: {
                        onlineResources: boolean;
                        participantName: boolean;
                        participantOtherName: boolean;
                        participantId: boolean;
                        participantRole: boolean;
                        participantStatus: boolean;
                        penalties: boolean;
                        rankings: boolean;
                        ratings: boolean;
                        representing: boolean;
                        participantRoleResponsibilities: boolean;
                        participantType: boolean;
                        person: {
                            addresses: boolean;
                            biographicalInformation: boolean;
                            birthDate: boolean;
                            contacts: boolean;
                            nationalityCode: boolean;
                            nativeFamilyName: boolean;
                            nativeGivenName: boolean;
                            onlineResources: boolean;
                            otherNames: boolean;
                            parentOrganisationId: boolean;
                            passportFamilyName: boolean;
                            passportGivenName: boolean;
                            personId: boolean;
                            personOtherIds: boolean;
                            previousNames: boolean;
                            sex: boolean;
                            standardFamilyName: boolean;
                            standardGivenName: boolean;
                            status: boolean;
                            tennisId: boolean;
                            wheelchair: boolean;
                        };
                    };
                    individualParticipantIds: boolean;
                    onlineResources: boolean;
                    participantName: boolean;
                    participantOtherName: boolean;
                    participantId: boolean;
                    participantRole: boolean;
                    participantStatus: boolean;
                    penalties: boolean;
                    rankings: boolean;
                    ratings: boolean;
                    representing: boolean;
                    participantRoleResponsibilities: boolean;
                    participantType: boolean;
                    person: {
                        addresses: boolean;
                        biographicalInformation: boolean;
                        birthDate: boolean;
                        contacts: boolean;
                        nationalityCode: boolean;
                        nativeFamilyName: boolean;
                        nativeGivenName: boolean;
                        onlineResources: boolean;
                        otherNames: boolean;
                        parentOrganisationId: boolean;
                        passportFamilyName: boolean;
                        passportGivenName: boolean;
                        personId: boolean;
                        personOtherIds: boolean;
                        previousNames: boolean;
                        sex: boolean;
                        standardFamilyName: boolean;
                        standardGivenName: boolean;
                        status: boolean;
                        tennisId: boolean;
                        wheelchair: boolean;
                    };
                };
            };
        };
        POLICY_RANKING_POINTS_ITF_JUNIOR: {
            rankingPoints: {
                policyName: string;
                policyVersion: string;
                pointsAuthority: string;
                validDateRange: {
                    startDate: string;
                };
                awardProfiles: ({
                    profileName: string;
                    levels: number[];
                    drawTypes: string[];
                    eventTypes: string[];
                    finishingPositionRanges: {
                        1: number;
                        2: number;
                        3: number;
                        4: number;
                        5: number;
                        6: number;
                        7: number;
                        8: number;
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: number;
                        2: number;
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                            };
                        };
                        2: {
                            level: {
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                            };
                        };
                    };
                })[];
                aggregationRules: {
                    rollingPeriodDays: number;
                    separateByGender: boolean;
                    perCategory: boolean;
                    countingBuckets: ({
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints"];
                        weight?: undefined;
                    } | {
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints"];
                        weight: number;
                    })[];
                };
                doublesAttribution: "fullToEach";
            };
        };
        POLICY_RANKING_POINTS_ITF_WTT: {
            rankingPoints: {
                policyName: string;
                policyVersion: string;
                pointsAuthority: string;
                validDateRange: {
                    startDate: string;
                };
                awardProfiles: {
                    profileName: string;
                    levels: number[];
                    drawTypes: string[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                1: number;
                                2: number;
                                3: number;
                                4: number;
                            };
                        };
                        2: number;
                    };
                }[];
                aggregationRules: {
                    rollingPeriodDays: number;
                    separateByGender: boolean;
                    perCategory: boolean;
                    bestOfCount: number;
                };
                doublesAttribution: "fullToEach";
            };
        };
        POLICY_RANKING_POINTS_BASIC: {
            rankingPoints: {
                policyName: string;
                policyVersion: string;
                awardProfiles: {
                    profileName: string;
                    finishingPositionRanges: {
                        1: number;
                        2: number;
                        4: number;
                        8: number;
                        16: number;
                        32: number;
                        64: number;
                        128: number;
                    };
                }[];
                requireWinForPoints: boolean;
                doublesAttribution: "fullToEach";
            };
        };
        POLICY_RANKING_POINTS_ATP: {
            rankingPoints: {
                policyName: string;
                policyVersion: string;
                pointsAuthority: string;
                validDateRange: {
                    startDate: string;
                };
                awardProfiles: ({
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                3: number;
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                            };
                        };
                        2: {
                            level: {
                                3: number;
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                            };
                        };
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                                14: number;
                                15: number;
                            };
                        };
                        2: {
                            level: {
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                                14: number;
                                15: number;
                            };
                        };
                        4: {
                            level: {
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                                14: number;
                                15: number;
                            };
                        };
                        8: {
                            level: {
                                9: number;
                                10: number;
                                11: number;
                                12: number;
                                13: number;
                                14: number;
                                15: number;
                            };
                        };
                    };
                } | {
                    profileName: string;
                    eventTypes: string[];
                    finishingPositionRanges: {
                        1: number;
                    };
                })[];
                aggregationRules: {
                    rollingPeriodDays: number;
                    separateByGender: boolean;
                    perCategory: boolean;
                    countingBuckets: ({
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"];
                        mandatoryRules: {
                            ruleName: string;
                            levels: number[];
                        }[];
                    } | {
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"];
                        mandatoryRules?: undefined;
                    })[];
                };
                doublesAttribution: "fullToEach";
            };
        };
        POLICY_RANKING_POINTS_WTA: {
            rankingPoints: {
                policyName: string;
                policyVersion: string;
                pointsAuthority: string;
                validDateRange: {
                    startDate: string;
                };
                awardProfiles: ({
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    finishingPositionRanges: {
                        1: number;
                        2: number;
                        4: number;
                        8: number;
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: number;
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                1: number;
                                3: number;
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        };
                        2: {
                            level: {
                                1: number;
                                3: number;
                                4: number;
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                            };
                        };
                        4: {
                            level: {
                                1: number;
                                3: number;
                                4: number;
                                5: number;
                                6: number;
                            };
                        };
                        8: {
                            level: {
                                1: number;
                            };
                        };
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                        };
                        2: {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                        };
                        4: {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                        };
                        8: {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                        };
                        16: ({
                            drawSize: number;
                            threshold: boolean;
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                        } | {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                                11: number;
                            };
                            drawSize?: undefined;
                            threshold?: undefined;
                        })[];
                        32: ({
                            drawSize: number;
                            threshold: boolean;
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        } | {
                            level: {
                                7: number;
                                8: number;
                                9: number;
                                10?: undefined;
                            };
                            drawSize?: undefined;
                            threshold?: undefined;
                        })[];
                        64: {
                            level: {
                                9: number;
                                10: number;
                            };
                        };
                    };
                } | {
                    profileName: string;
                    levels: number[];
                    eventTypes: string[];
                    stages: string[];
                    finishingPositionRanges: {
                        1: {
                            level: {
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        };
                        2: {
                            level: {
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        };
                        4: {
                            level: {
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        };
                        8: {
                            level: {
                                5: number;
                                6: number;
                                7: number;
                                8: number;
                                9: number;
                                10: number;
                            };
                        };
                        16: number;
                    };
                })[];
                aggregationRules: {
                    rollingPeriodDays: number;
                    separateByGender: boolean;
                    perCategory: boolean;
                    minCountableResults: number;
                    countingBuckets: ({
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"];
                        mandatoryRules: ({
                            ruleName: string;
                            levels: number[];
                            bestOfCount?: undefined;
                        } | {
                            ruleName: string;
                            levels: number[];
                            bestOfCount: number;
                        })[];
                    } | {
                        bucketName: string;
                        eventTypes: string[];
                        bestOfCount: number;
                        pointComponents: readonly ["positionPoints", "perWinPoints", "bonusPoints"];
                        mandatoryRules?: undefined;
                    })[];
                    tiebreakCriteria: readonly ["highestSingleResult", "mostCountingResults"];
                };
                doublesAttribution: "fullToEach";
            };
        };
        POLICY_ROUND_NAMING_DEFAULT: {
            roundNaming: {
                policyName: string;
                namingConventions: {
                    round: string;
                    pre: string;
                };
                qualifyingFinishMap: {
                    1: string;
                };
                abbreviatedRoundNamingMap: {
                    1: string;
                    2: string;
                    4: string;
                };
                roundNamingMap: {
                    1: string;
                    2: string;
                    4: string;
                };
                affixes: {
                    roundNumber: string;
                    preFeedRound: string;
                    preQualifying: string;
                };
                stageConstants: {
                    MAIN: string;
                    PLAY_OFF: string;
                    QUALIFYING: string;
                    CONSOLATION: string;
                };
            };
        };
        POLICY_SCHEDULING_DEFAULT: {
            scheduling: {
                allowModificationWhenMatchUpsScheduled: {
                    courts: boolean;
                    venues: boolean;
                };
                defaultTimes: {
                    averageTimes: {
                        categoryNames: never[];
                        minutes: {
                            default: number;
                        };
                    }[];
                    recoveryTimes: {
                        minutes: {
                            DOUBLES: number;
                            default: number;
                        };
                    }[];
                };
                defaultDailyLimits: {
                    SINGLES: number;
                    DOUBLES: number;
                    total: number;
                };
                matchUpAverageTimes: {
                    matchUpFormatCodes: string[];
                    averageTimes: ({
                        categoryNames: never[];
                        minutes: {
                            default: number;
                        };
                        categoryTypes?: undefined;
                    } | {
                        categoryTypes: string[];
                        minutes: {
                            default: number;
                        };
                        categoryNames?: undefined;
                    })[];
                }[];
                matchUpRecoveryTimes: ({
                    matchUpFormatCodes: string[];
                    recoveryTimes: {
                        categoryTypes: string[];
                        minutes: {
                            default: number;
                            DOUBLES: number;
                        };
                    }[];
                } | {
                    matchUpFormatCodes: string[];
                    recoveryTimes: {
                        categoryTypes: string[];
                        minutes: {
                            default: number;
                        };
                    }[];
                } | {
                    matchUpFormatCodes: string[];
                    recoveryTimes: {
                        categoryNames: never[];
                        minutes: {
                            default: number;
                        };
                    }[];
                })[];
                matchUpDailyLimits: never[];
            };
        };
        POLICY_SCORING_DEFAULT: {
            scoring: {
                processCodes: {
                    incompleteAssignmentsOnDefault: string[];
                };
                defaultMatchUpFormat: string;
                allowDeletionWithScoresPresent: {
                    drawDefinitions: boolean;
                    structures: boolean;
                };
                requireParticipantsForScoring: boolean;
                requireAllPositionsAssigned: undefined;
                allowChangePropagation: boolean;
                stage: {
                    MAIN: {
                        stageSequence: {
                            1: {
                                requireAllPositionsAssigned: boolean;
                            };
                        };
                    };
                };
                matchUpFormats: never[];
                matchUpStatusCodes: {
                    [x: number]: never[];
                };
            };
        };
        POLICY_SCORING_USTA: {
            scoring: {
                requireAllPositionsAssigned: boolean;
                stage: {
                    MAIN: {
                        stageSequence: {
                            1: {
                                requireAllPositionsAssigned: boolean;
                            };
                        };
                    };
                };
                defaultMatchUpFormat: string;
                matchUpFormats: ({
                    description: string;
                    matchUpFormat: string;
                    categoryNames: never[];
                    categoryTypes: never[];
                } | {
                    description: string;
                    matchUpFormat: string;
                    categoryNames?: undefined;
                    categoryTypes?: undefined;
                })[];
                matchUpStatusCodes: {
                    [x: number]: ({
                        description: string;
                        label: string;
                        matchUpStatusCodeDisplay: string;
                        matchUpStatusCode: string;
                    } | {
                        label: string;
                        matchUpStatusCodeDisplay: string;
                        matchUpStatusCode: string;
                        description?: undefined;
                    })[];
                    WITHDRAWN: {
                        matchUpStatusCodeDisplay: string;
                        matchUpStatusCode: string;
                        label: string;
                    }[];
                };
            };
        };
        POLICY_SEEDING_ITF: {
            seeding: {
                seedingProfile: {
                    positioning: string;
                };
                validSeedPositions: {
                    ignore: boolean;
                };
                duplicateSeedNumbers: boolean;
                drawSizeProgression: boolean;
                policyName: string;
                seedsCountThresholds: {
                    drawSize: number;
                    minimumParticipantCount: number;
                    seedsCount: number;
                }[];
            };
        };
        POLICY_SEEDING_DEFAULT: {
            seeding: {
                validSeedPositions: {
                    ignore: boolean;
                };
                duplicateSeedNumbers: boolean;
                drawSizeProgression: boolean;
                seedingProfile: {
                    drawTypes: {
                        ROUND_ROBIN_WITH_PLAYOFF: {
                            positioning: string;
                        };
                        ROUND_ROBIN: {
                            positioning: string;
                        };
                    };
                    positioning: string;
                };
                policyName: string;
                seedsCountThresholds: {
                    drawSize: number;
                    minimumParticipantCount: number;
                    seedsCount: number;
                }[];
            };
        };
        POLICY_OFFICIATING_EVALUATION_CHAIR_UMPIRE: EvaluationPolicy;
        POLICY_OFFICIATING_EVALUATION_REFEREE: EvaluationPolicy;
        POLICY_PRINT_DEFAULT: {
            print: {
                policyName: string;
            };
        };
    };
    flagIOC: typeof flagIOC;
};

declare function computeRatingDistributionStats({ binWidth, gapThreshold, ratings, }: {
    ratings: number[];
    binWidth?: number;
    gapThreshold?: number;
}): RatingDistributionStats;

declare const auditConstants: {
    AUTO_SCHEDULING_AUDIT: string;
    DELETE_EVENTS: string;
    DELETE_DRAW_DEFINITIONS: string;
};

declare const competitionFormatConstants: {
    INTENNSE_STANDARD: string;
    TENNIS_STANDARD: string;
    MATCHUP: string;
    SET: string;
    HALF: string;
    SEGMENT: string;
    BETWEEN_GAMES: string;
    BETWEEN_POINTS: string;
    ANY: string;
};

declare const drawDefinitionConstants: {
    MAIN: string;
    QUALIFYING: string;
    CONSOLATION: string;
    ITEM: string;
    CONTAINER: string;
    FIRST_MATCHUP: string;
    WINNER: any;
    LOSER: any;
    AD_HOC: string;
    FEED_IN: string;
    FLEX_ROUNDS: string;
    COMPASS: string;
    PLAY_OFF: string;
    PAGE_PLAYOFF: string;
    PAGE_PLAYOFF_ATTRIBUTES: {
        0: {
            name: string;
            abbreviation: string;
        };
        '0-1': {
            name: string;
            abbreviation: string;
        };
        '0-2': {
            name: string;
            abbreviation: string;
        };
    };
    PLAYOFF: string;
    SWISS: string;
    OLYMPIC: string;
    KNOCKOUT: string;
    SINGLE_ELIMINATION: string;
    DOUBLE_ELIMINATION: string;
    CURTIS: string;
    FICSF: string;
    FICQF: string;
    FICR16: string;
    MFIC: string;
    VOLUNTARY_CONSOLATION: string;
    FIRST_MATCH_LOSER_CONSOLATION: string;
    FIRST_ROUND_LOSER_CONSOLATION: string;
    MODIFIED_FEED_IN_CHAMPIONSHIP: string;
    FEED_IN_CHAMPIONSHIP_TO_R16: string;
    FEED_IN_CHAMPIONSHIP_TO_QF: string;
    FEED_IN_CHAMPIONSHIP_TO_SF: string;
    FEED_IN_CHAMPIONSHIP: string;
    LUCKY_DRAW: string;
    ADAPTIVE: string;
    ROUND_ROBIN_WITH_PLAYOFF: string;
    ROUND_ROBIN: string;
    DECIDER: string;
    BACKDRAW: string;
    COMPASS_ATTRIBUTES: {
        0: {
            name: string;
            abbreviation: string;
        };
        '0-1': {
            name: string;
            abbreviation: string;
        };
        '0-2': {
            name: string;
            abbreviation: string;
        };
        '0-3': {
            name: string;
            abbreviation: string;
        };
        '0-1-1': {
            name: string;
            abbreviation: string;
        };
        '0-1-2': {
            name: string;
            abbreviation: string;
        };
        '0-2-1': {
            name: string;
            abbreviation: string;
        };
        '0-1-1-1': {
            name: string;
            abbreviation: string;
        };
    };
    OLYMPIC_ATTRIBUTES: {
        0: {
            name: string;
            abbreviation: string;
        };
        '0-1': {
            name: string;
            abbreviation: string;
        };
        '0-2': {
            name: string;
            abbreviation: string;
        };
        '0-1-1': {
            name: string;
            abbreviation: string;
        };
    };
    ADAPTIVE_ATTRIBUTES: {
        0: {
            name: string;
            abbreviation: string;
        };
        '0-1': {
            name: string;
            abbreviation: string;
        };
        '0-2': {
            name: string;
            abbreviation: string;
        };
        '0-3': {
            name: string;
            abbreviation: string;
        };
        '0-1-1': {
            name: string;
            abbreviation: string;
        };
        '0-1-2': {
            name: string;
            abbreviation: string;
        };
        '0-2-1': {
            name: string;
            abbreviation: string;
        };
        '0-1-1-1': {
            name: string;
            abbreviation: string;
        };
    };
    DRAW: any;
    RANDOM: any;
    TOP_DOWN: any;
    BOTTOM_UP: any;
    CLUSTER: string;
    ADJACENT: string;
    SEPARATE: string;
    WATERFALL: string;
    WIN_RATIO: string;
    ROUND_OUTCOME: string;
    MULTI_STRUCTURE_DRAWS: string[];
    generatedDrawTypes: string[];
    stageOrder: {
        QUALIFYING: number;
        MAIN: number;
        PLAY_OFF: number;
        CONSOLATION: number;
        VOLUNTARY_CONSOLATION: number;
    };
    finishOrder: {
        MAIN: number;
        PLAY_OFF: number;
        CONSOLATION: number;
        QUALIFYING: number;
        VOLUNTARY_CONSOLATION: number;
    };
    AGGREGATE_EVENT_STRUCTURES: string;
    FINISHING_POSITIONS: string;
};

declare const displayConstants: {
    PUBLIC_DISPLAY: string;
    ADMIN_DISPLAY: string;
};

declare const entryStatusConstants: any;

declare const extensionConstants: {
    ACTIVE_SUSPENSION: string;
    APPLIED_POLICIES: string;
    COMPETITION_STATE: string;
    CONTEXT: string;
    DELEGATED_OUTCOME: string;
    DISABLED: string;
    DISABLE_LINKS: string;
    DISABLE_AUTO_CALC: string;
    DISPLAY: string;
    DRAFT_STATE: string;
    DRAW_DELETIONS: string;
    DRAW_PROFILE: string;
    EVENT_PROFILE: string;
    EVENT_WITHDRAWAL_REQUESTS: string;
    FLIGHT_PROFILE: string;
    GROUPING_ATTRIBUTE: string;
    LINEUPS: string;
    LINKED_TOURNAMENTS: string;
    MUTATION_LOCKS: string;
    PARTICIPANT_REPRESENTATIVES: string;
    PERSON_REQUESTS: string;
    POSITION_ACTIONS: string;
    RANKING_POINTS: string;
    REGISTRATION: string;
    ROUND_TARGET: string;
    SANCTIONING_CONSTRAINTS: string;
    SCHEDULE_LIMITS: string;
    SCHEDULE_TIMING: string;
    SCHEDULING_PROFILE: string;
    STATUS_DETAIL: string;
    SUB_ORDER: string;
    TALLY: string;
    TIE_FORMAT_MODIFICATIONS: string;
    FACTORY: string;
};

declare const flightConstants: {
    SPLIT_LEVEL_BASED: string;
    SPLIT_WATERFALL: string;
    SPLIT_SHUTTLE: string;
};

declare const genderConstants: {
    FEMALE_ABBR: string;
    OTHER_ABBR: string;
    MIXED_ABBR: string;
    MALE_ABBR: string;
    ANY_ABBR: string;
    FEMALE: string;
    MIXED: string;
    OTHER: string;
    MALE: string;
    ANY: string;
};

declare const keyValueConstants: {
    OUTCOMEKEYS: string[];
    SIDE1KEYS: string[];
    SIDE2KEYS: string[];
    MODIFIERS: string[];
    PROMPT: string;
    MOVEUP: string[];
    MOVEDOWN: string[];
    HOTKEYS: string;
};

declare const matchUpActionConstants: {
    REPLACE_TEAM_POSITION_METHOD: string;
    ASSIGN_TEAM_POSITION_METHOD: string;
    REMOVE_TEAM_POSITION_METHOD: string;
    REPLACE_PARTICIPANT: string;
    SUBSTITUTION_METHOD: string;
    REMOVE_SUBSTITUTION: string;
    REMOVE_PARTICIPANT: string;
    SCHEDULE_METHOD: string;
    SUBSTITUTION: string;
    SCHEDULE: string;
    PENALTY: string;
    REFEREE: string;
    STATUS: string;
    SCORE: string;
    START: string;
    END: string;
};

declare const matchUpTypes: {
    SINGLES_MATCHUP: string;
    SINGLES: string;
    DOUBLES_MATCHUP: string;
    DOUBLES: string;
    TEAM_MATCHUP: string;
    TEAM: string;
    HYBRID_MATCHUP: string;
    HYBRID: string;
};

declare const participantRoles: {
    ADMINISTRATION: any;
    CAPTAIN: any;
    COACH: any;
    COMPETITOR: any;
    DIRECTOR: any;
    HOSPITALITY: any;
    MEDIA: any;
    MEDICAL: any;
    OFFICIAL: any;
    OTHER: any;
    PHYSIO: any;
    SECURITY: any;
    STRINGER: any;
    SUPERVISOR: any;
    TRAINER: any;
    TRANSPORT: any;
    VOLUNTEER: any;
};

declare const penaltyConstants: {
    COACHING: string;
    BALL_ABUSE: string;
    RACKET_ABUSE: string;
    VERBAL_ABUSE: string;
    PHYSICAL_ABUSE: string;
    INELIGIBILITY: string;
    UNSPORTSMANLIKE_CONDUCT: string;
    PROHIBITED_SUBSTANCE: string;
    DRESS_CODE_VIOLATION: string;
    EQUIMENT_VIOLATION: string;
    LEAVING_THE_COURT: string;
    REFUSAL_TO_PLAY: string;
    FAILURE_TO_COMPLETE: string;
    NO_SHOW: string;
    OTHER: string;
    PUNCTUALITY: string;
    FAILUIRE_TO_SIGN_IN: string;
};

declare const positionActionConstants: {
    MODIFY_PAIR_ASSIGNMENT: string;
    QUALIFYING_PARTICIPANT: string;
    ALTERNATE_PARTICIPANT: string;
    WITHDRAW_PARTICIPANT: string;
    ASSIGN_PARTICIPANT: string;
    LUCKY_PARTICIPANT: string;
    REMOVE_ASSIGNMENT: string;
    SWAP_PARTICIPANTS: string;
    ADD_NICKNAME: string;
    REMOVE_SEED: string;
    ADD_PENALTY: string;
    ASSIGN_BYE: string;
    SEED_CASCADE: string;
    SEED_VALUE: string;
};

declare const rankingConstants: {
    RANKING_POINTS: string;
    QUALITY_WIN: string;
    FULL_TO_EACH: string;
    SPLIT_EVEN: string;
    TEAM_ONLY: string;
    CATEGORY_SCOPE_FIELDS: readonly ["ageCategoryCodes", "genders", "categoryNames", "categoryTypes", "ratingTypes", "ballTypes", "wheelchairClasses", "subTypes"];
    PROFILE_SCOPE_FIELDS: readonly ["eventTypes", "drawTypes", "drawSizes", "maxDrawSize", "stages", "stageSequences", "levels", "maxLevel", "flights", "maxFlightNumber", "participationOrder", "dateRanges"];
};

declare const ratingConstants: {
    ELO: string;
    NTRP: string;
    TRN: string;
    UTR: string;
    WTN: string;
    DUPR: string;
    UTR_P: string;
    UTPR: string;
    PSA: string;
    SQUASH_LEVELS: string;
    US_SQUASH: string;
    USATT: string;
    ITTF: string;
    USAR: string;
    BWF: string;
};

declare const requestConstants: {
    DO_NOT_SCHEDULE: string;
};

declare const resourceContants: {
    RESOURCE_SUB_TYPE: string;
    RESOURCE_TYPE: string;
    IDENTIFIER: string;
    NAME: string;
};

declare const resultConstants: {
    SUCCESS: {
        success: boolean;
    };
    ERROR: string;
};

declare const scaleConstants: {
    RANKING: string;
    RATING: string;
    SCALE: string;
    SEEDING: string;
};

declare const scheduleConstants: {
    SINGLES_DOUBLES: string;
    DOUBLES_SINGLES: string;
    TOTAL: string;
    CONFLICT_MATCHUP_ORDER: string;
    CONFLICT_PARTICIPANTS: string;
    CONFLICT_POTENTIAL_PARTICIPANTS: string;
    CONFLICT_COURT_DOUBLE_BOOKING: string;
    CONFLICT_POSITION_LINK: string;
    SCHEDULE_ISSUE_IDS: string;
    SCHEDULE_CONFLICT: string;
    SCHEDULE_WARNING: string;
    SCHEDULE_ERROR: string;
    SCHEDULE_ISSUE: string;
    SCHEDULE_STATE: string;
    BLOCKED: string;
    PRACTICE: string;
    MAINTENANCE: string;
};

declare const sortingConstants: {
    ASC: string;
    ASCENDING: string;
    DESC: string;
    DESCENDING: string;
};

declare const surfaceConstants: {
    CLAY: string;
    HARD: string;
    GRASS: string;
    CARPET: string;
    ARTIFICIAL: string;
};

declare const swissConstants: {
    BUCHHOLZ: string;
    MEDIAN_BUCHHOLZ: string;
    PROGRESSIVE_SCORE: string;
    RATING_BASED: string;
    SCORE_GROUP: string;
    SONNEBORN_BERGER: string;
};

declare const tallyConstants: {
    GEM_SCORE: string;
};

declare const tieFormatConstants: {
    COLLEGE_D3: string;
    COLLEGE_DEFAULT: string;
    COLLEGE_JUCO: string;
    DOMINANT_DUO: string;
    DOMINANT_DUO_MIXED: string;
    INTENNSE_2026: string;
    LAVER_CUP: string;
    TEAM_DOUBLES_3_AGGREGATION: string;
    USTA_BREWER_CUP: string;
    USTA_OZAKI_CUP: string;
    USTA_COLLEGE: string;
    USTA_GOLD_TEAM_CHALLENGE: string;
    USTA_INTERSECTIONAL: string;
    USTA_LEVEL_1: string;
    USTA_SECTION_BATTLE: string;
    USTA_SOUTHERN_LEVEL_5: string;
    USTA_TOC: string;
    USTA_WTT_ITT: string;
    USTA_ZONAL: string;
};

declare const timeItemConstants: {
    MUTUALLY_EXCLUSIVE_TIME_MODIFIERS: string[];
    AFTER_REST: string;
    ALLOCATE_COURTS: string;
    ASSIGN_COURT: string;
    ASSIGN_OFFICIAL: string;
    ASSIGN_VENUE: string;
    CHECK_IN: string;
    CHECK_OUT: string;
    COMPLETED_DATE: string;
    COURT_ANNOTATION: string;
    COURT_ORDER: string;
    ELIGIBILITY: string;
    END_TIME: string;
    FOLLOWED_BY: string;
    MEDICAL: string;
    MODIFICATION: string;
    NEXT_AVAILABLE: string;
    NOT_BEFORE: string;
    OTHER: string;
    PENALTY: string;
    PUBLIC: string;
    PUBLISH: string;
    RANKING: string;
    RATING: string;
    RAIN_DELAY: string;
    REGISTRATION: string;
    RESUME_TIME: string;
    RETRIEVAL: string;
    SCALE: string;
    SCHEDULE: string;
    SCHEDULED_DATE: string;
    SCHEDULED_TIME: string;
    SEEDING: string;
    START_TIME: string;
    STATUS: string;
    STOP_TIME: string;
    SUSPENSION: string;
    TIME_MODIFIERS: string;
    TO_BE_ANNOUNCED: string;
};

declare const topicConstants: {
    ADD_DRAW_DEFINITION: string;
    ADD_MATCHUPS: string;
    ADD_PARTICIPANTS: string;
    ADD_SCALE_ITEMS: string;
    ADD_EVENT: string;
    ADD_VENUE: string;
    AUDIT: string;
    DATA_ISSUE: string;
    DELETE_PARTICIPANTS: string;
    DELETE_VENUE: string;
    DELETED_DRAW_IDS: string;
    DELETED_MATCHUP_IDS: string;
    MODIFY_DRAW_DEFINITION: string;
    MODIFY_DRAW_ENTRIES: string;
    MODIFY_EVENT_ENTRIES: string;
    MODIFY_MATCHUP: string;
    MODIFY_PARTICIPANTS: string;
    MODIFY_POSITION_ASSIGNMENTS: string;
    MODIFY_SEED_ASSIGNMENTS: string;
    MODIFY_TOURNAMENT_DETAIL: string;
    MODIFY_VENUE: string;
    MUTATIONS: string;
    PUBLISH_EVENT_SEEDING: string;
    PUBLISH_EVENT: string;
    PUBLISH_ORDER_OF_PLAY: string;
    PUBLISH_PARTICIPANTS: string;
    UNPUBLISH_EVENT_SEEDING: string;
    UNPUBLISH_EVENT: string;
    UNPUBLISH_ORDER_OF_PLAY: string;
    UNPUBLISH_PARTICIPANTS: string;
    UNPUBLISH_TOURNAMENT: string;
    UPDATE_INCONTEXT_MATCHUP: string;
};

declare const tournamentConstants: {
    TOURNAMENT_IMAGE_RESOURCE_NAME: string;
    IN_PROGRESS: string;
    ABANDONED: string;
    CANCELLED: string;
    COMPLETED: string;
    ACTIVE: string;
};

declare const officiatingConstants: {
    readonly CERT_ACTIVE: "ACTIVE";
    readonly CERT_EXPIRED: "EXPIRED";
    readonly CERT_SUSPENDED: "SUSPENDED";
    readonly CERT_REVOKED: "REVOKED";
    readonly CERT_PENDING_RENEWAL: "PENDING_RENEWAL";
    readonly EVAL_DRAFT: "DRAFT";
    readonly EVAL_SUBMITTED: "SUBMITTED";
    readonly EVAL_REVIEWED: "REVIEWED";
    readonly EVAL_APPROVED: "APPROVED";
    readonly EVAL_REJECTED: "REJECTED";
    readonly ASSIGN_PROPOSED: "PROPOSED";
    readonly ASSIGN_CONFIRMED: "CONFIRMED";
    readonly ASSIGN_DECLINED: "DECLINED";
    readonly ASSIGN_CANCELLED: "CANCELLED";
    readonly ASSIGN_COMPLETED: "COMPLETED";
    readonly VALID_CERTIFICATION_TRANSITIONS: Record<CertificationStatus, CertificationStatus[]>;
    readonly VALID_EVALUATION_TRANSITIONS: Record<EvaluationStatus, EvaluationStatus[]>;
    readonly VALID_ASSIGNMENT_TRANSITIONS: Record<AssignmentStatus, AssignmentStatus[]>;
    readonly CERTIFICATION_TERMINAL: CertificationStatus[];
    readonly EVALUATION_TERMINAL: EvaluationStatus[];
    readonly ASSIGNMENT_TERMINAL: AssignmentStatus[];
    readonly EVALUATION_EDITABLE: EvaluationStatus[];
    readonly EVALUATION_SCALE_OPTIONS: readonly [{
        readonly value: 1;
        readonly label: "Unsatisfactory";
    }, {
        readonly value: 2;
        readonly label: "Below Average";
    }, {
        readonly value: 3;
        readonly label: "Average";
    }, {
        readonly value: 4;
        readonly label: "Good";
    }, {
        readonly value: 5;
        readonly label: "Excellent";
    }];
};

declare const sanctioningConstants: {
    readonly DRAFT: "DRAFT";
    readonly SUBMITTED: "SUBMITTED";
    readonly UNDER_REVIEW: "UNDER_REVIEW";
    readonly APPROVED: "APPROVED";
    readonly CONDITIONALLY_APPROVED: "CONDITIONALLY_APPROVED";
    readonly REJECTED: "REJECTED";
    readonly WITHDRAWN: "WITHDRAWN";
    readonly MODIFICATION_REQUESTED: "MODIFICATION_REQUESTED";
    readonly ACTIVE: "ACTIVE";
    readonly POST_EVENT: "POST_EVENT";
    readonly CLOSED: "CLOSED";
    readonly ISSUES_FLAGGED: "ISSUES_FLAGGED";
    readonly VALID_STATUS_TRANSITIONS: Record<SanctioningStatus, SanctioningStatus[]>;
    readonly TERMINAL_STATUSES: SanctioningStatus[];
    readonly EDITABLE_STATUSES: SanctioningStatus[];
    readonly AMENDABLE_STATUSES: SanctioningStatus[];
};

declare const venueConstants: {
    INDOOR: string;
    OUTDOOR: string;
};

declare const weekdayConstants: {
    MON: string;
    TUE: string;
    WED: string;
    THU: string;
    FRI: string;
    SAT: string;
    SUN: string;
};

declare const ENTRY_STATUS_REPORT = "entries.entryStatus";
declare const STRUCTURE_REPORT = "structure.drawReport";
declare const PARTICIPANT_STATS_REPORT = "participant.teamStats";
declare const PARTICIPANT_RESULTS_REPORT = "participant.results";
declare const VENUE_UTILIZATION_REPORT = "venue.utilization";
declare const MATCH_RESULTS_REPORT = "matchUp.results";
declare const MATCHUP_STATUS_REPORT = "matchUp.statusSummary";
declare const SEEDING_PERFORMANCE_REPORT = "participant.seedingPerformance";
declare const COMPETITIVENESS_REPORT = "matchUp.competitiveness";
declare const DRAW_REVISIONS_REPORT = "audit.drawRevisions";
declare const SCHEDULING_CHURN_REPORT = "audit.schedulingChurn";
declare const MUTATION_LOG_REPORT = "audit.mutationLog";
declare const POSITION_CHANGES_REPORT = "audit.positionChanges";
declare const REPORT_CATEGORIES: {
    readonly ENTRIES: "Entries";
    readonly DRAWS: "Draws";
    readonly MATCHUPS: "MatchUps";
    readonly PARTICIPANTS: "Participants";
    readonly SCHEDULING: "Scheduling";
    readonly AUDIT: "Audit";
};
declare const REPORT_SOURCE: {
    readonly FACTORY: "factory";
    readonly SERVER: "server";
};

declare const reportConstants_COMPETITIVENESS_REPORT: typeof COMPETITIVENESS_REPORT;
declare const reportConstants_DRAW_REVISIONS_REPORT: typeof DRAW_REVISIONS_REPORT;
declare const reportConstants_ENTRY_STATUS_REPORT: typeof ENTRY_STATUS_REPORT;
declare const reportConstants_MATCHUP_STATUS_REPORT: typeof MATCHUP_STATUS_REPORT;
declare const reportConstants_MATCH_RESULTS_REPORT: typeof MATCH_RESULTS_REPORT;
declare const reportConstants_MUTATION_LOG_REPORT: typeof MUTATION_LOG_REPORT;
declare const reportConstants_PARTICIPANT_RESULTS_REPORT: typeof PARTICIPANT_RESULTS_REPORT;
declare const reportConstants_PARTICIPANT_STATS_REPORT: typeof PARTICIPANT_STATS_REPORT;
declare const reportConstants_POSITION_CHANGES_REPORT: typeof POSITION_CHANGES_REPORT;
declare const reportConstants_REPORT_CATEGORIES: typeof REPORT_CATEGORIES;
declare const reportConstants_REPORT_SOURCE: typeof REPORT_SOURCE;
declare const reportConstants_SCHEDULING_CHURN_REPORT: typeof SCHEDULING_CHURN_REPORT;
declare const reportConstants_SEEDING_PERFORMANCE_REPORT: typeof SEEDING_PERFORMANCE_REPORT;
declare const reportConstants_STRUCTURE_REPORT: typeof STRUCTURE_REPORT;
declare const reportConstants_VENUE_UTILIZATION_REPORT: typeof VENUE_UTILIZATION_REPORT;
declare namespace reportConstants {
  export {
    reportConstants_COMPETITIVENESS_REPORT as COMPETITIVENESS_REPORT,
    reportConstants_DRAW_REVISIONS_REPORT as DRAW_REVISIONS_REPORT,
    reportConstants_ENTRY_STATUS_REPORT as ENTRY_STATUS_REPORT,
    reportConstants_MATCHUP_STATUS_REPORT as MATCHUP_STATUS_REPORT,
    reportConstants_MATCH_RESULTS_REPORT as MATCH_RESULTS_REPORT,
    reportConstants_MUTATION_LOG_REPORT as MUTATION_LOG_REPORT,
    reportConstants_PARTICIPANT_RESULTS_REPORT as PARTICIPANT_RESULTS_REPORT,
    reportConstants_PARTICIPANT_STATS_REPORT as PARTICIPANT_STATS_REPORT,
    reportConstants_POSITION_CHANGES_REPORT as POSITION_CHANGES_REPORT,
    reportConstants_REPORT_CATEGORIES as REPORT_CATEGORIES,
    reportConstants_REPORT_SOURCE as REPORT_SOURCE,
    reportConstants_SCHEDULING_CHURN_REPORT as SCHEDULING_CHURN_REPORT,
    reportConstants_SEEDING_PERFORMANCE_REPORT as SEEDING_PERFORMANCE_REPORT,
    reportConstants_STRUCTURE_REPORT as STRUCTURE_REPORT,
    reportConstants_VENUE_UTILIZATION_REPORT as VENUE_UTILIZATION_REPORT,
  };
}

declare const recoveryTimeRequiredMatchUpStatuses: any[];
declare const particicipantsRequiredMatchUpStatuses: any[];
declare const validMatchUpStatuses: any[];
declare const directingMatchUpStatuses: any[];
declare const nonDirectingMatchUpStatuses: any[];
declare const completedMatchUpStatuses: any[];
declare const activeMatchUpStatuses: any[];
declare const upcomingMatchUpStatuses: any[];
declare const matchUpStatusConstants: {
    ABANDONED: any;
    AWAITING_RESULT: any;
    BYE: any;
    CANCELLED: any;
    COMPLETED: any;
    DEAD_RUBBER: any;
    DEFAULTED: any;
    DOUBLE_WALKOVER: any;
    DOUBLE_DEFAULT: any;
    IN_PROGRESS: any;
    INCOMPLETE: any;
    NOT_PLAYED: any;
    RETIRED: any;
    SUSPENDED: any;
    TO_BE_PLAYED: any;
    WALKOVER: any;
};

type index_PointsAuthority = PointsAuthority;
declare const index_activeMatchUpStatuses: typeof activeMatchUpStatuses;
declare const index_auditConstants: typeof auditConstants;
declare const index_competitionFormatConstants: typeof competitionFormatConstants;
declare const index_completedMatchUpStatuses: typeof completedMatchUpStatuses;
declare const index_directingMatchUpStatuses: typeof directingMatchUpStatuses;
declare const index_displayConstants: typeof displayConstants;
declare const index_drawDefinitionConstants: typeof drawDefinitionConstants;
declare const index_entryStatusConstants: typeof entryStatusConstants;
declare const index_errorConditionConstants: typeof errorConditionConstants;
declare const index_eventConstants: typeof eventConstants;
declare const index_extensionConstants: typeof extensionConstants;
declare const index_flightConstants: typeof flightConstants;
declare const index_genderConstants: typeof genderConstants;
declare const index_keyValueConstants: typeof keyValueConstants;
declare const index_matchUpActionConstants: typeof matchUpActionConstants;
declare const index_matchUpStatusConstants: typeof matchUpStatusConstants;
declare const index_matchUpTypes: typeof matchUpTypes;
declare const index_nonDirectingMatchUpStatuses: typeof nonDirectingMatchUpStatuses;
declare const index_officiatingConstants: typeof officiatingConstants;
declare const index_particicipantsRequiredMatchUpStatuses: typeof particicipantsRequiredMatchUpStatuses;
declare const index_participantConstants: typeof participantConstants;
declare const index_participantRoles: typeof participantRoles;
declare const index_participantTypes: typeof participantTypes;
declare const index_penaltyConstants: typeof penaltyConstants;
declare const index_pointsAuthorityConstants: typeof pointsAuthorityConstants;
declare const index_policyConstants: typeof policyConstants;
declare const index_positionActionConstants: typeof positionActionConstants;
declare const index_rankingConstants: typeof rankingConstants;
declare const index_ratingConstants: typeof ratingConstants;
declare const index_recoveryTimeRequiredMatchUpStatuses: typeof recoveryTimeRequiredMatchUpStatuses;
declare const index_reportConstants: typeof reportConstants;
declare const index_requestConstants: typeof requestConstants;
declare const index_resourceContants: typeof resourceContants;
declare const index_resultConstants: typeof resultConstants;
declare const index_sanctioningConstants: typeof sanctioningConstants;
declare const index_scaleConstants: typeof scaleConstants;
declare const index_scheduleConstants: typeof scheduleConstants;
declare const index_sortingConstants: typeof sortingConstants;
declare const index_surfaceConstants: typeof surfaceConstants;
declare const index_swissConstants: typeof swissConstants;
declare const index_tallyConstants: typeof tallyConstants;
declare const index_tieFormatConstants: typeof tieFormatConstants;
declare const index_timeItemConstants: typeof timeItemConstants;
declare const index_topicConstants: typeof topicConstants;
declare const index_tournamentConstants: typeof tournamentConstants;
declare const index_upcomingMatchUpStatuses: typeof upcomingMatchUpStatuses;
declare const index_validMatchUpStatuses: typeof validMatchUpStatuses;
declare const index_venueConstants: typeof venueConstants;
declare const index_weekdayConstants: typeof weekdayConstants;
declare namespace index {
  export { index_activeMatchUpStatuses as activeMatchUpStatuses, index_auditConstants as auditConstants, index_competitionFormatConstants as competitionFormatConstants, index_completedMatchUpStatuses as completedMatchUpStatuses, index_directingMatchUpStatuses as directingMatchUpStatuses, index_displayConstants as displayConstants, index_drawDefinitionConstants as drawDefinitionConstants, index_entryStatusConstants as entryStatusConstants, index_errorConditionConstants as errorConditionConstants, index_eventConstants as eventConstants, index_extensionConstants as extensionConstants, index_flightConstants as flightConstants, index_genderConstants as genderConstants, index_keyValueConstants as keyValueConstants, index_matchUpActionConstants as matchUpActionConstants, index_matchUpStatusConstants as matchUpStatusConstants, index_matchUpTypes as matchUpTypes, index_nonDirectingMatchUpStatuses as nonDirectingMatchUpStatuses, index_officiatingConstants as officiatingConstants, index_particicipantsRequiredMatchUpStatuses as particicipantsRequiredMatchUpStatuses, index_participantConstants as participantConstants, index_participantRoles as participantRoles, index_participantTypes as participantTypes, index_penaltyConstants as penaltyConstants, index_pointsAuthorityConstants as pointsAuthorityConstants, index_policyConstants as policyConstants, index_positionActionConstants as positionActionConstants, index_rankingConstants as rankingConstants, index_ratingConstants as ratingConstants, index_recoveryTimeRequiredMatchUpStatuses as recoveryTimeRequiredMatchUpStatuses, index_reportConstants as reportConstants, index_requestConstants as requestConstants, index_resourceContants as resourceContants, index_resultConstants as resultConstants, index_sanctioningConstants as sanctioningConstants, index_scaleConstants as scaleConstants, index_scheduleConstants as scheduleConstants, index_sortingConstants as sortingConstants, index_surfaceConstants as surfaceConstants, index_swissConstants as swissConstants, index_tallyConstants as tallyConstants, index_tieFormatConstants as tieFormatConstants, index_timeItemConstants as timeItemConstants, index_topicConstants as topicConstants, index_tournamentConstants as tournamentConstants, index_upcomingMatchUpStatuses as upcomingMatchUpStatuses, index_validMatchUpStatuses as validMatchUpStatuses, index_venueConstants as venueConstants, index_weekdayConstants as weekdayConstants };
  export type { index_PointsAuthority as PointsAuthority };
}

export { AddressTypeEnum, AmendmentSeverityEnum, AmendmentStatusEnum, AssignmentStatusEnum, AvailabilityEngine, BallTypeEnum, CertificationFamilyEnum, CertificationLevelEnum, CertificationStatusEnum, ComplianceItemStatusEnum, ComplianceItemTypeEnum, ComplianceStatusEnum, CountryCodeEnum, CourtPositionEnum, DrawTypeEnum, EndorsementStatusEnum, EntryStatusEnum, EvaluationStatusEnum, EventNotFoundError, FactoryError, FinishingPositionEnum, InvalidDateError, InvalidValuesError, LengthUnitEnum, LinkTypeEnum, MatchUpNotFoundError, MatchUpStatusEnum, MissingDrawDefinitionError, MissingEventError, MissingOfficialRecordError, MissingSanctioningRecordError, MissingTournamentRecordError, MissingTournamentRecordsError, MissingValueError, OfficialRoleSubtypeEnum, OnlineResourceTypeEnum, ParticipantNotFoundError, ParticipantRoleEnum, ParticipantStatusEnum, ParticipantTypeEnum, PenaltyTypeEnum, PlayingDoubleHandCodeEnum, PlayingHandCodeEnum, PositioningProfileEnum, SanctioningRelationshipEnum, SanctioningStatusEnum, ScoringMethodEnum, ScoringTypeEnum, SeedingProfileEnum, SexEnum, ShotDetailEnum, ShotOutcomeEnum, ShotTypeEnum, StageTypeEnum, StructureNotFoundError, StructureTypeEnum, SurfaceCategoryEnum, TournamentLevelEnum, WeekdayEnum, WheelchairClassEnum, WinReasonEnum, activeMatchUpStatuses, askEngine, asyncEngine, auditConstants, index$1 as availability, index$8 as availabilityGovernor, calculateMatchStatistics, competitionEngine, competitionEngineAsync, competitionEngineUntyped, competitionFormatConstants, index$q as competitionGovernor, completedMatchUpStatuses, computeRatingDistributionStats, constructFactoryError, directingMatchUpStatuses, displayConstants, drawDefinitionConstants, index$p as drawsGovernor, dryRun, index$o as entriesGovernor, entryStatusConstants, errorConditionConstants, index$2 as errors, eventConstants, index$n as eventGovernor, explain, extensionConstants, index as factoryConstants, fixtures, flightConstants, forge, genderConstants, generatePatch, index$m as generationGovernor, globalState, index$4 as governors, keyValueConstants, matchUpActionConstants, matchUpEngine, index$l as matchUpFormatCode, index$l as matchUpFormatGovernor, index$k as matchUpGovernor, matchUpStatusConstants, matchUpTypes, mocksEngine, index$j as mocksGovernor, nonDirectingMatchUpStatuses, officiatingConstants, officiatingEngine, index$7 as officiatingGovernor, particicipantsRequiredMatchUpStatuses, participantConstants, index$i as participantGovernor, participantRoles, participantTypes, penaltyConstants, pointsAuthorityConstants, policyComposer, policyConstants, index$h as policyGovernor, policyRegistry, positionActionConstants, index$6 as practiceGovernor, index$g as publishingGovernor, index$f as queryGovernor, rankingConstants, index$e as rankingGovernor, ratingConstants, recoveryTimeRequiredMatchUpStatuses, registerSuggestions, reportConstants, index$d as reportGovernor, requestConstants, resourceContants, resultConstants, sanctioningConstants, sanctioningEngine, scaleConstants, syncEngine as scaleEngine, scheduleConstants, index$c as scheduleGovernor, index$b as scoreGovernor, sortingConstants, surfaceConstants, swissConstants, syncEngine, tallyConstants, tieFormatConstants, index$a as tieFormatGovernor, timeItemConstants, toStatObjects, index$3 as tools, topicConstants, tournamentConstants, tournamentEngine, tournamentEngineAsync, tournamentEngineUntyped, index$9 as tournamentGovernor, unwrap, unwrapOr, upcomingMatchUpStatuses, index$3 as utilities, validMatchUpStatuses, venueConstants, index$5 as venueGovernor, factoryVersion as version, weekdayConstants };
export type { AddScheduleAttributeArgs, Address, AddressProps, AddressTypeUnion, AggregationRules$2 as AggregationRules, Amendment, AmendmentRules, AmendmentSeverity, AmendmentStatus, Applicant, AssignmentStatus, Availability, AwardProfile, AwardProfileScope, BallTypeUnion, BiographicalInformation, BonusPointDef, Booking, BuildFacade, BuildResult, CalendarContext, CalendarEvent, CalendarRules, CalendarSection, Category, CategoryAggregationRule, CategoryScope, CategoryUnion, CertificationFamily, CertificationLevel, CertificationRequirement, CertificationRequirementResult, CertificationStatus, CheckInOutParticipantArgs, CollectionAssignment$1 as CollectionAssignment, CollectionDefinition, CollectionGroup, CollectionValueProfile, ComplianceItem, ComplianceItemStatus, ComplianceItemType, ComplianceRecord, ComplianceStatus, Condition, ConsolationAppetite, Contact, ContextContent, ContextProfile, Coordinates, CountingBucket$2 as CountingBucket, CountryCodeUnion, Court, CourtPosition, CourtPositionUnion, Credential, DateRange, DerivedFilter, DerivedRanking, Directives, DisciplineUnion, DistributionBin, DistributionGap, DocumentLink, DocumentReference, DoublesAttribution, DrawDefinition, DrawLink, DrawLinkSource, DrawLinkTarget, DrawMaticArgs, DrawOpts, DrawStatusUnion, DrawTypeUnion, DryRunResult, EmittedNotice, Endorsement, EndorsementStatus, EngineInspection, EngineInspectionCounts, EngineMethod, EntriesOpts, Entry, EntryFee, EntryStatusUnion, EvaluationCriterion, EvaluationFormField, EvaluationPolicy, EvaluationScore, EvaluationSection, EvaluationStatus, Event$1 as Event, EventBus, EventHandler, EventPredicate, EventProposal, EventSeed, EventTypeUnion, ExitProfiles, ExplainResult, Extension, FactoryEngine, FactoryEngineMethod, FactoryEngineTyped, FactoryErrorOptions, FinishingPositionUnion, Flight, FlightConfig, FlightProfile, FlightStructure, FlightValues, FlightingStrategy, FlightingStrategyType, Game, GenderInput, GenderUnion, GenerateDrawDefinitionArgs, GetMatchUpsArgs, GroupInfo, GroupsMatchUpsResult, HydratedCourt, HydratedMatchUp, HydratedParticipant, HydratedSide, HydratedVenue, IdCollections, IndoorOutdoorUnion, Interleave, JsonPatch, JsonPatchOp, LengthUnitUnion, LevelKeyed, LineParticipation, LineUp, LineValues, LinkTypeUnion, LogisticsOption, LogisticsSection, MandatoryRule, MappedMatchUps, MappedParticipant, MatchStatistics, MatchUp$1 as MatchUp, MatchUpFilters, MatchUpFinishingPositionRange, MatchUpSchedule, MatchUpStatusUnion, MatchUpsMap, MethodSignatures, OfficialAssignment, OfficialCertification, OfficialEvaluation, OfficialProposal, OfficialRecord, OfficialRecords, OfficialRoleSubtype, OfficialSuspension, OfficiatingDirective, OfficiatingDirectives, OfficiatingStatusTransition, OnlineResource, OnlineResourceTypeUnion, OpponentOutcome, Organisation, Participant$1 as Participant, ParticipantBuildResult, ParticipantFilters, ParticipantMap, ParticipantRoleUnion, ParticipantStatusUnion, ParticipantTypeUnion, ParticipantsProfile, Penalty, PenaltyBoxProfile$1 as PenaltyBoxProfile, PenaltyEscalation, PenaltyProfile$1 as PenaltyProfile, PenaltyTypeDefinition, PenaltyTypeUnion, PerWinPointsDef, Person$1 as Person, PersonData, PersonInput, PersonReference, PersonRequests, PersonnelRole, PersonnelRules, PlanWarning, PlayerRules$1 as PlayerRules, PlayingDoubleHandCodeUnion, PlayingHandCodeUnion, PlayoffAttributes, Point$1 as Point, PointAward$2 as PointAward, PointComponent, PointMultiplier$1 as PointMultiplier, PointPoolModel, PointProfile$1 as PointProfile, PointResultDefinition, PointsAuthority, PolicyComposer, PolicyDefinitions, PositionAssignment, PositionValue, PositionValueObject, PositioningProfileUnion, PostEventRequirement, PracticeRegistration, PracticeRegistrationStatus, PrizeMoney, ProposalChange, QualityWinProfile, QualityWinRange, QueryFacade, QueueMethod, RankedPlan, RankedPlanAggregate, RankingListEntry$1 as RankingListEntry, RankingPolicy, RatingDistributionStats, RegistrationEntryFee, RegistrationProfile, RejectedStrategy, ReportAvailability, ReportColumn, ReportContext, ReportDefinition, ReportResult, RequirementItem, ResultType, ReviewNote, Reviewer, RoundProfile, SanctioningDirective, SanctioningDirectives, SanctioningPolicy, SanctioningRecord, SanctioningRecords, SanctioningRelationship, SanctioningStatus, SanctioningTier, ScaleAttributes, ScaleItem, ScaleOption, ScheduleAnalysis, ScheduleConflict, ScheduleTimesResult, ScheduleTiming, ScheduleVisibilityFilters, ScheduledMatchUpArgs, Score$1 as Score, ScoreGroup, ScoringMethod, ScoringType, SeedAssignment, SeedBlock, SeedingProfile, SeedingProfileUnion, SegmentTimer, ServerRule$1 as ServerRule, Set, SexUnion, Shot, ShotDetailUnion, ShotOutcomeUnion, ShotTypeUnion, Side$1 as Side, SocialEvent, SourceFilter, Sponsor, SportUnion, StageTypeUnion, StatCounters$1 as StatCounters, StatObject, StatisticsOptions, StatusTransition, Structure, StructureKind, StructureParticipation, StructureProfile, StructureRecommendation, StructureSortConfig, StructureTypeUnion, Substitution, SubstitutionRules$1 as SubstitutionRules, SubstitutionTiming, SurfaceCategoryUnion, SwissParticipantRecord, SwissPolicy, SwissStanding, SwissState, Tally, TallyResult, TargetMatchUpId, Team, TeamAttribute, TeamCompetitor$1 as TeamCompetitor, TeamKey, TieFormat, TiebreakCriterion, TierClassification, TimeItem, TimeoutRules$1 as TimeoutRules, TimeoutScope, TimerProfile$1 as TimerProfile, Topic, TopicPayloadMap, Tournament, TournamentLevelUnion, TournamentProposal, TournamentRecords, TournamentStatusUnion, TransitionGuard, TransitionGuardType, UnifiedPersonID, UnifiedTournamentID, UnifiedVenueID, Unsubscribe, Unwrap, Venue, VenueProposal, WeekdayUnion, WeightUnitUnion, WheelchairClassUnion, WinCriteria, WinReasonUnion, WithPlayoffsArgs, WizardConstraints, WizardFlight, WizardGovernance, WizardParticipant, competitionFormat };