@allhailai/tempusmachina-react 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1275 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default from 'react';
+import * as temporal_polyfill from 'temporal-polyfill';
+import { Temporal } from 'temporal-polyfill';
+import * as _tempus_machina_core from '@allhailai/tempusmachina-core';
+import { EventInput, PluginDef, ViewPreset, Resource, BusinessHoursInput, EventDefaults, TemporalDateRange, NormalizedEvent, ViewLayout, PositionedEvent, DayCell as DayCell$1, BackgroundEvent as BackgroundEvent$1, TimeSlot as TimeSlot$1, ResourceLane as ResourceLane$1, ViewConfig, EventSourceDef, EventSourceInput, NormalizedEventSource } from '@allhailai/tempusmachina-core';
+import * as _allhailai_tempusmachina_core from '@allhailai/tempusmachina-core';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { Button as Button$1 } from '@base-ui/react/button';
+import { Toggle as Toggle$1 } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroup$1 } from '@base-ui/react/toggle-group';
+
+interface UseCalendarOptions {
+    events: EventInput[];
+    plugins: PluginDef[];
+    defaultDate?: Temporal.PlainDate;
+    date?: Temporal.PlainDate;
+    onDateChange?: (date: Temporal.PlainDate) => void;
+    defaultView?: ViewPreset;
+    view?: ViewPreset;
+    onViewChange?: (view: ViewPreset) => void;
+    timezone?: string;
+    locale?: string;
+    firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    slotDuration?: Temporal.Duration;
+    slotMinTime?: Temporal.PlainTime;
+    slotMaxTime?: Temporal.PlainTime;
+    resources?: Resource[];
+    businessHours?: BusinessHoursInput;
+    editable?: boolean;
+    selectable?: boolean;
+    eventMaxStack?: number;
+    eventDefaults?: EventDefaults;
+    validRange?: TemporalDateRange;
+    titleFormat?: Intl.DateTimeFormatOptions;
+    titleRangeSeparator?: string;
+    onDatesSet?: (info: {
+        start: Temporal.PlainDate;
+        end: Temporal.PlainDate;
+        view: ViewPreset;
+    }) => void;
+    onEventAdd?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventChange?: (info: {
+        event: NormalizedEvent;
+        oldEvent: NormalizedEvent;
+    }) => void;
+    onEventRemove?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventsSet?: (events: NormalizedEvent[]) => void;
+}
+interface UseCalendarReturn {
+    currentDate: Temporal.PlainDate;
+    currentView: ViewPreset;
+    viewLayout: ViewLayout | null;
+    visibleRange: TemporalDateRange;
+    events: NormalizedEvent[];
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+    goToDate: (date: Temporal.PlainDate) => void;
+    changeView: (view: ViewPreset) => void;
+    title: string;
+    addEvent: (event: EventInput) => void;
+    updateEvent: (id: string, patch: Partial<EventInput>) => void;
+    removeEvent: (id: string) => void;
+}
+/**
+ * Primary orchestration hook — wires the headless core engine to React state.
+ */
+declare function useCalendar(options: UseCalendarOptions): UseCalendarReturn;
+
+/**
+ * Calendar slots — render prop overrides for every visual element.
+ */
+interface CalendarSlots {
+    eventContent?: (props: EventContentProps) => React.ReactNode;
+    dayCellContent?: (props: DayCellContentProps) => React.ReactNode;
+    slotContent?: (props: SlotContentProps) => React.ReactNode;
+    headerContent?: (props: HeaderContentProps) => React.ReactNode;
+    moreLinkContent?: (props: MoreLinkContentProps) => React.ReactNode;
+    resourceLabelContent?: (props: ResourceLabelContentProps) => React.ReactNode;
+    nowIndicatorContent?: () => React.ReactNode;
+    /** Additional CSS class names for events (string or function) */
+    eventClassNames?: string | ((props: EventContentProps) => string);
+    /** Called after an event DOM element is mounted */
+    eventDidMount?: (info: {
+        el: HTMLElement;
+        event: _tempus_machina_core.NormalizedEvent;
+        view: _tempus_machina_core.ViewPreset;
+    }) => void;
+    /** Called before an event DOM element is unmounted */
+    eventWillUnmount?: (info: {
+        el: HTMLElement;
+        event: _tempus_machina_core.NormalizedEvent;
+        view: _tempus_machina_core.ViewPreset;
+    }) => void;
+    /** Called after a day cell DOM element is mounted */
+    dayCellDidMount?: (info: {
+        el: HTMLElement;
+        date: temporal_polyfill.Temporal.PlainDate;
+    }) => void;
+    /** Called after the view container is mounted */
+    viewDidMount?: (info: {
+        el: HTMLElement;
+        view: _tempus_machina_core.ViewPreset;
+    }) => void;
+    /** Called before the view container is unmounted */
+    viewWillUnmount?: (info: {
+        el: HTMLElement;
+        view: _tempus_machina_core.ViewPreset;
+    }) => void;
+}
+interface EventContentProps {
+    event: NormalizedEvent;
+    view: ViewPreset;
+    isStart: boolean;
+    isEnd: boolean;
+    isDragging: boolean;
+    timeText: string;
+}
+interface DayCellContentProps {
+    date: Temporal.PlainDate;
+    isToday: boolean;
+    isCurrentMonth: boolean;
+    isWeekend: boolean;
+    dayNumberText: string;
+    events: NormalizedEvent[];
+}
+interface SlotContentProps {
+    start: Temporal.PlainDateTime;
+    end: Temporal.PlainDateTime;
+    isBusinessHour: boolean;
+}
+interface HeaderContentProps {
+    title: string;
+    currentView: ViewPreset;
+    currentDate: Temporal.PlainDate;
+}
+interface MoreLinkContentProps {
+    count: number;
+    date: Temporal.PlainDate;
+}
+interface ResourceLabelContentProps {
+    resource: Resource;
+}
+/**
+ * The shape of the calendar context value.
+ */
+interface CalendarContextValue {
+    currentDate: Temporal.PlainDate;
+    currentView: ViewPreset;
+    viewLayout: ViewLayout | null;
+    visibleRange: TemporalDateRange;
+    events: NormalizedEvent[];
+    resources: Resource[];
+    timezone: string;
+    locale: string;
+    firstDayOfWeek: number;
+    editable: boolean;
+    selectable: boolean;
+    eventDefaults?: EventDefaults;
+    selectedRange: {
+        start: Temporal.ZonedDateTime;
+        end: Temporal.ZonedDateTime;
+    } | null;
+    select: (start: Temporal.ZonedDateTime, end: Temporal.ZonedDateTime) => void;
+    unselect: () => void;
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+    goToDate: (date: Temporal.PlainDate) => void;
+    changeView: (view: ViewPreset) => void;
+    addEvent: (event: EventInput) => void;
+    updateEvent: (id: string, patch: Partial<EventInput>) => void;
+    removeEvent: (id: string) => void;
+    title: string;
+    slots: CalendarSlots;
+    onEventClick?: (event: NormalizedEvent) => void;
+    onEventDrop?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+        newResourceId?: string;
+    }) => void;
+    onDateSelect?: (range: {
+        start: Temporal.PlainDateTime;
+        end: Temporal.PlainDateTime;
+        resourceId?: string;
+    }) => void;
+    onEventResize?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+    }) => void;
+    onDateClick?: (info: {
+        date: Temporal.PlainDate;
+        dateStr: string;
+        view: ViewPreset;
+        resourceId?: string;
+    }) => void;
+    onDatesSet?: (info: {
+        start: Temporal.PlainDate;
+        end: Temporal.PlainDate;
+        view: ViewPreset;
+    }) => void;
+    onUnselect?: () => void;
+    onEventMouseEnter?: (info: {
+        event: NormalizedEvent;
+        el: HTMLElement;
+    }) => void;
+    onEventMouseLeave?: (info: {
+        event: NormalizedEvent;
+        el: HTMLElement;
+    }) => void;
+    onEventDragStart?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventDragStop?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventResizeStart?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventResizeStop?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventAdd?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventChange?: (info: {
+        event: NormalizedEvent;
+        oldEvent: NormalizedEvent;
+    }) => void;
+    onEventRemove?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    onEventsSet?: (events: NormalizedEvent[]) => void;
+    onLoading?: (isLoading: boolean) => void;
+    onWindowResize?: (info: {
+        view: ViewPreset;
+    }) => void;
+}
+declare const CalendarContext: React$1.Context<CalendarContextValue | null>;
+/**
+ * Hook to consume the calendar context.
+ * Must be used within a <Calendar> provider.
+ */
+declare function useCalendarContext(): CalendarContextValue;
+
+interface CalendarProps extends UseCalendarOptions {
+    className?: string;
+    children?: React__default.ReactNode;
+    slots?: CalendarSlots;
+    /** Text direction: 'ltr' | 'rtl'. Auto-detected from locale if not set. */
+    direction?: 'ltr' | 'rtl';
+    /** Calendar height (e.g., '600px', 'auto') */
+    height?: string | number;
+    /** Calendar content height */
+    contentHeight?: string | number;
+    /** Aspect ratio for auto-sizing */
+    aspectRatio?: number;
+    onEventClick?: (event: NormalizedEvent) => void;
+    onEventDrop?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+        newResourceId?: string;
+    }) => void;
+    onDateSelect?: (range: {
+        start: Temporal.PlainDateTime;
+        end: Temporal.PlainDateTime;
+        resourceId?: string;
+    }) => void;
+    onEventResize?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+    }) => void;
+    /** Mouse enter on event */
+    onEventMouseEnter?: (info: {
+        event: NormalizedEvent;
+        el: HTMLElement;
+    }) => void;
+    /** Mouse leave from event */
+    onEventMouseLeave?: (info: {
+        event: NormalizedEvent;
+        el: HTMLElement;
+    }) => void;
+    /** Date click handler */
+    onDateClick?: (info: {
+        date: Temporal.PlainDate;
+        dateStr: string;
+        view: ViewPreset;
+        resourceId?: string;
+    }) => void;
+}
+/**
+ * <Calendar /> — Root compound component.
+ * Provides CalendarContext and renders children or default layout.
+ * Activates PDND drag-and-drop monitor when `editable` is true.
+ */
+declare function Calendar({ className, children, slots, direction, height, contentHeight, aspectRatio, onEventClick, onEventDrop, onDateSelect, onEventResize, onEventMouseEnter, onEventMouseLeave, onDateClick, ...options }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace Calendar {
+    var Header: typeof CalendarHeaderSlot;
+    var View: typeof CalendarViewSlot;
+    var NavPrev: typeof CalendarNavPrev;
+    var NavNext: typeof CalendarNavNext;
+    var NavToday: typeof CalendarNavToday;
+    var Title: typeof CalendarTitle;
+    var ViewSwitcher: typeof CalendarViewSwitcher;
+}
+declare function CalendarHeaderSlot({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarHeaderSlot {
+    var displayName: string;
+}
+declare function CalendarViewSlot({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarViewSlot {
+    var displayName: string;
+}
+declare function CalendarNavPrev({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarNavPrev {
+    var displayName: string;
+}
+declare function CalendarNavNext({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarNavNext {
+    var displayName: string;
+}
+declare function CalendarNavToday({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarNavToday {
+    var displayName: string;
+}
+declare function CalendarTitle({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarTitle {
+    var displayName: string;
+}
+declare function CalendarViewSwitcher({ views, className }: {
+    views?: ViewPreset[];
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CalendarViewSwitcher {
+    var displayName: string;
+}
+
+interface ToolbarConfig {
+    left?: string;
+    center?: string;
+    right?: string;
+}
+interface CustomButton {
+    text: string;
+    click: () => void;
+    icon?: React__default.ReactNode;
+}
+interface CalendarHeaderProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    /** Config-driven toolbar: { left: 'prev,next today', center: 'title', right: 'dayGridMonth,timeGridWeek,timeGridDay' } */
+    toolbar?: ToolbarConfig;
+    /** Override button text labels */
+    buttonText?: Partial<Record<string, string>>;
+    /** Custom buttons registry */
+    customButtons?: Record<string, CustomButton>;
+    /** Whether to use sticky positioning */
+    sticky?: boolean;
+}
+/**
+ * <CalendarHeader /> — Config-driven toolbar with prev/next, title, view switcher, and custom buttons.
+ *
+ * When `toolbar` prop is provided, renders from config tokens.
+ * Otherwise falls back to children, slots, or default layout.
+ */
+declare function CalendarHeader({ className, children, toolbar, buttonText, customButtons, sticky, }: CalendarHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface CalendarFooterProps {
+    className?: string;
+    /** Config-driven footer toolbar — same token format as headerToolbar */
+    toolbar?: ToolbarConfig;
+    /** Override button text labels */
+    buttonText?: Partial<Record<string, string>>;
+    /** Custom buttons registry */
+    customButtons?: Record<string, CustomButton>;
+}
+/**
+ * <CalendarFooter /> — Optional footer toolbar mirroring the header's config-driven rendering.
+ *
+ * Usage:
+ * ```tsx
+ * <CalendarFooter toolbar={{ left: 'prev,next', center: '', right: 'dayGridMonth,timeGridWeek' }} />
+ * ```
+ */
+declare function CalendarFooter({ className, toolbar, buttonText, customButtons, }: CalendarFooterProps): react_jsx_runtime.JSX.Element | null;
+
+interface DayGridProps {
+    className?: string;
+    /** Always show 6 weeks (default: false) */
+    fixedWeekCount?: boolean;
+    /** Show dates from adjacent months (default: true) */
+    showNonCurrentDates?: boolean;
+    /** Show week numbers column (default: false) */
+    weekNumbers?: boolean;
+}
+/**
+ * <DayGrid /> — Month view renderer.
+ * Renders a grid of weeks × days from viewLayout.weeks.
+ * Supports fixedWeekCount, showNonCurrentDates, and weekNumbers.
+ */
+declare function DayGrid({ className, fixedWeekCount, showNonCurrentDates, weekNumbers, }: DayGridProps): react_jsx_runtime.JSX.Element | null;
+
+type MoreLinkClick = 'popover' | 'day' | ((info: MoreLinkInfo) => void);
+interface MoreLinkInfo {
+    date: string;
+    allEvents: PositionedEvent[];
+    hiddenEvents: PositionedEvent[];
+}
+
+interface DayCellProps {
+    cell: DayCell$1;
+    /** How to handle "+N more" clicks */
+    moreLinkClick?: MoreLinkClick;
+    /** Enable clicking day number to navigate to day view */
+    navLinkDayClick?: boolean | ((date: Temporal.PlainDate) => void);
+}
+/**
+ * <DayCell /> — Individual day cell in the month grid.
+ * Supports dateClick, navLinkDayClick, moreLinkClick, and PDND drop targets.
+ */
+declare function DayCell({ cell, moreLinkClick, navLinkDayClick }: DayCellProps): react_jsx_runtime.JSX.Element;
+
+interface EventCardProps {
+    positionedEvent: PositionedEvent;
+    compact?: boolean;
+    /** Custom event time format */
+    eventTimeFormat?: Intl.DateTimeFormatOptions;
+    /** Whether to show event time (default: true) */
+    displayEventTime?: boolean;
+    /** Whether to show event end time (default: false) */
+    displayEventEnd?: boolean;
+}
+/**
+ * <EventCard /> — Renders a single event.
+ * Supports display modes: auto, block, list-item, none.
+ * When editable, integrates Pragmatic Drag and Drop for native drag behavior.
+ */
+declare function EventCard({ positionedEvent, compact, eventTimeFormat, displayEventTime, displayEventEnd, }: EventCardProps): react_jsx_runtime.JSX.Element | null;
+
+interface BackgroundEventProps {
+    /** Background event with positioning data */
+    backgroundEvent: BackgroundEvent$1;
+    /** Whether this is in a time-grid (uses top/height) or day-grid (full cell) */
+    variant?: 'timeGrid' | 'dayGrid';
+}
+/**
+ * <BackgroundEvent /> — Renders a translucent background overlay for events
+ * with display: 'background'. These appear behind regular events.
+ */
+declare function BackgroundEvent({ backgroundEvent, variant }: BackgroundEventProps): react_jsx_runtime.JSX.Element;
+
+interface TimeGridProps {
+    className?: string;
+    /** Initial scroll position (e.g., '06:00:00') */
+    scrollTime?: string;
+    /** Reset scroll on view change */
+    scrollTimeReset?: boolean;
+    /** Sticky header dates */
+    stickyHeaderDates?: boolean;
+    /** Slot label format override */
+    slotLabelFormat?: Intl.DateTimeFormatOptions;
+    /** Sticky footer scrollbar */
+    stickyFooterScrollbar?: boolean;
+}
+/**
+ * <TimeGrid /> — Week/day time view renderer.
+ * Renders time axis + day columns with positioned events.
+ * Supports scrollTime, stickyHeaderDates, and slot label formatting.
+ */
+declare function TimeGrid({ className, scrollTime, scrollTimeReset, stickyHeaderDates, slotLabelFormat, stickyFooterScrollbar, }: TimeGridProps): react_jsx_runtime.JSX.Element | null;
+
+interface TimeSlotProps {
+    slot: TimeSlot$1;
+    /** The date this slot belongs to (for drop target registration) */
+    date?: Temporal.PlainDate;
+    /** Resource ID (for resource views) */
+    resourceId?: string;
+}
+/**
+ * <TimeSlot /> — Individual time cell in the time-grid view.
+ * Acts as a PDND drop target when the calendar is editable.
+ */
+declare function TimeSlot({ slot, date, resourceId }: TimeSlotProps): react_jsx_runtime.JSX.Element;
+
+interface NowIndicatorProps {
+    position: number;
+}
+/**
+ * <NowIndicator /> — Current time line in time-grid views.
+ */
+declare function NowIndicator({ position }: NowIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface AllDayRowProps {
+    events: PositionedEvent[];
+    className?: string;
+}
+/**
+ * <AllDayRow /> — All-day event strip at the top of time-grid views.
+ */
+declare function AllDayRow({ events, className }: AllDayRowProps): react_jsx_runtime.JSX.Element | null;
+
+interface TimelineProps {
+    className?: string;
+}
+/**
+ * <Timeline /> — Horizontal resource timeline renderer.
+ */
+declare function Timeline({ className }: TimelineProps): react_jsx_runtime.JSX.Element | null;
+
+interface ResourceLaneProps {
+    lane: ResourceLane$1;
+    slotCount: number;
+}
+/**
+ * <ResourceLane /> — A single resource row in the timeline view.
+ */
+declare function ResourceLane({ lane, slotCount }: ResourceLaneProps): react_jsx_runtime.JSX.Element;
+
+interface AgendaProps {
+    className?: string;
+}
+/**
+ * <Agenda /> — List/agenda view renderer.
+ * Groups events by date in a flat list format.
+ */
+declare function Agenda({ className }: AgendaProps): react_jsx_runtime.JSX.Element | null;
+
+interface MultiMonthProps {
+    className?: string;
+}
+/**
+ * <MultiMonth /> — Renders multiple months in a stacked or grid layout.
+ *
+ * Used by multiMonthStack and multiMonthGrid view presets.
+ */
+declare function MultiMonth({ className }: MultiMonthProps): react_jsx_runtime.JSX.Element | null;
+
+interface ResourceTimeGridProps {
+    className?: string;
+}
+/**
+ * <ResourceTimeGrid /> — Renders a time grid where columns represent resources.
+ *
+ * Used by resourceTimeGridDay and resourceTimeGridWeek view presets.
+ */
+declare function ResourceTimeGrid({ className }: ResourceTimeGridProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Hook for date navigation controls.
+ */
+declare function useNavigation(): {
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+    goToDate: (date: temporal_polyfill.Temporal.PlainDate) => void;
+    currentDate: temporal_polyfill.Temporal.PlainDate;
+    title: string;
+};
+
+/**
+ * Hook for event store operations.
+ */
+declare function useEvents(): {
+    events: NormalizedEvent[];
+    addEvent: (event: _tempus_machina_core.EventInput) => void;
+    updateEvent: (id: string, patch: Partial<_tempus_machina_core.EventInput>) => void;
+    removeEvent: (id: string) => void;
+};
+
+/**
+ * Hook for view switching.
+ */
+declare function useView(): {
+    currentView: _allhailai_tempusmachina_core.ViewPreset;
+    changeView: (view: _allhailai_tempusmachina_core.ViewPreset) => void;
+    viewLayout: _allhailai_tempusmachina_core.ViewLayout | null;
+};
+
+/**
+ * Hook for time slot generation in the current view.
+ */
+declare function useSlots(): {
+    timeSlots: _tempus_machina_core.TimeSlot[];
+    columns: _tempus_machina_core.TimeGridColumn[];
+};
+
+type InteractionMode = 'idle' | 'dragging' | 'resizing' | 'selecting';
+interface InteractionState {
+    mode: InteractionMode;
+    activeEvent: NormalizedEvent | null;
+    ghostEvent: NormalizedEvent | null;
+    previewStart: Temporal.ZonedDateTime | null;
+    previewEnd: Temporal.ZonedDateTime | null;
+    /** The drop target currently being hovered */
+    dropTargetDate: string | null;
+    dropTargetTime: string | null;
+    dropTargetResourceId: string | null;
+}
+interface UseInteractionOptions {
+    /** All events for overlap checking */
+    events?: NormalizedEvent[];
+    /** View config for time resolution */
+    viewConfig?: ViewConfig;
+    /** Timezone */
+    timezone?: string;
+    /** Duration of revert animation on failed drop (ms) */
+    dragRevertDuration?: number;
+    /** When dragging between timed and all-day, maintain original duration */
+    allDayMaintainDuration?: boolean;
+    /** Whether events can be dragged between resources */
+    eventResourceEditable?: boolean;
+    /** Callback when event drag starts */
+    onEventDragStart?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    /** Callback when event drag stops */
+    onEventDragStop?: (info: {
+        event: NormalizedEvent;
+    }) => void;
+    /** Callback when event is dropped */
+    onEventDrop?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+        newResourceId?: string;
+        oldResourceId?: string;
+        revert: () => void;
+    }) => void;
+    /** Callback when event is resized */
+    onEventResize?: (info: {
+        event: NormalizedEvent;
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+        revert: () => void;
+    }) => void;
+}
+interface UseInteractionReturn {
+    state: InteractionState;
+    startDrag: (event: NormalizedEvent, position: {
+        x: number;
+        y: number;
+    }) => void;
+    startResize: (event: NormalizedEvent, edge: 'start' | 'end', position: {
+        x: number;
+        y: number;
+    }) => void;
+    startSelect: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    updatePosition: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    endInteraction: () => InteractionResult | null;
+    cancel: () => void;
+}
+interface InteractionResult {
+    type: 'move' | 'resize' | 'create' | 'select';
+    event?: NormalizedEvent;
+    newStart?: Temporal.ZonedDateTime;
+    newEnd?: Temporal.ZonedDateTime;
+    newResourceId?: string;
+}
+/**
+ * Drag/drop/resize state machine hook.
+ * Uses PDND's monitorForElements at the calendar root level for global drag awareness.
+ * Individual elements use useDragEvent/useDropSlot for PDND binding.
+ *
+ * This hook orchestrates the high-level interaction state (ghost events, previews)
+ * while PDND handles the browser-native drag mechanics.
+ */
+declare function useInteraction(options?: UseInteractionOptions): UseInteractionReturn;
+
+/**
+ * PDND data key for identifying calendar event drags.
+ */
+declare const CALENDAR_EVENT_TYPE = "tempus-machina/event";
+interface UseDragEventOptions {
+    /** The event being made draggable */
+    event: NormalizedEvent;
+    /** Whether this event is editable (default: true) */
+    editable?: boolean;
+    /** Whether the start time can be changed via drag */
+    startEditable?: boolean;
+    /** Minimum distance before drag activates (pixels) */
+    dragMinDistance?: number;
+    /** Callback when drag starts */
+    onDragStart?: (event: NormalizedEvent) => void;
+    /** Callback when drag ends (regardless of outcome) */
+    onDragEnd?: (event: NormalizedEvent) => void;
+}
+interface UseDragEventReturn {
+    /** Ref to attach to the draggable element */
+    dragRef: React.RefObject<HTMLElement | null>;
+    /** Ref to attach to a specific drag handle (optional) */
+    dragHandleRef: React.RefObject<HTMLElement | null>;
+    /** Whether this element is currently being dragged */
+    isDragging: boolean;
+}
+/**
+ * Hook to make an event card draggable using Pragmatic Drag and Drop.
+ *
+ * Usage:
+ * ```tsx
+ * const { dragRef, isDragging } = useDragEvent({ event });
+ * return <div ref={dragRef} style={{ opacity: isDragging ? 0.5 : 1 }}>...</div>;
+ * ```
+ */
+declare function useDragEvent(options: UseDragEventOptions): UseDragEventReturn;
+
+interface UseDropSlotOptions {
+    /** The date this slot represents */
+    date: Temporal.PlainDate;
+    /** Time position within the day (for time-grid slots) */
+    time?: Temporal.PlainTime;
+    /** Resource ID (for resource views) */
+    resourceId?: string;
+    /** View config for time resolution */
+    viewConfig: ViewConfig;
+    /** Timezone */
+    timezone: string;
+    /** Called when a valid drop occurs */
+    onEventDrop?: (info: {
+        event: {
+            id: string;
+            title: string;
+        };
+        newStart: Temporal.ZonedDateTime;
+        newEnd: Temporal.ZonedDateTime;
+        newResourceId?: string;
+    }) => void;
+    /** Called when drag enters this slot */
+    onDragEnter?: () => void;
+    /** Called when drag leaves this slot */
+    onDragLeave?: () => void;
+}
+interface UseDropSlotReturn {
+    /** Ref to attach to the drop target element */
+    dropRef: React.RefObject<HTMLElement | null>;
+    /** Whether something is currently dragging over this slot */
+    isDragOver: boolean;
+    /** Whether this slot can accept the current drag */
+    canDrop: boolean;
+}
+/**
+ * Hook to make a time slot or day cell a PDND drop target.
+ *
+ * Usage:
+ * ```tsx
+ * const { dropRef, isDragOver } = useDropSlot({
+ *   date, time, viewConfig, timezone,
+ *   onEventDrop: (info) => updateEvent(info.event.id, { start: info.newStart }),
+ * });
+ * return <div ref={dropRef} className={isDragOver ? 'bg-blue-100' : ''}>...</div>;
+ * ```
+ */
+declare function useDropSlot(options: UseDropSlotOptions): UseDropSlotReturn;
+
+interface UseSelectionOptions {
+    /** Whether selection is enabled */
+    selectable?: boolean;
+    /** Minimum distance in pixels before selection starts */
+    selectMinDistance?: number;
+    /** Whether to show a mirror overlay during selection */
+    selectMirror?: boolean;
+    /** Automatically unselect when clicking elsewhere */
+    unselectAuto?: boolean;
+    /** CSS selector for elements that should NOT trigger unselect */
+    unselectCancel?: string;
+    /** Timezone for time calculations */
+    timezone?: string;
+    /** Called when a date/time range is selected */
+    onSelect?: (info: SelectionInfo) => void;
+    /** Called when selection is cleared */
+    onUnselect?: () => void;
+    /** Called on single date click */
+    onDateClick?: (info: DateClickInfo) => void;
+}
+interface SelectionInfo {
+    start: Temporal.ZonedDateTime;
+    end: Temporal.ZonedDateTime;
+    allDay: boolean;
+    resourceId?: string;
+}
+interface DateClickInfo {
+    date: Temporal.PlainDate;
+    dateStr: string;
+    allDay: boolean;
+    resourceId?: string;
+}
+interface SelectionState {
+    /** Whether a selection is currently in progress (dragging) */
+    isSelecting: boolean;
+    /** Current selection range */
+    selection: SelectionInfo | null;
+    /** Mirror preview during drag-select */
+    previewStart: Temporal.ZonedDateTime | null;
+    previewEnd: Temporal.ZonedDateTime | null;
+}
+interface UseSelectionReturn {
+    /** Current selection state */
+    state: SelectionState;
+    /** Begin a selection at a given position */
+    startSelection: (info: {
+        date: Temporal.PlainDate;
+        time?: Temporal.PlainTime;
+        resourceId?: string;
+        allDay?: boolean;
+    }) => void;
+    /** Update the selection end as the pointer moves */
+    updateSelection: (info: {
+        date: Temporal.PlainDate;
+        time?: Temporal.PlainTime;
+    }) => void;
+    /** Finalize the selection */
+    endSelection: () => void;
+    /** Clear the current selection */
+    clearSelection: () => void;
+    /** Programmatically set a selection */
+    select: (start: Temporal.ZonedDateTime, end: Temporal.ZonedDateTime) => void;
+}
+/**
+ * Pointer-event-based selection hook for calendar date/time range selection.
+ * Uses pointer events (not PDND) because selection ≠ drag-and-drop.
+ *
+ * Supports:
+ * - Click-to-select-slot (single cell)
+ * - Drag-to-select-range (multiple cells)
+ * - selectMirror ghost preview
+ * - unselectAuto click-away
+ * - selectMinDistance threshold
+ */
+declare function useSelection(options?: UseSelectionOptions): UseSelectionReturn;
+
+/**
+ * Reactive current time hook.
+ * Updates on an interval for now-indicator positioning.
+ *
+ * @param intervalMs - Update interval in milliseconds (default: 60000 = 1 minute)
+ * @param timezone - IANA timezone string (default: local)
+ */
+declare function useTemporalNow(intervalMs?: number, timezone?: string): Temporal.ZonedDateTime;
+
+interface UseEventSourcesOptions {
+    /** Event source definitions */
+    eventSources: (EventSourceDef | EventSourceInput)[];
+    /** Current visible range — triggers refetch on change */
+    visibleRange: TemporalDateRange;
+    /** Timezone */
+    timezone: string;
+    /** Event defaults for normalization */
+    eventDefaults?: EventDefaults;
+    /** Whether to render events progressively as sources resolve */
+    progressiveEventRendering?: boolean;
+    /** Called when loading state changes */
+    onLoading?: (isLoading: boolean) => void;
+    /** Called when a source fails */
+    onSourceError?: (sourceId: string, error: Error) => void;
+}
+interface UseEventSourcesReturn {
+    /** All resolved events from all sources */
+    events: NormalizedEvent[];
+    /** Whether any source is currently loading */
+    isLoading: boolean;
+    /** Individual source states */
+    sources: NormalizedEventSource[];
+    /** Force refetch all sources */
+    refetchAll: () => void;
+    /** Force refetch a specific source */
+    refetch: (sourceId: string) => void;
+}
+/**
+ * Hook to manage multiple event sources with automatic refetching on range change.
+ *
+ * Supports:
+ * - Static arrays, JSON feed URLs, and async functions
+ * - Parallel fetching with error isolation
+ * - Progressive rendering (show events as they arrive)
+ * - Loading state callbacks
+ * - Manual refetch control
+ */
+declare function useEventSources(options: UseEventSourcesOptions): UseEventSourcesReturn;
+
+/**
+ * Data carried by an external draggable element.
+ */
+interface ExternalDragData {
+    /** Type identifier for filtering */
+    type: string;
+    /** Event data to create on drop */
+    eventData?: Partial<EventInput>;
+    /** Raw data from external source */
+    raw?: unknown;
+}
+interface ExternalDropInfo {
+    /** The slot date/time where the drop occurred */
+    date: Temporal.PlainDate;
+    time?: Temporal.PlainTime;
+    /** Resource ID if applicable */
+    resourceId?: string;
+    /** The external drag data */
+    dragData: ExternalDragData;
+    /** Whether the drop was on an all-day area */
+    allDay: boolean;
+}
+interface UseExternalDropOptions {
+    /** Whether the calendar accepts external drops */
+    droppable?: boolean;
+    /** Filter function for accepted drop types */
+    dropAccept?: string | string[] | ((type: string) => boolean);
+    /** Called when an external element is dropped onto the calendar */
+    onDrop?: (info: ExternalDropInfo) => void;
+    /** Called when an event is received from an external source */
+    onEventReceive?: (event: EventInput) => void;
+}
+interface UseExternalDropReturn {
+    /** Ref to attach to the calendar container for external drops */
+    dropRef: React.RefObject<HTMLElement | null>;
+    /** Whether an external element is currently being dragged over */
+    isDraggingOver: boolean;
+    /** Whether an external drag is currently active */
+    isExternalDragActive: boolean;
+}
+/**
+ * useExternalDrop — Accepts drops from external sources onto the calendar.
+ *
+ * Uses PDND's external adapter to handle files, text, and external HTML elements
+ * dragged from outside the calendar. External elements must attach PDND data
+ * via the consuming app's `draggable()` configuration.
+ *
+ * @example
+ * ```tsx
+ * const { dropRef, isDraggingOver } = useExternalDrop({
+ *   droppable: true,
+ *   dropAccept: 'task',
+ *   onDrop: (info) => console.log('Dropped:', info),
+ *   onEventReceive: (event) => addEvent(event),
+ * });
+ * ```
+ */
+declare function useExternalDrop(options: UseExternalDropOptions): UseExternalDropReturn;
+
+/** Data key used to identify calendar events in PDND data */
+declare const CALENDAR_BRIDGE_TYPE = "tempus-machina-bridge";
+interface UseCalendarBridgeOptions {
+    /** Unique ID for this calendar instance */
+    calendarId: string;
+    /** Called when an event leaves this calendar during drag */
+    onEventLeave?: (event: NormalizedEvent) => void;
+    /** Called when an event is received from another calendar */
+    onEventReceive?: (event: NormalizedEvent, sourceCalendarId: string) => void;
+    /** Called when an event is dropped back on its original calendar (no-op) */
+    onEventReturn?: (event: NormalizedEvent) => void;
+    /** Whether inter-calendar transfer is enabled */
+    enabled?: boolean;
+}
+interface UseCalendarBridgeReturn {
+    /** Unique calendar ID */
+    calendarId: string;
+    /** Ref to attach PDND bridge data to draggable events */
+    getBridgeData: (event: NormalizedEvent) => Record<string, unknown>;
+    /** Check if a drag source is from another calendar */
+    isFromOtherCalendar: (data: Record<string, unknown>) => boolean;
+}
+/**
+ * useCalendarBridge — Enables cross-calendar event transfer via PDND.
+ *
+ * Calendar A's monitor detects when an event drag leaves → fires `onEventLeave`.
+ * Calendar B's drop target receives the event → fires `onEventReceive`.
+ * Events carry source calendar identity via PDND's `getInitialData()` flow.
+ *
+ * No shared state needed — PDND's browser-native DnD handles cross-component transfer.
+ *
+ * @example
+ * ```tsx
+ * // Calendar A
+ * const bridgeA = useCalendarBridge({
+ *   calendarId: 'calendar-a',
+ *   onEventLeave: (event) => removeEvent(event.id),
+ * });
+ *
+ * // Calendar B
+ * const bridgeB = useCalendarBridge({
+ *   calendarId: 'calendar-b',
+ *   onEventReceive: (event, sourceId) => addEvent(event),
+ * });
+ * ```
+ */
+declare function useCalendarBridge(options: UseCalendarBridgeOptions): UseCalendarBridgeReturn;
+
+interface KeyboardNavHints {
+    /** Accessible hint for navigation buttons */
+    buttonHints?: {
+        prev?: string;
+        next?: string;
+        today?: string;
+    };
+    /** Hint for view switcher buttons */
+    viewHint?: (viewName: string) => string;
+    /** Hint for day number nav links */
+    navLinkHint?: string;
+    /** Hint for time slots */
+    timeHint?: (timeText: string) => string;
+    /** Hint for events */
+    eventHint?: (title: string) => string;
+    /** Hint for close buttons */
+    closeHint?: string;
+}
+interface UseKeyboardNavOptions {
+    /** Container ref — keyboard events are scoped to this element */
+    containerRef: React.RefObject<HTMLElement | null>;
+    /** Whether keyboard navigation is enabled */
+    enabled?: boolean;
+    /** Callback when a date is navigated to via keyboard */
+    onDateNav?: (direction: 'up' | 'down' | 'left' | 'right') => void;
+    /** Callback when Enter/Space is pressed on a focused date */
+    onDateSelect?: () => void;
+    /** Callback when Escape is pressed */
+    onCancel?: () => void;
+    /** Callback when Tab key cycles through events */
+    onEventFocus?: (eventId: string) => void;
+    /** Current view for determining navigation behavior */
+    currentView?: ViewPreset;
+    /** Accessible hints */
+    hints?: KeyboardNavHints;
+}
+interface UseKeyboardNavReturn {
+    /** Props to spread on the calendar container */
+    containerProps: {
+        role: 'grid';
+        tabIndex: number;
+        'aria-label': string;
+        onKeyDown: (e: React.KeyboardEvent) => void;
+    };
+    /** Props to spread on each grid cell */
+    getCellProps: (opts: {
+        date: string;
+        isSelected?: boolean;
+    }) => {
+        role: 'gridcell';
+        tabIndex: number;
+        'aria-selected': boolean;
+        'aria-label': string;
+    };
+    /** Props to spread on each event element */
+    getEventProps: (opts: {
+        id: string;
+        title: string;
+        timeText: string;
+    }) => {
+        role: 'button';
+        tabIndex: number;
+        'aria-label': string;
+        'aria-grabbed'?: boolean;
+    };
+}
+/**
+ * useKeyboardNav — Full keyboard navigation for the calendar.
+ *
+ * Arrow keys navigate between dates/events, Enter/Space selects,
+ * Escape cancels, Tab cycles through interactive events.
+ *
+ * @example
+ * ```tsx
+ * const { containerProps, getCellProps, getEventProps } = useKeyboardNav({
+ *   containerRef,
+ *   onDateNav: (dir) => navigateDate(dir),
+ *   onDateSelect: () => selectDate(),
+ * });
+ * ```
+ */
+declare function useKeyboardNav(options: UseKeyboardNavOptions): UseKeyboardNavReturn;
+
+interface UseTouchOptions {
+    /** Element ref for touch event binding */
+    elementRef: React.RefObject<HTMLElement | null>;
+    /** Whether touch interactions are enabled */
+    enabled?: boolean;
+    /** Long press delay for initiating drag (ms) */
+    longPressDelay?: number;
+    /** Long press delay specifically for events (ms) */
+    eventLongPressDelay?: number;
+    /** Long press delay specifically for selection (ms) */
+    selectLongPressDelay?: number;
+    /** Called when a long press is detected on an event */
+    onEventLongPress?: (info: TouchEventInfo) => void;
+    /** Called when a long press is detected on a slot (for selection) */
+    onSlotLongPress?: (info: TouchEventInfo) => void;
+    /** Called when a tap is detected */
+    onTap?: (info: TouchEventInfo) => void;
+    /** Called when a swipe gesture is detected */
+    onSwipe?: (direction: 'left' | 'right' | 'up' | 'down') => void;
+}
+interface TouchEventInfo {
+    /** Touch position relative to viewport */
+    clientX: number;
+    clientY: number;
+    /** The target element */
+    target: HTMLElement;
+    /** Data attributes from the target element */
+    date?: string;
+    time?: string;
+    eventId?: string;
+    resourceId?: string;
+}
+interface UseTouchReturn {
+    /** Whether a long press is currently active */
+    isLongPressing: boolean;
+}
+/**
+ * useTouch — Touch interaction support for the calendar.
+ *
+ * Provides long-press detection for drag initiation on touch devices,
+ * tap detection, and swipe gestures for navigation.
+ *
+ * @example
+ * ```tsx
+ * const { isLongPressing } = useTouch({
+ *   elementRef: calendarRef,
+ *   onEventLongPress: (info) => startDrag(info),
+ *   onSwipe: (dir) => dir === 'left' ? next() : prev(),
+ * });
+ * ```
+ */
+declare function useTouch(options: UseTouchOptions): UseTouchReturn;
+
+type ResourceSourceInput = Resource[] | string | ((fetchInfo: ResourceFetchInfo) => Promise<Resource[]>);
+interface ResourceFetchInfo {
+    start: string;
+    end: string;
+}
+interface UseResourcesOptions {
+    /** Initial resources or resource source */
+    resources?: ResourceSourceInput;
+    /** Sort function for resource ordering */
+    resourceOrder?: string | ((a: Resource, b: Resource) => number);
+    /** Width of the resource area in pixels */
+    resourceAreaWidth?: number;
+    /** Whether to refetch resources on date navigation */
+    refetchResourcesOnNavigate?: boolean;
+    /** Lifecycle callbacks */
+    onResourceAdd?: (resource: Resource) => void;
+    onResourceChange?: (resource: Resource) => void;
+    onResourceRemove?: (resource: Resource) => void;
+    onResourcesSet?: (resources: Resource[]) => void;
+}
+interface UseResourcesReturn {
+    /** Current list of resources */
+    resources: Resource[];
+    /** Whether resources are loading */
+    isLoading: boolean;
+    /** Add a resource */
+    addResource: (resource: Resource | (Omit<Resource, 'id'> & {
+        id?: string;
+    })) => void;
+    /** Remove a resource by ID */
+    removeResource: (resourceId: string) => void;
+    /** Update a resource */
+    updateResource: (resourceId: string, updates: Partial<Resource>) => void;
+    /** Replace all resources */
+    setResources: (resources: Resource[]) => void;
+    /** Trigger resource refetch (for function/URL sources) */
+    refetchResources: () => void;
+    /** Resource area width */
+    resourceAreaWidth: number;
+}
+/**
+ * useResources — Resource CRUD and data sourcing hook.
+ *
+ * Manages calendar resources with immutable state updates.
+ * Supports static arrays, JSON feed URLs, and async functions.
+ *
+ * @example
+ * ```tsx
+ * const { resources, addResource, removeResource } = useResources({
+ *   resources: [
+ *     { id: 'room-a', title: 'Room A' },
+ *     { id: 'room-b', title: 'Room B' },
+ *   ],
+ *   resourceOrder: 'title',
+ *   onResourceAdd: (r) => console.log('Added:', r),
+ * });
+ * ```
+ */
+declare function useResources(options?: UseResourcesOptions): UseResourcesReturn;
+
+interface ThemeContextValue {
+    theme: 'light' | 'dark';
+    setTheme: (theme: 'light' | 'dark') => void;
+    toggleTheme: () => void;
+}
+declare function useTheme(): ThemeContextValue;
+interface CalendarThemeProviderProps {
+    children: React__default.ReactNode;
+    defaultTheme?: 'light' | 'dark';
+}
+declare function CalendarThemeProvider({ children, defaultTheme, }: CalendarThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Utility for merging Tailwind CSS classes with proper conflict resolution.
+ * Combines clsx for conditional classes with tailwind-merge for deduplication.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Event card variants.
+ * Styled pill-shaped cards with hover elevation and active feedback.
+ */
+declare const eventCardVariants: (props?: ({
+    variant?: "default" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+    state?: "idle" | "dragging" | "resizing" | "selected" | "focused" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type EventCardVariants = VariantProps<typeof eventCardVariants>;
+/**
+ * Day cell variants for the month grid.
+ * Includes hover highlight for interactivity feedback.
+ */
+declare const dayCellVariants: (props?: ({
+    variant?: "default" | "today" | "weekend" | "otherMonth" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type DayCellVariants = VariantProps<typeof dayCellVariants>;
+/**
+ * Time slot variants.
+ * Alternating backgrounds for readability + hover state.
+ */
+declare const timeSlotVariants: (props?: ({
+    variant?: "default" | "odd" | "business" | "nonBusiness" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TimeSlotVariants = VariantProps<typeof timeSlotVariants>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, ...props }: Button$1.Props & VariantProps<typeof buttonVariants>): react_jsx_runtime.JSX.Element;
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: Toggle$1.Props & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: ToggleGroup$1.Props & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    orientation?: 'horizontal' | 'vertical';
+}): react_jsx_runtime.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: Toggle$1.Props & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+export { Agenda, type AgendaProps, AllDayRow, type AllDayRowProps, BackgroundEvent, type BackgroundEventProps, Button, CALENDAR_BRIDGE_TYPE, CALENDAR_EVENT_TYPE, Calendar, CalendarContext, type CalendarContextValue, CalendarFooter, type CalendarFooterProps, CalendarHeader, type CalendarHeaderProps, type CalendarProps, type CalendarSlots, CalendarThemeProvider, type CalendarThemeProviderProps, type CustomButton, type DateClickInfo, DayCell, type DayCellContentProps, type DayCellProps, type DayCellVariants, DayGrid, type DayGridProps, EventCard, type EventCardProps, type EventCardVariants, type EventContentProps, type ExternalDropInfo, type HeaderContentProps, type InteractionMode, type InteractionResult, type InteractionState, type KeyboardNavHints, type MoreLinkContentProps, MultiMonth, type MultiMonthProps, NowIndicator, type NowIndicatorProps, type ResourceLabelContentProps, ResourceLane, type ResourceLaneProps, type ResourceSourceInput, ResourceTimeGrid, type ResourceTimeGridProps, type SelectionInfo, type SelectionState, type SlotContentProps, type ThemeContextValue, TimeGrid, type TimeGridProps, TimeSlot, type TimeSlotProps, type TimeSlotVariants, Timeline, type TimelineProps, Toggle, ToggleGroup, ToggleGroupItem, type ToolbarConfig, type TouchEventInfo, type UseCalendarBridgeOptions, type UseCalendarBridgeReturn, type UseCalendarOptions, type UseCalendarReturn, type UseDragEventOptions, type UseDragEventReturn, type UseDropSlotOptions, type UseDropSlotReturn, type UseEventSourcesOptions, type UseEventSourcesReturn, type UseExternalDropOptions, type UseExternalDropReturn, type UseInteractionOptions, type UseInteractionReturn, type UseKeyboardNavOptions, type UseKeyboardNavReturn, type UseResourcesOptions, type UseResourcesReturn, type UseSelectionOptions, type UseSelectionReturn, type UseTouchOptions, type UseTouchReturn, buttonVariants, cn, dayCellVariants, eventCardVariants, timeSlotVariants, toggleVariants, useCalendar, useCalendarBridge, useCalendarContext, useDragEvent, useDropSlot, useEventSources, useEvents, useExternalDrop, useInteraction, useKeyboardNav, useNavigation, useResources, useSelection, useSlots, useTemporalNow, useTheme, useTouch, useView };