@mantine/schedule 9.0.0-alpha.0

package/lib/components/YearView/get-year-view-events/get-year-view-events.d.ts

@@ -0,0 +1,8 @@
+import { AnyDateValue, DateStringValue, ScheduleEventData } from '../../../types';
+export type GroupedEvents = Record<DateStringValue, ScheduleEventData[]>;
+interface GetYearViewEventsInput {
+    date: AnyDateValue;
+    events: ScheduleEventData[] | undefined;
+}
+export declare function getYearViewEvents({ date, events }: GetYearViewEventsInput): GroupedEvents;
+export {};

package/lib/components/YearView/handle-year-view-key-down.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+/** Reference to a 3D array of day buttons: [monthIndex][weekIndex][dayIndex] */
+export type YearViewControlsRef = RefObject<HTMLButtonElement[][][]>;
+export interface HandleYearViewKeyDownInput {
+    controlsRef: YearViewControlsRef;
+    monthIndex: number;
+    weekIndex: number;
+    dayIndex: number;
+    event: React.KeyboardEvent<HTMLButtonElement>;
+}
+export declare function handleYearViewKeyDown({ controlsRef, monthIndex, weekIndex, dayIndex, event, }: HandleYearViewKeyDownInput): void;

package/lib/components/YearView/index.d.ts

@@ -0,0 +1,9 @@
+import type { YearViewCssVariables, YearViewFactory, YearViewProps, YearViewStylesNames } from './YearView';
+export { YearView } from './YearView';
+export type { YearViewProps, YearViewFactory, YearViewStylesNames, YearViewCssVariables };
+export declare namespace YearView {
+    type Props = YearViewProps;
+    type Factory = YearViewFactory;
+    type StylesNames = YearViewStylesNames;
+    type CssVariables = YearViewCssVariables;
+}

package/lib/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useDragState } from './use-drag-state';
+export type { DragState, DropTarget, UseDragStateReturn } from './use-drag-state';
+export { useDragDropHandlers } from './use-drag-drop-handlers';
+export type { DragDropHandlers, UseDragDropHandlersOptions } from './use-drag-drop-handlers';
+export { useSlotDragSelect } from './use-slot-drag-select';

package/lib/hooks/use-drag-drop-handlers.d.ts

@@ -0,0 +1,51 @@
+import { DragContextValue } from '../components/DragContext/DragContext';
+import { DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
+export interface UseDragDropHandlersOptions<T = any> {
+    /** Whether drag and drop is enabled */
+    enabled: boolean;
+    /** Schedule interaction mode */
+    mode: ScheduleMode;
+    /** Called when event is dropped at new location */
+    onEventDrop?: (eventId: string | number, newStart: DateTimeStringValue, newEnd: DateTimeStringValue) => void;
+    /** Function to determine if event can be dragged */
+    canDragEvent?: (event: ScheduleEventData) => boolean;
+    /** Called when any event drag starts */
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    /** Called when any event drag ends */
+    onEventDragEnd?: () => void;
+    /**
+     * Function to calculate drop target dates from drop location.
+     * Receives the target location and the dragged event.
+     */
+    calculateDropTarget: (target: T, draggedEvent: ScheduleEventData) => {
+        start: Date;
+        end: Date;
+    };
+}
+export interface DragDropHandlers<T = any> {
+    /** Context value for DragContext.Provider */
+    dragContextValue: DragContextValue;
+    /** Current drop target */
+    dropTarget: T | null;
+    /** Handle drag start event */
+    handleDragStart: (event: ScheduleEventData) => void;
+    /** Handle drag end event */
+    handleDragEnd: () => void;
+    /** Handle drag over event */
+    handleDragOver: (e: React.DragEvent, target: T) => void;
+    /** Handle drag leave event */
+    handleDragLeave: () => void;
+    /** Handle drop event */
+    handleDrop: (e: React.DragEvent, target: T) => void;
+    /** Check if event is draggable */
+    isDraggableEvent: (event: ScheduleEventData) => boolean;
+    /** Check if target is the current drop target */
+    isDropTarget: (target: T) => boolean;
+}
+/**
+ * Hook that provides unified drag-drop handlers for Schedule views.
+ * Handles drag state management and event drops across Day, Week, and Month views.
+ *
+ * @template T - Type of the drop target (e.g., slot index, day string, etc.)
+ */
+export declare function useDragDropHandlers<T = any>(options: UseDragDropHandlersOptions<T>): DragDropHandlers<T>;

package/lib/hooks/use-drag-state.d.ts

@@ -0,0 +1,32 @@
+import { DateStringValue, ScheduleEventData } from '../types';
+export interface DropTarget {
+    /** Target date in YYYY-MM-DD format */
+    date: DateStringValue;
+    /** Target time in HH:mm:ss format (for DayView/WeekView) */
+    time?: string;
+    /** Target slot index (for DayView/WeekView) */
+    slotIndex?: number;
+}
+export interface DragState {
+    /** Whether an event is currently being dragged */
+    isDragging: boolean;
+    /** ID of the event being dragged */
+    draggedEventId: string | number | null;
+    /** The event being dragged */
+    draggedEvent: ScheduleEventData | null;
+    /** Current drop target information */
+    dropTarget: DropTarget | null;
+}
+export interface UseDragStateReturn {
+    /** Current drag state */
+    state: DragState;
+    /** Start dragging an event */
+    startDrag: (event: ScheduleEventData) => void;
+    /** End dragging */
+    endDrag: () => void;
+    /** Set the current drop target */
+    setDropTarget: (target: DropTarget | null) => void;
+    /** Clear the drop target */
+    clearDropTarget: () => void;
+}
+export declare function useDragState(): UseDragStateReturn;

package/lib/hooks/use-slot-drag-select.d.ts

@@ -0,0 +1,10 @@
+interface UseSlotDragSelectInput {
+    enabled?: boolean;
+    onDragEnd?: (startIndex: number, endIndex: number, group: string) => void;
+}
+export declare function useSlotDragSelect({ enabled, onDragEnd }: UseSlotDragSelectInput): {
+    handleSlotPointerDown: (_event: React.PointerEvent<HTMLButtonElement>, index: number, group: string) => void;
+    isSlotSelected: (index: number, group: string) => boolean;
+    isDragging: boolean;
+};
+export {};

package/lib/index.d.mts

@@ -0,0 +1,15 @@
+export * from './types';
+export type { ScheduleLabels, ScheduleLabelsOverride } from './labels';
+export { DEFAULT_SCHEDULE_LABELS, getLabel } from './labels';
+export * from './utils';
+export * from './components/Schedule';
+export * from './components/DayView';
+export * from './components/WeekView';
+export * from './components/MonthView';
+export * from './components/YearView';
+export * from './components/ScheduleEvent';
+export * from './components/ScheduleHeader';
+export * from './components/CurrentTimeIndicator';
+export * from './components/MoreEvents';
+export * from './components/MobileMonthView';
+export * from './components/DragContext';

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types';
+export type { ScheduleLabels, ScheduleLabelsOverride } from './labels';
+export { DEFAULT_SCHEDULE_LABELS, getLabel } from './labels';
+export * from './utils';
+export * from './components/Schedule';
+export * from './components/DayView';
+export * from './components/WeekView';
+export * from './components/MonthView';
+export * from './components/YearView';
+export * from './components/ScheduleEvent';
+export * from './components/ScheduleHeader';
+export * from './components/CurrentTimeIndicator';
+export * from './components/MoreEvents';
+export * from './components/MobileMonthView';
+export * from './components/DragContext';

package/lib/labels.d.ts

@@ -0,0 +1,24 @@
+export interface ScheduleLabels {
+    day: string;
+    week: string;
+    month: string;
+    year: string;
+    allDay: string;
+    weekday: string;
+    timeSlot: string;
+    today: string;
+    next: string;
+    previous: string;
+    more: string;
+    selectMonth: string;
+    selectYear: string;
+    switchToDayView: string;
+    switchToWeekView: string;
+    switchToMonthView: string;
+    switchToYearView: string;
+    viewSelectLabel: string;
+    moreLabel: (hiddenEventsCount: number) => string;
+}
+export declare const DEFAULT_SCHEDULE_LABELS: ScheduleLabels;
+export type ScheduleLabelsOverride = Partial<ScheduleLabels>;
+export declare function getLabel<K extends keyof ScheduleLabels>(key: K, override?: ScheduleLabelsOverride): ScheduleLabels[K];

package/lib/test-utils.d.ts

@@ -0,0 +1,7 @@
+import { ScheduleEventData } from './types';
+declare function createEvent(input: Partial<ScheduleEventData>): ScheduleEventData;
+export declare const testUtils: {
+    testDate: string;
+    createEvent: typeof createEvent;
+};
+export {};

package/lib/types.d.ts

@@ -0,0 +1,91 @@
+import dayjs from 'dayjs';
+import { MantineColor } from '@mantine/core';
+/** Date value type used by internal package utils */
+export type AnyDateValue = DateStringValue | Date | dayjs.Dayjs;
+/** Date value used by all Mantine components, format: `YYYY-MM-DD` */
+export type DateStringValue = string;
+/** DateTime value used by all Mantine components, format: `YYYY-MM-DD HH:mm:ss` */
+export type DateTimeStringValue = string;
+/** Day of the week, 0 – Sunday, 1 – Monday, etc. */
+export type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** string – dayjs format, callback function – custom formatter */
+export type DateLabelFormat = string | ((date: DateStringValue) => string);
+/** View level used by Schedule component */
+export type ScheduleViewLevel = 'day' | 'week' | 'month' | 'year';
+/** Interaction mode used by Schedule components */
+export type ScheduleMode = 'static' | 'default';
+/** Payload type for ScheduleEventData, defined in user application */
+export type EventPayload = Record<PropertyKey, any>;
+/** Event data object passed to all `@mantine/schedule` components */
+export interface ScheduleEventData<Payload extends EventPayload = EventPayload> {
+    /** Unique event id, used for key and identification */
+    id: string | number;
+    /** Event title, displayed in month, week and day views */
+    title: string;
+    /** Event start date/time */
+    start: Date | DateTimeStringValue;
+    /** Event end date/time */
+    end: Date | DateTimeStringValue;
+    /** Event background color. Key of `theme.colors` or any valid CSS color. */
+    color: MantineColor;
+    /** Event variant, default is `'light'` */
+    variant?: 'filled' | 'light';
+    /** Additional event data, defined by the user, not used internally by the library */
+    payload?: Payload;
+}
+export interface DayEventPositionData {
+    /** All day events */
+    allDay: boolean;
+    /** Event top position in %, represents start time */
+    top: number;
+    /** Event height in %, represents duration (end time - start time) */
+    height: number;
+    /** Event width in %, represents event size in overlap group */
+    width: number;
+    /** Event left offset in %, represents event position in overlap group */
+    offset: number;
+    /** Number of events in the overlap group */
+    overlaps: number;
+    /** Column index in the overlap group, 1-based */
+    column: number;
+}
+/** Event data with calculated position for day view */
+export interface DayPositionedEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventData<Payload> {
+    position: DayEventPositionData;
+}
+export interface WeekEventPositionData extends DayEventPositionData {
+    /** Week offset in %, represents event start position from the first day of the week (for regular events only) */
+    weekOffset?: number;
+    /** Row index for all-day events, used for vertical stacking */
+    row: number;
+    /** Indicates if the event hangs from the start, end, both or none of the week */
+    hanging: 'start' | 'end' | 'both' | 'none';
+}
+/** Event data with calculated position for week view */
+export interface WeekPositionedEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventData<Payload> {
+    position: WeekEventPositionData;
+}
+export interface MonthEventPositionData {
+    /** Start offset % from the start of the week (inset-inline-start) */
+    startOffset: number;
+    /** Event width in % */
+    width: number;
+    /** Week index in the month, 0-based */
+    weekIndex: number;
+    /** Event row index in the week, 0-based */
+    row: number;
+    /** Indicates if the event hangs from the start, end, both or none of the week */
+    hanging: 'start' | 'end' | 'both' | 'none';
+}
+/** Event data with calculated position for month view */
+export interface MonthPositionedEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventData<Payload> {
+    position: MonthEventPositionData;
+}
+export interface DropTarget {
+    /** Target date in YYYY-MM-DD format */
+    date: DateStringValue;
+    /** Target time in HH:mm:ss format (for DayView/WeekView) */
+    time?: string;
+    /** Target slot index (for DayView/WeekView) */
+    slotIndex?: number;
+}

package/lib/utils/calculate-drop-time/calculate-drop-time.d.ts

@@ -0,0 +1,22 @@
+import { AnyDateValue, ScheduleEventData } from '../../types';
+export interface CalculateDropTimeInput {
+    /** The event being dragged */
+    draggedEvent: ScheduleEventData;
+    /** Target date where event will be dropped */
+    targetDate: AnyDateValue;
+    /** Target time slot start time in HH:mm:ss format */
+    targetSlotTime: string;
+    /** Mouse Y position relative to the slot */
+    mouseYOffset?: number;
+    /** Height of one slot in pixels */
+    slotHeight?: number;
+    /** Minutes per slot */
+    intervalMinutes?: number;
+}
+export interface CalculateDropTimeResult {
+    /** New start date/time for the event */
+    start: Date;
+    /** New end date/time for the event */
+    end: Date;
+}
+export declare function calculateDropTime({ draggedEvent, targetDate, targetSlotTime, mouseYOffset, slotHeight, intervalMinutes, }: CalculateDropTimeInput): CalculateDropTimeResult;

package/lib/utils/calculate-month-drop-date/calculate-month-drop-date.d.ts

@@ -0,0 +1,14 @@
+import { DateStringValue, ScheduleEventData } from '../../types';
+export interface CalculateMonthDropDateInput {
+    /** The event being dragged */
+    draggedEvent: ScheduleEventData;
+    /** The target day where the event is being dropped */
+    targetDay: DateStringValue;
+}
+export interface CalculateMonthDropDateResult {
+    /** New start date for the event */
+    start: Date;
+    /** New end date for the event */
+    end: Date;
+}
+export declare function calculateMonthDropDate({ draggedEvent, targetDay, }: CalculateMonthDropDateInput): CalculateMonthDropDateResult;

package/lib/utils/clamp-interval-minutes/clamp-interval-minutes.d.ts

@@ -0,0 +1,2 @@
+/** Clamp interval minutes to valid values (1-60) and ensure it divides evenly into 60 */
+export declare function clampIntervalMinutes(intervalMinutes: number): number;

package/lib/utils/format-date/format-date.d.ts

@@ -0,0 +1,8 @@
+import dayjs from 'dayjs';
+import { DateLabelFormat } from '../../types';
+export interface FormatDateInput {
+    locale: string;
+    date: string | Date | dayjs.Dayjs;
+    format: DateLabelFormat;
+}
+export declare function formatDate({ locale, date, format }: FormatDateInput): string;

package/lib/utils/get-business-hours-mod/get-business-hours-mod.d.ts

@@ -0,0 +1,17 @@
+export interface GetBusinessHoursModInput {
+    time: string;
+    businessHours?: [string, string];
+    highlightBusinessHours?: boolean;
+}
+export interface BusinessHoursMod {
+    'business-hours': boolean;
+    'non-business-hours': boolean;
+}
+/**
+ * Determines if a given time is within business hours and returns modifier object
+ * @param time - Time string in HH:mm:ss format
+ * @param businessHours - Tuple of [start, end] times in HH:mm:ss format
+ * @param highlightBusinessHours - Whether to highlight business hours
+ * @returns Modifier object for styling business/non-business hours
+ */
+export declare function getBusinessHoursMod({ time, businessHours, highlightBusinessHours, }: GetBusinessHoursModInput): BusinessHoursMod;

package/lib/utils/get-current-time-position/get-current-time-position.d.ts

@@ -0,0 +1,6 @@
+interface GetCurrentTimePositionInput {
+    startTime?: string;
+    endTime?: string;
+}
+export declare function getCurrentTimePosition(input?: GetCurrentTimePositionInput): number;
+export {};

package/lib/utils/get-day-position/get-day-position.d.ts

@@ -0,0 +1,15 @@
+import { ScheduleEventData } from '../../types';
+interface GetDayPositionInput {
+    /** Event data to calculate position for */
+    event: ScheduleEventData;
+    /** Start time boundary for the day in HH:mm:ss format, `00:00:00` by default */
+    startTime?: string;
+    /** End time boundary for the day in HH:mm:ss format, `23:59:59` by default */
+    endTime?: string;
+}
+/** Calculates day position within given start and end time boundaries. Returns top and height in percentages. */
+export declare function getDayPosition({ event, startTime, endTime, }: GetDayPositionInput): {
+    top: number;
+    height: number;
+};
+export {};

package/lib/utils/get-day-time-intervals/get-day-time-intervals.d.ts

@@ -0,0 +1,19 @@
+export interface DayTimeInterval {
+    /** Start time of the interval in HH:mm:ss format */
+    startTime: string;
+    /** End time of the interval in HH:mm:ss format */
+    endTime: string;
+    /** Duration of the interval in seconds */
+    duration: number;
+    /** Indicates if the interval starts at the beginning of an hour */
+    isHourStart: boolean;
+}
+export interface GetDayTimeIntervalsInput {
+    /** Start time in HH:mm:ss format */
+    startTime: string;
+    /** End time in HH:mm:ss format, end of the day by default */
+    endTime?: string;
+    /** Interval in minutes, 60 by default */
+    intervalMinutes?: number;
+}
+export declare function getDayTimeIntervals({ startTime, endTime, intervalMinutes: _intervalMinutes, }: GetDayTimeIntervalsInput): DayTimeInterval[];

package/lib/utils/get-end-of-week/get-end-of-week.d.ts

@@ -0,0 +1,3 @@
+import dayjs from 'dayjs';
+import { AnyDateValue, DayOfWeek } from '../../types';
+export declare function getEndOfWeek(date: AnyDateValue, firstDayOfWeek?: DayOfWeek): string | dayjs.Dayjs;

package/lib/utils/get-month-days/get-month-days.d.ts

@@ -0,0 +1,8 @@
+import { AnyDateValue, DateStringValue, DayOfWeek } from '../../types';
+interface GetMonthDaysInput {
+    month: AnyDateValue;
+    firstDayOfWeek: DayOfWeek | undefined;
+    consistentWeeks: boolean | undefined;
+}
+export declare function getMonthDays({ month, firstDayOfWeek, consistentWeeks, }: GetMonthDaysInput): DateStringValue[][];
+export {};

package/lib/utils/get-month-range/get-month-range.d.ts

@@ -0,0 +1,13 @@
+import { AnyDateValue, DayOfWeek } from '../../types';
+interface GetMonthRangeInput {
+    month: AnyDateValue;
+    withOutsideDays: boolean | undefined;
+    consistentWeeks: boolean | undefined;
+    firstDayOfWeek: DayOfWeek;
+}
+/** Returns start and end dates as displayed in MonthView */
+export declare function getMonthRange({ month, withOutsideDays, consistentWeeks, firstDayOfWeek, }: GetMonthRangeInput): {
+    start: string;
+    end: string;
+};
+export {};

package/lib/utils/get-months-by-quarter/get-months-by-quarter.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue } from '../../types';
+export declare function getMonthsByQuarter(year: AnyDateValue): string[][];

package/lib/utils/get-months-list/get-months-list.d.ts

@@ -0,0 +1,11 @@
+import { DateLabelFormat } from '../../types';
+interface GetMonthsListInput {
+    locale: string;
+    format: DateLabelFormat;
+}
+interface MonthData {
+    month: number;
+    name: string;
+}
+export declare function getMonthsList({ locale, format }: GetMonthsListInput): MonthData[];
+export {};

package/lib/utils/get-start-of-week/get-start-of-week.d.ts

@@ -0,0 +1,7 @@
+import { AnyDateValue, DayOfWeek } from '../../types';
+interface GetStartOfWeekInput {
+    date: AnyDateValue;
+    firstDayOfWeek?: DayOfWeek;
+}
+export declare function getStartOfWeek({ date, firstDayOfWeek }: GetStartOfWeekInput): string;
+export {};

package/lib/utils/get-visible-events/get-visible-events.d.ts

@@ -0,0 +1,9 @@
+interface GetVisibleEventsInput {
+    maxEvents: number;
+    totalEvents: number;
+}
+export declare function getVisibleEvents({ maxEvents, totalEvents }: GetVisibleEventsInput): {
+    visibleEventsCount: number;
+    hiddenEventsCount: number;
+};
+export {};

package/lib/utils/get-week-days/get-week-days.d.ts

@@ -0,0 +1,13 @@
+import { AnyDateValue, DateStringValue, DayOfWeek } from '../../types';
+export interface GetWeekDaysInput {
+    /** Week to generate days for */
+    week: AnyDateValue;
+    /** Indices of weekend days, 0-6, where 0 is Sunday and 6 is Saturday. The default value is defined by `DatesProvider`. */
+    weekendDays?: DayOfWeek[];
+    /** If set to false, weekend days are hidden @default true */
+    withWeekendDays?: boolean;
+    /** Number 0-6, where 0 – Sunday and 6 – Saturday @default 1 */
+    firstDayOfWeek?: DayOfWeek;
+}
+/** Returns a list of days in a given week */
+export declare function getWeekDays({ week, weekendDays, withWeekendDays, firstDayOfWeek, }: GetWeekDaysInput): DateStringValue[];

package/lib/utils/get-week-number/get-week-number.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue } from '../../types';
+export declare function getWeekNumber(week: AnyDateValue | AnyDateValue[]): number;

package/lib/utils/get-weekdays-names/get-weekdays-names.d.ts

@@ -0,0 +1,8 @@
+import type { DateLabelFormat, DayOfWeek } from '../../types';
+interface GetWeekdaysNamesInput {
+    locale: string;
+    format?: DateLabelFormat;
+    firstDayOfWeek?: DayOfWeek;
+}
+export declare function getWeekdaysNames({ locale, format, firstDayOfWeek, }: GetWeekdaysNamesInput): import("react").ReactNode[];
+export {};

package/lib/utils/get-years-list/get-years-list.d.ts

@@ -0,0 +1,6 @@
+interface GetYearsListInput {
+    startYear: number;
+    endYear: number;
+}
+export declare function getYearsList({ startYear, endYear }: GetYearsListInput): number[];
+export {};

package/lib/utils/index.d.ts

@@ -0,0 +1,40 @@
+export { getWeekdaysNames } from './get-weekdays-names/get-weekdays-names';
+export { getStartOfWeek } from './get-start-of-week/get-start-of-week';
+export { getEndOfWeek } from './get-end-of-week/get-end-of-week';
+export { getWeekNumber } from './get-week-number/get-week-number';
+export { getMonthDays } from './get-month-days/get-month-days';
+export { isAfterMinDate } from './is-after-min-date/is-after-min-date';
+export { isBeforeMaxDate } from './is-before-max-date/is-before-max-date';
+export { isSameMonth } from './is-same-month/is-same-month';
+export { getMonthsByQuarter } from './get-months-by-quarter/get-months-by-quarter';
+export { getDayTimeIntervals } from './get-day-time-intervals/get-day-time-intervals';
+export { getWeekDays } from './get-week-days/get-week-days';
+export { getMonthsList } from './get-months-list/get-months-list';
+export { getYearsList } from './get-years-list/get-years-list';
+export { formatDate } from './format-date/format-date';
+export { toDateString } from './to-date-string/to-date-string';
+export { nextWeek } from './next-week/next-week';
+export { previousWeek } from './previous-week/previous-week';
+export { clampIntervalMinutes } from './clamp-interval-minutes/clamp-interval-minutes';
+export { getCurrentTimePosition } from './get-current-time-position/get-current-time-position';
+export { isInTimeRange } from './is-in-time-range/is-in-time-range';
+export { isAllDayEvent } from './is-all-day-event/is-all-day-event';
+export { validateEvent } from './validate-event/validate-event';
+export { sortEvents } from './sort-events/sort-events';
+export { isEventsOverlap } from './is-events-overlap/is-events-overlap';
+export { getVisibleEvents } from './get-visible-events/get-visible-events';
+export { isMultidayEvent } from './is-multiday-event/is-multiday-event';
+export { isEventInTimeRange } from './is-event-in-time-range/is-event-in-time-range';
+export { isWithinWeek } from './is-within-week/is-within-week';
+export { getMonthRange } from './get-month-range/get-month-range';
+export { parseTimeString } from './parse-time-string/parse-time-string';
+export { toTimeString } from './to-time-string/to-time-string';
+export { getDayPosition } from './get-day-position/get-day-position';
+export { calculateDropTime } from './calculate-drop-time/calculate-drop-time';
+export { calculateMonthDropDate } from './calculate-month-drop-date/calculate-month-drop-date';
+export { getBusinessHoursMod } from './get-business-hours-mod/get-business-hours-mod';
+export type { DayTimeInterval } from './get-day-time-intervals/get-day-time-intervals';
+export type { ParsedTime } from './parse-time-string/parse-time-string';
+export type { CalculateDropTimeInput, CalculateDropTimeResult, } from './calculate-drop-time/calculate-drop-time';
+export type { CalculateMonthDropDateInput, CalculateMonthDropDateResult, } from './calculate-month-drop-date/calculate-month-drop-date';
+export type { GetBusinessHoursModInput, BusinessHoursMod, } from './get-business-hours-mod/get-business-hours-mod';

package/lib/utils/is-after-min-date/is-after-min-date.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue } from '../../types';
+export declare function isAfterMinDate(date: AnyDateValue, minDate: AnyDateValue | undefined): boolean;

package/lib/utils/is-all-day-event/is-all-day-event.d.ts

@@ -0,0 +1,7 @@
+import { AnyDateValue, ScheduleEventData } from '../../types';
+interface IsAllDayEventInput {
+    event: ScheduleEventData;
+    date: AnyDateValue;
+}
+export declare function isAllDayEvent({ event, date }: IsAllDayEventInput): boolean;
+export {};

package/lib/utils/is-before-max-date/is-before-max-date.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue } from '../../types';
+export declare function isBeforeMaxDate(date: AnyDateValue, maxDate: AnyDateValue | undefined): boolean;

package/lib/utils/is-event-in-time-range/is-event-in-time-range.d.ts

@@ -0,0 +1,8 @@
+import { ScheduleEventData } from '../../types';
+interface IsEventInTimeRangeInput {
+    event: ScheduleEventData;
+    startTime?: string;
+    endTime?: string;
+}
+export declare function isEventInTimeRange({ event, startTime, endTime }: IsEventInTimeRangeInput): boolean;
+export {};

package/lib/utils/is-events-overlap/is-events-overlap.d.ts

@@ -0,0 +1,3 @@
+import { ScheduleEventData } from '../../types';
+/** Returns true if two events overlap in time */
+export declare function isEventsOverlap(event1: ScheduleEventData, event2: ScheduleEventData): boolean;

package/lib/utils/is-in-time-range/is-in-time-range.d.ts

@@ -0,0 +1,9 @@
+import { AnyDateValue } from '../../types';
+interface IsInTimeRangeInput {
+    date: AnyDateValue;
+    startTime?: string;
+    endTime?: string;
+}
+/** Returns true if the given date's time is within the specified time range */
+export declare function isInTimeRange({ date, startTime, endTime, }: IsInTimeRangeInput): boolean;
+export {};

package/lib/utils/is-multiday-event/is-multiday-event.d.ts

@@ -0,0 +1,2 @@
+import { ScheduleEventData } from '../../types';
+export declare function isMultidayEvent(event: ScheduleEventData): boolean;

package/lib/utils/is-same-month/is-same-month.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue } from '../../types';
+export declare function isSameMonth(date: AnyDateValue, comparison: AnyDateValue): boolean;

package/lib/utils/is-within-week/is-within-week.d.ts

@@ -0,0 +1,8 @@
+import { AnyDateValue, DayOfWeek, ScheduleEventData } from '../../types';
+interface IsWithinWeekInput {
+    event: ScheduleEventData;
+    targetWeek: AnyDateValue;
+    firstDayOfWeek: DayOfWeek;
+}
+export declare function isWithinWeek({ event, targetWeek, firstDayOfWeek }: IsWithinWeekInput): boolean;
+export {};

package/lib/utils/next-week/next-week.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue, DateStringValue, DayOfWeek } from '../../types';
+export declare function nextWeek(date: AnyDateValue, firstDayOfWeek: DayOfWeek): DateStringValue;

package/lib/utils/parse-time-string/parse-time-string.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedTime {
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+export declare function parseTimeString(time: string): ParsedTime;

package/lib/utils/previous-week/previous-week.d.ts

@@ -0,0 +1,2 @@
+import { AnyDateValue, DateStringValue, DayOfWeek } from '../../types';
+export declare function previousWeek(date: AnyDateValue, firstDayOfWeek: DayOfWeek): DateStringValue;