@mantine-vue/schedule 2.1.0

package/lib/components/shared.d.ts

@@ -0,0 +1,161 @@
+import dayjs from 'dayjs';
+import { type CSSProperties, type PropType, type VNodeChild } from 'vue';
+import type { BaseViewProps, EventDropData, NativeButtonProps, RenderEvent, RenderEventBody, TimeSlotClickData } from '../component-props';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../types';
+import type { BusinessHoursValue } from '../utils';
+export declare const baseViewProps: {
+    date: {
+        type: PropType<Date | DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: DateStringValue) => void>;
+    events: PropType<ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: ScheduleViewLevel) => void>;
+    previousControlProps: PropType<NativeButtonProps>;
+    nextControlProps: PropType<NativeButtonProps>;
+    todayControlProps: PropType<NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<RenderEventBody>;
+    renderEvent: PropType<RenderEvent>;
+    onEventClick: PropType<(event: ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export declare const timeViewProps: {
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    slotLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withCurrentTimeIndicator: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    withCurrentTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCurrentTime: PropType<() => AnyDateValue>;
+    slotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    highlightBusinessHours: BooleanConstructor;
+    businessHours: PropType<BusinessHoursValue>;
+    withEventsDragAndDrop: BooleanConstructor;
+    onEventDrop: PropType<(data: EventDropData) => void>;
+    canDragEvent: PropType<(event: ScheduleEventData) => boolean>;
+    onEventDragStart: PropType<(event: ScheduleEventData) => void>;
+    onEventDragEnd: PropType<() => void>;
+    onTimeSlotClick: PropType<(data: TimeSlotClickData) => void>;
+    onAllDaySlotClick: PropType<(date: DateStringValue, nativeEvent: MouseEvent) => void>;
+    withDragSlotSelect: BooleanConstructor;
+    onSlotDragEnd: FunctionConstructor;
+    startScrollTime: StringConstructor;
+    onExternalEventDrop: FunctionConstructor;
+    withEventResize: BooleanConstructor;
+    onEventResize: PropType<(data: EventDropData) => void>;
+    canResizeEvent: PropType<(event: ScheduleEventData) => boolean>;
+    date: {
+        type: PropType<Date | DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: DateStringValue) => void>;
+    events: PropType<ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: ScheduleViewLevel) => void>;
+    previousControlProps: PropType<NativeButtonProps>;
+    nextControlProps: PropType<NativeButtonProps>;
+    todayControlProps: PropType<NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<RenderEventBody>;
+    renderEvent: PropType<RenderEvent>;
+    onEventClick: PropType<(event: ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export declare function resolveScheduleRadius(radius: string | number | undefined): string | undefined;
+export declare function getExpandedEvents(events: ScheduleEventData[] | undefined, rangeStart: Date | string, rangeEnd: Date | string, expansionLimit: number): ScheduleEventData[];
+export declare function formatLabel(date: Date | string, locale: string | undefined, format: DateLabelFormat): string;
+/** Scoped slots that mirror the `renderEvent` / `renderEventBody` props. */
+export interface EventSlots {
+    eventBody?: (props: {
+        event: ScheduleEventData;
+    }) => VNodeChild;
+    event?: (props: Record<string, unknown> & {
+        event: ScheduleEventData;
+    }) => VNodeChild;
+}
+/**
+ * Build the slots object forwarded to a child component, omitting undefined entries.
+ * Returns a `Record<string, unknown>` (possibly empty) so it satisfies Vue's `RawSlots`
+ * type when passed as the third argument to `h()`.
+ */
+export declare function forwardEventSlots(slots: EventSlots | undefined): Record<string, unknown>;
+export declare function eventNode(event: ScheduleEventData, props: Pick<BaseViewProps, 'mode' | 'renderEvent' | 'renderEventBody' | 'onEventClick'> & {
+    withEventsDragAndDrop?: boolean;
+    canDragEvent?: (event: ScheduleEventData) => boolean;
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    onEventDragEnd?: () => void;
+}, extra?: Record<string, unknown>, slots?: EventSlots): VNodeChild;
+export declare function getDropEvent(events: ScheduleEventData[] | undefined, transfer: DataTransfer | null): ScheduleEventData | undefined;
+export declare function getTimeSlotDropTarget({ nativeEvent, container, intervals, date, }: {
+    nativeEvent: DragEvent;
+    container: HTMLElement;
+    intervals: Array<{
+        startTime: string;
+    }>;
+    date: string;
+}): {
+    slotIndex: number;
+    target: DateTimeStringValue;
+} | undefined;
+export declare function moveEventTo(event: ScheduleEventData, newStart: dayjs.ConfigType): {
+    eventId: string | number;
+    newStart: DateTimeStringValue;
+    newEnd: DateTimeStringValue;
+    event: ScheduleEventData;
+};
+export declare function moveEventToAllDay(event: ScheduleEventData, date: dayjs.ConfigType): {
+    eventId: string | number;
+    newStart: DateTimeStringValue;
+    newEnd: DateTimeStringValue;
+    event: ScheduleEventData;
+};
+export declare function todayString(): string;

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

@@ -0,0 +1,28 @@
+import { type Ref } from 'vue';
+interface SelectedRange {
+    group: string;
+    start: number;
+    end: number;
+}
+export interface UseSlotDragSelectInput {
+    /** Whether slot drag selection is enabled */
+    enabled: () => boolean;
+    /** Called with the selected range once a multi-slot drag finishes */
+    onDragEnd?: () => ((startIndex: number, endIndex: number, group: string) => void) | undefined;
+}
+export interface SlotDragSelect {
+    /** Begin a slot selection at the given index/group */
+    handleSlotPointerDown: (event: PointerEvent, index: number, group: string) => void;
+    /** Whether the slot at index within group is currently selected */
+    isSlotSelected: (index: number, group: string) => boolean;
+    /** Whether a slot drag selection is currently in progress */
+    isDragging: () => boolean;
+}
+/**
+ * Composable that provides unified slot drag-selection for Day, Week and Month views.
+ * tracks a selected range as the pointer
+ * moves across elements carrying `data-drag-slot-index` / `data-drag-slot-group`.
+ */
+export declare function useSlotDragSelect(input: UseSlotDragSelectInput): SlotDragSelect;
+export type SelectedRangeRef = Ref<SelectedRange | null>;
+export {};

package/lib/hooks/use-event-resize.d.ts

@@ -0,0 +1,31 @@
+import type { EventDropData } from '../component-props';
+import type { ScheduleEventData, ScheduleMode } from '../types';
+type ResizeEdge = 'top' | 'bottom';
+interface HandleResizeStartInput {
+    event: ScheduleEventData;
+    edge: ResizeEdge;
+    container: HTMLElement;
+    originalTop: number;
+    originalHeight: number;
+    eventDate: string;
+    pointerEvent: PointerEvent;
+}
+export interface UseEventResizeInput {
+    enabled: () => boolean;
+    mode: () => ScheduleMode;
+    startTime: () => string;
+    endTime: () => string;
+    intervalMinutes: () => number;
+    onEventResize: () => ((data: EventDropData) => void) | undefined;
+    canResizeEvent: () => ((event: ScheduleEventData) => boolean) | undefined;
+}
+export declare function useEventResize(input: UseEventResizeInput): {
+    handleResizeStart: ({ event, edge, container, originalTop, originalHeight, eventDate, pointerEvent, }: HandleResizeStartInput) => void;
+    getResizePosition: (eventId: string | number) => {
+        top: number;
+        height: number;
+    } | null;
+    isResizableEvent: (event: ScheduleEventData) => boolean;
+    wasResizing: () => 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,25 @@
+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;
+    noEvents: 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,141 @@
+import dayjs from 'dayjs';
+import type { MantineColor } from '@mantine-vue/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, unknown>;
+/** RFC 5545 recurrence data */
+export interface ScheduleRecurrenceData {
+    /** Recurrence rule string, for example: `FREQ=WEEKLY;BYDAY=MO,WE` */
+    rrule: string;
+    /** Exception datetimes in `YYYY-MM-DD HH:mm:ss` or valid date string format */
+    exdate?: DateTimeStringValue[];
+    /** Optional explicit series start datetime */
+    dtstart?: DateTimeStringValue;
+}
+/** Metadata attached to generated recurring instances */
+export interface RecurringInstanceMeta {
+    /** If true, event is generated from recurrence rule */
+    isRecurringInstance: boolean;
+    /** Parent series event id */
+    recurringEventId: string | number;
+    /** Original occurrence datetime key */
+    recurrenceId: DateTimeStringValue;
+    /** Original occurrence dates before any drag/drop updates */
+    originalStart: DateTimeStringValue;
+    originalEnd: DateTimeStringValue;
+}
+interface ScheduleEventBase<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';
+    /** Event display mode. Background events render as full-width, non-interactive blocks behind regular events. @default 'default' */
+    display?: 'default' | 'background';
+    /** Additional event data, defined by the user, not used internally by the library */
+    payload?: Payload;
+}
+/** One-off event without recurrence */
+export interface ScheduleSingleEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventBase<Payload> {
+    recurrence?: never;
+    recurringEventId?: never;
+    recurrenceId?: never;
+}
+/** Recurring series source event */
+export interface ScheduleRecurringSeriesEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventBase<Payload> {
+    /** Recurrence definition for the event series */
+    recurrence: ScheduleRecurrenceData;
+    recurringEventId?: never;
+    recurrenceId?: never;
+}
+/** Override for one specific recurring occurrence */
+export interface ScheduleRecurringOverrideEventData<Payload extends EventPayload = EventPayload> extends ScheduleEventBase<Payload> {
+    recurrence?: never;
+    /** Parent recurring series id */
+    recurringEventId: string | number;
+    /** Occurrence id (`YYYY-MM-DD HH:mm:ss`) */
+    recurrenceId: DateTimeStringValue;
+}
+interface ScheduleEventRuntimeMeta {
+    /** Metadata for generated recurring instances */
+    recurringInstance?: RecurringInstanceMeta;
+}
+/** Event data object passed to all `@mantine/schedule` components */
+export type ScheduleEventData<Payload extends EventPayload = EventPayload> = (ScheduleSingleEventData<Payload> & ScheduleEventRuntimeMeta) | (ScheduleRecurringSeriesEventData<Payload> & ScheduleEventRuntimeMeta) | (ScheduleRecurringOverrideEventData<Payload> & ScheduleEventRuntimeMeta);
+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 type DayPositionedEventData<Payload extends EventPayload = EventPayload> = 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 type WeekPositionedEventData<Payload extends EventPayload = EventPayload> = 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 type MonthPositionedEventData<Payload extends EventPayload = EventPayload> = 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;
+}
+export {};

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/expand-recurring-events/expand-recurring-events.d.ts

@@ -0,0 +1,10 @@
+import { ScheduleEventData } from '../../types';
+interface ExpandRecurringEventsInput {
+    events: ScheduleEventData[] | undefined;
+    rangeStart: Date | string;
+    rangeEnd: Date | string;
+    expansionLimit?: number;
+}
+declare const DEFAULT_EXPANSION_LIMIT = 2000;
+export declare function expandRecurringEvents({ events, rangeStart, rangeEnd, expansionLimit, }: ExpandRecurringEventsInput): ScheduleEventData[];
+export { DEFAULT_EXPANSION_LIMIT };

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,26 @@
+import { DayOfWeek } from '../../types';
+/** Business hours range in `HH:mm:ss` format */
+export type BusinessHoursRange = [string, string];
+/** Per-day business hours map keyed by day of the week (0 – Sunday, 6 – Saturday). `null` marks a day as fully outside business hours. */
+export type BusinessHoursPerDay = Partial<Record<DayOfWeek, BusinessHoursRange | null>>;
+/** Business hours value – tuple applies to every day, record configures business hours per day */
+export type BusinessHoursValue = BusinessHoursRange | BusinessHoursPerDay;
+export interface GetBusinessHoursModInput {
+    time: string;
+    businessHours?: BusinessHoursValue;
+    highlightBusinessHours?: boolean;
+    dayOfWeek?: DayOfWeek;
+}
+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, or per-day record keyed by day of the week
+ * @param highlightBusinessHours - Whether to highlight business hours
+ * @param dayOfWeek - Day of the week (0 – Sunday, 6 – Saturday), used to resolve per-day business hours
+ * @returns Modifier object for styling business/non-business hours
+ */
+export declare function getBusinessHoursMod({ time, businessHours, highlightBusinessHours, dayOfWeek, }: GetBusinessHoursModInput): BusinessHoursMod;

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

@@ -0,0 +1,10 @@
+import { AnyDateValue } from '../../types';
+interface GetCurrentTimePositionInput {
+    startTime?: string;
+    endTime?: string;
+    now?: AnyDateValue;
+    /** Number of minutes per time slot. Used to align the indicator to whole slots when `endTime` does not divide evenly. */
+    intervalMinutes?: number;
+}
+export declare function getCurrentTimePosition(input?: GetCurrentTimePositionInput): number;
+export {};

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

@@ -0,0 +1,17 @@
+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;
+    /** Number of minutes per time slot, `60` by default. Used to align the canvas to whole slots when `endTime` does not divide evenly. */
+    intervalMinutes?: number;
+}
+/** Calculates day position within given start and end time boundaries. Returns top and height in percentages. */
+export declare function getDayPosition({ event, startTime, endTime, intervalMinutes, }: 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;