courthive-components 1.1.0 → 1.1.1

package/dist/components/temporal-grid/controller/temporalGridControl.d.ts

@@ -0,0 +1,137 @@
+import { temporal, TemporalEngine } from 'tods-competition-factory';
+import { TemporalViewState } from '../engine/viewState';
+import { DEFAULT_COLOR_SCHEME, ResourceGroupingMode } from './viewProjections';
+import { BlockPopoverManager } from '../ui/blockPopover';
+import { CourtTimeline } from '../timeline/CourtTimeline';
+type BlockType = temporal.BlockType;
+type CourtRef = temporal.CourtRef;
+type DayId = temporal.DayId;
+export 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;
+}
+export 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;
+}
+/** Create a temporal grid controller */
+export declare function createTemporalGridControl(engine: TemporalEngine, config: TemporalGridControlConfig): TemporalGridControl;
+export {};

package/dist/components/temporal-grid/controller/viewProjections.d.ts

@@ -0,0 +1,220 @@
+import { temporal } from 'tods-competition-factory';
+type BlockType = temporal.BlockType;
+type CourtMeta = temporal.CourtMeta;
+type CourtRef = temporal.CourtRef;
+type VenueDayTimeline = temporal.VenueDayTimeline;
+/**
+ * Timeline Group (represents a court or facility group header)
+ */
+export interface TimelineGroup {
+    id: string;
+    content: string;
+    nestedGroups?: string[];
+    showNested?: boolean;
+    className?: string;
+    title?: string;
+    order?: number;
+    visible?: boolean;
+    courtRef?: CourtRef;
+    surface?: string;
+    indoor?: boolean;
+    hasLights?: boolean;
+    tags?: string[];
+    isGroup?: boolean;
+}
+/**
+ * Timeline Item (represents a block or segment)
+ */
+export interface TimelineItem {
+    id: string;
+    group: string;
+    content: string;
+    start: Date | string;
+    end?: Date | string;
+    type?: 'box' | 'point' | 'range' | 'background';
+    className?: string;
+    style?: string;
+    title?: string;
+    editable?: boolean | {
+        updateTime?: boolean;
+        updateGroup?: boolean;
+        remove?: boolean;
+    };
+    selectable?: boolean;
+    blockId?: string;
+    status?: string;
+    reason?: string;
+    isBlock?: boolean;
+    isSegment?: boolean;
+    isConflict?: boolean;
+    conflictCode?: string;
+    severity?: string;
+    message?: string;
+    contributingBlocks?: string[];
+}
+/** @deprecated Use TimelineGroup instead */
+export type CalendarResource = TimelineGroup;
+/** @deprecated Use TimelineItem instead */
+export type CalendarEvent = TimelineItem;
+/**
+ * Grouping modes for resources
+ */
+export type ResourceGroupingMode = 'BY_VENUE' | 'BY_SURFACE' | 'BY_TAG' | 'FLAT';
+/**
+ * Configuration for view projections
+ */
+export interface ProjectionConfig {
+    groupingMode?: ResourceGroupingMode;
+    layerVisibility?: Map<BlockType, boolean>;
+    showSegmentLabels?: boolean;
+    colorScheme?: BlockColorScheme;
+}
+/**
+ * Color scheme for block types
+ */
+export 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;
+}
+export declare const DEFAULT_COLOR_SCHEME: BlockColorScheme;
+/**
+ * Build timeline groups from facility timelines.
+ * Converts courts into timeline groups, grouped by facility.
+ */
+export declare function buildResourcesFromTimelines(timelines: VenueDayTimeline[], courtMeta: CourtMeta[], _config?: ProjectionConfig): TimelineGroup[];
+/**
+ * Build venue group headers for nested grouping.
+ * Creates group headers for CourtTimeline.
+ */
+export declare function buildVenueGroups(timelines: VenueDayTimeline[]): TimelineGroup[];
+/**
+ * Build timeline items from facility timelines.
+ * Converts rail segments into background items showing availability status.
+ */
+export declare function buildEventsFromTimelines(timelines: VenueDayTimeline[], config?: ProjectionConfig): TimelineItem[];
+/**
+ * Build draggable/editable block items.
+ * These represent user-created blocks that can be moved and resized.
+ */
+export declare function buildBlockEvents(blocks: Array<{
+    id: string;
+    court: CourtRef;
+    start: string;
+    end: string;
+    type: BlockType;
+    reason?: string;
+}>, config?: ProjectionConfig): TimelineItem[];
+/**
+ * Build visual indicators for conflicts.
+ * Creates overlay items showing where conflicts exist.
+ */
+export declare function buildConflictEvents(conflicts: Array<{
+    code: string;
+    message: string;
+    severity: 'ERROR' | 'WARN' | 'INFO';
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    courts: CourtRef[];
+}>): TimelineItem[];
+/**
+ * Filter items by time range
+ */
+export declare function filterEventsByTimeRange(events: TimelineItem[], timeRange: {
+    start: string;
+    end: string;
+}): TimelineItem[];
+/**
+ * Filter groups by facility
+ */
+export declare function filterResourcesByVenue(resources: TimelineGroup[], venueId: string): TimelineGroup[];
+/**
+ * Sort groups by court name
+ */
+export declare function sortResources(resources: TimelineGroup[]): TimelineGroup[];
+/**
+ * Build capacity curve visualization.
+ * Creates a visual representation of courts available over time.
+ */
+export declare function buildCapacityVisualization(capacityPoints: Array<{
+    time: string;
+    courtsAvailable: number;
+    courtsSoftBlocked: number;
+    courtsHardBlocked: number;
+}>): Array<{
+    time: string;
+    value: number;
+    label: string;
+}>;
+/**
+ * Parse group ID back to court reference
+ */
+export declare function parseResourceId(resourceId: string): CourtRef | null;
+/**
+ * Parse item ID to extract block ID
+ */
+export declare function parseBlockEventId(eventId: string): string | null;
+/**
+ * Check if an item is a segment (background) or block (editable)
+ */
+export declare function isSegmentEvent(event: TimelineItem): boolean;
+export declare function isBlockEvent(event: TimelineItem): boolean;
+export declare function isConflictEvent(event: TimelineItem): boolean;
+/**
+ * Generate CSS patterns for different block types
+ * (stripes, dots, hatching, etc.)
+ */
+export declare function generateBlockPatternCSS(): string;
+/**
+ * Build timeline window configuration
+ */
+export declare function buildTimelineWindowConfig(config: {
+    dayStartTime: string;
+    dayEndTime: string;
+    slotMinutes: number;
+    day: string;
+}): {
+    start: Date;
+    end: Date;
+    min: Date;
+    max: Date;
+    zoomMin: number;
+    zoomMax: number;
+};
+/**
+ * Build hidden date ranges to collapse overnight gaps.
+ * Uses `repeat: 'daily'` so the gap is hidden every day in a multi-day view.
+ */
+export declare function buildHiddenDates(config: {
+    dayStartTime: string;
+    dayEndTime: string;
+    referenceDay: string;
+    bufferMinutes?: number;
+}): Array<{
+    start: Date;
+    end: Date;
+    repeat: 'daily' | 'weekly' | 'monthly' | 'yearly';
+}>;
+/**
+ * @deprecated Use buildTimelineWindowConfig instead
+ */
+export declare function buildTimeSlotConfig(config: {
+    dayStartTime: string;
+    dayEndTime: string;
+    slotMinutes: number;
+}): {
+    slotDuration: string;
+    slotMinTime: string;
+    slotMaxTime: string;
+};
+export {};

package/dist/components/temporal-grid/engine/viewState.d.ts

@@ -0,0 +1,34 @@
+import { temporal } from 'tods-competition-factory';
+type BlockType = temporal.BlockType;
+type DayId = temporal.DayId;
+export interface ViewStateSnapshot {
+    selectedDay: DayId | null;
+    selectedVenue: string | null;
+    selectedCourt: string | null;
+    layerVisibility: Map<BlockType, boolean>;
+}
+export interface ViewChangeEvent {
+    type: 'VIEW_CHANGED';
+    payload: Partial<ViewStateSnapshot>;
+}
+export type ViewChangeListener = (event: ViewChangeEvent) => void;
+export declare class TemporalViewState {
+    private selectedDay;
+    private selectedVenue;
+    private selectedCourt;
+    private readonly layerVisibility;
+    private readonly listeners;
+    setSelectedDay(day: DayId): void;
+    getSelectedDay(): DayId | null;
+    setSelectedVenue(venueId: string | null): void;
+    getSelectedVenue(): string | null;
+    setSelectedCourt(courtId: string | null): void;
+    getSelectedCourt(): string | null;
+    setLayerVisibility(layerId: BlockType, visible: boolean): void;
+    getLayerVisibility(): Map<BlockType, boolean>;
+    isLayerVisible(layerId: BlockType): boolean;
+    getSnapshot(): ViewStateSnapshot;
+    subscribe(listener: ViewChangeListener): () => void;
+    private emit;
+}
+export {};

package/dist/components/temporal-grid/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Temporal Grid - Main Entry Point
+ *
+ * Engine modules re-exported from tods-competition-factory via `temporal` namespace.
+ * Controller, UI, and view state are local to courthive-components.
+ */
+export { TemporalEngine, TemporalEngine as TemporalGridEngine, temporal } from 'tods-competition-factory';
+export { TemporalViewState, type ViewChangeEvent, type ViewChangeListener, type ViewStateSnapshot } from './engine/viewState';
+export { createTemporalGridControl, TemporalGridControl, type TemporalGridControlConfig } from './controller/temporalGridControl';
+export { buildBlockEvents, buildCapacityVisualization, buildConflictEvents, buildEventsFromTimelines, buildVenueGroups, buildHiddenDates, buildResourcesFromTimelines, buildTimeSlotConfig, buildTimelineWindowConfig, DEFAULT_COLOR_SCHEME, filterEventsByTimeRange, filterResourcesByVenue, generateBlockPatternCSS, isBlockEvent, isConflictEvent, isSegmentEvent, parseBlockEventId, parseResourceId, sortResources, type BlockColorScheme, type CalendarEvent, type CalendarResource, type TimelineGroup, type TimelineItem, type ProjectionConfig, type ResourceGroupingMode } from './controller/viewProjections';
+export { createTemporalGrid, TemporalGrid, type TemporalGridCallbacks, type TemporalGridConfig, type TemporalGridLabels } from './ui/temporalGrid';
+export { ModernTimePicker, showModernTimePicker, type TimePickerConfig } from './ui/modernTimePicker';
+export { createBlockPopoverManager, type BlockPopoverManager, type BlockPopoverOptions, type EngineBlockPopoverOptions } from './ui/blockPopover';
+export { buildStatsBar, type StatsBarUpdate } from './ui/statsBar';
+export { buildViewToolbar, VIEW_PRESETS, type ViewPreset } from './ui/viewToolbar';
+export { showCourtAvailabilityModal, type CourtAvailabilityModalConfig } from './ui/courtAvailabilityModal';
+export { CourtTimeline } from './timeline/CourtTimeline';
+export type { TimelineGroupData, TimelineItemData, TimelineOptions, TimelineCallbacks, MultiRowSpan } from './timeline/types';

package/dist/components/temporal-grid/timeline/CourtTimeline.d.ts

@@ -0,0 +1,77 @@
+import { TimelineGroupData, TimelineItemData, TimelineOptions, MultiRowSpan } from './types';
+export 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;
+}

package/dist/components/temporal-grid/timeline/InteractionManager.d.ts

@@ -0,0 +1,59 @@
+import { TimeScale } from './TimeScale';
+import { RowLayout } from './RowLayout';
+import { ItemRenderer } from './ItemRenderer';
+import { InteractionMode, TimelineCallbacks, TimelineItemData } from './types';
+export declare class InteractionManager {
+    private scale;
+    private layout;
+    private renderer;
+    private contentArea;
+    private callbacks;
+    private snapMinutes;
+    private enablePinchZoom;
+    /** Element that receives wheel events (defaults to contentArea, can be overridden) */
+    private wheelTarget;
+    private mode;
+    private gesture;
+    private items;
+    /** Ghost state for multi-row creation */
+    private ghostStartTime;
+    private ghostEndTime;
+    private ghostTopRow;
+    private ghostBottomRow;
+    /** Drag guard — suppresses click handler after drag */
+    private justDragged;
+    /** Auto-scroll RAF handle */
+    private autoScrollRaf;
+    private autoScrollDelta;
+    /** Scroll container (the body wrapper that scrolls vertically) */
+    private scrollContainer;
+    constructor(scale: TimeScale, layout: RowLayout, renderer: ItemRenderer, callbacks: TimelineCallbacks, snapMinutes?: number, enablePinchZoom?: boolean);
+    setItems(items: TimelineItemData[]): void;
+    setScrollContainer(el: HTMLElement): void;
+    /** Override the element that receives wheel events (e.g. timeline root instead of content area) */
+    setWheelTarget(el: HTMLElement): void;
+    /** Attach event listeners to the content area */
+    attach(): void;
+    /** Detach all event listeners */
+    detach(): void;
+    getMode(): InteractionMode;
+    private onPointerDown;
+    private startGesture;
+    private onPointerMove;
+    private handleDragMove;
+    private handleResizeMove;
+    private onPointerUp;
+    private onDblClick;
+    private handleGhostTimeResize;
+    private handleGhostRowResize;
+    private updateGhostDisplay;
+    private confirmGhost;
+    private cancelGhost;
+    private onWheel;
+    /** Callback set by CourtTimeline to trigger re-render when scale changes */
+    onScaleChanged: (() => void) | null;
+    private onKeyDown;
+    private checkAutoScroll;
+    private startAutoScroll;
+    private stopAutoScroll;
+}

package/dist/components/temporal-grid/timeline/ItemRenderer.d.ts

@@ -0,0 +1,35 @@
+import { TimeScale } from './TimeScale';
+import { RowLayout } from './RowLayout';
+import { TimelineItemData } from './types';
+export declare class ItemRenderer {
+    private scale;
+    private layout;
+    private contentArea;
+    private items;
+    /** Currently rendered item elements, keyed by item ID */
+    private itemElements;
+    /** Ghost element for multi-row creation */
+    private ghostEl;
+    private ghostCountBadge;
+    constructor(scale: TimeScale, layout: RowLayout);
+    setItems(items: TimelineItemData[]): void;
+    render(): void;
+    private renderItem;
+    updateItemPosition(itemId: string, x: number, y: number, width: number): void;
+    showGhost(opts: {
+        startTime: Date;
+        endTime: Date;
+        topRowIndex: number;
+        bottomRowIndex: number;
+    }): void;
+    clearGhost(): void;
+    isGhostVisible(): boolean;
+    highlightRows(indices: number[]): void;
+    clearHighlights(): void;
+    /** Find the item ID at a given DOM element (bubble up from event target) */
+    static hitTest(target: EventTarget | null): {
+        itemId: string | null;
+        handle: string | null;
+    };
+    destroy(): void;
+}

package/dist/components/temporal-grid/timeline/RowLayout.d.ts

@@ -0,0 +1,38 @@
+import { TimelineGroupData } from './types';
+export declare class RowLayout {
+    private groups;
+    private rowHeight;
+    /** Label panel (left side) */
+    private labelPanel;
+    /** Content area (right side, scrollable) */
+    private contentArea;
+    /** Group ID → row index lookup */
+    private groupIndex;
+    constructor(rowHeight?: number);
+    getLabelPanel(): HTMLDivElement;
+    getContentArea(): HTMLDivElement;
+    getRowHeight(): number;
+    getGroups(): TimelineGroupData[];
+    getGroupCount(): number;
+    /** Get the group at a given index */
+    getGroupAtIndex(index: number): TimelineGroupData | undefined;
+    /**
+     * Convert a y-offset (relative to content area top) to a group ID.
+     * Returns null if y is outside all rows.
+     */
+    yToGroupId(y: number): string | null;
+    /** Convert a group ID to its row index (0-based). Returns -1 if not found. */
+    groupIdToRowIndex(id: string): number;
+    /**
+     * Get all group IDs whose rows intersect the vertical range [yStart, yEnd].
+     * Used for multi-row ghost creation.
+     */
+    getRowRange(yStart: number, yEnd: number): string[];
+    /** Get the y-offset of a row's top edge */
+    getRowTop(index: number): number;
+    setGroups(groups: TimelineGroupData[]): void;
+    render(): void;
+    private renderLabels;
+    private renderRows;
+    destroy(): void;
+}

package/dist/components/temporal-grid/timeline/TimeAxis.d.ts

@@ -0,0 +1,41 @@
+import { TimeScale } from './TimeScale';
+export declare class TimeAxis {
+    private readonly dayEl;
+    private readonly hourEl;
+    private readonly scale;
+    private tickConfig;
+    /** Callback fired when a day label is clicked, with the day string (YYYY-MM-DD) */
+    onDayClick?: (dayStr: string) => void;
+    constructor(scale: TimeScale, timeAxisOpts?: {
+        scale: string;
+        step: number;
+    });
+    /** Get the day-label row element */
+    getDayElement(): HTMLDivElement;
+    /** Get the hour-tick row element */
+    getHourElement(): HTMLDivElement;
+    /** Update the time axis options (e.g. when switching views) */
+    setTimeAxisOptions(opts: {
+        scale: string;
+        step: number;
+    }): void;
+    /** Re-render both rows for the current visible window */
+    render(): void;
+    private renderDayLabels;
+    private renderDayLabelsWithBounds;
+    private renderHourTicks;
+    private renderHourTicksWithBounds;
+    /**
+     * Get the list of day-start dates visible in the current window,
+     * respecting visibleDays if set, otherwise probing calendar days.
+     */
+    private getVisibleDayDates;
+    /**
+     * Render vertical gridlines into a target container (e.g. content area).
+     * Uses the same tick positions as the hour ticks.
+     */
+    renderGridlines(container: HTMLDivElement, totalHeight: number): void;
+    /** Compute x positions for all visible ticks */
+    private computeTickPositions;
+    destroy(): void;
+}