courthive-components 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -1,4006 +1,80 @@
-import { Instance } from 'tippy.js';
-import { temporal } from 'tods-competition-factory';
-import { TemporalEngine } from 'tods-competition-factory';
-
-export declare function activateScheduleCellTypeAhead({ cell, listProvider, onSelect, onCancel }: ScheduleCellTypeAheadOptions): {
-    destroy: () => void;
-};
-
-declare interface Address {
-    addressType?: string;
-    city?: string;
-    state?: string;
-    country?: string;
-    countryCode?: string;
-    postalCode?: string;
-}
-
-export declare interface AgeCategoryConfig {
-    labels?: {
-        title?: string;
-        consideredDateLabel?: string;
-        typeLabel?: string;
-        ageLabel?: string;
-        standardCodesLabel?: string;
-    };
-    options?: {
-        ages?: number[];
-        categoryTypes?: string[];
-    };
-    preDefinedCodes?: Array<{
-        code: string;
-        text: string;
-    }>;
-    defaultConsideredDate?: string;
-}
-
-export declare function applyDropCommit(profileDraft: SchedulingProfile, drag: DragPayload, drop: DropTarget): DropResult;
-
-export declare interface AverageTimeEntry {
-    categoryNames?: string[];
-    categoryTypes?: string[];
-    minutes: MinutesEntry;
-}
-
-export declare function badmintonCourt(className: string): SVGSVGElement;
-
-export declare function barButton(itemConfig: any): HTMLButtonElement;
-
-export declare function baseballDiamond(className: string): SVGSVGElement;
-
-export declare function basketballCourt(className: string): SVGSVGElement;
-
-/**
- * Color scheme for block types
- */
-declare interface BlockColorScheme {
-    AVAILABLE: string;
-    BLOCKED: string;
-    PRACTICE: string;
-    MAINTENANCE: string;
-    RESERVED: string;
-    CLOSED: string;
-    SCHEDULED: string;
-    SOFT_BLOCK: string;
-    HARD_BLOCK: string;
-    LOCKED: string;
-    UNSPECIFIED: string;
-}
-
-declare interface BlockPopoverManager {
-    show(target: HTMLElement, options: BlockPopoverOptions): void;
-    showForEngineBlock(target: HTMLElement, options: EngineBlockPopoverOptions): void;
-    destroy(): void;
-    isActiveFor(itemId: string): boolean;
-}
-
-declare interface BlockPopoverOptions {
-    itemId: string;
-    blockTypes: Array<{
-        type: string;
-        color: string;
-        label: string;
-    }>;
-    currentType?: string;
-    startTime?: string;
-    endTime?: string;
-    onTypeSelected: (type: string) => void;
-    onAdjustTime?: (startTime: string, endTime: string) => void;
-    onDelete?: () => void;
-}
-
-declare type BlockType = temporal.BlockType;
-
-declare type BlockType_2 = temporal.BlockType;
-
-export declare function buildCourtGridSlot(courtGridElement: HTMLElement | undefined, callbacks: CourtGridSlotCallbacks, options?: CourtGridSlotOptions): UIPanel_3<SchedulePageState>;
-
-export declare function buildDateStrip(callbacks: DateStripCallbacks): UIPanel<ProfileStoreState>;
-
-export declare function buildEdgeEditor(callbacks: EdgeEditorCallbacks): UIPanel_2<TopologyState>;
-
-export declare function buildEditorShell(callbacks: EditorShellCallbacks): EditorShellPanel;
-
-export declare function buildInspectorPanel(): UIPanel<ProfileStoreState>;
-
-/**
- * Build a mobile-first full-page interactive scoring shell around a
- * `ScoringEngine` (wrapped by the existing `InlineScoringManager`).
- *
- * This is the courthive-public Phase 2 scoring UI: anonymous,
- * local-only, mobile-first. It does NOT persist state itself —
- * consumers subscribe to `stateChanged` events and handle
- * persistence (IndexedDB in courthive-public's case).
- *
- * Phase 2 targets standard tennis matchUpFormats (`SET3-S:6/TB7`,
- * `SET5-S:6/TB7`, etc.). INTENNSE bolt scoring, pickleball score
- * caps, doubles lineup changes, and other format-specific behaviors
- * are deferred to Phase 2.5+.
- *
- * The DOM structure:
- * ```
- * .chc-interactive-scoring-shell
- *   .chc-iss-header          (side names + format indicator)
- *   .chc-iss-score-display   (current set scores + game score)
- *   .chc-iss-point-buttons   (big Side 1 / Side 2 point-won buttons)
- *   .chc-iss-control-bar     (undo, reset, complete indicator)
- * ```
- *
- * All styling lives in `interactive-scoring.css` using the shared
- * `--sp-*` / `--chc-*` theme variables.
- */
-export declare function buildInteractiveScoringShell(config: InteractiveScoringShellConfig): InteractiveScoringShell;
-
-export declare function buildIssueIndex(results: ValidationResult[]): IssueIndex;
-
-export declare function buildIssuesPanel(callbacks: IssuesPanelCallbacks): UIPanel<ProfileStoreState>;
-
-export declare function buildJsonEditor(config: {
-    initialData: Record<string, unknown>;
-    onChange: (data: Record<string, unknown>) => void;
-}): PolicyEditorInstance;
-
-export declare function buildMatchUpCard(item: CatalogMatchUpItem, callbacks: MatchUpCardCallbacks): HTMLElement;
-
-export declare function buildMatchUpCatalog(callbacks: MatchUpCatalogCallbacks): UIPanel_3<SchedulePageState>;
-
-export declare function buildNodeEditor(callbacks: NodeEditorCallbacks): UIPanel_2<TopologyState>;
-
-export declare function buildPolicyCatalogLayout(panels: {
-    catalogPanel: UIPanel_4<PolicyCatalogState>;
-    editorShell: EditorShellPanel;
-}): UIPanel_4<PolicyCatalogState>;
-
-export declare function buildPolicyCatalogPanel(callbacks: PolicyCatalogPanelCallbacks): UIPanel_4<PolicyCatalogState>;
-
-export declare function buildRoundCard(data: RoundCardData, callbacks: RoundCardCallbacks): HTMLElement;
-
-export declare function buildRoundCatalog(callbacks: RoundCatalogCallbacks): UIPanel<ProfileStoreState>;
-
-export declare function buildScheduleDateStrip(callbacks: DateStripCallbacks_2): UIPanel_3<SchedulePageState>;
-
-export declare function buildScheduleGridCell(data: ScheduleCellData, config?: ScheduleCellConfig): HTMLElement;
-
-export declare function buildScheduleInspectorPanel(): UIPanel_3<SchedulePageState>;
-
-export declare function buildScheduleIssueIndex(issues: ScheduleIssue[]): ScheduleIssueIndex;
-
-export declare function buildScheduleIssuesPanel(): UIPanel_3<SchedulePageState>;
-
-export declare function buildSchedulePageLayout(panels: SchedulePageLayoutPanels, callbacks: SchedulePageLayoutCallbacks, options?: {
-    hideLeft?: boolean;
-    catalogSide?: 'left' | 'right';
-}): {
-    element: HTMLElement;
-    update: (state: SchedulePageState) => void;
-};
-
-export declare function buildSchedulingEditorPanel(store: SchedulingEditorStore, config: SchedulingEditorConfig): {
-    element: HTMLElement;
-    update(state: SchedulingEditorState): void;
-};
-
-export declare function buildSchedulingProfileLayout(panels: LayoutPanels, options?: {
-    hideLeft?: boolean;
-    catalogSide?: 'left' | 'right';
-}): {
-    element: HTMLElement;
-    update: (state: ProfileStoreState) => void;
-};
-
-/**
- * Build a SetScore object from input values
- * Assigns winningSide if set is complete
- */
-export declare function buildSetScore(setIndex: number, side1Value: string, side2Value: string, tiebreakValue: string | undefined, config: MatchUpConfig): SetScore;
-
-export declare function buildStructureCard(node: TopologyNode, callbacks: StructureCardCallbacks, isSelected: boolean, hasWinnerLink: boolean, roundAnnotations?: RoundAnnotation[], warnings?: string[], advanceInfo?: string, positionChips?: PositionChip[]): HTMLElement;
-
-export declare function buildToolbar(callbacks: ToolbarCallbacks, templates: TopologyTemplate[], options?: ToolbarOptions): UIPanel_2<TopologyState>;
-
-export declare function buildTopologyBuilderLayout({ toolbar, canvas, nodeEditor, edgeEditor }: {
-    toolbar: UIPanel_2<TopologyState>;
-    canvas: UIPanel_2<TopologyState>;
-    nodeEditor: UIPanel_2<TopologyState>;
-    edgeEditor: UIPanel_2<TopologyState>;
-}): UIPanel_2<TopologyState>;
-
-export declare function buildTopologyCanvas(callbacks: CanvasCallbacks): UIPanel_2<TopologyState>;
-
-export declare function buildVenueBoard(callbacks: VenueBoardCallbacks): UIPanel<ProfileStoreState>;
-
-/**
- * Factory function to create a burst chart renderer.
- * Accepts either SunburstDrawData (new) or TournamentDraw (legacy, auto-converted).
- */
-export declare function burstChart(options?: BurstChartOptions): {
-    render: (container: HTMLElement, drawData: SunburstDrawData, title: string) => BurstChartInstance;
-};
-
-export declare interface BurstChartEventHandlers {
-    clickSegment?: (data: SegmentData) => void;
-    clickCenter?: () => void;
-}
-
-/** Handle returned by render() for controlling the chart after rendering */
-export declare interface BurstChartInstance {
-    /** Highlight all segments belonging to a player. Returns count of highlighted nodes. Omit name to clear. */
-    highlightPlayer: (playerName?: string) => number;
-    /** Show or hide the entire chart SVG */
-    hide: (hidden: boolean) => void;
-}
-
-export declare interface BurstChartOptions {
-    width?: number;
-    height?: number;
-    title?: string;
-    colorBySeeds?: boolean;
-    countryCodes?: Record<string, string>;
-    eventHandlers?: BurstChartEventHandlers;
-    textScaleFactor?: number;
-}
-
-/**
- * Calculate the complement score for smart complement entry
- * Returns null if no predictable complement exists
- *
- * @param digit - The digit entered (0-9)
- * @param setFormat - The format for this set
- * @returns Complement value or null if digit >= setTo (no predictable complement)
- */
-export declare function calculateComplement(digit: number, setFormat?: SetFormat): number | null;
-
-declare interface CanvasCallbacks {
-    onSelectNode: (nodeId: string | null) => void;
-    onSelectEdge: (edgeId: string | null) => void;
-    onDoubleClickNode?: (nodeId: string) => void;
-    onMoveNode: (nodeId: string, x: number, y: number) => void;
-    onCreateEdge: (sourceNodeId: string, targetNodeId: string, linkType: 'WINNER' | 'LOSER' | 'POSITION') => void;
-    onPortMouseDown: (nodeId: string, portType: 'winner' | 'loser') => void;
-}
-
-declare interface CardPopoverCallbacks {
-    onDelete: (locator: RoundLocator) => void;
-    onSetNotBeforeTime: (locator: RoundLocator) => void;
-}
-
-declare interface CardPopoverManager {
-    show(target: HTMLElement, locator: RoundLocator): void;
-    destroy(): void;
-    isActiveFor(locator: RoundLocator): boolean;
-}
-
-declare interface CatalogDragPayload {
-    type: 'CATALOG_ROUND';
-    roundRef: CatalogRoundItem;
-}
-
-export declare interface CatalogFilters {
-    eventType?: string;
-    eventName?: string;
-    drawName?: string;
-    gender?: string;
-    roundName?: string;
-}
-
-export declare type CatalogGroupBy = 'event' | 'draw' | 'round';
-
-export declare interface CatalogMatchUpDragPayload {
-    type: 'CATALOG_MATCHUP';
-    matchUp: CatalogMatchUpItem;
-}
-
-export declare interface CatalogMatchUpItem {
-    matchUpId: string;
-    eventId: string;
-    eventName: string;
-    drawId: string;
-    drawName?: string;
-    structureId: string;
-    roundNumber: number;
-    roundName?: string;
-    matchUpFormat?: string;
-    matchUpType?: 'SINGLES' | 'DOUBLES';
-    matchUpStatus?: string;
-    gender?: string;
-    sides?: MatchUpSide[];
-    isScheduled: boolean;
-    scheduledTime?: string;
-    scheduledCourtName?: string;
-}
-
-export declare interface CatalogRoundItem {
-    tournamentId: string;
-    eventId: string;
-    eventName: string;
-    drawId: string;
-    drawName?: string;
-    structureId: string;
-    structureType?: string;
-    roundNumber: number;
-    roundName?: string;
-    matchCountEstimate?: number;
-}
-
-export declare interface Category {
-    ageCategoryCode?: string;
-    ageMax?: number;
-    ageMaxDate?: string;
-    ageMin?: number;
-    ageMinDate?: string;
-    ballType?: string;
-    categoryName?: string;
-    categoryType?: string;
-    notes?: string;
-    ratingMax?: number;
-    ratingMin?: number;
-    ratingType?: string;
-    type?: 'AGE' | 'RATING' | 'BOTH';
-}
-
-export declare interface CategoryConfig {
-    labels?: {
-        title?: string;
-        categoryNameLabel?: string;
-        typeLabel?: string;
-        ageCategoryCodeLabel?: string;
-        ratingTypeLabel?: string;
-        ratingMinLabel?: string;
-        ratingMaxLabel?: string;
-        ballTypeLabel?: string;
-        notesLabel?: string;
-    };
-    options?: {
-        types?: string[];
-        ratingTypes?: string[];
-        ballTypes?: string[];
-    };
-    defaultConsideredDate?: string;
-    modalConfig?: any;
-}
-
-export declare const cModal: {
-    close: (conditional?: boolean) => void;
-    open: ({ title, content, buttons, footer, config, onClose }?: ModalParams) => {
-        setContent: ({ content: newContent, config }: {
-            content?: ModalContent;
-            config?: ModalConfig;
-        }) => void;
-        setButtons: ({ buttons, config }: {
-            buttons: ModalButton[];
-            config?: ModalConfig;
-        }) => void;
-        update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
-            content?: ModalContent;
-            buttons?: ModalButton[];
-            title?: string;
-            config?: ModalConfig;
-            onClose?: (params: {
-                content?: any;
-            }) => void;
-        }) => void;
-    };
-};
-
-declare interface Composition {
-    theme: string;
-    configuration?: Configuration;
-}
-
-export declare interface CompositionEditorConfig {
-    /** Initial composition to edit */
-    composition?: Composition;
-    /** Name for display/save */
-    compositionName?: string;
-    /** View-only mode */
-    readOnly?: boolean;
-    /** Called when user saves */
-    onSave?: (result: SavedComposition) => void;
-    /** Called on every change (live preview) */
-    onChange?: (composition: Composition) => void;
-    /** Restrict available theme choices */
-    availableThemes?: string[];
-}
-
-export declare type CompositionEditorListener = (state: CompositionEditorState) => void;
-
-export declare interface CompositionEditorOptions {
-    initialPreset?: string;
-    initialHeader?: Partial<HeaderConfig>;
-    initialFooter?: Partial<FooterConfig>;
-    onApply?: (result: CompositionEditorResult) => void;
-}
-
-/** Standard panel interface */
-export declare interface CompositionEditorPanel {
-    element: HTMLElement;
-    update(state: CompositionEditorState): void;
-}
-
-export declare interface CompositionEditorResult {
-    header: HeaderConfig;
-    footer: FooterConfig;
-    preset?: string;
-}
-
-export declare type CompositionEditorSectionId = 'theme' | 'display' | 'score' | 'participant' | 'placeholder' | 'scale' | 'layout';
-
-export declare interface CompositionEditorState {
-    compositionName: string;
-    theme: string;
-    configuration: Configuration;
-    expandedSections: Set<CompositionEditorSectionId>;
-    isDirty: boolean;
-    readOnly: boolean;
-}
-
-export declare class CompositionEditorStore {
-    private state;
-    private readonly listeners;
-    private readonly config;
-    constructor(config: CompositionEditorConfig);
-    getState(): CompositionEditorState;
-    subscribe(listener: CompositionEditorListener): () => void;
-    toggleSection(sectionId: CompositionEditorSectionId): void;
-    setTheme(theme: string): void;
-    setCompositionName(name: string): void;
-    setConfigField<K extends keyof Configuration>(key: K, value: Configuration[K]): void;
-    /** Update a nested object field (e.g., gameScore, placeHolders, scaleAttributes) */
-    setConfigNestedField<K extends keyof Configuration>(key: K, nestedKey: string, value: unknown): void;
-    /** Replace the entire configuration (e.g., loading a preset) */
-    setConfiguration(configuration: Configuration): void;
-    /** Load a full composition (theme + config + name) */
-    loadComposition(name: string, theme: string, configuration: Configuration): void;
-    resetToInitial(): void;
-    private setState;
-    private emit;
-    private notifyChange;
-}
-
-export declare const compositions: Record<string, Composition>;
-
-declare interface Configuration {
-    flags?: boolean;
-    flag?: boolean;
-    teamLogo?: boolean;
-    roundHeader?: boolean;
-    winnerChevron?: boolean;
-    centerInfo?: boolean;
-    resultsInfo?: boolean;
-    scoreBox?: boolean;
-    gameScoreOnly?: boolean;
-    gameScore?: {
-        position?: 'leading' | 'trailing';
-        inverted?: boolean;
-    };
-    drawPositions?: boolean;
-    allDrawPositions?: boolean;
-    drawPositionColor?: string;
-    bracketedSeeds?: boolean | 'square';
-    scheduleInfo?: boolean;
-    matchUpFooter?: boolean;
-    showAddress?: boolean;
-    seedingElement?: 'sup' | 'span';
-    matchUpHover?: boolean | string;
-    participantDetail?: string;
-    inlineAssignment?: boolean;
-    participantProvider?: () => Participant[];
-    assignmentInputFontSize?: string;
-    persistInputFields?: boolean;
-    hasQualifying?: boolean;
-    inlineScoring?: {
-        mode: 'points' | 'games';
-        showFooter?: boolean;
-        showSituation?: boolean;
-        canUndo?: boolean;
-        canRedo?: boolean;
-        isComplete?: boolean;
-        isDirty?: boolean;
-        situationText?: string;
-    };
-    useParticipantName?: boolean;
-    genderColor?: boolean | string;
-    winnerColor?: boolean | string;
-    placeHolders?: {
-        tbd?: string;
-        bye?: string;
-        qualifier?: string;
-    };
-    scaleAttributes?: {
-        scaleColor?: string;
-        scaleType?: string;
-        scaleName?: string;
-        accessor?: string;
-        eventType?: string;
-        fallback?: boolean;
-        scalePosition?: 'left' | 'right';
-        rawValue?: any;
-    };
-    clickAway?: boolean;
-    backdrop?: boolean;
-    maxWidth?: number;
-    fontSize?: string;
-    padding?: string;
-    className?: string;
-    style?: Partial<CSSStyleDeclaration>;
-    info?: string;
-    menu?: {
-        menuItems: Array<{
-            label: string;
-            onClick: () => void;
-            active?: boolean;
-        }>;
-    };
-    title?: {
-        padding?: string;
-    };
-    content?: {
-        padding?: string;
-    };
-    footer?: {
-        padding?: string;
-        className?: string;
-    };
-    dictionary?: {
-        close?: string;
-    };
-}
-
-declare interface ContentBlock {
-    draw?: DrawContent;
-    schedule?: ScheduleContent;
-}
-
-export declare function controlBar(params: {
-    table?: any;
-    targetClassName?: string;
-    items?: any[];
-    onSelection?: (rows: any[]) => void;
-    target?: HTMLElement;
-    selectItemFn?: (params: any) => void;
-}): {
-    elements: Record<string, HTMLElement>;
-    inputs: Record<string, HTMLInputElement>;
-};
-
-declare interface CourtAvailabilityModalConfig {
-    title: string;
-    currentDay: string;
-    currentStartTime: string;
-    currentEndTime: string;
-    showScopeToggle?: boolean;
-    venueBounds?: {
-        startTime: string;
-        endTime: string;
-    };
-    onConfirm: (params: {
-        startTime: string;
-        endTime: string;
-        scope: 'current-day' | 'all-days';
-    }) => void;
-    onCancel?: () => void;
-    /** Custom labels for UI text */
-    labels?: {
-        startTime?: string;
-        endTime?: string;
-        applyTo?: string;
-        currentDayOnly?: string;
-        allDays?: string;
-        cancel?: string;
-        apply?: string;
-        venueWarning?: string;
-    };
-}
-
-declare interface CourtGridSlotCallbacks {
-    onMatchUpDrop?: (payload: SchedulePageDragPayload, event: DragEvent) => void;
-}
-
-declare interface CourtGridSlotOptions {
-    gridMaxHeight?: string;
-}
-
-export declare function courthiveComponentsVersion(): string;
-
-declare type CourtRef = temporal.CourtRef;
-
-declare type CourtRef_2 = temporal.CourtRef;
-
-declare class CourtTimeline {
-    private options;
-    private callbacks;
-    private scale;
-    private timeAxis;
-    private layout;
-    private renderer;
-    private interaction;
-    private rootEl;
-    private bodyEl;
-    private resizeObserver;
-    private _batchUpdating;
-    private eventListeners;
-    constructor(container: HTMLElement, items: TimelineItemData[], groups: TimelineGroupData[], options?: TimelineOptions);
-    setGroups(groups: TimelineGroupData[]): void;
-    setItems(items: TimelineItemData[]): void;
-    setWindow(start: Date, end: Date, _opts?: {
-        animation?: boolean;
-    }): void;
-    setOptions(opts: Partial<TimelineOptions>): void;
-    on(event: string, handler: (...args: any[]) => void): void;
-    off(event: string, handler: (...args: any[]) => void): void;
-    private emit;
-    /** Register callback for multi-row ghost creation */
-    onMultiRowCreate(handler: (span: MultiRowSpan) => void): void;
-    /** Register onAdd callback (double-click on empty area → single block) */
-    onAdd(handler: (item: {
-        group: string;
-        start: Date;
-        end: Date;
-    }) => void): void;
-    /** Register onMove callback (drag/resize completed) */
-    onMove(handler: (item: {
-        id: string;
-        group: string;
-        start: Date;
-        end: Date;
-    }) => boolean): void;
-    /** Register onMoving callback (live validation during drag) */
-    onMoving(handler: (item: {
-        id: string;
-        group: string;
-        start: Date;
-        end: Date;
-    }) => {
-        start: Date;
-        end: Date;
-    } | null): void;
-    /** Register callback for click on a day label in the axis header */
-    onDayClick(handler: (dayStr: string) => void): void;
-    /** Get the content area element (for external DOM queries like popover anchoring) */
-    getContentElement(): HTMLElement;
-    /**
-     * Set daily operating bounds. Overnight gaps are collapsed so each day
-     * only shows the operating window (e.g., "07:00" to "21:00").
-     */
-    setDailyBounds(startTime: string, endTime: string): void;
-    /** Remove daily bounds — return to continuous 24-hour mode */
-    clearDailyBounds(): void;
-    /**
-     * Set the explicit list of days to display. In daily-bounds mode, only
-     * these days get column space — gap days are fully collapsed.
-     */
-    setVisibleDays(days: string[]): void;
-    /** Clear visible days restriction while keeping daily bounds active */
-    clearVisibleDays(): void;
-    /**
-     * Begin a batch update. While batching, renderAll() calls are suppressed.
-     * Call endBatchUpdate() when done to trigger a single render.
-     */
-    beginBatchUpdate(): void;
-    /** End batch update and trigger a single render. */
-    endBatchUpdate(): void;
-    private renderAll;
-    destroy(): void;
-}
-
-export declare function createCardPopoverManager(callbacks: CardPopoverCallbacks): CardPopoverManager;
-
-export declare function createCompositionEditor(container: HTMLElement, config: CompositionEditorConfig): {
-    destroy: () => void;
-    getComposition: () => SavedComposition;
-};
-
-/**
- * Creates an interactive footer bar for inline scoring:
- * [Undo] [Redo] [Clear] [Submit]  |  situation flags
- */
-export declare function createInlineScoringFooter(params: FooterParams): {
-    element: HTMLElement;
-    update: () => void;
-};
-
-export declare function createPolicyCatalog(config: PolicyCatalogConfig, container: HTMLElement): PolicyCatalogControl;
-
-export declare function createPrintCompositionEditor(container: HTMLElement, config: PrintCompositionEditorConfig): PrintCompositionEditorHandle;
-
-export declare function createSchedulePage(config: SchedulePageConfig, container: HTMLElement): SchedulePageControl;
-
-/**
- * Convenience factory for standalone use (e.g., TMX scheduling page).
- */
-export declare function createSchedulingEditor(config: SchedulingEditorConfig, container: HTMLElement): SchedulingEditorControl;
-
-export declare function createSchedulingProfile(config: SchedulingProfileConfig, container: HTMLElement): SchedulingProfileControl;
-
-/**
- * Create and render a temporal grid
- */
-export declare function createTemporalGrid(config: TemporalGridConfig, container: HTMLElement): TemporalGrid;
-
-declare interface DateStripCallbacks {
-    onDateSelected: (date: string) => void;
-}
-
-declare interface DateStripCallbacks_2 {
-    onDateSelected: (date: string) => void;
-}
-
-declare function dateValidator(value: any): boolean;
-
-declare type DayId = temporal.DayId;
-
-declare type DayId_2 = temporal.DayId;
-
-declare type DayId_3 = temporal.DayId;
-
-declare const DEFAULT_COLOR_SCHEME: BlockColorScheme;
-
-export declare const DEFAULT_SCHEDULE_CELL_CONFIG: ScheduleCellConfig;
-
-export declare interface DemandAdapter {
-    estimateDayDemandMinutes: (date: string, profile: SchedulingProfile) => number;
-}
-
-export declare interface DependencyAdapter {
-    /**
-     * Returns roundKeyStrings for all rounds that must complete
-     * before the given round can proceed.
-     * Key format: "tournamentId|eventId|drawId|structureId|roundNumber"
-     */
-    getRoundDependencies: (roundKeyString: string) => string[];
-}
-
-export declare function destroyTipster(target?: HTMLElement | any): void;
-
-export declare interface DisplayExtensionValue {
-    compositionName?: string;
-    theme?: string;
-    configuration?: Partial<Configuration>;
-}
-
-export declare type DragPayload = CatalogDragPayload | PlannedDragPayload;
-
-declare interface DrawContent {
-    includeSeedings?: boolean;
-    includeScores?: boolean;
-    showByes?: boolean;
-    showDrawPositions?: boolean;
-}
-
-export declare const drawer: (drawerId?: string) => any;
-
-export declare interface DrawerOptions {
-    title?: string;
-    content?: string | ((elem: HTMLElement, close: () => void) => any);
-    side?: 'left' | 'right';
-    width?: string;
-    footer?: string | ((elem: HTMLElement, close: () => void) => any);
-    callback?: () => void;
-    onClose?: () => boolean | void;
-}
-
-export declare interface DrawOptionsResult {
-    drawOptions: any;
-    postGenerationMethods: any[];
-}
-
-export declare class DrawStateManager {
-    private tournamentRecord;
-    private readonly drawId;
-    private readonly structureId;
-    private readonly eventId;
-    private renderCallback?;
-    private focusDrawPosition?;
-    constructor({ tournamentRecord, drawId, structureId, eventId }: {
-        tournamentRecord: any;
-        drawId: string;
-        structureId: string;
-        eventId?: string;
-    });
-    /**
-     * Set callback to trigger re-render when state changes
-     */
-    setRenderCallback(callback: RenderCallback): void;
-    /**
-     * Get participant IDs from draw entries (via flight profile or drawDefinition.entries)
-     */
-    private getDrawEntryParticipantIds;
-    /**
-     * Get participants entered in the draw (including qualifiers)
-     */
-    getAllParticipants(): Participant[];
-    /**
-     * Get participants that haven't been assigned to draw positions yet
-     */
-    getAvailableParticipants(): Participant[];
-    /**
-     * Remove participant assignment from a draw position
-     */
-    removeAssignment({ drawPosition }: {
-        drawPosition: number;
-    }): {
-        success: boolean;
-        error?: any;
-    };
-    /**
-     * Assign a participant to a specific draw position
-     * Note: Direct assignment replaces existing assignment (even with scores)
-     */
-    assignParticipant({ drawPosition, participantId }: {
-        drawPosition: number;
-        participantId: string;
-    }): {
-        success: boolean;
-        error?: any;
-    };
-    /**
-     * Get and clear the drawPosition that should receive focus
-     */
-    getAndClearFocusDrawPosition(): number | undefined;
-    /**
-     * Assign a BYE to a specific draw position
-     * Note: Direct assignment replaces existing assignment (even with scores)
-     */
-    assignBye({ drawPosition }: {
-        drawPosition: number;
-    }): {
-        success: boolean;
-        error?: any;
-    };
-    /**
-     * Assign a QUALIFIER placeholder to a specific draw position
-     * Note: Used when structure has qualifying stage feeding into it
-     */
-    assignQualifier({ drawPosition }: {
-        drawPosition: number;
-    }): {
-        success: boolean;
-        error?: any;
-    };
-    /**
-     * Get all matchUps for the draw with properly populated drawPosition data
-     */
-    getMatchUps(): any[];
-    /**
-     * Get current tournament state
-     */
-    getState(): any;
-    /**
-     * Get draw context information
-     */
-    getContext(): {
-        drawId: string;
-        structureId: string;
-    };
-}
-
-export declare function dropDownButton({ target, button, stateChange }: {
-    target?: HTMLElement;
-    button: any;
-    stateChange?: () => void;
-}): HTMLDivElement;
-
-export declare interface DropResult {
-    ok: boolean;
-    profile: SchedulingProfile;
-}
-
-export declare interface DropTarget {
-    date: string;
-    venueId: string;
-    index: number;
-}
-
-declare interface EdgeEditorCallbacks {
-    onUpdateEdge: (edgeId: string, updates: Partial<TopologyEdge>) => void;
-    onDeleteEdge: (edgeId: string) => void;
-    readOnly?: boolean;
-}
-
-declare interface EditorShellCallbacks {
-    onSave: () => void;
-    onReset: () => void;
-    onApply: () => void;
-    onDuplicate: () => void;
-}
-
-declare interface EditorShellPanel extends UIPanel_4<PolicyCatalogState> {
-    bodyElement: HTMLElement;
-}
-
-declare const emailValidator: (value: string) => RegExpMatchArray | null;
-
-/** Create empty scheduling policy with sensible structure */
-export declare function emptySchedulingPolicy(): SchedulingPolicyData;
-
-declare interface EngineBlockPopoverOptions {
-    itemId: string;
-    blockId: string;
-    engine: TemporalEngine;
-    day: string;
-    onBlockChanged: () => void;
-}
-
-/**
- * Bridge: converts ScoringEngine state into a TODS-compatible MatchUp object
- * suitable for renderMatchUp(). Injects live point display into the active set.
- */
-export declare function engineToMatchUp(engine: any, baseMatchUp: MatchUp): MatchUp;
-
-declare interface EventHandlers {
-    matchUpClick?: (params: {
-        pointerEvent: MouseEvent;
-        matchUp: MatchUp;
-    }) => void;
-    participantClick?: (params: {
-        individualParticipant: IndividualParticipant;
-        matchUp?: MatchUp;
-        pointerEvent: MouseEvent;
-        participant?: Participant;
-        side?: Side;
-    }) => void;
-    assignParticipant?: (params: {
-        matchUp: MatchUp;
-        side: Side;
-        sideNumber: number;
-        participant: Participant;
-        pointerEvent?: Event;
-    }) => void;
-    assignBye?: (params: {
-        matchUp: MatchUp;
-        side: Side;
-        sideNumber: number;
-        pointerEvent?: Event;
-    }) => void;
-    assignQualifier?: (params: {
-        matchUp: MatchUp;
-        side: Side;
-        sideNumber: number;
-        pointerEvent?: Event;
-    }) => void;
-    removeAssignment?: (params: {
-        matchUp: MatchUp;
-        side: Side;
-        sideNumber: number;
-        pointerEvent?: Event;
-    }) => void;
-    scoreClick?: (params: {
-        pointerEvent: MouseEvent;
-        matchUp: MatchUp;
-    }) => void;
-    pillClick?: (params: {
-        pointerEvent: MouseEvent;
-        matchUp: MatchUp;
-        sideNumber: number;
-    }) => void;
-    scoreIncrement?: (params: {
-        matchUpId: string;
-        sideNumber: number;
-        scoreType: 'point' | 'game' | 'set';
-    }) => void;
-    inlineUndo?: (params: {
-        matchUpId: string;
-    }) => void;
-    inlineRedo?: (params: {
-        matchUpId: string;
-    }) => void;
-    inlineClear?: (params: {
-        matchUpId: string;
-    }) => void;
-    inlineSubmit?: (params: {
-        matchUpId: string;
-    }) => void;
-    [key: string]: any;
-}
-
-export declare function filterCatalog(catalog: CatalogRoundItem[], query: string, plannedKeys: Set<string>, behavior?: PlannedRoundBehavior): Array<CatalogRoundItem & {
-    isPlanned: boolean;
-}>;
-
-export declare function filterMatchUpCatalog(catalog: CatalogMatchUpItem[], query: string, behavior?: ScheduledBehavior, filters?: CatalogFilters, showCompleted?: boolean): CatalogMatchUpItem[];
-
-/**
- * Filter catalog items by search query.
- * Matches against name, policyType label, description, and source.
- */
-export declare function filterPolicyCatalog(catalog: PolicyCatalogItem[], searchQuery: string): PolicyCatalogItem[];
-
-export declare function findIssuesForLocator(ruleResults: ValidationResult[], locator: RoundLocator): ValidationResult[];
-
-export declare interface FixAction {
-    kind: FixActionKind;
-    label: string;
-    locator?: RoundLocator;
-    after?: RoundLocator;
-    before?: RoundLocator;
-    date?: string;
-}
-
-declare type FixActionKind = 'JUMP_TO_ITEM' | 'OPEN_TEMPORAL_GRID' | 'MOVE_ITEM_AFTER' | 'MOVE_ITEM_BEFORE';
-
-export declare interface FlightProfileConfig {
-    labels?: {
-        title?: string;
-        flightsCountLabel?: string;
-        namingTypeLabel?: string;
-        customNameLabel?: string;
-        suffixTypeLabel?: string;
-        scaleTypeLabel?: string;
-        scaleNameLabel?: string;
-        eventTypeLabel?: string;
-        splitMethodLabel?: string;
-        flightNamesLabel?: string;
-        cancel?: string;
-        ok?: string;
-        existingNote?: string;
-    };
-    options?: {
-        eventTypes?: string[];
-        ratingTypes?: string[];
-    };
-    eventType?: string;
-}
-
-declare interface FooterBlock {
-    layout?: PrintFooterLayout;
-    showTimestamp?: boolean;
-    showPageNumbers?: boolean;
-}
-
-declare interface FooterConfig {
-    layout: string;
-    showPageNumbers?: boolean;
-    showTimestamp?: boolean;
-    releaseDate?: string;
-    drawCeremonyDate?: string;
-    notes?: string[];
-}
-
-declare interface FooterParams {
-    matchUpId: string;
-    manager: InlineScoringManager;
-    baseMatchUp: MatchUp;
-    onUpdate: (matchUp: MatchUp) => void;
-    showSituation?: boolean;
-}
-
-/** Get a human-readable description for a matchUp format code */
-export declare function formatCodeLabel(code: string): string;
-
-/**
- * Convert a tods-competition-factory `getEventData().drawsData[i].structures[0]`
- * object into the TODS-aligned SunburstDrawData that the sunburst consumes.
- */
-export declare function fromFactoryDrawData(structure: any): SunburstDrawData;
-
-/**
- * Convert a legacy TournamentDraw (with R128/R64/.../F/W round keys)
- * into the TODS-aligned SunburstDrawData.
- */
-export declare function fromLegacyDraw(tournamentDraw: any): SunburstDrawData;
-
-export declare function generatePreviewMatchUps({ structureType, drawSize, stage, structureId, qualifyingPositions, structureOptions }: {
-    structureType: string;
-    drawSize: number;
-    stage?: string;
-    structureId?: string;
-    qualifyingPositions?: number;
-    structureOptions?: any;
-}): SchematicMatchUp[];
-
-export declare interface GenerateTeamsConfig {
-    callback?: (participants: any[]) => void;
-    consideredDate?: string;
-    title?: string;
-    /** Builtin + user tieFormats for team size inference */
-    tieFormats?: {
-        label: string;
-        value: string;
-        tieFormat: any;
-    }[];
-    /** Custom labels for form fields and buttons */
-    labels?: {
-        gender?: string;
-        teamsCount?: string;
-        tieFormatTemplate?: string;
-        manualTeamSize?: string;
-        playersPerTeam?: string;
-        countries?: string;
-        cancel?: string;
-        generate?: string;
-        genderAny?: string;
-        genderFemale?: string;
-        genderMale?: string;
-    };
-}
-
-/**
- * Main function to open the age category modal
- */
-export declare function getAgeCategoryModal({ existingAgeCategoryCode, existingCategory, editorConfig: userConfig, consideredDate: providedDate, callback, config, modalConfig }?: {
-    existingAgeCategoryCode?: string;
-    existingCategory?: {
-        ageCategoryCode?: string;
-        [key: string]: any;
-    };
-    editorConfig?: AgeCategoryConfig;
-    consideredDate?: string;
-    callback?: (category: {
-        ageCategoryCode: string;
-        [key: string]: any;
-    }) => void;
-    config?: AgeCategoryConfig;
-    modalConfig?: any;
-}): {
-    setContent: ({ content: newContent, config }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        config?: ModalConfig;
-    }) => void;
-    setButtons: ({ buttons, config }: {
-        buttons: ModalButton[];
-        config?: ModalConfig;
-    }) => void;
-    update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        buttons?: ModalButton[];
-        title?: string;
-        config?: ModalConfig;
-        onClose?: (params: {
-            content?: any;
-        }) => void;
-    }) => void;
-};
-
-/**
- * Opens the Category editor modal
- * @param existingCategory - Optional existing category to edit
- * @param editorConfig - Optional configuration for labels and options
- * @param callback - Called with the category when user clicks OK
- * @returns Modal result with open() and close() functions
- */
-export declare function getCategoryModal(params: {
-    existingCategory?: Category;
-    editorConfig?: CategoryConfig;
-    callback?: (category: Category) => void;
-}): any;
-
-/**
- * Opens the Flight Profile editor modal
- * @param existingFlightProfile - Optional existing flight profile to edit
- * @param editorConfig - Optional configuration for labels and options
- * @param callback - Called with the flight profile configuration when user clicks OK
- * @returns Modal result with open() and close() functions
- */
-export declare function getFlightProfileModal(params: {
-    existingFlightProfile?: any;
-    editorConfig?: FlightProfileConfig;
-    callback?: (config: any) => void;
-}): any;
-
-export declare function getGenerateTeamsModal(config?: GenerateTeamsConfig): void;
-
-export declare function getMatchUpFormatModal({ existingMatchUpFormat, callback, config, modalConfig }?: {
-    existingMatchUpFormat?: string;
-    callback?: (format: string) => void;
-    config?: MatchUpFormatConfig;
-    modalConfig?: any;
-}): {
-    setContent: ({ content: newContent, config }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        config?: ModalConfig;
-    }) => void;
-    setButtons: ({ buttons, config }: {
-        buttons: ModalButton[];
-        config?: ModalConfig;
-    }) => void;
-    update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        buttons?: ModalButton[];
-        title?: string;
-        config?: ModalConfig;
-        onClose?: (params: {
-            content?: any;
-        }) => void;
-    }) => void;
-};
-
-/**
- * Get the match winner based on sets won
- * Returns undefined if match is not complete
- */
-export declare function getMatchWinner(sets: SetScore[], bestOf: number, exactly?: number): 1 | 2 | undefined;
-
-/**
- * Calculate the maximum allowed score for a regular set game score
- * based on the opponent's score and set rules
- *
- * For timed sets, returns Infinity (no maximum) since scores don't need relationships
- */
-export declare function getMaxAllowedScore(setIndex: number, side: 1 | 2, currentScores: {
-    side1: number;
-    side2: number;
-}, config: MatchUpConfig): number;
-
-/**
- * Opens a modal for generating mock participants with configurable options.
- *
- * Features:
- * - Gender selection (Any/Male/Female)
- * - Participant count (8-256)
- * - Age range with automatic validation (ageMax >= ageMin)
- * - Number of countries to limit nationality diversity
- * - Optional WTN/UTR ratings
- * - Birthdate generation based on consideredDate and age range
- *
- * @param config - Configuration options
- * @returns void
- *
- * @example
- * // Basic usage
- * getMockParticipantsModal({
- *   callback: (participants) => {
- *     console.log('Generated participants:', participants);
- *     // Add participants to tournament
- *   }
- * });
- *
- * @example
- * // With consideredDate and defaults
- * getMockParticipantsModal({
- *   consideredDate: '2024-12-31',
- *   callback: (participants) => {
- *     // Add participants to tournament
- *   },
- *   defaults: {
- *     participantsCount: 64,
- *     ageMin: 10,
- *     ageMax: 18,
- *     nationalityCodesCount: 10,
- *     wtnRating: true
- *   }
- * });
- */
-export declare function getMockParticipantsModal(config?: MockParticipantsConfig): void;
-
-export declare function getPlannedRoundKeys(profile: {
-    venues: {
-        rounds: {
-            roundSegment?: unknown;
-        }[];
-    }[];
-}[]): Set<string>;
-
-/** Lookup metadata by policyType string */
-export declare function getPolicyTypeMeta(policyType: string): PolicyTypeMeta | undefined;
-
-/**
- * Get port position relative to canvas for SVG edge rendering.
- */
-export declare function getPortPosition(node: TopologyNode, portType: 'input' | 'winner' | 'loser'): {
-    x: number;
-    y: number;
-};
-
-export declare function getRoundAt(profile: SchedulingProfile, locator: RoundLocator): RoundProfile | null;
-
-/**
- * Get current scoring configuration
- */
-export declare function getScoringConfig(): ScoringConfig;
-
-/**
- * Get the format for a specific set index
- * Uses finalSetFormat for deciding set if available
- */
-export declare function getSetFormatForIndex(setIndex: number, config: MatchUpConfig): SetFormat | undefined;
-
-/**
- * Calculate which side won a set
- * Returns undefined if set is not complete
- */
-export declare function getSetWinner(setIndex: number, scores: {
-    side1: number;
-    side2: number;
-    tiebreak?: number;
-}, config: MatchUpConfig): 1 | 2 | undefined;
-
-export declare function getVenueRounds(profile: SchedulingProfile, date: string, venueId: string): RoundProfile[];
-
-export declare interface GridMatchUpDragPayload {
-    type: 'GRID_MATCHUP';
-    matchUp: CatalogMatchUpItem;
-    sourceTime?: string;
-    sourceCourt?: string;
-}
-
-export declare function groupCatalog(items: Array<CatalogRoundItem & {
-    isPlanned: boolean;
-}>, mode: CatalogGroupBy): Map<string, Array<CatalogRoundItem & {
-    isPlanned: boolean;
-}>>;
-
-export declare function groupMatchUpCatalog(items: CatalogMatchUpItem[], mode: MatchUpCatalogGroupBy): Map<string, CatalogMatchUpItem[]>;
-
-/**
- * Group catalog items by type or source.
- * Returns a Map with stable group ordering.
- */
-export declare function groupPolicyCatalog(catalog: PolicyCatalogItem[], groupBy: PolicyCatalogGroupBy): Map<string, PolicyCatalogItem[]>;
-
-declare interface HeaderBlock {
-    layout?: PrintHeaderLayout;
-    tournamentName?: string;
-    subtitle?: string;
-}
-
-/**
- * Composition Editor Modal — configure PDF header/footer layouts.
- *
- * Opens a modal with two tabs (via menu): Header Config and Footer Config.
- * Each tab provides form controls for selecting layouts and entering field values.
- * Returns the composed HeaderConfig + FooterConfig for pdf-factory.
- */
-declare interface HeaderConfig {
-    layout: string;
-    tournamentName: string;
-    subtitle?: string;
-    startDate?: string;
-    endDate?: string;
-    location?: string;
-    city?: string;
-    country?: string;
-    surface?: string;
-    prizeMoney?: string;
-    currency?: string;
-    supervisor?: string;
-    grade?: string;
-    sectionLabel?: string;
-    organizer?: string;
-    chiefUmpire?: string;
-    tournamentId?: string;
-}
-
-export declare function hockeyRink(className: string): SVGSVGElement;
-
-declare interface IndividualParticipant {
-    participantOtherName?: string;
-    participantId: string;
-    participantName?: string;
-    person?: Person;
-    teams?: Participant[];
-    rankings?: ScalesByType;
-    ratings?: ScalesByType;
-    useOtherName?: boolean;
-}
-
-/**
- * Initialize drawer HTML structure in the DOM
- */
-export declare function initDrawer(drawerId?: string): void;
-
-export declare interface InlineScoringCallbacks {
-    onScoreChange?: (params: {
-        matchUpId: string;
-        matchUp: MatchUp;
-        engine: any;
-    }) => void;
-    onMatchComplete?: (params: {
-        matchUpId: string;
-        winningSide: number;
-        engine: any;
-    }) => void;
-    onEndMatch?: (params: {
-        matchUpId: string;
-        matchUpStatus: string;
-        sideNumber?: number;
-        engine: any;
-    }) => void;
-    onSubmit?: (params: {
-        matchUpId: string;
-        matchUp: MatchUp;
-        engine: any;
-    }) => void;
-}
-
-export declare interface InlineScoringConfig {
-    mode: InlineScoringMode;
-    showFooter?: boolean;
-    showSituation?: boolean;
-    /** Runtime state for footer buttons — set by renderInlineMatchUp before calling renderMatchUp */
-    canUndo?: boolean;
-    canRedo?: boolean;
-    isComplete?: boolean;
-    situationText?: string;
-}
-
-export declare interface InlineScoringEngineState {
-    engine: any;
-    matchUpFormat: string;
-    pointCount: number;
-}
-
-/**
- * Manages ScoringEngine instances for inline scoring in draw brackets.
- * One engine per matchUpId; lazily created on first interaction.
- */
-export declare class InlineScoringManager {
-    private engines;
-    readonly callbacks: InlineScoringCallbacks;
-    constructor(callbacks?: InlineScoringCallbacks);
-    /**
-     * Get or create a ScoringEngine for a matchUp.
-     * If the matchUp has existing score data, initializes the engine with it.
-     */
-    getOrCreate(matchUpId: string, matchUpFormat: string, existingMatchUp?: MatchUp): InlineScoringEngineState;
-    get(matchUpId: string): InlineScoringEngineState | undefined;
-    has(matchUpId: string): boolean;
-    /**
-     * Add a point for a side. Used in 'points' mode.
-     * @param winner - 0 for side 1, 1 for side 2
-     */
-    addPoint(matchUpId: string, winner: 0 | 1, baseMatchUp: MatchUp): MatchUp | undefined;
-    /**
-     * Add a game for a side. Used in 'games' mode.
-     * @param winner - 0 for side 1, 1 for side 2
-     */
-    addGame(matchUpId: string, winner: 0 | 1, baseMatchUp: MatchUp): MatchUp | undefined;
-    /**
-     * Add a set score. Used in 'entry' mode.
-     */
-    addSet(matchUpId: string, side1Score: number, side2Score: number, baseMatchUp: MatchUp): MatchUp | undefined;
-    undo(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
-    redo(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
-    reset(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
-    /**
-     * Get the current engine-derived matchUp data.
-     */
-    getMatchUp(matchUpId: string, baseMatchUp: MatchUp): MatchUp;
-    /**
-     * Get situation flags (break point, set point, etc.) for display.
-     */
-    getSituation(matchUpId: string): Record<string, boolean> | undefined;
-    canUndo(matchUpId: string): boolean;
-    canRedo(matchUpId: string): boolean;
-    isComplete(matchUpId: string): boolean;
-    remove(matchUpId: string): void;
-    clear(): void;
-    private notifyAndReturn;
-}
-
-export declare type InlineScoringMode = 'points' | 'games';
-
-/**
- * Handle returned by `buildInteractiveScoringShell`. Consumers mount
- * `element` into the DOM, subscribe to state changes via
- * `addEventListener`, and call `destroy()` on unmount.
- */
-export declare interface InteractiveScoringShell {
-    /** The root DOM element for the scoring UI. Mount this into the page. */
-    element: HTMLElement;
-    /** Get the current MatchUp snapshot (for persistence). */
-    getState(): MatchUp;
-    /** Reset the scoring engine to 0-0. */
-    reset(): void;
-    /** Remove all listeners and release engine resources. */
-    destroy(): void;
-    /** Subscribe to state change events. */
-    addEventListener(type: 'stateChanged', listener: (event: CustomEvent<StateChangedDetail>) => void): void;
-    removeEventListener(type: 'stateChanged', listener: (event: CustomEvent<StateChangedDetail>) => void): void;
-}
-
-/**
- * Configuration for `buildInteractiveScoringShell`.
- *
- * The shell is a mobile-first, full-page interactive scoring UI that
- * wraps a `ScoringEngine` (via the existing `InlineScoringManager`)
- * and presents two large point-entry buttons, a current score
- * display, and a control bar with undo/reset.
- *
- * The shell is stateful but emits a `stateChanged` CustomEvent on
- * every point so consumers (courthive-public for Phase 2) can
- * persist the current MatchUp to IndexedDB or any other store.
- *
- * Phase 2 targets standard tennis matchUpFormats. INTENNSE, pickleball,
- * and other formats are deferred to Phase 2.5+.
- */
-export declare interface InteractiveScoringShellConfig {
-    /** Unique matchUp id — used as the engine key and the persistence key. */
-    matchUpId: string;
-    /** matchUpFormat code, e.g. `'SET3-S:6/TB7'`. */
-    matchUpFormat: string;
-    /** Tournament id, for context display only (never sent anywhere). */
-    tournamentId: string;
-    /** Display name for side 1 (singles player or doubles pair). */
-    side1Name: string;
-    /** Display name for side 2. */
-    side2Name: string;
-    /**
-     * Optional initial MatchUp to resume from — typically loaded from
-     * IndexedDB. If omitted, the shell starts at 0-0.
-     */
-    initialMatchUp?: MatchUp;
-}
-
-export declare function isCompletedStatus(status?: string): boolean;
-
-/**
- * Determine if match is complete based on sets won
- */
-export declare function isMatchComplete(sets: SetScore[], bestOf: number, exactly?: number): boolean;
-
-/**
- * Determine if a set is complete based on its scores
- */
-export declare function isSetComplete(setIndex: number, scores: {
-    side1: number;
-    side2: number;
-    tiebreak?: number;
-}, config: MatchUpConfig): boolean;
-
-/**
- * Check if a set is tiebreak-only (e.g., TB10)
- */
-export declare function isSetTiebreakOnly(format?: SetFormat): boolean;
-
-/**
- * Check if a set format is timed (e.g., T10, T20)
- */
-export declare function isSetTimed(format?: SetFormat): boolean;
-
-export declare interface IssueIndex {
-    all: ValidationResult[];
-    bySeverity: Record<Severity, ValidationResult[]>;
-    byDate: Record<string, ValidationResult[]>;
-    byVenue: Record<string, ValidationResult[]>;
-    byDraw: Record<string, ValidationResult[]>;
-    counts: {
-        total: number;
-        ERROR: number;
-        WARN: number;
-        INFO: number;
-        byDate: Record<string, SeverityCounts>;
-        byVenue: Record<string, SeverityCounts>;
-        byDraw: Record<string, SeverityCounts>;
-    };
-}
-
-declare interface IssuesPanelCallbacks {
-    onFixAction: (action: FixAction) => void;
-}
-
-declare interface LayoutPanels {
-    dateStrip: UIPanel<ProfileStoreState>;
-    issuesPanel: UIPanel<ProfileStoreState>;
-    venueBoard: UIPanel<ProfileStoreState>;
-    roundCatalog: UIPanel<ProfileStoreState>;
-    inspectorPanel: UIPanel<ProfileStoreState>;
-}
-
-declare interface LineUp {
-    participantId?: string;
-}
-
-/**
- * Maps a factory hydrated matchUp object to the flat ScheduleCellData shape.
- * Handles sides[].participant.participantName nesting, schedule.* extraction, etc.
- */
-export declare function mapMatchUpToCellData(matchUp: any): ScheduleCellData;
-
-/**
- * MatchUp format constants
- * Generated from matchUpFormats.json for use in tests
- */
-export declare const MATCH_FORMATS: {
-    readonly SET3_S6_TB7: "SET3-S:6/TB7";
-    readonly SET3_S6_TB7_F_TB10: "SET3-S:6/TB7-F:TB10";
-    readonly SET3_S6_TB10: "SET3-S:6/TB10";
-    readonly SET3_S6_F_TB10: "SET3-S:6-F:TB10";
-    readonly SET3_S6_TB7_NOAD: "SET3-S:6/TB7NOAD";
-    readonly SET3_S8_TB7: "SET3-S:8/TB7";
-    readonly SET3_S8_TB7_AT7: "SET3-S:8/TB7@7";
-    readonly SET3_S4_TB7: "SET3-S:4/TB7";
-    readonly SET3_S4_TB7_F_TB10: "SET3-S:4/TB7-F:TB10";
-    readonly SET3_S4_TB5_AT3_F_TB10: "SET3-S:4/TB5@3-F:TB10";
-    readonly SET5_S6_TB7: "SET5-S:6/TB7";
-    readonly SET5_S6_TB7_F_TB10: "SET5-S:6/TB7-F:TB10";
-    readonly SET1_S6_TB7: "SET1-S:6/TB7";
-    readonly SET1_S6_TB10: "SET1-S:6/TB10";
-    readonly SET1_S6_TB7_AT5: "SET1-S:6/TB7@5";
-    readonly SET1_S8_TB7: "SET1-S:8/TB7";
-    readonly SET1_S4_TB7: "SET1-S:4/TB7";
-    readonly SET1_S5_TB9_AT4: "SET1-S:5/TB9@4";
-    readonly SET1_S_TB7: "SET1-S:T7";
-    readonly SET1_S_TB10: "SET1-S:TB10";
-    readonly SET1_S_TB21: "SET1-S:T21";
-    readonly SET1_S8: "SET1-S:8";
-    readonly SET1_S10: "SET1-S:10";
-    readonly FAST4: "SET5-S:4/NOAD";
-    readonly SET3X_T10A_TB1: "SET3XA-S:T10-F:TB1";
-    readonly SET3X_T10A_TB1_NOAD: "SET3XA-S:T10-F:TB1NOAD";
-    readonly SET4X_T10A_TB1: "SET4XA-S:T10-F:TB1";
-};
-
-declare interface MatchUp {
-    matchUpId: string;
-    matchUpType?: 'SINGLES' | 'DOUBLES';
-    matchUpFormat?: string;
-    matchUpStatus?: string;
-    winningSide?: number;
-    roundNumber?: number;
-    roundPosition?: number;
-    finishingRound?: number;
-    roundFactor?: number;
-    stage?: string;
-    isRoundRobin?: boolean;
-    preFeedRound?: boolean;
-    collectionId?: string;
-    drawPositions?: number[];
-    structureName?: string;
-    structureId: string;
-    drawId?: string;
-    containerStructureId?: string;
-    tournamentId?: string;
-    roundOrder?: number;
-    venueId?: string;
-    courtId?: string;
-    sides?: Side[];
-    score?: Score;
-    schedule?: Schedule;
-    readyToScore?: boolean;
-    [key: string]: any;
-}
-
-export declare interface MatchUpAverageTime {
-    matchUpFormatCodes: string[];
-    averageTimes: AverageTimeEntry[];
-}
-
-declare interface MatchUpCardCallbacks {
-    onClick?: (matchUp: CatalogMatchUpItem) => void;
-}
-
-declare interface MatchUpCatalogCallbacks {
-    onSearchChange: (query: string) => void;
-    onGroupByChange: (mode: MatchUpCatalogGroupBy) => void;
-    onFilterChange: (filters: CatalogFilters) => void;
-    onShowCompletedChange: (show: boolean) => void;
-    onShowScheduledChange?: (show: boolean) => void;
-    onMatchUpSelected?: (matchUp: CatalogMatchUpItem) => void;
-    onDropRemove?: (matchUpId: string) => void;
-}
-
-export declare type MatchUpCatalogGroupBy = 'event' | 'draw' | 'round' | 'structure';
-
-/**
- * Configuration for a matchUp
- * Should be derived from TODS matchUpFormat strings using matchUpFormatCode.parse()
- */
-export declare type MatchUpConfig = {
-    bestOf: number;
-    exactly?: number;
-    setFormat?: SetFormat;
-    finalSetFormat?: SetFormat;
-};
-
-export declare type MatchUpFormatCode = (typeof MATCH_FORMATS)[keyof typeof MATCH_FORMATS];
-
-declare interface MatchUpFormatConfig {
-    labels?: {
-        title?: string;
-        setFormatLabel?: string;
-        finalSetLabel?: string;
-        tiebreakLabel?: string;
-        finalSetToggleLabel?: string;
-        standardFormatsLabel?: string;
-        cancel?: string;
-        select?: string;
-        custom?: string;
-        aggregate?: string;
-        game?: string;
-        gameType?: string;
-        deuceRule?: string;
-        none?: string;
-        traditional?: string;
-        consecutive2?: string;
-        consecutive3?: string;
-        consecutive4?: string;
-        goldenPoint?: string;
-        starPoint?: string;
-        games?: string;
-        points?: string;
-        descriptors?: {
-            bestOf?: string;
-            exactly?: string;
-        };
-        what?: {
-            sets?: string;
-            tiebreaks?: string;
-            timedSets?: string;
-        };
-        advantage?: {
-            ad?: string;
-            noAd?: string;
-        };
-    };
-    options?: {
-        bestOf?: number[];
-        exactly?: number[];
-        setTo?: number[];
-        tiebreakTo?: number[];
-        tiebreakToExactly?: number[];
-        tiebreakAt?: number[];
-        minutes?: number[];
-        winBy?: number[];
-        matchRoots?: string[];
-        gameFormats?: string[];
-        modifiers?: string[];
-    };
-    preDefinedFormats?: Array<{
-        code: string;
-        text: string;
-    }>;
-}
-
-export declare function matchUpLabel(item: CatalogMatchUpItem): string;
-
-export declare interface MatchUpRecoveryTime {
-    matchUpFormatCodes: string[];
-    recoveryTimes: RecoveryTimeEntry[];
-}
-
-export declare function matchUpSearchKey(item: CatalogMatchUpItem): string;
-
-/**
- * Schedule Page — Type Definitions
- *
- * All interfaces for the schedule page component.
- * The component provides layout + matchUp catalog; the consumer injects the court grid.
- */
-export declare interface MatchUpSide {
-    participantName?: string;
-    participantId?: string;
-    seedNumber?: number;
-    ranking?: number;
-}
-
-export declare function maxSeverity(issues: ValidationResult[]): Severity | null;
-
-/**
- * Scheduling Policy Editor — Type Definitions
- *
- * Mirrors the factory's scheduling policy data shape exactly.
- */
-export declare interface MinutesEntry {
-    default: number;
-    DOUBLES?: number;
-}
-
-/**
- * Configuration for mock participants generation
- */
-export declare interface MockParticipantsConfig {
-    /** Callback invoked when participants are generated */
-    callback?: (participants: any[]) => void;
-    /** Tournament end date for birthdate calculation (ISO format: YYYY-MM-DD) */
-    consideredDate?: string;
-    /** Custom title for the modal */
-    title?: string;
-    /** Custom labels for form fields */
-    labels?: {
-        gender?: string;
-        count?: string;
-        ageRange?: string;
-        minAge?: string;
-        maxAge?: string;
-        ratings?: string;
-        countries?: string;
-        role?: string;
-        cancel?: string;
-        generate?: string;
-        genderAny?: string;
-        genderFemale?: string;
-        genderMale?: string;
-        /** @deprecated Use ratings label instead */
-        wtn?: string;
-        /** @deprecated Use ratings label instead */
-        utr?: string;
-    };
-    /** Default values for form fields */
-    defaults?: {
-        gender?: string;
-        participantsCount?: number;
-        participantRole?: string;
-        ageMin?: number;
-        ageMax?: number;
-        nationalityCodesCount?: number;
-        /** Array of rating type names to pre-select (e.g., ['WTN', 'UTR', 'DUPR']) */
-        ratings?: string[];
-        /** @deprecated Use ratings: ['WTN'] instead */
-        wtnRating?: boolean;
-        /** @deprecated Use ratings: ['UTR'] instead */
-        utrRating?: boolean;
-    };
-    /** Available participant role options. If not provided, only COMPETITOR is used. */
-    roleOptions?: {
-        label: string;
-        value: string;
-    }[];
-}
-
-declare interface ModalButton {
-    label?: string;
-    text?: string;
-    id?: string;
-    intent?: string;
-    close?: boolean | (() => void);
-    disabled?: boolean;
-    hide?: boolean;
-    onClick?: (params: {
-        e: MouseEvent;
-        content?: any;
-    }) => void;
-    footer?: {
-        className?: string;
-    };
-}
-
-declare interface ModalConfig extends Configuration {
-    onClose?: (params: {
-        content?: any;
-    }) => void;
-}
-
-declare type ModalContent = string | HTMLElement | ((container: HTMLElement) => any);
-
-declare interface ModalParams {
-    title?: string;
-    content?: string | HTMLElement | ((container: HTMLElement) => any);
-    buttons?: ModalButton[];
-    footer?: string | HTMLElement;
-    config?: ModalConfig;
-    onClose?: (params: {
-        content?: any;
-    }) => void;
-}
-
-declare interface MultiRowSpan {
-    /** IDs of all groups covered by the ghost */
-    groupIds: string[];
-    /** Top row index (0-based) */
-    topRowIndex: number;
-    /** Bottom row index (inclusive, 0-based) */
-    bottomRowIndex: number;
-    /** Time range */
-    startTime: Date;
-    endTime: Date;
-}
-
-declare const nameValidator: (minLength: number, maxLength?: number) => (value: string) => boolean;
-
-declare interface NodeEditorCallbacks {
-    onUpdateNode: (nodeId: string, updates: Partial<TopologyNode>) => void;
-    onUpdateEdge: (edgeId: string, updates: Partial<TopologyEdge>) => void;
-    onDeleteNode: (nodeId: string) => void;
-    readOnly?: boolean;
-    hideDelete?: boolean;
-}
-
-export declare function notesToolbar(options?: NotesToolbarOptions): HTMLElement;
-
-export declare interface NotesToolbarOptions {
-    onBold?: () => void;
-    onItalic?: () => void;
-    onUnderline?: () => void;
-    onStrike?: () => void;
-    onHeading?: (level: number | false) => void;
-    onColor?: (color: string) => void;
-    onBackground?: (color: string) => void;
-    onBulletList?: () => void;
-    onOrderedList?: () => void;
-    onAlign?: (align: string) => void;
-    onBlockquote?: () => void;
-    onCodeBlock?: () => void;
-    onLink?: (url: string) => void;
-    onVideo?: (url: string) => void;
-    onClearFormatting?: () => void;
-}
-
-declare const numericRange: (min: number, max: number) => (value: string | number) => boolean;
-
-declare function numericValidator(value: string | number): boolean;
-
-export declare function openCompositionEditorModal(options?: CompositionEditorOptions): any;
-
-export declare function openScheduleCellConfigModal(options?: ScheduleCellConfigOptions): {
-    setContent: ({ content: newContent, config }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        config?: ModalConfig;
-    }) => void;
-    setButtons: ({ buttons, config }: {
-        buttons: ModalButton[];
-        config?: ModalConfig;
-    }) => void;
-    update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
-        content?: string | HTMLElement | ((container: HTMLElement) => any);
-        buttons?: ModalButton[];
-        title?: string;
-        config?: ModalConfig;
-        onClose?: (params: {
-            content?: any;
-        }) => void;
-    }) => void;
-};
-
-export declare function padelCourt(className: string): SVGSVGElement;
-
-declare interface PageBlock {
-    pageSize?: PrintPageSize;
-    orientation?: PrintPageOrientation;
-    margins?: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    };
-}
-
-declare interface Participant {
-    participantId: string;
-    participantName?: string;
-    participantOtherName?: string;
-    participantType?: 'INDIVIDUAL' | 'PAIR' | 'TEAM';
-    individualParticipants?: IndividualParticipant[];
-    entryStatus?: string;
-    luckyAdvancement?: boolean;
-    person?: Person;
-    useOtherName?: boolean;
-}
-
-/** Controls how participant names are rendered inside a cell */
-export declare interface ParticipantDisplayConfig {
-    nameFormat?: 'full' | 'last' | 'lastFirst' | 'firstLast';
-    showSeed?: boolean;
-    showRanking?: boolean;
-    showNationality?: boolean;
-    boldWinner?: boolean;
-    showPotentials?: boolean;
-}
-
-export declare function participantLabel(side?: MatchUpSide): string;
-
-declare const passwordValidator: (value: any) => boolean;
-
-export declare interface PendingScheduleAction {
-    kind: 'schedule' | 'unschedule';
-    matchUpId: string;
-    /** Present for 'schedule' actions — the full item that was dropped */
-    matchUp?: CatalogMatchUpItem;
-    /** The DragEvent from the drop, if available */
-    event?: DragEvent;
-}
-
-declare interface Person {
-    personId?: string;
-    standardFamilyName?: string;
-    standardGivenName?: string;
-    nationalityCode?: string;
-    addresses?: Address[];
-    rankings?: Ranking[];
-    ratings?: Rating[];
-    sex?: 'MALE' | 'FEMALE' | 'MIXED';
-    [key: string]: any;
-}
-
-export declare function pickleballCourt(className: string): SVGSVGElement;
-
-declare interface PlannedDragPayload {
-    type: 'PLANNED_ROUND';
-    locator: RoundLocator;
-}
-
-declare type PlannedRoundBehavior = 'dim' | 'hide' | 'navigate';
-
-/** Get all unique group names in display order */
-export declare const POLICY_TYPE_GROUPS: PolicyTypeGroup[];
-
-export declare const POLICY_TYPE_METADATA: PolicyTypeMeta[];
-
-export declare type PolicyCatalogChangeListener = (state: PolicyCatalogState) => void;
-
-export declare interface PolicyCatalogConfig {
-    builtinPolicies?: PolicyCatalogItem[];
-    userPolicies?: PolicyCatalogItem[];
-    editorPlugins?: PolicyEditorPlugin[];
-    onPolicySaved?: (item: PolicyCatalogItem) => void;
-    onPolicyApplied?: (item: PolicyCatalogItem) => void;
-    onPolicyCreated?: (item: PolicyCatalogItem) => void;
-    onPolicyDeleted?: (id: string) => void;
-    onSelectionChanged?: (item: PolicyCatalogItem | null) => void;
-}
-
-export declare class PolicyCatalogControl {
-    private readonly store;
-    private readonly layout;
-    private readonly editorShell;
-    private readonly unsubscribe;
-    private currentEditor;
-    private container;
-    constructor(config: PolicyCatalogConfig);
-    render(container: HTMLElement): void;
-    destroy(): void;
-    getStore(): PolicyCatalogStore;
-    private handleSelectPolicy;
-    private mountEditorForSelection;
-    private syncEditorFromStore;
-    private destroyCurrentEditor;
-}
-
-export declare type PolicyCatalogGroupBy = 'type' | 'source';
-
-export declare interface PolicyCatalogItem {
-    id: string;
-    name: string;
-    policyType: string;
-    source: PolicySource;
-    description: string;
-    policyData: Record<string, unknown>;
-}
-
-declare interface PolicyCatalogPanelCallbacks {
-    onSearchChange: (query: string) => void;
-    onGroupByChange: (mode: PolicyCatalogGroupBy) => void;
-    onSelectPolicy: (id: string) => void;
-    onNewPolicy?: (policyType: string) => void;
-    onDuplicatePolicy?: (id: string) => void;
-    onDeletePolicy?: (id: string) => void;
-}
-
-export declare interface PolicyCatalogState {
-    catalog: PolicyCatalogItem[];
-    searchQuery: string;
-    groupBy: PolicyCatalogGroupBy;
-    selectedId: string | null;
-    editorDraft: Record<string, unknown> | null;
-    dirty: boolean;
-}
-
-export declare class PolicyCatalogStore {
-    private state;
-    private readonly listeners;
-    private readonly config;
-    constructor(config: PolicyCatalogConfig);
-    getState(): PolicyCatalogState;
-    getSelectedItem(): PolicyCatalogItem | null;
-    setCatalogSearch(query: string): void;
-    setCatalogGroupBy(mode: PolicyCatalogGroupBy): void;
-    selectPolicy(id: string): void;
-    clearSelection(): void;
-    updateEditorDraft(data: Record<string, unknown>): void;
-    markDirty(): void;
-    markClean(): void;
-    savePolicy(): void;
-    resetDraft(): void;
-    applyPolicy(): void;
-    addNewPolicy(policyType: string): string;
-    duplicatePolicy(sourceId: string): string | null;
-    deletePolicy(id: string): void;
-    subscribe(listener: PolicyCatalogChangeListener): () => void;
-    private setState;
-    private emit;
-}
-
-export declare interface PolicyEditorInstance {
-    element: HTMLElement;
-    setData(data: Record<string, unknown>): void;
-    getData(): Record<string, unknown>;
-    destroy(): void;
-}
-
-export declare interface PolicyEditorPlugin {
-    policyType: string;
-    create(config: {
-        initialData: Record<string, unknown>;
-        onChange: (data: Record<string, unknown>) => void;
-    }): PolicyEditorInstance;
-}
-
-export declare type PolicySource = 'builtin' | 'user';
-
-/**
- * Policy Catalog — Type Definitions
- */
-export declare type PolicyTypeGroup = 'Tournament Operations' | 'Scoring & Results' | 'Ranking Points' | 'Draw Configuration' | 'Participants' | 'Display & Audit';
-
-export declare interface PolicyTypeMeta {
-    policyType: string;
-    label: string;
-    description: string;
-    group: PolicyTypeGroup;
-    hasEditor: boolean;
-}
-
-declare interface PositionChip {
-    position: number;
-    edgeId: string;
-    targetName: string;
-}
-
-export declare interface PrintCompositionConfig {
-    name?: string;
-    page?: PageBlock;
-    header?: HeaderBlock;
-    footer?: FooterBlock;
-    content?: ContentBlock;
-}
-
-export declare interface PrintCompositionEditorConfig {
-    /** The print type whose composition is being edited. Determines which content fields render. */
-    printType: PrintType;
-    /** Initial config to seed the form. Defaults applied for missing fields. */
-    config?: PrintCompositionConfig;
-    /** When true, all fields are disabled. */
-    readOnly?: boolean;
-    /** Fired when the user clicks Save. */
-    onSave?: (config: PrintCompositionConfig) => void;
-    /** Fired on every field change with the current config. */
-    onChange?: (config: PrintCompositionConfig) => void;
-}
-
-export declare interface PrintCompositionEditorHandle {
-    /** Remove the editor from the DOM and detach listeners. */
-    destroy: () => void;
-    /** Get the current config (deep clone). */
-    getConfig: () => PrintCompositionConfig;
-    /** Replace the config and re-render. */
-    setConfig: (config: PrintCompositionConfig) => void;
-}
-
-export declare type PrintFooterLayout = 'standard' | 'seedings' | 'officials' | 'none';
-
-export declare type PrintHeaderLayout = 'grand-slam' | 'itf' | 'minimal' | 'none';
-
-export declare type PrintPageOrientation = 'portrait' | 'landscape' | 'auto';
-
-export declare type PrintPageSize = 'a4' | 'letter';
-
-/**
- * Types for the print-composition editor.
- *
- * The editor produces a config that mirrors pdf-factory's `CompositionConfig`
- * shape but is defined locally to avoid a hard runtime dep on pdf-factory.
- * Callers (admin-client) bridge this object to pdf-factory at print time.
- *
- * See `Mentat/planning/PRINT_COMPOSITION_POLICY_PLAN.md` for the
- * end-to-end architecture.
- */
-export declare type PrintType = 'draw' | 'schedule' | 'playerList' | 'courtCard' | 'signInSheet' | 'matchCard';
-
-declare type ProfileChangeListener = (state: ProfileStoreState) => void;
-
-export declare class ProfileStore {
-    private state;
-    private readonly listeners;
-    private readonly config;
-    constructor(config: SchedulingProfileConfig);
-    getState(): ProfileStoreState;
-    getSchedulingProfile(): SchedulingProfile;
-    selectDate(date: string): void;
-    selectCard(locator: RoundLocator | null): void;
-    setCatalogSearch(query: string): void;
-    setCatalogGroupBy(mode: CatalogGroupBy): void;
-    navigateToRound(item: CatalogRoundItem): void;
-    dropRound(drag: DragPayload, drop: DropTarget): {
-        ok: boolean;
-        errorMessage?: string;
-    };
-    removeRound(locator: RoundLocator): void;
-    setNotBeforeTime(locator: RoundLocator, time: string | undefined): void;
-    applyFixAction(action: FixAction): void;
-    subscribe(listener: ProfileChangeListener): () => void;
-    private setState;
-    private commitProfile;
-    private addRejectionNotice;
-    private revalidate;
-    private emit;
-}
-
-export declare interface ProfileStoreState {
-    profileDraft: SchedulingProfile;
-    venues: VenueInfo[];
-    roundCatalog: CatalogRoundItem[];
-    schedulableDates: string[];
-    activeDates?: string[];
-    selectedDate: string | null;
-    selectedLocator: RoundLocator | null;
-    ruleResults: ValidationResult[];
-    issueIndex: IssueIndex;
-    catalogSearchQuery: string;
-    catalogGroupBy: CatalogGroupBy;
-    plannedRoundBehavior: PlannedRoundBehavior;
-}
-
-declare interface Ranking {
-    rankingType?: string;
-    ranking?: number;
-    rankingDate?: string;
-}
-
-declare interface Rating {
-    ratingType?: string;
-    rating?: number;
-    ratingDate?: string;
-    [key: string]: any;
-}
-
-export declare interface RecoveryTimeEntry {
-    categoryNames?: string[];
-    categoryTypes?: string[];
-    minutes: MinutesEntry;
-}
-
-export declare function renderButtons(target: HTMLElement, buttons: any[], close?: () => void): {
-    elements: Record<string, HTMLElement>;
-};
-
-export declare type RenderCallback = () => void;
-
-export declare function renderContainer({ content, theme }: {
-    content: string | HTMLElement;
-    theme?: string;
-}): HTMLElement;
-
-export declare function renderField(item: any): {
-    field: HTMLDivElement;
-    inputElement?: HTMLDivElement | HTMLSelectElement;
-    datepicker?: any;
-    subFields?: any[];
-};
-
-export declare function renderForm(elem: HTMLElement, items: any[], relationships?: any[]): any;
-
-/**
- * Renders a matchUp with inline scoring interactivity.
- * Sets up event handlers and configuration state, then delegates to `renderMatchUp`.
- * The footer buttons (Undo/Redo/Clear/Submit) are rendered by `renderMatchUp` itself,
- * driven by the inlineScoring config state and eventHandlers passed down.
- *
- * Returns a container element that re-renders itself after each scoring action.
- */
-export declare function renderInlineMatchUp(params: RenderInlineMatchUpParams): HTMLElement;
-
-declare interface RenderInlineMatchUpParams {
-    matchUp: MatchUp;
-    composition: Composition;
-    manager: InlineScoringManager;
-    matchUpFormat?: string;
-    eventHandlers?: EventHandlers;
-    isLucky?: boolean;
-    isAdHoc?: boolean;
-    className?: string;
-    moiety?: boolean;
-    initialRoundNumber?: number;
-    isFinalRound?: boolean;
-    searchActive?: boolean;
-    selectedMatchUpId?: string;
-}
-
-export declare function renderMatchUp(params: {
-    composition?: Composition;
-    initialRoundNumber?: number;
-    matchUp: MatchUp;
-    moiety?: boolean;
-    selectedMatchUpId?: string;
-    searchActive?: boolean;
-    isFinalRound?: boolean;
-    isLucky?: boolean;
-    isAdHoc?: boolean;
-    eventHandlers?: EventHandlers;
-    className?: string;
-}): HTMLElement;
-
-export declare function renderMenu(elem: HTMLElement, menu: any[], close?: () => void): {
-    focusElement?: HTMLElement;
-};
-
-export declare function renderOptions(select: HTMLSelectElement, item: any): void;
-
-export declare function renderParticipant({ initialRoundNumber, eventHandlers, sideContainer, composition, participant, placeholder, sideNumber, matchUp }: {
-    initialRoundNumber?: number;
-    eventHandlers?: EventHandlers;
-    sideContainer?: boolean;
-    composition?: Composition;
-    participant?: Participant;
-    placeholder?: any;
-    sideNumber?: number;
-    matchUp?: MatchUp;
-}): HTMLElement;
-
-export declare function renderParticipantInput({ matchUp, side, sideNumber, eventHandlers, composition, position, currentParticipant }: {
-    matchUp: MatchUp;
-    side?: Side;
-    sideNumber?: number;
-    eventHandlers?: EventHandlers;
-    composition?: Composition;
-    position?: number;
-    currentParticipant?: any;
-}): HTMLElement;
-
-export declare function renderRound({ initialRoundNumber, selectedMatchUpId, eventHandlers, isFinalRound, isRoundRobin, searchActive, composition, roundFactor, roundNumber, roundProfile, minWidth, matchUps, context, isLucky }: {
-    initialRoundNumber?: number;
-    selectedMatchUpId?: string;
-    eventHandlers?: EventHandlers;
-    isFinalRound?: boolean;
-    isRoundRobin?: boolean;
-    searchActive?: boolean;
-    composition?: Composition;
-    roundFactor?: number;
-    roundNumber: number;
-    roundProfile?: any;
-    minWidth?: string;
-    matchUps: MatchUp[];
-    context?: any;
-    isLucky?: boolean;
-}): HTMLElement;
-
-export declare function renderRoundHeader({ eventHandlers, roundMatchUps, roundProfile, roundNumber, context }: {
-    eventHandlers?: EventHandlers;
-    roundMatchUps?: MatchUp[];
-    roundProfile?: any;
-    roundNumber: number;
-    context?: any;
-}): HTMLElement;
-
-/**
- * Renders a compact matchup: two 5px-tall slots separated by a 1px divider.
- * Total height 11px vs ~60px for the full renderMatchUp.
- */
-export declare function renderSchematicMatchUp({ matchUp, moiety, isFirstRound, isFinalRound, isRoundRobin, isLucky }: {
-    matchUp: SchematicMatchUp;
-    moiety?: boolean;
-    isFirstRound?: boolean;
-    isFinalRound?: boolean;
-    isRoundRobin?: boolean;
-    isLucky?: boolean;
-    initialRoundNumber?: number;
-}): HTMLElement;
-
-/**
- * Renders a round column with optional simplified header (round number only)
- * and compact schematic matchups.
- */
-export declare function renderSchematicRound({ initialRoundFactor, initialRoundNumber, isFinalRound, isRoundRobin, roundNumber, matchUps, showHeader, isLucky }: {
-    initialRoundFactor?: number;
-    initialRoundNumber?: number;
-    isFinalRound?: boolean;
-    isRoundRobin?: boolean;
-    roundNumber: number;
-    matchUps: SchematicMatchUp[];
-    showHeader?: boolean;
-    isLucky?: boolean;
-}): HTMLElement;
-
-/**
- * Compact bracket renderer showing structure shape without participant details.
- * Uses the same getRoundMatchUps() engine call as renderStructure but produces
- * a much smaller visual (~14px per matchup vs ~60px).
- */
-export declare function renderSchematicStructure({ initialRoundNumber, showHeaders, structureId, matchUps }: {
-    initialRoundNumber?: number;
-    showHeaders?: boolean;
-    structureId?: string;
-    matchUps: SchematicMatchUp[];
-}): HTMLElement;
-
-/**
- * Render a full team scorecard: header + collection panels + matchUp grids.
- */
-export declare function renderScorecard({ matchUp, composition, eventHandlers, swapSides }: ScorecardOptions): HTMLDivElement;
-
-export declare function renderStructure({ initialRoundNumber, selectedMatchUpId, eventHandlers, searchActive, composition, structureId, finalColumn, matchUps, minWidth, context }: {
-    initialRoundNumber?: number;
-    selectedMatchUpId?: string;
-    eventHandlers?: EventHandlers;
-    searchActive?: boolean;
-    composition?: Composition;
-    structureId?: string;
-    finalColumn?: boolean | HTMLElement;
-    matchUps: MatchUp[];
-    minWidth?: string;
-    context?: any;
-}): HTMLElement;
-
-/**
- * Render the team vs team header with names and aggregate score.
- */
-export declare function renderTeamVsHeader({ side1Name, side2Name, sets, winningSide, side1Id, side2Id }: TeamVsOptions): HTMLDivElement;
-
-/**
- * Reset configuration to defaults
- */
-export declare function resetScoringConfig(): void;
-
-/**
- * Resolves a published composition from a DISPLAY extension value.
- * Returns a new composition object (never mutates the built-in singletons).
- * Falls back to 'National' if the named composition is not found.
- */
-export declare function resolvePublishedComposition(display?: DisplayExtensionValue, fallbackName?: string): Composition;
-
-/**
- * Grouping modes for resources
- */
-declare type ResourceGroupingMode = 'BY_VENUE' | 'BY_SURFACE' | 'BY_TAG' | 'FLAT';
-
-declare interface RoundAnnotation {
-    roundNumber: number;
-    linkType: string;
-    direction: 'source' | 'target';
-    edgeId: string;
-    isSelected: boolean;
-}
-
-declare interface RoundCardCallbacks {
-    onClick: (locator: RoundLocator) => void;
-    onContextMenu?: (locator: RoundLocator, target: HTMLElement) => void;
-}
-
-declare interface RoundCardData {
-    round: RoundProfile;
-    locator: RoundLocator;
-    isSelected: boolean;
-    severity: Severity | null;
-}
-
-declare interface RoundCatalogCallbacks {
-    onSearchChange: (query: string) => void;
-    onGroupByChange: (mode: CatalogGroupBy) => void;
-    onDropRemove?: (locator: RoundLocator) => void;
-    onNavigateToPlanned?: (item: CatalogRoundItem) => void;
-}
-
-export declare interface RoundKey {
-    tournamentId: string;
-    eventId: string;
-    drawId: string;
-    structureId: string;
-    roundNumber: number;
-}
-
-export declare interface RoundLocator {
-    date: string;
-    venueId: string;
-    index: number;
-    roundKey: RoundKey;
-    roundSegment?: RoundSegment;
-}
-
-export declare interface RoundProfile {
-    tournamentId: string;
-    eventId: string;
-    eventName?: string;
-    drawId: string;
-    drawName?: string;
-    structureId: string;
-    structureType?: string;
-    roundNumber: number;
-    roundName?: string;
-    roundSegment?: RoundSegment;
-    notBeforeTime?: string;
-    sortOrder?: number;
-    matchCountEstimate?: number;
-}
-
-/**
- * Scheduling Profile — Type Definitions
- *
- * All interfaces for the scheduling profile builder component.
- * The SchedulingProfile shape matches the factory's `scheduleProfileRounds()` input.
- */
-export declare interface RoundSegment {
-    segmentNumber: number;
-    segmentsCount: number;
-}
-
-/** JSON-serializable snapshot of a composition (no functions/DOM refs) */
-export declare interface SavedComposition {
-    compositionName: string;
-    theme: string;
-    configuration: Configuration;
-    version?: number;
-}
-
-declare interface ScaleItem {
-    scaleName?: string;
-    scaleValue?: any;
-    [key: string]: any;
-}
-
-declare interface ScalesByType {
-    SINGLES?: ScaleItem[];
-    DOUBLES?: ScaleItem[];
-}
-
-declare interface Schedule {
-    scheduledDate?: string;
-    scheduledTime?: string;
-    startTime?: string;
-    endTime?: string;
-    courtId?: string;
-    courtName?: string;
-    venueId?: string;
-    venueAbbreviation?: string;
-}
-
-/**
- * JSON-serializable cell configuration.
- * 3 fixed zones (header, body, footer), each containing an ordered array of field identifiers.
- * Safe for factory extensions and publishing data.
- */
-export declare interface ScheduleCellConfig {
-    header: ScheduleCellField[];
-    body: ScheduleCellField[];
-    footer: ScheduleCellField[];
-    participantDisplay?: ParticipantDisplayConfig;
-}
-
-export declare interface ScheduleCellConfigOptions {
-    initial?: Partial<ScheduleCellDisplayConfig>;
-    onApply?: (config: ScheduleCellDisplayConfig) => void;
-}
-
-/**
- * Flat data shape the cell renderer consumes — mapped from factory matchUp objects.
- * Decouples the renderer from the factory's nested matchUp shape.
- */
-export declare interface ScheduleCellData {
-    matchUpId: string;
-    drawId?: string;
-    eventName?: string;
-    roundName?: string;
-    matchUpFormat?: string;
-    matchUpType?: string;
-    matchUpStatus?: string;
-    winningSide?: number;
-    gender?: string;
-    sides?: ScheduleCellSide[];
-    potentialParticipants?: any[][];
-    schedule?: {
-        scheduledTime?: string;
-        startTime?: string;
-        timeModifiers?: string[];
-        courtAnnotation?: string;
-        courtId?: string;
-        courtOrder?: number;
-        venueId?: string;
-    };
-    score?: {
-        scoreStringSide1?: string;
-        scoreStringSide2?: string;
-    };
-    umpire?: string;
-    /** Conflict state injected by proConflicts */
-    scheduleState?: string;
-    issueType?: string;
-    issueIds?: string[];
-    /** Blocked cell (alternative to matchUp) */
-    isBlocked?: boolean;
-    booking?: {
-        bookingType?: string;
-        rowCount?: number;
-        notes?: string;
-    };
-}
-
-/**
- * Schedule Cell Configurator Modal — select what info appears in OOP grid cells.
- *
- * Provides checkboxes for each field that can appear in a schedule cell:
- * participant names, match number, event/round, nationality, seeds,
- * scheduled time, format code, score.
- *
- * Returns a CellConfig object consumed by pdf-factory's scheduleV2 renderer.
- */
-export declare interface ScheduleCellDisplayConfig {
-    showParticipantNames: boolean;
-    showNationality: boolean;
-    showSeedings: boolean;
-    showMatchNumber: boolean;
-    showEventRound: boolean;
-    showScheduledTime: boolean;
-    showMatchFormat: boolean;
-    showScore: boolean;
-    nameFormat: 'full' | 'abbreviated' | 'lastOnly';
-    cellStyle: 'detailed' | 'compact';
-}
-
-/** Field identifiers for the 3-zone cell layout */
-export declare type ScheduleCellField = 'time' | 'eventRound' | 'participants' | 'score' | 'matchUpStatus' | 'matchUpFormat' | 'umpire';
-
-/** Participant info for a single side of a matchUp cell */
-export declare interface ScheduleCellSide {
-    sideNumber?: number;
-    participantName?: string;
-    participantId?: string;
-    seedNumber?: number;
-    ranking?: number;
-    nationality?: string;
-    /** Team name when participant is a member of a team (tie/team event) */
-    teamName?: string;
-    /** True if this side is a BYE (no participant) */
-    bye?: boolean;
-}
-
-/**
- * Schedule Cell TypeAhead — inline autocomplete for empty grid cells.
- *
- * Activates an Awesomplete typeahead input inside an empty schedule cell.
- * The consumer provides a list of unscheduled matchUps and a selection callback.
- * Reuses the existing createTypeAhead helper (Awesomplete wrapper).
- */
-export declare interface ScheduleCellTypeAheadOptions {
-    /** The grid cell element to activate the typeahead in */
-    cell: HTMLElement;
-    /** Returns the list of assignable matchUps as { label, value } */
-    listProvider: () => Array<{
-        label: string;
-        value: string;
-    }>;
-    /** Called when a matchUp is selected — value is the matchUpId */
-    onSelect: (matchUpId: string) => void;
-    /** Called when the typeahead is dismissed without selection */
-    onCancel?: () => void;
-}
-
-declare interface ScheduleContent {
-    cellStyle?: 'detailed' | 'compact';
-    showMatchNumbers?: boolean;
-    alertBanner?: string;
-}
-
-export declare interface ScheduleDate {
-    date: string;
-    isActive: boolean;
-    matchUpCount?: number;
-    issueCount?: number;
-}
-
-export declare interface ScheduleDay {
-    scheduleDate: string;
-    venues: VenueSchedule[];
-}
-
-export declare type ScheduledBehavior = 'dim' | 'hide';
-
-export declare interface ScheduleIssue {
-    severity: ScheduleIssueSeverity;
-    message: string;
-    matchUpId?: string;
-    date?: string;
-    /** Structured conflict data for rich rendering */
-    issueType?: string;
-    prefix?: string;
-    participants?: string;
-    conflictParticipants?: string[];
-    /** All matchUpIds involved in this conflict (for click-to-scroll fallback) */
-    conflictMatchUpIds?: string[];
-}
-
-export declare interface ScheduleIssueCounts {
-    total: number;
-    ERROR: number;
-    WARN: number;
-    INFO: number;
-}
-
-export declare interface ScheduleIssueIndex {
-    all: ScheduleIssue[];
-    bySeverity: Record<ScheduleIssueSeverity, ScheduleIssue[]>;
-    byDate: Record<string, ScheduleIssue[]>;
-    counts: ScheduleIssueCounts;
-    countsByDate: Record<string, ScheduleIssueCounts>;
-}
-
-export declare type ScheduleIssueSeverity = 'ERROR' | 'WARN' | 'INFO';
-
-export declare type SchedulePageChangeListener = (state: SchedulePageState) => void;
-
-export declare interface SchedulePageConfig {
-    matchUpCatalog: CatalogMatchUpItem[];
-    scheduleDates: ScheduleDate[];
-    issues?: ScheduleIssue[];
-    courtGridElement?: HTMLElement;
-    /** Max height for the court grid viewport (e.g. '500px', '60vh'). Defaults to none (fills available space). */
-    gridMaxHeight?: string;
-    /** When true, the left column (date strip + issues panel) is not rendered at all. */
-    hideLeft?: boolean;
-    /** Which side to place the matchUp catalog. Defaults to 'right'. */
-    catalogSide?: 'left' | 'right';
-    scheduledBehavior?: ScheduledBehavior;
-    schedulingMode?: SchedulingMode;
-    onDateSelected?: (date: string) => void;
-    onMatchUpDrop?: (payload: SchedulePageDragPayload, event: DragEvent) => void;
-    onMatchUpRemove?: (matchUpId: string) => void;
-    onMatchUpSelected?: (matchUp: CatalogMatchUpItem | null) => void;
-    /** Called in 'bulk' mode when the user triggers save — receives all pending actions */
-    onBulkSave?: (actions: PendingScheduleAction[]) => void;
-}
-
-export declare class SchedulePageControl {
-    private readonly store;
-    private readonly layout;
-    private readonly unsubscribe;
-    private container;
-    constructor(config: SchedulePageConfig);
-    render(container: HTMLElement): void;
-    destroy(): void;
-    setMatchUpCatalog(catalog: CatalogMatchUpItem[]): void;
-    setScheduleDates(dates: ScheduleDate[]): void;
-    setIssues(issues: ScheduleIssue[]): void;
-    save(): PendingScheduleAction[];
-    discardPending(): void;
-    get hasUnsavedChanges(): boolean;
-    getStore(): SchedulePageStore;
-}
-
-export declare type SchedulePageDragPayload = CatalogMatchUpDragPayload | GridMatchUpDragPayload;
-
-declare interface SchedulePageLayoutCallbacks {
-    onToggleLeft: () => void;
-}
-
-declare interface SchedulePageLayoutPanels {
-    dateStrip: UIPanel_3<SchedulePageState>;
-    issuesPanel: UIPanel_3<SchedulePageState>;
-    courtGridSlot: UIPanel_3<SchedulePageState>;
-    matchUpCatalog: UIPanel_3<SchedulePageState>;
-    inspectorPanel: UIPanel_3<SchedulePageState>;
-}
-
-export declare interface SchedulePageState {
-    matchUpCatalog: CatalogMatchUpItem[];
-    scheduleDates: ScheduleDate[];
-    issues: ScheduleIssue[];
-    selectedDate: string | null;
-    selectedMatchUp: CatalogMatchUpItem | null;
-    catalogSearchQuery: string;
-    catalogGroupBy: MatchUpCatalogGroupBy;
-    catalogFilters: CatalogFilters;
-    showCompleted: boolean;
-    showScheduled: boolean;
-    scheduledBehavior: ScheduledBehavior;
-    schedulingMode: SchedulingMode;
-    pendingActions: PendingScheduleAction[];
-    hasUnsavedChanges: boolean;
-    leftCollapsed: boolean;
-    hideLeft: boolean;
-}
-
-export declare class SchedulePageStore {
-    private state;
-    private readonly listeners;
-    private readonly config;
-    constructor(config: SchedulePageConfig);
-    getState(): SchedulePageState;
-    setMatchUpCatalog(catalog: CatalogMatchUpItem[]): void;
-    setScheduleDates(dates: ScheduleDate[]): void;
-    setIssues(issues: ScheduleIssue[]): void;
-    handleMatchUpDrop(payload: SchedulePageDragPayload, event: DragEvent): void;
-    handleMatchUpRemove(matchUpId: string): void;
-    /**
-     * Flush all pending actions via the onBulkSave callback and clear the queue.
-     * Returns the actions that were flushed.
-     */
-    save(): PendingScheduleAction[];
-    /**
-     * Discard all pending actions without saving.
-     */
-    discardPending(): void;
-    getPendingActions(): PendingScheduleAction[];
-    selectDate(date: string): void;
-    selectMatchUp(matchUp: CatalogMatchUpItem | null): void;
-    setCatalogSearch(query: string): void;
-    setCatalogGroupBy(mode: MatchUpCatalogGroupBy): void;
-    setCatalogFilters(filters: CatalogFilters): void;
-    setShowCompleted(show: boolean): void;
-    setShowScheduled(show: boolean): void;
-    toggleLeftPanel(): void;
-    subscribe(listener: SchedulePageChangeListener): () => void;
-    private setState;
-    private emit;
-}
-
-export declare type SchedulingEditorChangeListener = (state: SchedulingEditorState) => void;
-
-export declare interface SchedulingEditorConfig {
-    initialPolicy?: SchedulingPolicyData;
-    categoryNames?: string[];
-    categoryTypes?: string[];
-    matchUpFormatCodes?: string[];
-    onChange?: (policy: SchedulingPolicyData) => void;
-}
-
-export declare class SchedulingEditorControl {
-    private readonly store;
-    private readonly panel;
-    private readonly unsubscribe;
-    private container;
-    constructor(config: SchedulingEditorConfig);
-    render(container: HTMLElement): void;
-    destroy(): void;
-    getData(): SchedulingPolicyData;
-    setData(data: SchedulingPolicyData): void;
-    getStore(): SchedulingEditorStore;
-    /**
-     * Create as a PolicyEditorInstance for embedding in the catalog editor shell.
-     */
-    static createEditorInstance(config: {
-        initialData: Record<string, unknown>;
-        onChange: (data: Record<string, unknown>) => void;
-    }): PolicyEditorInstance;
-}
-
-export declare type SchedulingEditorSection = 'modificationFlags' | 'dailyLimits' | 'defaultTimes' | 'averageTimes' | 'recoveryTimes';
-
-export declare interface SchedulingEditorState {
-    draft: SchedulingPolicyData;
-    expandedSections: Set<SchedulingEditorSection>;
-    dirty: boolean;
-}
-
-export declare class SchedulingEditorStore {
-    private state;
-    private readonly listeners;
-    private readonly config;
-    constructor(config: SchedulingEditorConfig);
-    getState(): SchedulingEditorState;
-    getData(): SchedulingPolicyData;
-    setData(data: SchedulingPolicyData): void;
-    toggleSection(sectionId: SchedulingEditorSection): void;
-    setModificationFlag(key: 'courts' | 'venues', value: boolean): void;
-    setDailyLimit(key: 'SINGLES' | 'DOUBLES' | 'total', value: number): void;
-    setDefaultAverageTime(index: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
-    setDefaultRecoveryTime(index: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
-    addAverageFormatGroup(): void;
-    removeAverageFormatGroup(index: number): void;
-    setAverageFormatCodes(groupIndex: number, codes: string[]): void;
-    setAverageTime(groupIndex: number, overrideIndex: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
-    addAverageCategoryOverride(groupIndex: number): void;
-    removeAverageCategoryOverride(groupIndex: number, overrideIndex: number): void;
-    setAverageOverrideCategories(groupIndex: number, overrideIndex: number, key: 'categoryNames' | 'categoryTypes', values: string[]): void;
-    addRecoveryFormatGroup(): void;
-    removeRecoveryFormatGroup(index: number): void;
-    setRecoveryFormatCodes(groupIndex: number, codes: string[]): void;
-    setRecoveryTime(groupIndex: number, overrideIndex: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
-    addRecoveryCategoryOverride(groupIndex: number): void;
-    removeRecoveryCategoryOverride(groupIndex: number, overrideIndex: number): void;
-    setRecoveryOverrideCategories(groupIndex: number, overrideIndex: number, key: 'categoryNames' | 'categoryTypes', values: string[]): void;
-    subscribe(listener: SchedulingEditorChangeListener): () => void;
-    private commitDraft;
-    private emit;
-}
-
-/**
- * Controls how drop/remove actions are committed:
- * - 'immediate': each drop fires the consumer callback right away (e.g. executionQueue per action)
- * - 'bulk': actions accumulate in a pending queue; consumer calls save() to flush
- */
-export declare type SchedulingMode = 'immediate' | 'bulk';
-
-export declare interface SchedulingPolicyData {
-    allowModificationWhenMatchUpsScheduled?: {
-        courts: boolean;
-        venues: boolean;
-    };
-    defaultTimes?: {
-        averageTimes?: AverageTimeEntry[];
-        recoveryTimes?: RecoveryTimeEntry[];
-    };
-    defaultDailyLimits?: {
-        SINGLES?: number;
-        DOUBLES?: number;
-        total?: number;
-    };
-    matchUpAverageTimes?: MatchUpAverageTime[];
-    matchUpRecoveryTimes?: MatchUpRecoveryTime[];
-    matchUpDailyLimits?: unknown[];
-}
-
-export declare type SchedulingProfile = ScheduleDay[];
-
-export declare interface SchedulingProfileConfig {
-    venues: VenueInfo[];
-    roundCatalog: CatalogRoundItem[];
-    schedulableDates: string[];
-    activeDates?: string[];
-    /** When true, the left column (date strip + issues panel) is not rendered. */
-    hideLeft?: boolean;
-    /** Which side to place the round catalog. Defaults to 'right'. */
-    catalogSide?: 'left' | 'right';
-    initialProfile?: SchedulingProfile;
-    selectedDate?: string;
-    temporalAdapter?: TemporalAdapter;
-    demandAdapter?: DemandAdapter;
-    dependencyAdapter?: DependencyAdapter;
-    venueOrder?: string[];
-    plannedRoundBehavior?: PlannedRoundBehavior;
-    onProfileChanged?: (profile: SchedulingProfile) => void;
-    onFixAction?: (action: FixAction) => void;
-}
-
-export declare class SchedulingProfileControl {
-    private readonly store;
-    private readonly layout;
-    private readonly unsubscribe;
-    private readonly popover;
-    private container;
-    constructor(config: SchedulingProfileConfig);
-    render(container: HTMLElement): void;
-    destroy(): void;
-    getProfile(): SchedulingProfile;
-    getStore(): ProfileStore;
-}
-
-export declare interface SchedulingValidationResult {
-    severity: SchedulingValidationSeverity;
-    path: string;
-    message: string;
-}
-
-export declare type SchedulingValidationSeverity = 'error' | 'warning';
-
-export declare interface SchematicMatchUp {
-    matchUpId: string;
-    roundNumber: number;
-    roundPosition?: number;
-    drawPositions?: number[];
-    finishingRound?: number;
-    roundFactor?: number;
-    stage?: string;
-    isRoundRobin?: boolean;
-    preFeedRound?: boolean;
-    structureId?: string;
-    collectionId?: string;
-}
-
-declare interface Score {
-    scoreStringSide1?: string;
-    scoreStringSide2?: string;
-    sets?: SetScore_2[];
-}
-
-export declare interface ScorecardOptions {
-    matchUp: any;
-    composition?: any;
-    eventHandlers?: any;
-    swapSides?: boolean;
-}
-
-export declare type ScoreOutcome = {
-    isValid: boolean;
-    sets: SetScore[];
-    scoreObject?: any;
-    winningSide?: number;
-    matchUpStatus?: string;
-    error?: string;
-    matchUpFormat?: string;
-    score?: string;
-};
-
-/**
- * Scoring configuration for courthive-components
- * This provides a simple configuration object that can be modified by consumers
- */
-declare interface ScoringConfig {
-    scoringApproach?: 'freeScore' | 'dynamicSets' | 'dialPad' | 'inlineScoring';
-    smartComplements?: boolean;
-    composition?: string;
-    idiom?: string;
-    dateFormat?: string;
-    timeFormat?: string;
-}
-
-export declare function scoringModal(params: ScoringModalParams): void;
-
-export declare type ScoringModalLabels = {
-    title?: string;
-    cancel?: string;
-    clear?: string;
-    submit?: string;
-    format?: string;
-    formatEditTitle?: string;
-    irregularEnding?: string;
-    winner?: string;
-    retired?: string;
-    walkover?: string;
-    defaulted?: string;
-    validScore?: string;
-    scoreIncomplete?: string;
-    invalidScore?: string;
-    scoreTips?: string;
-    setScores?: string;
-    tiebreaks?: string;
-    matchTiebreaks?: string;
-    irregularEndings?: string;
-    addSet?: boolean;
-    dynamicSetsTips?: string;
-    dialPadTips?: string;
-};
-
-export declare type ScoringModalParams = {
-    matchUp: any;
-    callback: (outcome: any) => void;
-    onClose?: () => void;
-    labels?: ScoringModalLabels;
-};
-
-export declare interface SegmentData {
-    participantName?: string;
-    drawPosition?: number;
-    seedNumber?: number;
-    entryStatus?: string;
-    nationalityCode?: string;
-    scoreString?: string;
-    matchUpStatus?: string;
-    roundName?: string;
-    depth: number;
-    matchUp?: SunburstMatchUp;
-}
-
-export declare function selectItem(params: SelectItemParams): void;
-
-export declare interface SelectItemOption {
-    label: string;
-    onClick?: () => void;
-    [key: string]: any;
-}
-
-export declare interface SelectItemParams {
-    title: string;
-    placeholder?: string;
-    options: SelectItemOption[];
-    selectionLimit?: number;
-    /** Factory to create a selection table. If not provided, a simple list is used. */
-    createTable?: (config: {
-        anchorId: string;
-        data: any[];
-        selectionLimit?: number;
-        onSelected: (value: any[]) => void;
-    }) => {
-        table: any;
-        destroy?: () => void;
-    };
-    /** Factory to create a search filter function for the table. */
-    createFilter?: (table: any) => (value: string) => void;
-}
-
-/**
- * Set format information returned by matchUpFormatCode.parse()
- */
-export declare type SetFormat = {
-    setTo?: number;
-    tiebreakAt?: number;
-    tiebreakFormat?: {
-        tiebreakTo?: number;
-        noAd?: boolean;
-    };
-    tiebreakSet?: {
-        tiebreakTo?: number;
-        noAd?: boolean;
-    };
-    timed?: boolean;
-    minutes?: number;
-};
-
-/**
- * Type definitions for scoring modal V2
- */
-export declare type SetScore = {
-    setNumber?: number;
-    side1Score?: number;
-    side2Score?: number;
-    side1TiebreakScore?: number;
-    side2TiebreakScore?: number;
-    side1PointScore?: string | number;
-    side2PointScore?: string | number;
-    winningSide?: number;
-};
-
-declare interface SetScore_2 {
-    setNumber: number;
-    side1Score?: number;
-    side2Score?: number;
-    side1TiebreakScore?: number;
-    side2TiebreakScore?: number;
-    side1PointScore?: number | string;
-    side2PointScore?: number | string;
-    winningSide?: number;
-}
-
-/**
- * Set scoring configuration (can be partial)
- */
-export declare function setScoringConfig(config: Partial<ScoringConfig>): void;
-
-export declare type Severity = 'ERROR' | 'WARN' | 'INFO';
-
-declare interface SeverityCounts {
-    total: number;
-    ERROR: number;
-    WARN: number;
-    INFO: number;
-}
-
-/**
- * Determine if smart complement should be applied for a given input
- *
- * @param digit - The digit being entered
- * @param isShiftPressed - Whether Shift key is pressed
- * @param setIndex - Index of the current set
- * @param sets - Current sets array
- * @param config - Match configuration
- * @param smartComplementsUsed - Set of indices where complement was already used
- * @param smartComplementsEnabled - Whether feature is enabled in settings
- * @returns Result indicating if/how complement should be applied
- */
-export declare function shouldApplySmartComplement(digit: number, isShiftPressed: boolean, setIndex: number, sets: SetScore[], config: MatchUpConfig, smartComplementsUsed: Set<number>, smartComplementsEnabled: boolean): SmartComplementResult;
-
-/**
- * Determine if a new set row should be created
- */
-export declare function shouldCreateNextSet(currentSetIndex: number, sets: SetScore[], config: MatchUpConfig): boolean;
-
-/**
- * Determine if tiebreak input should be visible for a set
- */
-export declare function shouldShowTiebreak(setIndex: number, scores: {
-    side1: number;
-    side2: number;
-}, config: MatchUpConfig): boolean;
-
-export declare function showCourtAvailabilityModal(config: CourtAvailabilityModalConfig): Promise<void>;
-
-declare interface Side {
-    sideNumber: number;
-    drawPosition?: number;
-    participant?: Participant;
-    participantFed?: string;
-    sourceMatchUp?: MatchUp;
-    qualifier?: boolean;
-    bye?: boolean;
-    lineUp?: LineUp[];
-    score?: SideScore;
-    seedNumber?: number;
-    seedValue?: string | number;
-}
-
-declare interface SideScore {
-    scoreStringSide?: string;
-    games?: number;
-    points?: number;
-}
-
-/**
- * Result of smart complement calculation
- */
-export declare type SmartComplementResult = {
-    field1Value: number;
-    field2Value: number;
-    shouldApply: boolean;
-    reason?: string;
-};
-
-export declare const standardTemplates: TopologyTemplate[];
-
-/**
- * Detail payload for the `stateChanged` CustomEvent.
- */
-export declare interface StateChangedDetail {
-    matchUpId: string;
-    matchUp: MatchUp;
-    isComplete: boolean;
-    winningSide?: number;
-}
-
-declare interface StructureCardCallbacks {
-    onSelect: (nodeId: string) => void;
-    onSelectEdge: (edgeId: string) => void;
-    onDoubleClick?: (nodeId: string) => void;
-    onPortMouseDown: (nodeId: string, portType: 'winner' | 'loser') => void;
-    onPortMouseUp: (nodeId: string) => void;
-    onDragStart: (nodeId: string, startX: number, startY: number) => void;
-}
-
-/**
- * BurstChart D3v7 - Tournament Sunburst Visualization
- *
- * Modern D3v7 implementation with emoji flags and clean TypeScript architecture.
- * Consumes TODS-aligned SunburstDrawData natively.
- *
- * Features:
- * - D3v7 partition layout
- * - Emoji flags (no image dependencies)
- * - Interactive hover with winner/opponent display
- * - Tournament title with text wrapping
- * - Color coding by seed/entry type
- * - Three-line hover display (winner, score, opponent)
- */
-/** TODS-aligned draw structure for the sunburst */
-export declare interface SunburstDrawData {
-    drawSize: number;
-    roundMatchUps: Record<number, SunburstMatchUp[]>;
-    seedAssignments?: {
-        participantId: string;
-        seedNumber: number;
-    }[];
-}
-
-export declare interface SunburstMatchUp {
-    roundNumber: number;
-    roundName?: string;
-    matchUpStatus: string;
-    winningSide?: number;
-    drawPositions: number[];
-    scoreString?: string;
-    sides: SunburstSide[];
-}
-
-export declare interface SunburstSide {
-    sideNumber: number;
-    drawPosition: number;
-    participantName?: string;
-    nationalityCode?: string;
-    seedNumber?: number;
-    entryStatus?: string;
-}
-
-export declare interface TeamVsOptions {
-    side1Name: string;
-    side2Name: string;
-    sets?: any[];
-    winningSide?: number;
-    side1Id?: string;
-    side2Id?: string;
-}
-
-export declare interface TemporalAdapter {
-    isDateAvailable: (date: string) => {
-        ok: boolean;
-        reason?: string;
-    };
-    getDayCapacityMinutes?: (date: string) => number;
-}
-
-export declare class TemporalGrid {
-    private engine;
-    private control;
-    private config;
-    private rootElement;
-    private venueTreeElement;
-    private calendarElement;
-    private capacityElement;
-    private statsBarInstance;
-    private viewToolbarResult;
-    private datepicker;
-    private visibleCourts;
-    private initialSnapshot;
-    private isDirty;
-    constructor(config: TemporalGridConfig);
-    /**
-     * Render the component into a container
-     */
-    render(container: HTMLElement): void;
-    /**
-     * Destroy the component and cleanup
-     */
-    destroy(): void;
-    private createRootElement;
-    private renderToolbar;
-    /**
-     * Initialize the datepicker on the toolbar date input.
-     * Must be called after the toolbar element is in the DOM.
-     */
-    private initDatepicker;
-    private handleDateChange;
-    private renderCapacityIndicator;
-    private renderVenueTree;
-    private renderCalendar;
-    /** Serialize current engine state (blocks + availability) for comparison */
-    private takeSnapshot;
-    /** Compare current state to initial snapshot and update dirty flag */
-    private checkDirtyState;
-    /** Reset the snapshot (call after a successful save) */
-    resetDirtyState(): void;
-    private updateStatsBar;
-    private updateCapacityStats;
-    private updateVenueTree;
-    private handleEngineEvent;
-    private handleBlockSelected;
-    private handleCourtSelected;
-    private handleTimeRangeSelected;
-    private handleCourtCheckboxChange;
-    private handleVenueCheckboxChange;
-    private updateVenueCheckboxState;
-    /**
-     * Get the engine instance
-     */
-    getEngine(): TemporalEngine;
-    /**
-     * Get the controller instance
-     */
-    getControl(): TemporalGridControl | null;
-    /**
-     * Set the selected day
-     */
-    setDay(day: DayId_2): void;
-    /**
-     * Refresh the display
-     */
-    refresh(): void;
-}
-
-declare interface TemporalGridCallbacks {
-    /**
-     * Called when dirty state changes (blocks/availability modified vs initial)
-     */
-    onDirtyChange?: (isDirty: boolean) => void;
-}
-
-export declare interface TemporalGridConfig extends Partial<TemporalGridControlConfig>, TemporalGridCallbacks {
-    /**
-     * Tournament record (TODS format)
-     */
-    tournamentRecord: any;
-    /**
-     * Engine configuration overrides
-     */
-    engineConfig?: {
-        dayStartTime?: string;
-        dayEndTime?: string;
-        slotMinutes?: number;
-    };
-    /**
-     * Initial selected day
-     */
-    initialDay?: DayId_2;
-    /**
-     * Show facility tree
-     */
-    showVenueTree?: boolean;
-    /**
-     * Show capacity indicator
-     */
-    showCapacity?: boolean;
-    /**
-     * Show toolbar
-     */
-    showToolbar?: boolean;
-    /**
-     * i18n labels
-     */
-    labels?: TemporalGridLabels;
-    /**
-     * Language code for datepicker localization (e.g. 'en', 'fr', 'de')
-     */
-    language?: string;
-    /**
-     * Callback when "Set Default Availability" is clicked
-     */
-    onSetDefaultAvailability?: () => void;
-    /**
-     * Callback when "Save to Tournament" is clicked
-     */
-    onSave?: () => void;
-    /**
-     * Callback when mutations are applied
-     */
-    onMutationsApplied?: (mutations: any[]) => void;
-}
-
-declare class TemporalGridControl {
-    private readonly engine;
-    private timeline;
-    private readonly config;
-    private unsubscribe;
-    private currentItems;
-    private isRendering;
-    private popoverManager;
-    private viewState;
-    private currentDay;
-    private currentView;
-    private selectedCourts;
-    private visibleCourts;
-    constructor(engine: TemporalEngine, config: TemporalGridControlConfig);
-    private initialize;
-    /**
-     * Ensure timeline exists. Defers creation to the next macro-task so the
-     * container has layout dimensions (matches the working story pattern).
-     */
-    private ensureTimeline;
-    /**
-     * Build the current view data from the engine.
-     */
-    /**
-     * Get the list of days visible in the current view.
-     */
-    getViewDays(): string[];
-    private buildViewData;
-    /**
-     * Create the timeline with initial data already populated.
-     */
-    private createTimelineWithData;
-    /** Set the selected day (public API) */
-    setDay(day: DayId): void;
-    /** Get current selected day */
-    getDay(): DayId | null;
-    /** Set view mode */
-    setView(view: string): void;
-    /** Set a named view preset (day/days3/week/all) */
-    setViewPreset(viewKey: string): void;
-    /** Select courts for multi-court operations */
-    setSelectedCourts(courts: CourtRef[]): void;
-    /** Get selected courts */
-    getSelectedCourts(): CourtRef[];
-    /** Set which courts are visible in the timeline */
-    setVisibleCourts(courts: Set<string> | null): void;
-    /** Set layer visibility */
-    setLayerVisibility(layerId: BlockType, visible: boolean): void;
-    /** Refresh the calendar display */
-    refresh(): void;
-    /** Destroy the controller and cleanup */
-    destroy(): void;
-    private updateTimelineWindow;
-    private render;
-    /**
-     * onMove: Called when user finishes dragging or resizing an item.
-     * Returns true to accept, false to reject.
-     */
-    private handleOnMove;
-    /**
-     * onMoving: Live validation during drag (optional visual feedback).
-     * Destroys active popover, clamps to court availability.
-     * Returns clamped start/end, or null to reject.
-     */
-    private handleOnMoving;
-    /**
-     * Timeline click handler: Routes to popover based on item type.
-     * Handles ghost confirmation (multi-row create) and block click → popover.
-     */
-    private handleTimelineClick;
-    /**
-     * Multi-row ghost creation handler.
-     * Called when user confirms a ghost spanning one or more court rows.
-     * Creates one block per court via engine.applyBlock.
-     */
-    private handleMultiRowCreate;
-    /** Get the popover manager (for external access) */
-    getPopoverManager(): BlockPopoverManager;
-    private handleEngineEvent;
-    /** Snap a date to the nearest N-minute increment */
-    private snapToMinutes;
-    /**
-     * Format a Date as a local-time ISO string (no timezone offset).
-     * Engine stores times as wall-clock strings like "2026-06-15T09:00:00".
-     * toISOString() converts to UTC which shifts the time by the local offset.
-     */
-    private toLocalISO;
-    /** Show conflict dialog */
-    private showConflictDialog;
-    /** Get timeline instance (for advanced usage) */
-    getTimeline(): CourtTimeline | null;
-    /** Get engine instance */
-    getEngine(): TemporalEngine;
-    /** Get view state (for external consumers to subscribe to view changes) */
-    getViewState(): TemporalViewState;
-}
-
-declare interface TemporalGridControlConfig {
-    /** Container element for the timeline */
-    container: HTMLElement;
-    /** Initial selected day */
-    initialDay?: DayId;
-    /** Initial view mode */
-    initialView?: 'day' | 'week';
-    /** Resource grouping mode */
-    groupingMode?: ResourceGroupingMode;
-    /** Whether to show conflict indicators */
-    showConflicts?: boolean;
-    /** Whether segments should have labels */
-    showSegmentLabels?: boolean;
-    /** Custom color scheme */
-    colorScheme?: typeof DEFAULT_COLOR_SCHEME;
-    /** Callback when a block is selected */
-    onBlockSelected?: (blockId: string) => void;
-    /** Callback when a court is selected */
-    onCourtSelected?: (court: CourtRef) => void;
-    /** Callback when time range is selected */
-    onTimeRangeSelected?: (params: {
-        courts: CourtRef[];
-        start: string;
-        end: string;
-    }) => void;
-    /** Callback when engine blocks change (for stats bar, external consumers) */
-    onBlocksChanged?: () => void;
-    /** Callback when a day label is double-clicked (for navigating to 1-Day view) */
-    onDayNavigate?: (day: string) => void;
-}
-
-/**
- * i18n labels for the temporal grid component.
- * All fields are optional — English defaults are used when omitted.
- */
-export declare interface TemporalGridLabels {
-    view?: string;
-    day1?: string;
-    days3?: string;
-    week?: string;
-    tournament?: string;
-    courtAvailability?: string;
-    totalHours?: string;
-    blocked?: string;
-    available?: string;
-    avgPerCourt?: string;
-    setDefaultAvailability?: string;
-    saveToTournament?: string;
-}
-
-declare class TemporalViewState {
-    private selectedDay;
-    private selectedVenue;
-    private selectedCourt;
-    private readonly layerVisibility;
-    private readonly listeners;
-    setSelectedDay(day: DayId_3): void;
-    getSelectedDay(): DayId_3 | null;
-    setSelectedVenue(venueId: string | null): void;
-    getSelectedVenue(): string | null;
-    setSelectedCourt(courtId: string | null): void;
-    getSelectedCourt(): string | null;
-    setLayerVisibility(layerId: BlockType_2, visible: boolean): void;
-    getLayerVisibility(): Map<BlockType_2, boolean>;
-    isLayerVisible(layerId: BlockType_2): boolean;
-    getSnapshot(): ViewStateSnapshot;
-    subscribe(listener: ViewChangeListener): () => void;
-    private emit;
-}
-
-export declare function tennisCourt(className: string): SVGSVGElement;
-
-declare interface TimelineGroupData {
-    id: string;
-    content: string;
-    order?: number;
-    courtRef?: CourtRef_2;
-    surface?: string;
-    indoor?: boolean;
-    hasLights?: boolean;
-    tags?: string[];
-}
-
-declare interface TimelineItemData {
-    id: string;
-    group: string;
-    content: string;
-    start: Date | string;
-    end?: Date | string;
-    type?: 'range' | 'background';
-    className?: string;
-    style?: string;
-    title?: string;
-    editable?: boolean | {
-        updateTime?: boolean;
-        updateGroup?: boolean;
-        remove?: boolean;
-    };
-    blockId?: string;
-    status?: string;
-    reason?: string;
-    isBlock?: boolean;
-    isSegment?: boolean;
-    isConflict?: boolean;
-}
-
-declare interface TimelineOptions {
-    /** Visible window start */
-    start?: Date;
-    /** Visible window end */
-    end?: Date;
-    /** Minimum allowed date (pan limit) */
-    min?: Date;
-    /** Maximum allowed date (pan limit) */
-    max?: Date;
-    /** Minimum visible duration in ms (zoom limit) */
-    zoomMin?: number;
-    /** Maximum visible duration in ms (zoom limit) */
-    zoomMax?: number;
-    /** Snap function: given a Date, return snapped Date */
-    snap?: (date: Date) => Date;
-    /** Row height in pixels (default 40) */
-    rowHeight?: number;
-    /** Time axis formatting */
-    timeAxis?: {
-        scale: string;
-        step: number;
-    };
-    /** Whether to show tooltips on hover */
-    showTooltips?: boolean;
-    /** Enable pinch-to-zoom (ctrl+wheel). Default false. */
-    enablePinchZoom?: boolean;
-    /** Height of the container (CSS value) */
-    height?: string;
-}
-
-export declare function tipster(params: TipsterParams): Instance | undefined;
-
-declare type TipsterParams = {
-    title?: string;
-    options?: any[];
-    menuItems?: any[];
-    coords?: any;
-    callback?: (result: any) => void;
-    config?: any;
-    target?: HTMLElement;
-    items?: any[];
-};
-
-export declare const toggleOverlay: ({ target }: {
-    target: HTMLElement;
-}) => (rows?: any[]) => void;
-
-declare interface ToolbarCallbacks {
-    onAddStructure: (stage: string, structureType?: string) => void;
-    onLoadTemplate: (template: TopologyTemplate) => void;
-    onAutoLayout: () => void;
-    onGenerate: () => void;
-    onSaveTemplate?: () => void;
-    onClear?: () => void;
-}
-
-declare interface ToolbarOptions {
-    hideTemplates?: boolean;
-    hideGenerate?: boolean;
-    readOnly?: boolean;
-}
-
-export declare interface TopologyBuilderConfig {
-    initialState?: Partial<TopologyState>;
-    onGenerate?: (state: TopologyState) => void;
-    onDoubleClickNode?: (node: TopologyNode, state: TopologyState) => void;
-    onSaveTemplate?: (state: TopologyState) => void;
-    onClear?: () => void;
-    templates?: TopologyTemplate[];
-    hideTemplates?: boolean;
-    hideGenerate?: boolean;
-    hideDelete?: boolean;
-    readOnly?: boolean;
-}
-
-export declare class TopologyBuilderControl {
-    private readonly store;
-    private readonly layout;
-    private readonly unsubscribe;
-    private readonly config;
-    constructor(config?: TopologyBuilderConfig);
-    private buildToolbarPanel;
-    private buildCanvasPanel;
-    private handleCreateEdge;
-    render(container: HTMLElement): void;
-    destroy(): void;
-    autoLayout(): void;
-    getState(): TopologyState;
-    loadState(state: TopologyState): void;
-    private addDefaultStructure;
-    private scrollCanvasToNode;
-    private handleGenerate;
-}
-
-export declare type TopologyChangeListener = (state: TopologyState) => void;
-
-export declare interface TopologyEdge {
-    id: string;
-    sourceNodeId: string;
-    targetNodeId: string;
-    linkType: 'WINNER' | 'LOSER' | 'POSITION';
-    sourceRoundNumber?: number;
-    targetRoundNumber?: number;
-    feedProfile?: string;
-    finishingPositions?: number[];
-    qualifyingPositions?: number;
-    label?: string;
-}
-
-export declare interface TopologyNode {
-    id: string;
-    structureName: string;
-    stage: 'MAIN' | 'QUALIFYING' | 'CONSOLATION' | 'PLAY_OFF';
-    structureType: string;
-    drawSize: number;
-    qualifyingPositions?: number;
-    matchUpFormat?: string;
-    structureOptions?: any;
-    position: {
-        x: number;
-        y: number;
-    };
-    matchUps?: SchematicMatchUp[];
-}
-
-export declare interface TopologyState {
-    nodes: TopologyNode[];
-    edges: TopologyEdge[];
-    selectedNodeId: string | null;
-    selectedEdgeId: string | null;
-    drawName: string;
-    templateName?: string;
-}
-
-export declare class TopologyStore {
-    private state;
-    private listeners;
-    constructor(initialState?: Partial<TopologyState>);
-    getState(): TopologyState;
-    subscribe(listener: TopologyChangeListener): () => void;
-    private notify;
-    setDrawName(name: string): void;
-    addNode(partial: Omit<TopologyNode, 'id' | 'position'>): TopologyNode;
-    updateNode(nodeId: string, updates: Partial<Omit<TopologyNode, 'id'>>): void;
-    removeNode(nodeId: string): void;
-    addEdge(partial: Omit<TopologyEdge, 'id' | 'label'>): TopologyEdge | null;
-    updateEdge(edgeId: string, updates: Partial<Omit<TopologyEdge, 'id'>>): void;
-    removeEdge(edgeId: string): void;
-    selectNode(nodeId: string | null): void;
-    selectEdge(edgeId: string | null): void;
-    /**
-     * If the given node is a consolation structure, clamp its drawSize so it
-     * does not exceed the total capacity of inbound links.
-     */
-    private clampConsolationDrawSize;
-    /** Sum of losers that all inbound edges can deliver to a node. */
-    private inboundCapacity;
-    /** Find a non-overlapping position for a newly added node. */
-    private nextNodePosition;
-    autoLayout(): void;
-    loadState(newState: TopologyState): void;
-    private computeEdgeLabel;
-}
-
-export declare interface TopologyTemplate {
-    name: string;
-    description?: string;
-    state: Omit<TopologyState, 'selectedNodeId' | 'selectedEdgeId'>;
-}
-
-export declare function topologyToDrawOptions(state: TopologyState): DrawOptionsResult;
-
-export declare interface UIPanel<T = unknown> {
-    element: HTMLElement;
-    update: (state: T) => void;
-    destroy?: () => void;
-}
-
-declare interface UIPanel_2<T = unknown> {
-    element: HTMLElement;
-    update: (state: T) => void;
-    destroy?: () => void;
-}
-
-declare interface UIPanel_3<T = unknown> {
-    element: HTMLElement;
-    update: (state: T) => void;
-    destroy?: () => void;
-}
-
-declare interface UIPanel_4<S> {
-    element: HTMLElement;
-    update(state: S): void;
-}
-
-export declare function updateHeadingSelect(toolbar: HTMLElement, level: number | false): void;
-
-/**
- * Update the aggregate tie score in-place (avoids full re-render).
- */
-export declare function updateTieScore(result: any, side1Id?: string, side2Id?: string, swapSides?: boolean): void;
-
-export declare function updateToolbarState(toolbar: HTMLElement, activeMap: Record<string, boolean>): void;
-
-export declare function validateProfile({ profile, temporal, dependencies, venueOrder }: ValidateProfileParams): ValidationResult[];
-
-declare interface ValidateProfileParams {
-    profile: SchedulingProfile;
-    temporal?: TemporalAdapter;
-    dependencies?: DependencyAdapter;
-    venueOrder?: string[];
-}
-
-export declare function validateSchedulingPolicy(data: SchedulingPolicyData): SchedulingValidationResult[];
-
-export declare function validateTopology(state: TopologyState): ValidationError[];
-
-export declare type ValidationCode = 'DATE_UNAVAILABLE' | 'DUPLICATE_ROUND' | 'DUPLICATE_SEGMENT' | 'INVALID_SEGMENT_CONFIG' | 'ROUND_ORDER_VIOLATION' | 'DEPENDENCY_VIOLATION' | 'DAY_OVERLOAD' | 'DROP_REJECTED';
-
-export declare interface ValidationError {
-    severity: 'error' | 'warning';
-    message: string;
-    nodeId?: string;
-    edgeId?: string;
-}
-
-export declare interface ValidationResult {
-    code: ValidationCode;
-    severity: Severity;
-    message: string;
-    context: {
-        date?: string;
-        venueId?: string;
-        scope?: string;
-        drawId?: string;
-        structureId?: string;
-        locator?: RoundLocator;
-        prerequisite?: RoundLocator;
-        demandMinutes?: number;
-        capacityMinutes?: number;
-        ratio?: number;
-        reason?: string;
-    };
-    fixActions?: FixAction[];
-}
-
-/**
- * Validate input field and update UI with success/error styling.
- *
- * OVERVIEW:
- * Runs a validation function on input value and updates the input field and help text
- * with appropriate styling (success=green, error=red) and error messages. Used by
- * renderField to provide real-time validation feedback.
- *
- * PARAMETERS:
- * @param item - Field configuration object containing error message
- * @param e - Event object with target.value containing input value
- * @param input - Input element to add success/error classes to
- * @param help - Help text element to display error message
- * @param fx - Validation function that returns true if valid, false if invalid
- *
- * ============================================================================
- * BEHAVIOR
- * ============================================================================
- *
- * VALIDATION FLOW:
- * 1. Extract value from e.target.value
- * 2. Call validation function fx(value)
- * 3. If invalid (fx returns false):
- *    - Set help text to item.error or 'Invalid'
- *    - Remove 'is-success' class from input
- *    - Add 'is-danger' class to input (red border)
- *    - Add 'is-danger' class to help (red text)
- * 4. If valid (fx returns true):
- *    - Clear help text
- *    - Remove 'is-danger' classes
- *    - Add 'is-success' class to input (green border)
- *
- * VISUAL FEEDBACK:
- * - Invalid: Red border on input + red error message below
- * - Valid: Green border on input + no message
- * - Neutral: No border color + no message (before first input)
- *
- * ============================================================================
- * VALIDATION FUNCTIONS
- * ============================================================================
- *
- * Validation functions should:
- * - Accept a string value parameter
- * - Return true if valid, false if invalid
- * - Be synchronous (no async validation)
- *
- * COMMON VALIDATORS:
- * - nameValidator(minLength) - checks minimum character length
- * - emailValidator() - validates email format
- * - passwordValidator() - checks password requirements
- * - numericRange(min, max) - validates number is in range
- * - Custom: (value) => value.length > 0 && value.includes('@')
- *
- * ============================================================================
- * USAGE NOTES
- * ============================================================================
- *
- * TYPICAL USAGE:
- * - Called automatically by renderField when validator property is set
- * - Attached to 'input' event for real-time validation
- * - Rarely called directly - use via renderField configuration
- *
- * ERROR MESSAGES:
- * - Set via item.error property in field configuration
- * - Default message is 'Invalid' if item.error not provided
- * - Should be clear and actionable (e.g., "Minimum 5 characters")
- *
- * STYLING:
- * - Uses CSS classes: is-success, is-danger
- * - Input field gets colored border
- * - Help text appears below input with matching color
- *
- * ============================================================================
- * EXAMPLE USAGE
- * ============================================================================
- *
- * @example
- * // Automatic usage via renderField
- * const field = renderField({
- *   label: 'Username',
- *   field: 'username',
- *   validator: (value) => value.length >= 5,
- *   error: 'Username must be at least 5 characters'
- * });
- * // validator() is called automatically on input event
- *
- * @example
- * // Direct usage (rare)
- * const input = document.getElementById('email');
- * const help = document.getElementById('email-help');
- * const item = { error: 'Invalid email format' };
- * const emailValidator = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
- *
- * input.addEventListener('input', (e) => {
- *   validator(item, e, input, help, emailValidator);
- * });
- *
- * @example
- * // Custom validator with multiple conditions
- * const passwordValidator = (value) => {
- *   return value.length >= 8 &&
- *          /[A-Z]/.test(value) &&
- *          /[0-9]/.test(value);
- * };
- * const field = renderField({
- *   label: 'Password',
- *   field: 'password',
- *   type: 'password',
- *   validator: passwordValidator,
- *   error: 'Password must be 8+ chars with uppercase and number'
- * });
- */
-export declare function validator(item: any, e: any, input: HTMLElement, help: HTMLElement, fx?: (value: string) => boolean): void;
-
-export declare namespace validators {
-    export {
-        nameValidator,
-        numericValidator,
-        numericRange,
-        passwordValidator,
-        dateValidator,
-        wordValidator,
-        emailValidator
-    }
-}
-
-declare interface VenueBoardCallbacks {
-    onDrop: (drag: DragPayload, drop: DropTarget) => void;
-    onCardClick: (locator: RoundLocator) => void;
-    onCardContextMenu?: (locator: RoundLocator, target: HTMLElement) => void;
-}
-
-export declare interface VenueInfo {
-    venueId: string;
-    name: string;
-}
-
-export declare interface VenueSchedule {
-    venueId: string;
-    rounds: RoundProfile[];
-}
-
-declare interface ViewChangeEvent {
-    type: 'VIEW_CHANGED';
-    payload: Partial<ViewStateSnapshot>;
-}
-
-declare type ViewChangeListener = (event: ViewChangeEvent) => void;
-
-declare interface ViewStateSnapshot {
-    selectedDay: DayId_3 | null;
-    selectedVenue: string | null;
-    selectedCourt: string | null;
-    layerVisibility: Map<BlockType_2, boolean>;
-}
-
-declare const wordValidator: (minWords: number, maxWords?: number) => (value: string) => boolean;
-
-export { }
+export { renderParticipant } from './components/renderStructure/renderParticipant';
+export { renderParticipantInput } from './components/renderStructure/renderParticipantInput';
+export { renderRoundHeader } from './components/renderStructure/renderRoundHeader';
+export { renderStructure } from './components/renderStructure/renderStructure';
+export { renderContainer } from './components/renderStructure/renderContainer';
+export { renderMatchUp } from './components/renderStructure/renderMatchUp';
+export { compositions } from './compositions/compositions';
+export { resolvePublishedComposition } from './compositions/resolvePublishedComposition';
+export type { DisplayExtensionValue } from './compositions/resolvePublishedComposition';
+export { renderRound } from './components/renderStructure/renderRound';
+export { renderSchematicStructure, renderSchematicRound, renderSchematicMatchUp } from './components/renderSchematicStructure';
+export type { SchematicMatchUp } from './components/renderSchematicStructure';
+export { cModal } from './components/modal/cmodal';
+export { getMockParticipantsModal } from './components/modal/mockParticipants';
+export type { MockParticipantsConfig } from './components/modal/mockParticipants';
+export { getGenerateTeamsModal } from './components/modal/generateTeamsModal';
+export type { GenerateTeamsConfig } from './components/modal/generateTeamsModal';
+export { openCompositionEditorModal } from './components/modal/compositionEditorModal';
+export type { CompositionEditorResult, CompositionEditorOptions } from './components/modal/compositionEditorModal';
+export { openScheduleCellConfigModal } from './components/modal/scheduleCellConfigModal';
+export type { ScheduleCellDisplayConfig, ScheduleCellConfigOptions } from './components/modal/scheduleCellConfigModal';
+export { getMatchUpFormatModal } from './components/matchUpFormat/matchUpFormat';
+export { getAgeCategoryModal } from './components/categories/ageCategory/ageCategory';
+export type { AgeCategoryConfig } from './components/categories/ageCategory/ageCategory';
+export { getCategoryModal } from './components/categories/category/category';
+export type { CategoryConfig, Category } from './components/categories/category/category';
+export { getFlightProfileModal } from './components/flightProfile/flightProfileNew';
+export type { FlightProfileConfig } from './components/flightProfile/flightProfileNew';
+export { scoringModal } from './components/scoring/scoringModal';
+export { setScoringConfig, getScoringConfig, resetScoringConfig } from './components/scoring/config';
+export type { ScoringModalParams, ScoringModalLabels, ScoreOutcome, SetScore } from './components/scoring/types';
+export { getSetFormatForIndex, isSetTiebreakOnly, isSetTimed, getMaxAllowedScore, isSetComplete, getSetWinner, isMatchComplete, getMatchWinner, calculateComplement, shouldApplySmartComplement, shouldShowTiebreak, shouldCreateNextSet, buildSetScore } from './components/scoring/logic/dynamicSetsLogic';
+export type { SetFormat, MatchUpConfig, SmartComplementResult } from './components/scoring/logic/dynamicSetsLogic';
+export { drawer, initDrawer } from './components/drawer/drawer';
+export type { DrawerOptions } from './components/drawer/drawer';
+export { notesToolbar, updateToolbarState, updateHeadingSelect } from './components/notes-toolbar/notesToolbar';
+export type { NotesToolbarOptions } from './components/notes-toolbar/notesToolbar';
+export { tipster, destroyTipster } from './components/popover/tipster';
+export { tennisCourt, basketballCourt, baseballDiamond, hockeyRink, pickleballCourt, badmintonCourt, padelCourt } from './components/courts';
+export { courthiveComponentsVersion } from './version';
+export { MATCH_FORMATS } from './constants/matchUpFormats';
+export type { MatchUpFormatCode } from './constants/matchUpFormats';
+export { renderButtons } from './components/forms/renderButtons';
+export { renderField, renderOptions } from './components/forms/renderField';
+export { renderForm } from './components/forms/renderForm';
+export { renderMenu } from './components/forms/renderMenu';
+export { validator } from './components/forms/renderValidator';
+export * as validators from './validators';
+export { DrawStateManager } from './helpers/drawStateManager';
+export type { RenderCallback } from './helpers/drawStateManager';
+export { burstChart } from './components/burstChart/burstChart';
+export type { SunburstDrawData, SunburstMatchUp, SunburstSide, SegmentData, BurstChartEventHandlers, BurstChartOptions, BurstChartInstance } from './components/burstChart/burstChart';
+export { fromFactoryDrawData, fromLegacyDraw } from './components/burstChart/matchUpTransform';
+export { controlBar } from './components/controlBar/controlBar';
+export { toggleOverlay } from './components/controlBar/toggleOverlay';
+export { dropDownButton } from './components/button/dropDownButton';
+export { barButton } from './components/button/barButton';
+export { selectItem } from './components/modal/selectItem';
+export type { SelectItemParams, SelectItemOption } from './components/modal/selectItem';
+export { SchedulingProfileControl, ProfileStore, createSchedulingProfile, validateProfile, buildIssueIndex, applyDropCommit, filterCatalog, groupCatalog, getPlannedRoundKeys, getVenueRounds, getRoundAt, findIssuesForLocator, maxSeverity, buildDateStrip, buildVenueBoard, buildRoundCatalog, buildInspectorPanel, buildIssuesPanel, buildRoundCard, createCardPopoverManager, buildSchedulingProfileLayout } from './components/scheduling-profile';
+export { createTemporalGrid, TemporalGrid, showCourtAvailabilityModal } from './components/temporal-grid';
+export type { TemporalGridConfig, TemporalGridLabels } from './components/temporal-grid';
+export { TopologyBuilderControl, TopologyStore, topologyToDrawOptions, validateTopology, generatePreviewMatchUps, standardTemplates, buildTopologyCanvas, buildStructureCard, getPortPosition, buildNodeEditor, buildEdgeEditor, buildToolbar, buildTopologyBuilderLayout } from './components/topology-builder';
+export type { TopologyNode, TopologyEdge, TopologyState, TopologyChangeListener, TopologyBuilderConfig, TopologyTemplate, DrawOptionsResult, ValidationError } from './components/topology-builder';
+export type { SchedulingProfile, ScheduleDay, VenueSchedule, RoundProfile, RoundSegment, VenueInfo, CatalogRoundItem, CatalogGroupBy, RoundKey, RoundLocator, DragPayload, DropTarget, DropResult, Severity, ValidationCode, FixAction, ValidationResult, IssueIndex, ProfileStoreState, SchedulingProfileConfig, TemporalAdapter, DemandAdapter, DependencyAdapter, UIPanel } from './components/scheduling-profile';
+export { SchedulePageControl, SchedulePageStore, createSchedulePage, filterMatchUpCatalog, groupMatchUpCatalog, isCompletedStatus, buildScheduleIssueIndex, matchUpLabel, participantLabel, matchUpSearchKey, buildScheduleDateStrip, buildScheduleIssuesPanel, buildMatchUpCatalog, buildMatchUpCard, buildScheduleInspectorPanel, buildCourtGridSlot, buildSchedulePageLayout, buildScheduleGridCell, mapMatchUpToCellData, DEFAULT_SCHEDULE_CELL_CONFIG, activateScheduleCellTypeAhead, buildActiveStripPanel } from './components/schedule-page';
+export type { CatalogMatchUpItem, CatalogFilters, MatchUpSide, ScheduleDate, ScheduleIssue, ScheduleIssueSeverity, ScheduleIssueIndex, ScheduleIssueCounts, MatchUpCatalogGroupBy, ScheduledBehavior, SchedulingMode, PendingScheduleAction, CatalogMatchUpDragPayload, GridMatchUpDragPayload, SchedulePageDragPayload, SchedulePageConfig, SchedulePageState, SchedulePageChangeListener, ScheduleCellConfig, ScheduleCellField, ParticipantDisplayConfig, ScheduleCellData, ScheduleCellSide, ScheduleCellTypeAheadOptions, ActiveStripPanel, ActiveStripPanelCallbacks, ActiveStripPanelData, ActiveStripPanelOptions, ActiveStripCourtMeta } from './components/schedule-page';
+export { createCompositionEditor } from './components/composition-editor/compositionEditor';
+export { CompositionEditorStore } from './components/composition-editor/compositionEditorStore';
+export type { CompositionEditorConfig, SavedComposition, CompositionEditorState, CompositionEditorListener, SectionId as CompositionEditorSectionId, EditorPanel as CompositionEditorPanel } from './components/composition-editor/compositionEditorTypes';
+export { createPrintCompositionEditor } from './components/print-composition-editor/printCompositionEditor';
+export type { PrintCompositionConfig, PrintCompositionEditorConfig, PrintCompositionEditorHandle, PrintType, HeaderLayout as PrintHeaderLayout, FooterLayout as PrintFooterLayout, PageSize as PrintPageSize, PageOrientation as PrintPageOrientation } from './components/print-composition-editor/printCompositionEditorTypes';
+export { renderScorecard, renderTeamVsHeader, updateTieScore } from './components/scorecard';
+export type { ScorecardOptions, TeamVsOptions } from './components/scorecard';
+export { InlineScoringManager, renderInlineMatchUp, engineToMatchUp, createInlineScoringFooter } from './components/inline-scoring';
+export type { InlineScoringMode, InlineScoringConfig, InlineScoringCallbacks, InlineScoringEngineState } from './components/inline-scoring';
+export { buildInteractiveScoringShell } from './components/interactive-scoring';
+export type { InteractiveScoringShell, InteractiveScoringShellConfig, StateChangedDetail } from './components/interactive-scoring';
+export { PolicyCatalogControl, PolicyCatalogStore, createPolicyCatalog, filterPolicyCatalog, groupPolicyCatalog, POLICY_TYPE_METADATA, POLICY_TYPE_GROUPS, getPolicyTypeMeta, buildPolicyCatalogPanel, buildEditorShell, buildPolicyCatalogLayout, buildJsonEditor, SchedulingEditorControl, createSchedulingEditor, SchedulingEditorStore, validateSchedulingPolicy, formatCodeLabel, emptySchedulingPolicy, buildSchedulingEditorPanel } from './components/policy-catalog';
+export type { PolicyCatalogItem, PolicyCatalogState, PolicyCatalogChangeListener, PolicyCatalogConfig, PolicyEditorInstance, PolicyEditorPlugin, PolicySource, PolicyTypeGroup, PolicyTypeMeta, CatalogGroupBy as PolicyCatalogGroupBy, SchedulingPolicyData, SchedulingEditorState, SchedulingEditorSection, SchedulingEditorChangeListener, SchedulingEditorConfig, SchedulingValidationResult, ValidationSeverity as SchedulingValidationSeverity, MinutesEntry, AverageTimeEntry, RecoveryTimeEntry, MatchUpAverageTime, MatchUpRecoveryTime } from './components/policy-catalog';