@ethlete/bracket 1.0.0-next.1

package/types/ethlete-bracket.d.ts

@@ -0,0 +1,1021 @@
+import * as _ethlete_bracket from '@ethlete/bracket';
+
+declare const BRACKET_ERROR_CODES: {
+    /** The source has no rounds/matches to render. */
+    readonly SOURCE_EMPTY: 3401;
+    /** An integration received a tournament mode it does not support. */
+    readonly MODE_UNSUPPORTED: 3402;
+    /** Two rounds in the source share an id. */
+    readonly DUPLICATE_ROUND: 3403;
+    /** Two matches in the source share an id. */
+    readonly DUPLICATE_MATCH: 3404;
+    /** A round-to-round relation could not be resolved (malformed round structure). */
+    readonly ROUND_RELATION_INVALID: 3405;
+    /** A match-to-match relation could not be resolved (match counts don't line up). */
+    readonly MATCH_RELATION_INVALID: 3406;
+    /** The computed layout grid is in an inconsistent state. */
+    readonly GRID_INVALID: 3407;
+    /** Swiss groups could not be generated from the source. */
+    readonly SWISS_GROUPING_FAILED: 3408;
+    /** A Swiss group ended up without any matches while headers are enabled. */
+    readonly SWISS_GROUP_EMPTY: 3409;
+    /** A match's resolved winner id is not among its participants. */
+    readonly WINNER_NOT_FOUND: 3410;
+    /** A required key was missing from an internal bracket lookup map. */
+    readonly DATA_LOOKUP_FAILED: 3411;
+    /** The default cards are rendering but no `matchNormalizer` was registered to feed them. */
+    readonly MISSING_MATCH_NORMALIZER: 3412;
+    /** No registered {@link BracketLayout} matches the source's tournament `mode`. */
+    readonly LAYOUT_NOT_REGISTERED: 3413;
+};
+
+type BracketSlotSourceKind = 'match-outcome' | 'standing-rank' | 'seed' | 'swiss-bucket' | 'bye' | 'external';
+type BracketSlotSource = {
+    kind: BracketSlotSourceKind;
+    role: 'winner' | 'loser' | null;
+    matchId: string | null;
+    standingId: string | null;
+    rank: number | null;
+    label: string | null;
+    /** The seeding position this slot is reserved for. Optional - a source may carry no seeding at all. */
+    seed?: number | null;
+    /** What {@link standingId} is called, for a slot that has to be worded without a lookup. */
+    standingName?: string | null;
+};
+type BracketMatchSlot = {
+    participantId: string | null;
+    source: BracketSlotSource | null;
+};
+type BracketMatchSource<TMatchData> = {
+    data: TMatchData;
+    id: string;
+    roundId: string;
+    home: string | null;
+    away: string | null;
+    /** Where the home participant comes from. Omit for legacy sources that do not carry provenance. */
+    homeSource?: BracketSlotSource | null;
+    /** Where the away participant comes from. Omit for legacy sources that do not carry provenance. */
+    awaySource?: BracketSlotSource | null;
+    winner: MatchParticipantSide | null;
+    status: BracketMatchStatus;
+};
+type BracketDataSource<TRoundData, TMatchData> = {
+    rounds: BracketRoundSource<TRoundData>[];
+    matches: BracketMatchSource<TMatchData>[];
+    mode: TournamentMode;
+};
+type BracketRoundSource<TRoundData> = {
+    type: BracketRoundType;
+    id: string;
+    data: TRoundData;
+    name: string;
+};
+
+declare class BracketMap<TKey, TValue> extends Map<TKey, TValue> {
+    constructor();
+    getOrThrow(key: TKey): TValue;
+    first(): TValue | undefined;
+    last(): TValue | undefined;
+}
+
+declare const BRACKET_DATA_LAYOUT: {
+    readonly LEFT_TO_RIGHT: "left-to-right";
+    /**
+     * Folded in half: each round up to the first one too small to halve is drawn twice, once on each
+     * side, converging on that round and the ones after it. Halves the height and roughly doubles the
+     * width, which is what a poster or a broadcast graphic wants.
+     *
+     * Carried by the mirrored layout factories - a layout that has no fold to make (swiss) simply has no
+     * mirrored variant.
+     */
+    readonly MIRRORED: "mirrored";
+};
+type BracketDataLayout = (typeof BRACKET_DATA_LAYOUT)[keyof typeof BRACKET_DATA_LAYOUT];
+
+type MatchParticipantId = string & {
+    _brand: 'MatchParticipantId';
+};
+type MatchParticipantShortId = string & {
+    _brand: 'MatchParticipantShortId';
+};
+type BracketParticipantBase = {
+    id: MatchParticipantId;
+    shortId: MatchParticipantShortId;
+};
+type BracketParticipantWithRelationsBase = BracketParticipantBase & {
+    matchIds: BracketMatchId[];
+};
+declare const createParticipantsMapBase: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>) => BracketMap<MatchParticipantId, BracketParticipantWithRelationsBase>;
+
+type BracketRoundId = string & {
+    _brand: 'BracketRoundId';
+};
+type BracketRoundShortId = string & {
+    _brand: 'BracketRoundShortId';
+};
+type BracketRoundPosition = number & {
+    _brand: 'BracketRoundPosition';
+};
+type BracketRoundMirrorType = (typeof BRACKET_ROUND_MIRROR_TYPE)[keyof typeof BRACKET_ROUND_MIRROR_TYPE];
+declare const BRACKET_ROUND_MIRROR_TYPE: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+declare const COMMON_BRACKET_ROUND_TYPE: {
+    readonly THIRD_PLACE: "third-place";
+    readonly FINAL: "final";
+};
+declare const SINGLE_ELIMINATION_BRACKET_ROUND_TYPE: {
+    readonly SINGLE_ELIMINATION_BRACKET: "single-elimination-bracket";
+};
+declare const DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE: {
+    readonly UPPER_BRACKET: "upper-bracket";
+    readonly LOWER_BRACKET: "lower-bracket";
+    readonly REVERSE_FINAL: "reverse-final";
+};
+declare const SWISS_BRACKET_ROUND_TYPE: {
+    readonly SWISS: "swiss";
+};
+declare const GROUP_BRACKET_ROUND_TYPE: {
+    readonly GROUP: "group";
+};
+type CommonBracketRoundType = (typeof COMMON_BRACKET_ROUND_TYPE)[keyof typeof COMMON_BRACKET_ROUND_TYPE];
+type SingleEliminationBracketRoundType = CommonBracketRoundType | (typeof SINGLE_ELIMINATION_BRACKET_ROUND_TYPE)[keyof typeof SINGLE_ELIMINATION_BRACKET_ROUND_TYPE];
+type DoubleEliminationBracketRoundType = CommonBracketRoundType | (typeof DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE)[keyof typeof DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE];
+type SwissBracketRoundType = (typeof SWISS_BRACKET_ROUND_TYPE)[keyof typeof SWISS_BRACKET_ROUND_TYPE];
+type GroupBracketRoundType = (typeof GROUP_BRACKET_ROUND_TYPE)[keyof typeof GROUP_BRACKET_ROUND_TYPE];
+type BracketRoundType = SingleEliminationBracketRoundType | DoubleEliminationBracketRoundType | SwissBracketRoundType | GroupBracketRoundType;
+type BracketRoundBase<TRoundData> = {
+    /**
+     * How deep this round sits in its own bracket - 0 for the opening round, counted separately for the
+     * upper and lower halves of a double elimination.
+     *
+     * **Both halves of a mirrored round share it.** That is what makes it the fold's coordinate: a
+     * mirrored layout draws each depth twice, once on each side, so the depth is the only thing that says
+     * which right-hand column belongs opposite which left-hand one.
+     */
+    logicalIndex: number;
+    type: BracketRoundType;
+    id: BracketRoundId;
+    shortId: BracketRoundShortId;
+    data: TRoundData;
+    position: BracketRoundPosition;
+    name: string;
+    matchCount: number;
+    mirrorRoundType: BracketRoundMirrorType | null;
+    isFirstRound: boolean;
+    isLastRound: boolean;
+    isFirstOfType: boolean;
+    isLastOfType: boolean;
+};
+type BracketRoundWithRelationsBase<TRoundData> = BracketRoundBase<TRoundData> & {
+    matchIds: BracketMatchId[];
+};
+declare const createRoundsMapBase: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>, options: GenerateBracketDataOptions) => BracketMap<BracketRoundId, BracketRoundWithRelationsBase<TRoundData>>;
+
+type ParticipantMatchResult = 'win' | 'loss' | 'tie';
+type MatchParticipantSide = 'home' | 'away';
+type BracketMatchParticipantBase = BracketParticipantBase & {
+    result: ParticipantMatchResult | null;
+    isEliminated: boolean;
+    isEliminationMatch: boolean;
+    tieCount: number;
+    winCount: number;
+    lossCount: number;
+    side: MatchParticipantSide;
+};
+type BracketMatchParticipantWithRelationsBase = BracketMatchParticipantBase & BracketParticipantWithRelationsBase;
+declare const createNewMatchParticipantBase: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>, participantId: MatchParticipantId | null, match: BracketMatchSource<TMatchData>, rounds: BracketMap<BracketRoundId, BracketRoundWithRelationsBase<TRoundData>>, matchRoundId: BracketRoundId, participants: BracketMap<MatchParticipantId, BracketParticipantWithRelationsBase>) => BracketMatchParticipantWithRelationsBase | null;
+
+type BracketMatchId = string & {
+    _brand: 'BracketMatchId';
+};
+type BracketMatchShortId = string & {
+    _brand: 'BracketMatchShortId';
+};
+type BracketMatchPosition = number & {
+    _brand: 'BracketMatchPosition';
+};
+type BracketMatchStatus = 'completed' | 'pending';
+type BracketMatchBase<TMatchData> = {
+    data: TMatchData;
+    indexInRound: number;
+    id: BracketMatchId;
+    shortId: BracketMatchShortId;
+    position: BracketMatchPosition;
+    winnerSide: MatchParticipantSide | null;
+    status: BracketMatchStatus;
+    homeSource: BracketSlotSource | null;
+    awaySource: BracketSlotSource | null;
+};
+type BracketMatchWithRelationsBase<TMatchData> = BracketMatchBase<TMatchData> & {
+    roundId: BracketRoundId;
+    home: BracketMatchParticipantWithRelationsBase | null;
+    away: BracketMatchParticipantWithRelationsBase | null;
+    winner: BracketMatchParticipantWithRelationsBase | null;
+};
+declare const createMatchesMapBase: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>, rounds: BracketMap<BracketRoundId, BracketRoundWithRelationsBase<TRoundData>>, participants: BracketMap<MatchParticipantId, BracketParticipantWithRelationsBase>) => BracketMap<BracketMatchId, BracketMatchWithRelationsBase<TMatchData>>;
+
+declare const TOURNAMENT_MODE: {
+    readonly SINGLE_ELIMINATION: "single-elimination";
+    readonly DOUBLE_ELIMINATION: "double-elimination";
+    readonly SWISS_WITH_ELIMINATION: "swiss-with-elimination";
+};
+type TournamentMode = (typeof TOURNAMENT_MODE)[keyof typeof TOURNAMENT_MODE];
+/** Wins that advance a participant out of a swiss stage. */
+declare const SWISS_ADVANCE_WINS = 3;
+/** Losses that eliminate a participant from a swiss stage. */
+declare const SWISS_ELIMINATE_LOSSES = 3;
+
+type BracketBase<TRoundData, TMatchData> = {
+    rounds: BracketMap<BracketRoundId, BracketRoundWithRelationsBase<TRoundData>>;
+    matches: BracketMap<BracketMatchId, BracketMatchWithRelationsBase<TMatchData>>;
+    participants: BracketMap<MatchParticipantId, BracketParticipantWithRelationsBase>;
+    mode: TournamentMode;
+};
+type GenerateBracketDataOptions = {
+    layout: BracketDataLayout;
+};
+type CreateBracketOptions<TMatchData> = GenerateBracketDataOptions & {
+    /** The matches feeding this one, upper arm first. Slot provenance is used when omitted. */
+    previousMatchIds?: (match: BracketMatchSource<TMatchData>) => string[];
+};
+declare const createBracketBase: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>, options: GenerateBracketDataOptions) => BracketBase<TRoundData, TMatchData>;
+
+type BracketPosition = {
+    inline: {
+        start: number;
+        end: number;
+        center: number;
+    };
+    block: {
+        start: number;
+        end: number;
+        center: number;
+    };
+};
+
+/** One connector between two cards, ready for an SVG `<path>`. */
+type BracketEdge = {
+    /**
+     * Stable while only the geometry changes, so a template's `@for` moves the same `<path>` instead of
+     * replacing it - which is what lets the `d` transition run. Unique within one drawing.
+     */
+    id: string;
+    /** The `d` attribute, which is what draws the line. */
+    d: string;
+    /** The same path as a value for the CSS `d` property - the one a transition can animate. */
+    cssPath: string;
+    /** The participant short ids the journey highlight matches on, space separated. */
+    cssClass: string;
+    strokeWidth: number;
+    dashArray: number;
+    dashOffset: number;
+    /** A color, or `url(#id)` naming one of the drawing's {@link BracketGradient}s. */
+    stroke: string;
+};
+/** A box drawn behind the connectors - a swiss layout's group border. */
+type BracketRect = {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The corner radius, as the `rx` attribute. */
+    radius: number;
+    cssClass: string;
+    stroke: string;
+    strokeWidth: number;
+};
+type BracketGradientStop = {
+    /** A CSS/SVG offset, e.g. `'50%'`. */
+    offset: string;
+    color: string;
+};
+/** A horizontal gradient in user space, which an edge's `stroke` names by `url(#id)`. */
+type BracketGradient = {
+    id: string;
+    fromX: number;
+    toX: number;
+    stops: BracketGradientStop[];
+};
+/**
+ * Everything a layout draws between the cells, as data rather than as SVG markup: the host renders it
+ * with `@for`, so nothing has to be trusted past the sanitizer and a connector can animate.
+ */
+type BracketDrawing = {
+    edges: BracketEdge[];
+    rects: BracketRect[];
+    gradients: BracketGradient[];
+};
+
+type PathOptions = {
+    /** Unique within one drawing - see {@link BracketEdge.id}. */
+    id: string;
+    width: number;
+    dashArray: number;
+    dashOffset: number;
+    className: string;
+    stroke?: string;
+};
+declare const path: (d: string, options: PathOptions) => BracketEdge;
+
+type CurveOptions = {
+    lineStartingCurveAmount: number;
+    lineEndingCurveAmount: number;
+    path: PathOptions;
+    inverted?: boolean;
+};
+declare const curvePath: (from: BracketPosition, to: BracketPosition, direction: "up" | "down", options: CurveOptions) => _ethlete_bracket.BracketEdge;
+
+type BracketRoundRelationNothingToOne<TRoundData, TMatchData> = {
+    type: 'nothing-to-one';
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+    nextRoundMatchFactor: number;
+};
+type BracketRoundRelationOneToNothing<TRoundData, TMatchData> = {
+    type: 'one-to-nothing';
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousRound: BracketRound<TRoundData, TMatchData>;
+    previousRoundMatchFactor: number;
+    rootRoundMatchFactor: number;
+};
+type BracketRoundRelationOneToOne<TRoundData, TMatchData> = {
+    type: 'one-to-one';
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousRound: BracketRound<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+    nextRoundMatchFactor: number;
+    previousRoundMatchFactor: number;
+    rootRoundMatchFactor: number;
+};
+type BracketRoundRelationTwoToOne<TRoundData, TMatchData> = {
+    type: 'two-to-one';
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousUpperRound: BracketRound<TRoundData, TMatchData>;
+    previousLowerRound: BracketRound<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+    nextRoundMatchFactor: number;
+    previousUpperRoundMatchFactor: number;
+    previousLowerRoundMatchFactor: number;
+    upperRootRoundMatchFactor: number;
+    lowerRootRoundMatchFactor: number;
+};
+type BracketRoundRelationTwoToNothing<TRoundData, TMatchData> = {
+    type: 'two-to-nothing';
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousUpperRound: BracketRound<TRoundData, TMatchData>;
+    previousLowerRound: BracketRound<TRoundData, TMatchData>;
+    previousUpperRoundMatchFactor: number;
+    previousLowerRoundMatchFactor: number;
+    upperRootRoundMatchFactor: number;
+    lowerRootRoundMatchFactor: number;
+};
+type BracketRoundRelation<TRoundData, TMatchData> = BracketRoundRelationNothingToOne<TRoundData, TMatchData> | BracketRoundRelationOneToNothing<TRoundData, TMatchData> | BracketRoundRelationOneToOne<TRoundData, TMatchData> | BracketRoundRelationTwoToOne<TRoundData, TMatchData> | BracketRoundRelationTwoToNothing<TRoundData, TMatchData>;
+declare const generateRoundRelationsNew: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>) => BracketRoundRelation<TRoundData, TMatchData>[];
+
+type BracketMatchFactor = number;
+type BracketMatchRelationOneToOne<TRoundData, TMatchData> = {
+    type: 'one-to-one';
+    currentMatch: BracketMatch<TRoundData, TMatchData>;
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousMatch: BracketMatch<TRoundData, TMatchData>;
+    previousRound: BracketRound<TRoundData, TMatchData>;
+    nextMatch: BracketMatch<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+};
+type BracketMatchRelationNothingToOne<TRoundData, TMatchData> = {
+    type: 'nothing-to-one';
+    currentMatch: BracketMatch<TRoundData, TMatchData>;
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    nextMatch: BracketMatch<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+};
+type BracketMatchRelationOneToNothing<TRoundData, TMatchData> = {
+    type: 'one-to-nothing';
+    currentMatch: BracketMatch<TRoundData, TMatchData>;
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousMatch: BracketMatch<TRoundData, TMatchData>;
+    previousRound: BracketRound<TRoundData, TMatchData>;
+};
+type BracketMatchRelationTwoToOne<TRoundData, TMatchData> = {
+    type: 'two-to-one';
+    currentMatch: BracketMatch<TRoundData, TMatchData>;
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousUpperMatch: BracketMatch<TRoundData, TMatchData>;
+    previousUpperRound: BracketRound<TRoundData, TMatchData>;
+    previousLowerMatch: BracketMatch<TRoundData, TMatchData>;
+    previousLowerRound: BracketRound<TRoundData, TMatchData>;
+    nextMatch: BracketMatch<TRoundData, TMatchData>;
+    nextRound: BracketRound<TRoundData, TMatchData>;
+};
+type BracketMatchRelationTwoToNothing<TRoundData, TMatchData> = {
+    type: 'two-to-nothing';
+    currentMatch: BracketMatch<TRoundData, TMatchData>;
+    currentRound: BracketRound<TRoundData, TMatchData>;
+    previousUpperMatch: BracketMatch<TRoundData, TMatchData>;
+    previousUpperRound: BracketRound<TRoundData, TMatchData>;
+    previousLowerMatch: BracketMatch<TRoundData, TMatchData>;
+    previousLowerRound: BracketRound<TRoundData, TMatchData>;
+};
+type BracketMatchRelation<TRoundData, TMatchData> = BracketMatchRelationOneToOne<TRoundData, TMatchData> | BracketMatchRelationTwoToOne<TRoundData, TMatchData> | BracketMatchRelationNothingToOne<TRoundData, TMatchData> | BracketMatchRelationOneToNothing<TRoundData, TMatchData> | BracketMatchRelationTwoToNothing<TRoundData, TMatchData>;
+type MatchPositionMaps<TRoundData, TMatchData> = Map<BracketRoundId, Map<BracketMatchPosition, BracketMatch<TRoundData, TMatchData>>>;
+declare const generateMatchPosition: (match: BracketMatch<unknown, unknown>, factor: BracketMatchFactor) => BracketMatchPosition;
+declare const generateMatchRelationPositions: <TRoundData, TMatchData>(relation: BracketRoundRelation<TRoundData, TMatchData>, match: BracketMatch<TRoundData, TMatchData>) => {
+    nextRoundMatchPosition: BracketMatchPosition;
+    previousUpperRoundMatchPosition: BracketMatchPosition;
+    previousLowerRoundMatchPosition: BracketMatchPosition;
+};
+declare const generateMatchRelationsNew: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>, options?: {
+    source?: {
+        matches: BracketMatchSource<TMatchData>[];
+    };
+    previousMatchIds?: (match: BracketMatchSource<TMatchData>) => string[];
+}) => BracketMatchRelation<TRoundData, TMatchData>[];
+
+type Bracket<TRoundData, TMatchData> = {
+    rounds: BracketMap<BracketRoundId, BracketRound<TRoundData, TMatchData>>;
+    roundsByType: BracketMap<BracketRoundType, BracketMap<BracketRoundId, BracketRound<TRoundData, TMatchData>>>;
+    matches: BracketMap<BracketMatchId, BracketMatch<TRoundData, TMatchData>>;
+    participants: BracketMap<MatchParticipantId, BracketParticipant<TRoundData, TMatchData>>;
+    mode: TournamentMode;
+};
+type BracketRound<TRoundData, TMatchData> = BracketRoundBase<TRoundData> & {
+    matches: BracketMap<BracketMatchId, BracketMatch<TRoundData, TMatchData>>;
+    relation: BracketRoundRelation<TRoundData, TMatchData>;
+};
+type BracketMatch<TRoundData, TMatchData> = BracketMatchBase<TMatchData> & {
+    round: BracketRound<TRoundData, TMatchData>;
+    home: BracketMatchParticipant<TRoundData, TMatchData> | null;
+    away: BracketMatchParticipant<TRoundData, TMatchData> | null;
+    winner: BracketMatchParticipant<TRoundData, TMatchData> | null;
+    relation: BracketMatchRelation<TRoundData, TMatchData>;
+};
+type BracketParticipantMatch<TRoundData, TMatchData> = BracketMatch<TRoundData, TMatchData> & {
+    me: BracketMatchParticipant<TRoundData, TMatchData>;
+    opponent: BracketMatchParticipant<TRoundData, TMatchData> | null;
+};
+type BracketParticipant<TRoundData, TMatchData> = BracketParticipantBase & {
+    matches: BracketMap<BracketMatchId, BracketParticipantMatch<TRoundData, TMatchData>>;
+};
+type BracketMatchParticipant<TRoundData, TMatchData> = BracketMatchParticipantBase & {
+    matches: BracketMap<BracketMatchId, BracketMatch<TRoundData, TMatchData>>;
+};
+declare const createBracket: <TRoundData, TMatchData>(source: BracketDataSource<TRoundData, TMatchData>, options: CreateBracketOptions<TMatchData>) => Bracket<TRoundData, TMatchData>;
+
+type BracketPickSet = {
+    /** The participant the viewer picked to win a match. */
+    matchWinner: (matchId: string) => string | null;
+    /** The participant the viewer put on a table position. */
+    standingRank: (options: {
+        standingId: string;
+        rank: number;
+    }) => string | null;
+};
+declare const isBracketSlotPredictable: (source: BracketSlotSource | null) => boolean;
+/** How a resolution weighs a prediction against what is already known. Both parts default to the stricter answer. */
+type BracketSlotResolutionPolicy = {
+    /**
+     * Whether the participant really standing on a slot of the given match outranks whatever the picks
+     * predict for it. Must answer from the match alone, and answer the same way throughout one
+     * resolution: the walk memoizes per slot.
+     *
+     * `true` answers with the real participant wherever one is known - the pairing a pick was made
+     * against, which is what an open round should show. `false`, the default, answers with the
+     * prediction even where reality already disagrees, which is what a locked round should show: the
+     * record of the guess.
+     */
+    realParticipantOutranksPick?: (match: BracketMatch<unknown, unknown>) => boolean;
+    /**
+     * Whether a predicted winner still counts while one side of the match it was made on is unknown.
+     * `false`, the default, drops it until both sides resolve. `true` keeps it until both sides are
+     * known and it is neither of them - until then nothing contradicts it.
+     */
+    keepPickWhileFeederSideIsOpen?: boolean;
+};
+type ResolveBracketSlotOptions = BracketSlotResolutionPolicy & {
+    bracket: Bracket<unknown, unknown>;
+    picks: BracketPickSet;
+    matchId: string;
+    side: MatchParticipantSide;
+};
+/** Who the viewer's own picks put in a slot, or `null` while their picks do not reach it. */
+declare const resolveBracketSlot: (options: ResolveBracketSlotOptions) => string | null;
+
+type BracketPickMigrationOptions = BracketSlotResolutionPolicy & {
+    bracket: Bracket<unknown, unknown>;
+    /** The participant the viewer picked on a match, on the match they picked it on. */
+    pickAsMade: (matchId: string) => string | null;
+    /** The participant the viewer put on a table position, for the `standing-rank` slots a round resolves from. */
+    standingRank?: (options: {
+        standingId: string;
+        rank: number;
+    }) => string | null;
+    /** Matches whose picks the backend already keeps. Their picks neither travel out nor take one in. */
+    lockedMatchIds?: ReadonlySet<string>;
+};
+type BracketPickMigration = {
+    /** The pick that counts on a match: the one made on it, or the one that followed its participant here. */
+    pickByMatchId: Record<string, string | undefined>;
+    /** For a match that took a pick in, the match that pick was made on. */
+    movedFromByMatchId: Record<string, string | undefined>;
+    /** For a match whose pick nothing in its round can honour, that pick. Such a match holds no selection. */
+    strandedByMatchId: Record<string, string | undefined>;
+};
+/**
+ * Where every pick stands once each one has followed its participant into whichever match of its own
+ * round that participant now plays. A pick nothing in the round can honour comes back stranded.
+ */
+declare const migrateBracketPicks: (options: BracketPickMigrationOptions) => BracketPickMigration;
+
+type BracketRoundSwissGroupId = string & {
+    _brand: 'BracketRoundSwissGroupId';
+};
+type BracketRoundSwissGroup<TRoundData, TMatchData> = {
+    id: BracketRoundSwissGroupId;
+    name: string;
+    matches: BracketMap<BracketMatchId, BracketMatch<TRoundData, TMatchData>>;
+    allowedMatchCount: number;
+};
+type BracketRoundSwissGroupMap<TRoundData, TMatchData> = Map<BracketRoundSwissGroupId, BracketRoundSwissGroup<TRoundData, TMatchData>>;
+type BracketRoundSwissData<TRoundData, TMatchData> = {
+    groups: BracketRoundSwissGroupMap<TRoundData, TMatchData>;
+};
+type BracketRoundMapWithSwissData<TRoundData, TMatchData> = Map<BracketRoundId, BracketRoundSwissData<TRoundData, TMatchData>>;
+declare const BRACKET_SWISS_GROUP_COLOR_TYPE: {
+    /** The starting group (0-0) */
+    readonly NEUTRAL: "neutral";
+    /** The group has more wins than losses */
+    readonly POSITIVE: "positive";
+    /** The group is one loss away from elimination */
+    readonly NEGATIVE: "negative";
+    /** Everything in between */
+    readonly WARNING: "warning";
+};
+type BracketSwissGroupColorType = (typeof BRACKET_SWISS_GROUP_COLOR_TYPE)[keyof typeof BRACKET_SWISS_GROUP_COLOR_TYPE];
+/**
+ * Colors for the swiss group borders and connection lines, keyed by the group color type
+ * (see {@link getSwissGroupColorType}). Connection lines are drawn in the neutral color and fade
+ * into the target group color on the last portion before touching its border.
+ * Any CSS color value is allowed. Missing entries fall back to the connector/border color
+ * (the `--et-bracket-line-color` / `--et-bracket-swiss-group-border-color` custom properties,
+ * which default to `--et-surface-border-solid`).
+ */
+type BracketSwissColors = Partial<Record<BracketSwissGroupColorType, string>>;
+declare const getSwissGroupColorType: (wins: number, losses: number) => BracketSwissGroupColorType;
+declare const getAvailableSwissGroupsForRound: (roundNumber: number, totalMatchesInRound: number) => {
+    id: BracketRoundSwissGroupId;
+    name: string;
+    matchesInGroup: number;
+}[];
+declare const generateBracketRoundSwissGroupMaps: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>) => BracketRoundMapWithSwissData<TRoundData, TMatchData> | null;
+
+type BracketComponentType<TInputs> = new (...args: never[]) => TInputs;
+type BracketComponentInput<TValue> = () => TValue;
+type Dimensions = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+type Spacing = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+type BracketRoundHeaderComponent<TRoundData, TMatchData> = BracketComponentType<{
+    bracketRound: BracketComponentInput<BracketRound<TRoundData, TMatchData>>;
+}>;
+type ComponentInputValue<T> = () => {
+    [P in keyof T]: T[P] extends BracketComponentInput<infer TValue> ? TValue : never;
+};
+type BracketMatchComponent<TRoundData, TMatchData> = BracketComponentType<{
+    bracketRound: BracketComponentInput<BracketRound<TRoundData, TMatchData>>;
+    bracketMatch: BracketComponentInput<BracketMatch<TRoundData, TMatchData>>;
+}>;
+type BracketContinueComponent<TRoundData, TMatchData> = BracketComponentType<{
+    /** The matches whose winners advance to the next competition stage */
+    bracketMatches: BracketComponentInput<BracketMatch<TRoundData, TMatchData>[]>;
+}>;
+type BracketComponents<TRoundData, TMatchData> = {
+    roundHeader: BracketRoundHeaderComponent<TRoundData, TMatchData>;
+    match: BracketMatchComponent<TRoundData, TMatchData>;
+    finalMatch: BracketMatchComponent<TRoundData, TMatchData>;
+    continue?: BracketContinueComponent<TRoundData, TMatchData>;
+};
+
+type CreateBracketElementPartConfig = {
+    elementPartHeight: number;
+};
+/**
+ * A row is a part of an element.
+ */
+type BracketElementPart = {
+    dimensions: Dimensions;
+};
+declare const createBracketElementPart: (config: CreateBracketElementPartConfig) => {
+    elementPart: BracketElementPart;
+};
+
+/**
+ * An element is a slice of a section.
+ * It can be a match, a header, a gap, etc.
+ */
+type BracketElementBase = {
+    area: string;
+    /** The dimensions of the actual element */
+    dimensions: Dimensions;
+    /** The dimensions of the container that holds the element */
+    containerDimensions: Dimensions;
+    parts: ReadonlyArray<BracketElementPart>;
+    span?: BracketElementSpanCoordinates;
+    isHidden?: boolean;
+};
+type HeaderBracketElement<TRoundData, TMatchData> = BracketElementBase & HeaderBracketElementDetails<TRoundData, TMatchData>;
+type MatchBracketElement<TRoundData, TMatchData> = BracketElementBase & MatchBracketElementDetails<TRoundData, TMatchData>;
+type GapBracketElement = BracketElementBase & GapBracketElementDetails;
+type ContinueBracketElement<TRoundData, TMatchData> = BracketElementBase & ContinueBracketElementDetails<TRoundData, TMatchData>;
+type BracketElement<TRoundData, TMatchData> = HeaderBracketElement<TRoundData, TMatchData> | MatchBracketElement<TRoundData, TMatchData> | GapBracketElement | ContinueBracketElement<TRoundData, TMatchData>;
+type BracketElementSpanCoordinates = {
+    masterColumnStart: number;
+    masterColumnEnd: number;
+    sectionStart: number;
+    sectionEnd: number;
+    subColumnStart: number;
+    subColumnEnd: number;
+};
+type BracketElementToCreateBase = {
+    area: string;
+    partHeights: number[];
+    elementHeight: number;
+};
+type HeaderBracketElementDetails<TRoundData, TMatchData> = {
+    type: 'header';
+    component: BracketRoundHeaderComponent<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    roundSwissGroup: BracketRoundSwissGroup<TRoundData, TMatchData> | null;
+};
+type HeaderBracketElementToCreate<TRoundData, TMatchData> = BracketElementToCreateBase & HeaderBracketElementDetails<TRoundData, TMatchData>;
+type MatchBracketElementDetails<TRoundData, TMatchData> = {
+    type: 'match';
+    component: BracketMatchComponent<TRoundData, TMatchData>;
+    match: BracketMatch<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    roundSwissGroup: BracketRoundSwissGroup<TRoundData, TMatchData> | null;
+};
+type MatchBracketElementToCreate<TRoundData, TMatchData> = BracketElementToCreateBase & MatchBracketElementDetails<TRoundData, TMatchData>;
+type GapBracketElementDetails = {
+    type: 'matchGap' | 'roundHeaderGap' | 'roundGap' | 'colGap';
+};
+type GapBracketElementToCreate = BracketElementToCreateBase & GapBracketElementDetails;
+type ContinueBracketElementDetails<TRoundData, TMatchData> = {
+    type: 'continue';
+    component: BracketContinueComponent<TRoundData, TMatchData>;
+    matches: BracketMatch<TRoundData, TMatchData>[];
+};
+type ContinueBracketElementToCreate<TRoundData, TMatchData> = BracketElementToCreateBase & ContinueBracketElementDetails<TRoundData, TMatchData>;
+type BracketElementToCreate<TRoundData, TMatchData> = HeaderBracketElementToCreate<TRoundData, TMatchData> | MatchBracketElementToCreate<TRoundData, TMatchData> | GapBracketElementToCreate | ContinueBracketElementToCreate<TRoundData, TMatchData>;
+type BracketElementType = HeaderBracketElementToCreate<unknown, unknown>['type'] | MatchBracketElementToCreate<unknown, unknown>['type'] | GapBracketElementToCreate['type'] | ContinueBracketElementToCreate<unknown, unknown>['type'];
+type MutableBracketElement<TRoundData, TMatchData> = {
+    element: BracketElement<TRoundData, TMatchData>;
+};
+declare const createBracketElement: <TRoundData, TMatchData>(config: BracketElementToCreate<TRoundData, TMatchData>) => MutableBracketElement<TRoundData, TMatchData>;
+
+type BracketSubColumn<TRoundData, TMatchData> = {
+    dimensions: Dimensions;
+    elements: ReadonlyArray<BracketElement<TRoundData, TMatchData>>;
+    span: BracketSubColumnSpan;
+};
+type BracketSubColumnSpan = {
+    isStart: boolean;
+    isEnd: boolean;
+};
+type CreateBracketSubColumnConfig = {
+    span: BracketSubColumnSpan;
+};
+type MutableBracketSubColumn<TRoundData, TMatchData> = {
+    subColumn: BracketSubColumn<TRoundData, TMatchData>;
+    pushElement: (...elements: BracketElement<TRoundData, TMatchData>[]) => void;
+};
+declare const createBracketSubColumn: <TRoundData, TMatchData>(config: CreateBracketSubColumnConfig) => MutableBracketSubColumn<TRoundData, TMatchData>;
+
+type BracketMasterColumnSectionType = 'round' | 'gap';
+type BracketMasterColumnSection<TRoundData, TMatchData> = {
+    subColumns: ReadonlyArray<BracketSubColumn<TRoundData, TMatchData>>;
+    dimensions: Dimensions;
+    type: BracketMasterColumnSectionType;
+    /** Overrides the master column padding for this section */
+    padding?: Spacing;
+};
+type CreateBracketMasterColumnSectionConfig = {
+    type: BracketMasterColumnSectionType;
+    padding?: Spacing;
+};
+type MutableBracketMasterColumnSection<TRoundData, TMatchData> = {
+    masterColumnSection: BracketMasterColumnSection<TRoundData, TMatchData>;
+    pushSubColumn: (...subColumns: BracketSubColumn<TRoundData, TMatchData>[]) => void;
+};
+declare const createBracketMasterColumnSection: <TRoundData, TMatchData>(config: CreateBracketMasterColumnSectionConfig) => MutableBracketMasterColumnSection<TRoundData, TMatchData>;
+
+type BracketMasterColumn<TRoundData, TMatchData> = {
+    sections: ReadonlyArray<BracketMasterColumnSection<TRoundData, TMatchData>>;
+    dimensions: Dimensions;
+    padding: Spacing;
+};
+type CreateBracketMasterColumnConfig = {
+    columnWidth: number;
+    padding: Spacing;
+};
+type MutableBracketMasterColumn<TRoundData, TMatchData> = {
+    masterColumn: BracketMasterColumn<TRoundData, TMatchData>;
+    pushSection: (...sections: BracketMasterColumnSection<TRoundData, TMatchData>[]) => void;
+};
+declare const createBracketMasterColumn: <TRoundData, TMatchData>(config: CreateBracketMasterColumnConfig) => MutableBracketMasterColumn<TRoundData, TMatchData>;
+
+type BracketGrid<TRoundData, TMatchData> = {
+    masterColumns: ReadonlyArray<BracketMasterColumn<TRoundData, TMatchData>>;
+    dimensions: Dimensions;
+};
+type MutableBracketGrid<TRoundData, TMatchData> = {
+    grid: BracketGrid<TRoundData, TMatchData>;
+    pushMasterColumn: (...masterColumns: BracketMasterColumn<TRoundData, TMatchData>[]) => void;
+    calculateDimensions: () => void;
+    setupElementSpans: () => void;
+};
+declare const createBracketGrid: <TRoundData, TMatchData>(config: {
+    spanElementWidth: number;
+}) => MutableBracketGrid<TRoundData, TMatchData>;
+
+type FinalizedBracketColumn<TRoundData = unknown, TMatchData = unknown> = {
+    dimensions: Dimensions;
+    elements: FinalizedBracketElement<TRoundData, TMatchData>[];
+};
+type FinalizedHeaderBracketElement<TRoundData, TMatchData> = {
+    type: 'header';
+    dimensions: Dimensions;
+    component: BracketRoundHeaderComponent<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    roundSwissGroup: BracketRoundSwissGroup<TRoundData, TMatchData> | null;
+};
+type FinalizedMatchBracketElement<TRoundData, TMatchData> = {
+    type: 'match';
+    dimensions: Dimensions;
+    component: BracketMatchComponent<TRoundData, TMatchData>;
+    match: BracketMatch<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    roundSwissGroup: BracketRoundSwissGroup<TRoundData, TMatchData> | null;
+    classes: string;
+};
+type FinalizedContinueBracketElement<TRoundData, TMatchData> = {
+    type: 'continue';
+    dimensions: Dimensions;
+    component: BracketContinueComponent<TRoundData, TMatchData>;
+    matches: BracketMatch<TRoundData, TMatchData>[];
+};
+type FinalizedBracketElement<TRoundData = unknown, TMatchData = unknown> = FinalizedHeaderBracketElement<TRoundData, TMatchData> | FinalizedMatchBracketElement<TRoundData, TMatchData> | FinalizedContinueBracketElement<TRoundData, TMatchData>;
+type FinalizedBracketMatchElementMap<TRoundData, TMatchData> = BracketMap<string, FinalizedMatchBracketElement<TRoundData, TMatchData>>;
+declare const finalizeBracketGrid: <TRoundData, TMatchData>(grid: MutableBracketGrid<TRoundData, TMatchData>) => {
+    columns: FinalizedBracketColumn<TRoundData, TMatchData>[];
+    elementMap: FinalizedBracketMatchElementMap<TRoundData, TMatchData>;
+};
+
+type ComputedBracketGrid<TRoundData, TMatchData> = {
+    raw: MutableBracketGrid<TRoundData, TMatchData>;
+    columns: FinalizedBracketColumn<TRoundData, TMatchData>[];
+    matchElementMap: FinalizedBracketMatchElementMap<TRoundData, TMatchData>;
+};
+/** Returns the width needed to render a computed bracket grid without horizontal clipping. */
+declare const bracketGridNaturalWidth: <TRoundData, TMatchData>(grid: ComputedBracketGrid<TRoundData, TMatchData>) => number;
+type CreateBracketGridConfig = {
+    includeRoundHeaders: boolean;
+    columnWidth: number;
+    matchHeight: number;
+    roundHeaderHeight: number;
+    roundHeaderGap: number;
+    columnGap: number;
+    rowRoundGap: number;
+    rowGap: number;
+    rowSpanRoundId: string | null;
+    /** @internal Resolved by a grid builder from `rowSpanRoundId`. */
+    rowSpanMatchCount?: number;
+    finalMatchHeight: number;
+    finalColumnWidth: number;
+    /**
+     * What the final keeps between its round header and its card, in px, where that is more than
+     * `roundHeaderGap`. The room goes to the final's column alone. Unset gives it the same gap as every
+     * other round.
+     */
+    finalRoundHeaderGap?: number | null;
+    /**
+     * How far below the top of the final's card a third place match sits, in px, when the two share a
+     * column. Unset (or `null`) gives the third place a column of its own.
+     */
+    thirdPlaceTopOffset?: number | null;
+    swissGroupPadding: number;
+    swissGroupBorderWidth: number;
+    layout: BracketDataLayout;
+    continueElement?: {
+        columnWidth: number;
+        elementHeight: number;
+    } | null;
+};
+
+type DrawManDimensions<TRoundData, TMatchData> = {
+    columnWidth: number;
+    matchHeight: number;
+    roundHeaderHeight: number;
+    columnGap: number;
+    upperLowerGap: number;
+    rowGap: number;
+    bracketGrid: ComputedBracketGrid<TRoundData, TMatchData>;
+    path: Omit<PathOptions, 'className' | 'id'>;
+    curve: Omit<CurveOptions, 'path' | 'inverted'>;
+    /** Path options for the lines connecting the continuing matches to the continue element */
+    continuePath?: Omit<PathOptions, 'className' | 'id'>;
+};
+declare const drawMan: <TRoundData, TMatchData>(dimensions: DrawManDimensions<TRoundData, TMatchData>) => BracketDrawing;
+
+type DrawSwissManDimensions<TRoundData, TMatchData> = {
+    bracketGrid: ComputedBracketGrid<TRoundData, TMatchData>;
+    path: Omit<PathOptions, 'className' | 'stroke' | 'id'>;
+    curve: {
+        lineStartingCurveAmount: number;
+    };
+    groupBorder: {
+        padding: number;
+        radius: number;
+        width: number;
+    };
+    colors?: BracketSwissColors;
+    /** Used to create document wide unique ids for the connection line gradients */
+    idPrefix: string;
+};
+declare const drawSwissMan: <TRoundData, TMatchData>(dimensions: DrawSwissManDimensions<TRoundData, TMatchData>) => BracketDrawing;
+
+declare const createDoubleEliminationGrid: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>, options: CreateBracketGridConfig, components: BracketComponents<TRoundData, TMatchData>) => ComputedBracketGrid<TRoundData, TMatchData>;
+
+/**
+ * Draws a double elimination as two mirrored blocks, one above the other: the winners bracket folded
+ * around its own centre, the losers bracket folded around its own, and nothing but a gap between them.
+ * Each block's deciding rounds hang vertically below the round its two halves converge on.
+ *
+ * @internal
+ */
+declare const createStackedDoubleEliminationGrid: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>, options: CreateBracketGridConfig, components: BracketComponents<TRoundData, TMatchData>) => ComputedBracketGrid<TRoundData, TMatchData>;
+
+declare const calculateUpperLowerRatio: (upperRoundsCount: number, lowerRoundsCount: number) => number;
+declare const calculateColumnSplitFactor: (upperToLowerRatio: number) => 1 | 2;
+declare const calculateLowerRoundIndex: (subColumnIndex: number, splitFactor: number) => number;
+declare const calculateUpperRoundIndex: (subColumnIndex: number, upperToLowerRatio: number, splitFactor: number) => number;
+
+declare const isBracketContinueMatch: <TRoundData, TMatchData>(match: BracketMatch<TRoundData, TMatchData>) => boolean;
+declare const getBracketContinueMatches: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>) => BracketMatch<TRoundData, TMatchData>[];
+type CreateBracketContinueMasterColumnConfig<TRoundData, TMatchData> = {
+    existingMasterColumns: ReadonlyArray<BracketMasterColumn<TRoundData, TMatchData>>;
+    columnWidth: number;
+    elementHeight: number;
+    /** Vertical space taken by the round header block (header + gap). 0 if headers are hidden. */
+    headerOffset: number;
+    component: BracketContinueComponent<TRoundData, TMatchData>;
+    matches: BracketMatch<TRoundData, TMatchData>[];
+};
+declare const createBracketContinueMasterColumn: <TRoundData, TMatchData>(config: CreateBracketContinueMasterColumnConfig<TRoundData, TMatchData>) => BracketMasterColumn<TRoundData, TMatchData>;
+
+type CreateFoldedThirdPlaceSectionConfig<TRoundData, TMatchData> = {
+    /** The sub column holding the final, which the folded round is placed relative to. */
+    finalSubColumn: BracketSubColumn<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    /** How far below the top of the final's card the third place card sits, in px. */
+    topOffset: number;
+    options: CreateBracketGridConfig;
+    components: BracketComponents<TRoundData, TMatchData>;
+};
+/**
+ * The third place match as a second section of the final's master column: one card the given number of
+ * px below the top of the final's, with its own round header above it.
+ *
+ * @internal
+ */
+declare const createFoldedThirdPlaceSection: <TRoundData, TMatchData>(config: CreateFoldedThirdPlaceSectionConfig<TRoundData, TMatchData>) => BracketMasterColumnSection<TRoundData, TMatchData>;
+
+type CreateBracketGapMasterColumnConfig<TRoundData, TMatchData> = {
+    existingMasterColumns: ReadonlyArray<BracketMasterColumn<TRoundData, TMatchData>>;
+    columnGap: number;
+};
+declare const createBracketGapMasterColumn: <TRoundData, TMatchData>(config: CreateBracketGapMasterColumnConfig<TRoundData, TMatchData>) => BracketMasterColumn<TRoundData, TMatchData>;
+
+type CreateRoundBracketSubColumnRelativeToFirstRoundConfig<TRoundData, TMatchData> = {
+    firstRound: BracketRound<TRoundData, TMatchData>;
+    round: BracketRound<TRoundData, TMatchData>;
+    span: BracketSubColumnSpan;
+    hasReverseFinal: boolean;
+    options: CreateBracketGridConfig;
+    components: BracketComponents<TRoundData, TMatchData>;
+    /**
+     * Reserved space below the last match, for a layout whose columns are taller than the first round
+     * needs - a stacked bracket's centre chain hanging past the bottom of its block.
+     */
+    bottomPadding?: number;
+    /**
+     * How many first-round rows each of this round's matches owns. Derived from the round's own match
+     * count when unset; a folded round is placed by its offset instead and takes `1`.
+     */
+    matchFactor?: number;
+};
+declare const createRoundBracketSubColumnRelativeToFirstRound: <TRoundData, TMatchData>(config: CreateRoundBracketSubColumnRelativeToFirstRoundConfig<TRoundData, TMatchData>) => _ethlete_bracket.BracketSubColumn<TRoundData, TMatchData>;
+
+declare const resolveBracketGridRowSpan: <TRoundData, TMatchData>(bracket: Bracket<TRoundData, TMatchData>, options: CreateBracketGridConfig) => CreateBracketGridConfig;
+
+declare const createSingleEliminationGrid: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>, options: CreateBracketGridConfig, components: BracketComponents<TRoundData, TMatchData>) => ComputedBracketGrid<TRoundData, TMatchData>;
+
+declare const createSwissGrid: <TRoundData, TMatchData>(bracketData: Bracket<TRoundData, TMatchData>, options: CreateBracketGridConfig, components: BracketComponents<TRoundData, TMatchData>) => ComputedBracketGrid<TRoundData, TMatchData>;
+
+type LineOptions = {
+    path: PathOptions;
+    /** Draw right to left - the flow direction of a mirrored bracket's way back. */
+    inverted?: boolean;
+};
+declare const linePath: (from: BracketPosition, to: BracketPosition, options: LineOptions) => _ethlete_bracket.BracketEdge;
+/**
+ * The connector between two cards sharing a column, where {@link linePath} and `curvePath` both
+ * degenerate to a zero-width horizontal run: straight down (or up) the column, edge to edge.
+ */
+declare const verticalPath: (from: BracketPosition, to: BracketPosition, options: LineOptions) => _ethlete_bracket.BracketEdge;
+type GutterLineOptions = LineOptions & {
+    /** How far past the column's edge the vertical run sits - half a column gap keeps it clear of both. */
+    gutter: number;
+};
+/**
+ * A same-column connector for two cards with others stacked between them: out sideways, along the
+ * empty strip beside the column, and back in. {@link verticalPath} would run through everything in
+ * its way.
+ */
+declare const gutterPath: (from: BracketPosition, to: BracketPosition, options: GutterLineOptions) => _ethlete_bracket.BracketEdge;
+
+type BracketLayoutRegistration = {
+    name: string;
+    mode: TournamentMode;
+};
+/** Returns the first registered layout matching the tournament mode. */
+declare const resolveBracketLayout: <TLayout extends BracketLayoutRegistration>(layouts: readonly TLayout[] | undefined, mode: TournamentMode) => TLayout;
+
+/** How a group-table prediction scored on one position, once the real order is in. */
+declare const STANDING_PICK_OUTCOME: {
+    /** The participant finished on exactly the predicted position. */
+    readonly EXACT: "exact";
+    /** They finished on the predicted side of the advancing line, on another position. */
+    readonly PARTIAL: "partial";
+    /** They finished on the other side of the advancing line. */
+    readonly WRONG: "wrong";
+};
+type StandingPickOutcome = (typeof STANDING_PICK_OUTCOME)[keyof typeof STANDING_PICK_OUTCOME];
+/**
+ * How the participant predicted on `predictedPosition` scored, given where they really finished.
+ *
+ * `advancingCount` is how many positions advance, so a position is on the advancing side while it is
+ * `<= advancingCount`. Ending up on the other side of that line is `WRONG` whatever the distance; the
+ * predicted side of it is `EXACT` on the predicted position and `PARTIAL` on any other.
+ *
+ * `EXACT` is awarded below the line as well. An app whose API stores only the advancing positions holds no
+ * prediction for the rest - the order there is whatever its UI happened to draw - and should narrow the
+ * result to `PARTIAL`/`WRONG` itself for those positions.
+ *
+ * Returns the outcome and no points: what an outcome is worth is a rule of the competition, and
+ * `POINTS[outcome]` is a lookup the app already owns.
+ */
+declare const standingPickOutcome: (options: {
+    /** The position the participant was predicted to finish on, 1-based. */
+    predictedPosition: number;
+    /** The position they really finished on, 1-based. */
+    actualPosition: number;
+    /** How many positions advance. */
+    advancingCount: number;
+}) => StandingPickOutcome;
+
+/** A prediction already stored for one position of a group table. */
+type StandingPick = {
+    /** The position it was stored on, 1-based. */
+    position: number;
+    /** The participant predicted to finish there. */
+    participantId: string;
+};
+/**
+ * The order to show a group table in before anyone moves a row: every stored pick takes the position it was
+ * stored on, and the participants without one follow in the order the backend listed them, filling the gaps.
+ *
+ * A pick the field cannot hold is dropped rather than drawn - a position outside
+ * `1..participantIds.length`, an id that is not in the field, a second pick for a position or for a
+ * participant already placed (the lowest position keeps it). The result is therefore always a permutation
+ * of `participantIds`.
+ */
+declare const standingPickStartOrder: (options: {
+    /** The participants, in the order the backend listed them. */
+    participantIds: readonly string[];
+    /** What is already stored, in any order. */
+    picks: readonly StandingPick[];
+}) => string[];
+
+export { BRACKET_DATA_LAYOUT, BRACKET_ERROR_CODES, BRACKET_ROUND_MIRROR_TYPE, BRACKET_SWISS_GROUP_COLOR_TYPE, BracketMap, COMMON_BRACKET_ROUND_TYPE, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, GROUP_BRACKET_ROUND_TYPE, SINGLE_ELIMINATION_BRACKET_ROUND_TYPE, STANDING_PICK_OUTCOME, SWISS_ADVANCE_WINS, SWISS_BRACKET_ROUND_TYPE, SWISS_ELIMINATE_LOSSES, TOURNAMENT_MODE, bracketGridNaturalWidth, calculateColumnSplitFactor, calculateLowerRoundIndex, calculateUpperLowerRatio, calculateUpperRoundIndex, createBracket, createBracketBase, createBracketContinueMasterColumn, createBracketElement, createBracketElementPart, createBracketGapMasterColumn, createBracketGrid, createBracketMasterColumn, createBracketMasterColumnSection, createBracketSubColumn, createDoubleEliminationGrid, createFoldedThirdPlaceSection, createMatchesMapBase, createNewMatchParticipantBase, createParticipantsMapBase, createRoundBracketSubColumnRelativeToFirstRound, createRoundsMapBase, createSingleEliminationGrid, createStackedDoubleEliminationGrid, createSwissGrid, curvePath, drawMan, drawSwissMan, finalizeBracketGrid, generateBracketRoundSwissGroupMaps, generateMatchPosition, generateMatchRelationPositions, generateMatchRelationsNew, generateRoundRelationsNew, getAvailableSwissGroupsForRound, getBracketContinueMatches, getSwissGroupColorType, gutterPath, isBracketContinueMatch, isBracketSlotPredictable, linePath, migrateBracketPicks, path, resolveBracketGridRowSpan, resolveBracketLayout, resolveBracketSlot, standingPickOutcome, standingPickStartOrder, verticalPath };
+export type { Bracket, BracketBase, BracketComponentInput, BracketComponentType, BracketComponents, BracketContinueComponent, BracketDataLayout, BracketDataSource, BracketDrawing, BracketEdge, BracketElement, BracketElementBase, BracketElementPart, BracketElementSpanCoordinates, BracketElementToCreate, BracketElementToCreateBase, BracketElementType, BracketGradient, BracketGradientStop, BracketGrid, BracketLayoutRegistration, BracketMasterColumn, BracketMasterColumnSection, BracketMasterColumnSectionType, BracketMatch, BracketMatchBase, BracketMatchComponent, BracketMatchFactor, BracketMatchId, BracketMatchParticipant, BracketMatchParticipantBase, BracketMatchParticipantWithRelationsBase, BracketMatchPosition, BracketMatchRelation, BracketMatchRelationNothingToOne, BracketMatchRelationOneToNothing, BracketMatchRelationOneToOne, BracketMatchRelationTwoToNothing, BracketMatchRelationTwoToOne, BracketMatchShortId, BracketMatchSlot, BracketMatchSource, BracketMatchStatus, BracketMatchWithRelationsBase, BracketParticipant, BracketParticipantBase, BracketParticipantMatch, BracketParticipantWithRelationsBase, BracketPickMigration, BracketPickMigrationOptions, BracketPickSet, BracketPosition, BracketRect, BracketRound, BracketRoundBase, BracketRoundHeaderComponent, BracketRoundId, BracketRoundMapWithSwissData, BracketRoundMirrorType, BracketRoundPosition, BracketRoundRelation, BracketRoundRelationNothingToOne, BracketRoundRelationOneToNothing, BracketRoundRelationOneToOne, BracketRoundRelationTwoToNothing, BracketRoundRelationTwoToOne, BracketRoundShortId, BracketRoundSource, BracketRoundSwissData, BracketRoundSwissGroup, BracketRoundSwissGroupId, BracketRoundSwissGroupMap, BracketRoundType, BracketRoundWithRelationsBase, BracketSlotResolutionPolicy, BracketSlotSource, BracketSlotSourceKind, BracketSubColumn, BracketSubColumnSpan, BracketSwissColors, BracketSwissGroupColorType, CommonBracketRoundType, ComponentInputValue, ComputedBracketGrid, ContinueBracketElement, ContinueBracketElementDetails, ContinueBracketElementToCreate, CreateBracketContinueMasterColumnConfig, CreateBracketElementPartConfig, CreateBracketGapMasterColumnConfig, CreateBracketGridConfig, CreateBracketMasterColumnConfig, CreateBracketMasterColumnSectionConfig, CreateBracketOptions, CreateBracketSubColumnConfig, CreateFoldedThirdPlaceSectionConfig, CreateRoundBracketSubColumnRelativeToFirstRoundConfig, CurveOptions, Dimensions, DoubleEliminationBracketRoundType, DrawManDimensions, DrawSwissManDimensions, FinalizedBracketColumn, FinalizedBracketElement, FinalizedBracketMatchElementMap, FinalizedContinueBracketElement, FinalizedHeaderBracketElement, FinalizedMatchBracketElement, GapBracketElement, GapBracketElementDetails, GapBracketElementToCreate, GenerateBracketDataOptions, GroupBracketRoundType, GutterLineOptions, HeaderBracketElement, HeaderBracketElementDetails, HeaderBracketElementToCreate, LineOptions, MatchBracketElement, MatchBracketElementToCreate, MatchParticipantId, MatchParticipantShortId, MatchParticipantSide, MatchPositionMaps, MutableBracketElement, MutableBracketGrid, MutableBracketMasterColumn, MutableBracketMasterColumnSection, MutableBracketSubColumn, ParticipantMatchResult, PathOptions, SingleEliminationBracketRoundType, Spacing, StandingPick, StandingPickOutcome, SwissBracketRoundType, TournamentMode };