courthive-components 1.1.0 → 1.2.0

package/dist/components/print-composition-editor/printCompositionEditorTypes.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 type PrintType = 'draw' | 'schedule' | 'playerList' | 'courtCard' | 'signInSheet' | 'matchCard';
+export type HeaderLayout = 'grand-slam' | 'itf' | 'minimal' | 'none';
+export type FooterLayout = 'standard' | 'seedings' | 'officials' | 'none';
+export type PageSize = 'a4' | 'letter';
+export type PageOrientation = 'portrait' | 'landscape' | 'auto';
+export interface PageBlock {
+    pageSize?: PageSize;
+    orientation?: PageOrientation;
+    margins?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+export interface HeaderBlock {
+    layout?: HeaderLayout;
+    tournamentName?: string;
+    subtitle?: string;
+}
+export interface FooterBlock {
+    layout?: FooterLayout;
+    showTimestamp?: boolean;
+    showPageNumbers?: boolean;
+}
+export interface DrawContent {
+    includeSeedings?: boolean;
+    includeScores?: boolean;
+    showByes?: boolean;
+    showDrawPositions?: boolean;
+}
+export interface ScheduleContent {
+    cellStyle?: 'detailed' | 'compact';
+    showMatchNumbers?: boolean;
+    alertBanner?: string;
+}
+export interface ContentBlock {
+    draw?: DrawContent;
+    schedule?: ScheduleContent;
+}
+export interface PrintCompositionConfig {
+    name?: string;
+    page?: PageBlock;
+    header?: HeaderBlock;
+    footer?: FooterBlock;
+    content?: ContentBlock;
+}
+export 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 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;
+}

package/dist/components/renderSchematicStructure/index.d.ts

@@ -0,0 +1,4 @@
+export { renderSchematicStructure } from './renderSchematicStructure';
+export { renderSchematicRound } from './renderSchematicRound';
+export { renderSchematicMatchUp } from './renderSchematicMatchUp';
+export type { SchematicMatchUp } from './renderSchematicMatchUp';

package/dist/components/renderSchematicStructure/renderSchematicMatchUp.d.ts

@@ -0,0 +1,26 @@
+export interface SchematicMatchUp {
+    matchUpId: string;
+    roundNumber: number;
+    roundPosition?: number;
+    drawPositions?: number[];
+    finishingRound?: number;
+    roundFactor?: number;
+    stage?: string;
+    isRoundRobin?: boolean;
+    preFeedRound?: boolean;
+    structureId?: string;
+    collectionId?: string;
+}
+/**
+ * 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;

package/dist/components/renderSchematicStructure/renderSchematicRound.d.ts

@@ -0,0 +1,15 @@
+import { SchematicMatchUp } from './renderSchematicMatchUp';
+/**
+ * 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;

package/dist/components/renderSchematicStructure/renderSchematicStructure.d.ts

@@ -0,0 +1,12 @@
+import { SchematicMatchUp } from './renderSchematicMatchUp';
+/**
+ * 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;

package/dist/components/renderStructure/isLuckyDraw.d.ts

@@ -0,0 +1,9 @@
+import { RoundProfile } from 'tods-competition-factory';
+interface IsLuckyDrawParams {
+    roundsNotPowerOf2?: boolean;
+    hasNoRoundPositions?: boolean;
+    roundNumbers?: number[];
+    roundProfile?: RoundProfile;
+}
+export declare function isLuckyDraw({ roundsNotPowerOf2, hasNoRoundPositions, roundNumbers, roundProfile }: IsLuckyDrawParams): boolean;
+export {};

package/dist/components/renderStructure/renderAddress.d.ts

@@ -0,0 +1,5 @@
+import { IndividualParticipant } from '../../types';
+export declare function renderAddress({ individualParticipant, className }: {
+    individualParticipant?: IndividualParticipant;
+    className?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderCenterInfo.d.ts

@@ -0,0 +1,10 @@
+import { EventHandlers, MatchUp } from '../../types';
+export declare function renderCenterInfo({ eventHandlers, entryStatus, sideNumber, className, matchUp }: {
+    eventHandlers?: EventHandlers;
+    entryStatus?: string;
+    sideNumber?: number;
+    className?: string;
+    matchUp?: MatchUp;
+}): {
+    element: HTMLElement;
+};

package/dist/components/renderStructure/renderContainer.d.ts

@@ -0,0 +1,4 @@
+export declare function renderContainer({ content, theme }: {
+    content: string | HTMLElement;
+    theme?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderFlag.d.ts

@@ -0,0 +1,6 @@
+import { IndividualParticipant, MatchUp } from '../../types';
+export declare function renderFlag({ matchUp, individualParticipant, spacer }: {
+    matchUp?: MatchUp;
+    individualParticipant?: IndividualParticipant;
+    spacer?: boolean;
+}): HTMLElement;

package/dist/components/renderStructure/renderFrill.d.ts

@@ -0,0 +1,10 @@
+import { Composition, IndividualParticipant, MatchUp, Side } from '../../types';
+export declare function renderFrill({ individualParticipant, composition, className, matchUp, spacer, side, type }: {
+    individualParticipant?: IndividualParticipant;
+    composition?: Composition;
+    className?: string;
+    matchUp?: MatchUp;
+    spacer?: boolean;
+    side?: Side;
+    type?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderGameScore.d.ts

@@ -0,0 +1,3 @@
+export declare function renderGameScore({ value }?: {
+    value?: string | number;
+}): HTMLInputElement;

package/dist/components/renderStructure/renderIndividual.d.ts

@@ -0,0 +1,12 @@
+import { Composition, EventHandlers, IndividualParticipant, MatchUp, Side } from '../../types';
+export declare function renderIndividual(params: {
+    isWinningSide?: boolean;
+    side?: Side;
+    sideNumber?: number;
+    individualParticipant?: IndividualParticipant;
+    matchUp?: MatchUp;
+    composition?: Composition;
+    eventHandlers?: EventHandlers;
+}): {
+    element: HTMLElement;
+};

package/dist/components/renderStructure/renderMatchUp.d.ts

@@ -0,0 +1,14 @@
+import { Composition, EventHandlers, MatchUp } from '../../types';
+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;

package/dist/components/renderStructure/renderParticipant.d.ts

@@ -0,0 +1,11 @@
+import { Composition, EventHandlers, MatchUp, Participant } from '../../types';
+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;

package/dist/components/renderStructure/renderParticipantDetail.d.ts

@@ -0,0 +1,7 @@
+import { Composition, IndividualParticipant } from '../../types';
+export declare function renderParticipantDetail(params: {
+    composition?: Composition;
+    individualParticipant?: IndividualParticipant;
+    className?: string;
+    [key: string]: any;
+}): HTMLElement;

package/dist/components/renderStructure/renderParticipantInput.d.ts

@@ -0,0 +1,10 @@
+import { Composition, EventHandlers, MatchUp, Side } from '../../types';
+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;

package/dist/components/renderStructure/renderPersonAttribute.d.ts

@@ -0,0 +1,6 @@
+import { IndividualParticipant } from '../../types';
+export declare function renderPersonAttribute({ individualParticipant, attribute, className }: {
+    individualParticipant?: IndividualParticipant;
+    attribute: string;
+    className?: string;
+}): HTMLElement | string;

package/dist/components/renderStructure/renderRound.d.ts

@@ -0,0 +1,17 @@
+import { Composition, EventHandlers, MatchUp } from '../../types';
+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;

package/dist/components/renderStructure/renderRoundHeader.d.ts

@@ -0,0 +1,8 @@
+import { EventHandlers, MatchUp } from '../../types';
+export declare function renderRoundHeader({ eventHandlers, roundMatchUps, roundProfile, roundNumber, context }: {
+    eventHandlers?: EventHandlers;
+    roundMatchUps?: MatchUp[];
+    roundProfile?: any;
+    roundNumber: number;
+    context?: any;
+}): HTMLElement;

package/dist/components/renderStructure/renderScale.d.ts

@@ -0,0 +1,8 @@
+import { Composition, IndividualParticipant, MatchUp } from '../../types';
+export declare function renderScale({ individualParticipant, composition, className, matchUp, spacer }: {
+    individualParticipant?: IndividualParticipant;
+    composition?: Composition;
+    className?: string;
+    matchUp?: MatchUp;
+    spacer?: boolean;
+}): HTMLElement;

package/dist/components/renderStructure/renderSchedule.d.ts

@@ -0,0 +1,5 @@
+import { EventHandlers, MatchUp } from '../../types';
+export declare function renderSchedule({ matchUp, eventHandlers }: {
+    matchUp?: MatchUp;
+    eventHandlers?: EventHandlers;
+}): HTMLElement;

package/dist/components/renderStructure/renderSeeding.d.ts

@@ -0,0 +1,6 @@
+import { Composition, Side } from '../../types';
+export declare function renderSeeding({ className, composition, side }: {
+    className?: string;
+    composition?: Composition;
+    side?: Side;
+}): HTMLElement | string;

package/dist/components/renderStructure/renderSide.d.ts

@@ -0,0 +1,9 @@
+import { Composition, EventHandlers, MatchUp } from '../../types';
+export declare function renderSide({ initialRoundNumber, eventHandlers, composition, sideNumber, className, matchUp }: {
+    initialRoundNumber?: number;
+    eventHandlers?: EventHandlers;
+    composition?: Composition;
+    sideNumber: number;
+    className?: string;
+    matchUp: MatchUp;
+}): HTMLElement;

package/dist/components/renderStructure/renderSideScore.d.ts

@@ -0,0 +1,16 @@
+import { Composition, EventHandlers, MatchUp, SetScore } from '../../types';
+export declare function setScore({ gameScoreOnly, scoreStripes, set, sideNumber }: {
+    gameScoreOnly?: boolean;
+    scoreStripes?: boolean;
+    set: SetScore & {
+        editing?: number;
+    };
+    sideNumber: number;
+}): HTMLElement;
+export declare function renderSideScore({ participantHeight, eventHandlers, composition, sideNumber, matchUp }: {
+    participantHeight?: number;
+    eventHandlers?: EventHandlers;
+    composition?: Composition;
+    sideNumber: number;
+    matchUp: MatchUp;
+}): HTMLElement;

package/dist/components/renderStructure/renderStatusPill.d.ts

@@ -0,0 +1,3 @@
+export declare function renderStatusPill({ matchUpStatus }: {
+    matchUpStatus?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderStructure.d.ts

@@ -0,0 +1,13 @@
+import { Composition, EventHandlers, MatchUp } from '../../types';
+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;

package/dist/components/renderStructure/renderTeam.d.ts

@@ -0,0 +1,5 @@
+import { IndividualParticipant } from '../../types';
+export declare function renderTeam({ individualParticipant, className }: {
+    individualParticipant?: IndividualParticipant;
+    className?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderTeamLogo.d.ts

@@ -0,0 +1,4 @@
+export declare function renderTeamLogo({ participantId }: {
+    teamLogo?: any;
+    participantId?: string;
+}): HTMLElement;

package/dist/components/renderStructure/renderTick.d.ts

@@ -0,0 +1,3 @@
+export declare function renderTick({ dim }?: {
+    dim?: string;
+}): string;

package/dist/components/schedule-page/controller/schedulePageControl.d.ts

@@ -0,0 +1,21 @@
+import { SchedulePageStore } from '../engine/schedulePageStore';
+import { SchedulePageConfig, CatalogMatchUpItem, ScheduleDate, ScheduleIssue, PendingScheduleAction } from '../types';
+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;
+    setActiveStripVisible(visible: boolean): void;
+    toggleActiveStrip(): void;
+    get activeStripVisible(): boolean;
+    save(): PendingScheduleAction[];
+    discardPending(): void;
+    get hasUnsavedChanges(): boolean;
+    getStore(): SchedulePageStore;
+}

package/dist/components/schedule-page/domain/activeStrip.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Schedule Page — Active Strip
+ *
+ * The active strip is a one-row summary that sits above the court grid and
+ * shows, for each court, what is "actively" happening: the in-progress
+ * matchUp if any, otherwise the next pending matchUp, otherwise the most
+ * recent completed matchUp, otherwise free.
+ *
+ * Two pure functions:
+ *
+ *   - computeActiveStrip(grid)
+ *       Picks the cell to surface per court column.
+ *
+ *   - computeActiveStripDropTarget(grid, courtId, dragged)
+ *       Picks a row when a matchUp is dropped onto a court's strip cell.
+ *       It infers a "temporal floor" from the existing grid:
+ *         (a) any row across all courts where the dragged matchUp's
+ *             participants already appear — the dragged matchUp must land
+ *             below those rows;
+ *         (b) within the same draw, any row holding a lower-round matchUp —
+ *             the dragged matchUp must land below those rows too.
+ *       The dragged matchUp's own existing cell is ignored (relocation).
+ *
+ * Both functions are framework-free and DOM-free; tests do not require a UI.
+ */
+export interface ActiveStripGridMatchUp {
+    matchUpId: string;
+    drawId?: string;
+    roundNumber?: number;
+    matchUpStatus?: string;
+    winningSide?: number;
+    /** True when at least one set/score has been entered. */
+    hasScore?: boolean;
+    participantIds: string[];
+    /**
+     * Consumer-defined opaque payload, passed through unchanged.
+     * Useful so the cell renderer can reach the full grid-cell data.
+     */
+    payload?: unknown;
+}
+export interface ActiveStripCourtColumn {
+    courtId: string;
+    /** Ordered cells from row 0 (top) downward. `null` marks an empty row. */
+    cells: (ActiveStripGridMatchUp | null)[];
+}
+export interface ActiveStripGrid {
+    columns: ActiveStripCourtColumn[];
+}
+export type ActiveStripCellState = 'free' | 'in-progress' | 'next' | 'completed';
+export interface ActiveStripCell {
+    courtId: string;
+    state: ActiveStripCellState;
+    matchUp?: ActiveStripGridMatchUp;
+    rowIndex?: number;
+}
+export interface ActiveStripDropCandidate {
+    matchUpId: string;
+    drawId?: string;
+    roundNumber?: number;
+    participantIds: string[];
+}
+export interface ActiveStripDropTarget {
+    courtId: string;
+    rowIndex: number;
+}
+export interface ActiveStripStatusOptions {
+    inProgressStatuses?: ReadonlySet<string>;
+    completedStatuses?: ReadonlySet<string>;
+}
+export declare function computeActiveStripCell(column: ActiveStripCourtColumn, options?: ActiveStripStatusOptions): ActiveStripCell;
+export declare function computeActiveStrip(grid: ActiveStripGrid, options?: ActiveStripStatusOptions): ActiveStripCell[];
+export declare function computeActiveStripDropTarget(grid: ActiveStripGrid, targetCourtId: string, dragged: ActiveStripDropCandidate): ActiveStripDropTarget;

package/dist/components/schedule-page/domain/matchUpCatalogProjections.d.ts

@@ -0,0 +1,4 @@
+import { CatalogMatchUpItem, CatalogFilters, MatchUpCatalogGroupBy, ScheduledBehavior } from '../types';
+export declare function isCompletedStatus(status?: string): boolean;
+export declare function filterMatchUpCatalog(catalog: CatalogMatchUpItem[], query: string, behavior?: ScheduledBehavior, filters?: CatalogFilters, showCompleted?: boolean): CatalogMatchUpItem[];
+export declare function groupMatchUpCatalog(items: CatalogMatchUpItem[], mode: MatchUpCatalogGroupBy): Map<string, CatalogMatchUpItem[]>;

package/dist/components/schedule-page/domain/scheduleIssues.d.ts

@@ -0,0 +1,2 @@
+import { ScheduleIssue, ScheduleIssueIndex } from '../types';
+export declare function buildScheduleIssueIndex(issues: ScheduleIssue[]): ScheduleIssueIndex;

package/dist/components/schedule-page/domain/utils.d.ts

@@ -0,0 +1,5 @@
+import { CatalogMatchUpItem, MatchUpSide } from '../types';
+export declare function deepClone<T>(obj: T): T;
+export declare function matchUpLabel(item: CatalogMatchUpItem): string;
+export declare function participantLabel(side?: MatchUpSide): string;
+export declare function matchUpSearchKey(item: CatalogMatchUpItem): string;

package/dist/components/schedule-page/engine/schedulePageStore.d.ts

@@ -0,0 +1,36 @@
+import { SchedulePageState, SchedulePageChangeListener, SchedulePageConfig, CatalogMatchUpItem, CatalogFilters, ScheduleDate, ScheduleIssue, MatchUpCatalogGroupBy, PendingScheduleAction, SchedulePageDragPayload } from '../types';
+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;
+    setActiveStripVisible(visible: boolean): void;
+    toggleActiveStrip(): void;
+    subscribe(listener: SchedulePageChangeListener): () => void;
+    private setState;
+    private emit;
+}

package/dist/components/schedule-page/index.d.ts

@@ -0,0 +1,28 @@
+import { SchedulePageConfig } from './types';
+import { SchedulePageControl } from './controller/schedulePageControl';
+/**
+ * Schedule Page — Public API
+ *
+ * Main entry point for the schedule page component.
+ */
+export { SchedulePageControl } from './controller/schedulePageControl';
+export { SchedulePageStore } from './engine/schedulePageStore';
+export { filterMatchUpCatalog, groupMatchUpCatalog, isCompletedStatus } from './domain/matchUpCatalogProjections';
+export { buildScheduleIssueIndex } from './domain/scheduleIssues';
+export { matchUpLabel, participantLabel, matchUpSearchKey, deepClone } from './domain/utils';
+export { computeActiveStrip, computeActiveStripCell, computeActiveStripDropTarget } from './domain/activeStrip';
+export type { ActiveStripCell, ActiveStripCellState, ActiveStripCourtColumn, ActiveStripDropCandidate, ActiveStripDropTarget, ActiveStripGrid, ActiveStripGridMatchUp, ActiveStripStatusOptions } from './domain/activeStrip';
+export { buildScheduleDateStrip } from './ui/dateStrip';
+export { buildScheduleIssuesPanel } from './ui/issuesPanel';
+export { buildMatchUpCatalog } from './ui/matchUpCatalog';
+export { buildMatchUpCard } from './ui/matchUpCard';
+export { buildScheduleInspectorPanel } from './ui/inspectorPanel';
+export { buildCourtGridSlot } from './ui/courtGridSlot';
+export { buildSchedulePageLayout } from './ui/schedulePageLayout';
+export { buildActiveStripPanel } from './ui/activeStrip';
+export type { ActiveStripPanel, ActiveStripPanelCallbacks, ActiveStripPanelData, ActiveStripPanelOptions, ActiveStripCourtMeta } from './ui/activeStrip';
+export { buildScheduleGridCell, mapMatchUpToCellData, DEFAULT_SCHEDULE_CELL_CONFIG } from './ui/scheduleGridCell';
+export { activateScheduleCellTypeAhead } from './ui/scheduleCellTypeAhead';
+export type { ScheduleCellTypeAheadOptions } from './ui/scheduleCellTypeAhead';
+export type { CatalogMatchUpItem, CatalogFilters, MatchUpSide, ScheduleDate, ScheduleIssue, ScheduleIssueSeverity, ScheduleIssueIndex, ScheduleIssueCounts, MatchUpCatalogGroupBy, ScheduledBehavior, SchedulingMode, PendingScheduleAction, CatalogMatchUpDragPayload, GridMatchUpDragPayload, SchedulePageDragPayload, SchedulePageConfig, SchedulePageState, SchedulePageChangeListener, UIPanel, ScheduleCellConfig, ScheduleCellField, ParticipantDisplayConfig, ScheduleCellData, ScheduleCellSide } from './types';
+export declare function createSchedulePage(config: SchedulePageConfig, container: HTMLElement): SchedulePageControl;