@mantine/schedule 9.0.0-alpha.0

package/lib/components/DragContext/DragContext.d.ts

@@ -0,0 +1,18 @@
+import { DropTarget, ScheduleEventData } from '../../types';
+export interface DragContextValue {
+    /** 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;
+    /** Called when drag starts */
+    onDragStart?: (event: ScheduleEventData) => void;
+    /** Called when drag ends */
+    onDragEnd?: () => void;
+    /** Set the current drop target */
+    setDropTarget?: (target: DropTarget | null) => void;
+}
+export declare const DragContext: import("react").Context<DragContextValue>;

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

@@ -0,0 +1,2 @@
+export { DragContext } from './DragContext';
+export type { DragContextValue } from './DragContext';

package/lib/components/MobileMonthView/MobileMonthView.d.ts

@@ -0,0 +1,94 @@
+import React from 'react';
+import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
+import { ScheduleLabelsOverride } from '../../labels';
+import { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleMode } from '../../types';
+import { RenderEvent } from '../ScheduleEvent/ScheduleEvent';
+export type MobileMonthViewStylesNames = 'mobileMonthView' | 'mobileMonthViewHeader' | 'mobileMonthViewHeaderBackButton' | 'mobileMonthViewHeaderLabel' | 'mobileMonthViewCalendar' | 'mobileMonthViewWeekdays' | 'mobileMonthViewWeekday' | 'mobileMonthViewWeekdaysCorner' | 'mobileMonthViewWeek' | 'mobileMonthViewWeekNumber' | 'mobileMonthViewDay' | 'mobileMonthViewDayIndicators' | 'mobileMonthViewDayIndicator' | 'mobileMonthViewEventsList' | 'mobileMonthViewEventsHeader' | 'mobileMonthViewEvent' | 'mobileMonthViewEventColor' | 'mobileMonthViewEventBody' | 'mobileMonthViewEventTitle' | 'mobileMonthViewEventTime' | 'mobileMonthViewNoEvents';
+export type MobileMonthViewCssVariables = {
+    mobileMonthView: '--mobile-month-view-radius';
+};
+export interface MobileMonthViewRenderHeaderInput {
+    /** Current interaction mode */
+    mode: ScheduleMode;
+    /** Current date displayed in the view */
+    date: Date | string;
+    /** Default header element */
+    defaultHeader: React.ReactNode;
+}
+export interface MobileMonthViewProps extends BoxProps, StylesApiProps<MobileMonthViewFactory>, ElementProps<'div'> {
+    __staticSelector?: string;
+    /** Date to display, Date object or date string in `YYYY-MM-DD 00:00:00` format */
+    date: Date | string;
+    /** Called with the new date value when a date is selected */
+    onDateChange?: (value: DateStringValue) => void;
+    /** Currently selected date (controlled) */
+    selectedDate?: Date | string | null;
+    /** Default selected date (uncontrolled) */
+    defaultSelectedDate?: Date | string | null;
+    /** Called when selected date changes */
+    onSelectedDateChange?: (value: DateStringValue | null) => void;
+    /** If set, week numbers are displayed in the first column @default false */
+    withWeekNumbers?: boolean;
+    /** If set, weekdays names are displayed in the first row @default true */
+    withWeekDays?: boolean;
+    /** Locale passed down to dayjs, overrides value defined on `DatesProvider` */
+    locale?: string;
+    /** Number 0-6, where 0 – Sunday and 6 – Saturday. @default 1 – Monday */
+    firstDayOfWeek?: DayOfWeek;
+    /** `dayjs` format for weekdays names. By default, the first letter of the weekday. */
+    weekdayFormat?: DateLabelFormat;
+    /** Indices of weekend days, 0-6, where 0 is Sunday and 6 is Saturday. The default value is defined by `DatesProvider`. */
+    weekendDays?: DayOfWeek[];
+    /** Props passed down to the week number button */
+    getWeekNumberProps?: (weekStartDate: DateStringValue) => Record<string, any>;
+    /** Props passed down to the day button */
+    getDayProps?: (date: DateStringValue) => Record<string, any>;
+    /** Called when day is clicked */
+    onDayClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Called with first day of the week when week number is clicked */
+    onWeekNumberClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** If set, always renders 6 weeks in the month view @default true */
+    consistentWeeks?: boolean;
+    /** If set, highlights the current day @default true */
+    highlightToday?: boolean;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default theme.defaultRadius */
+    radius?: MantineRadius;
+    /** If set, days from the previous and next months are displayed to fill the weeks @default false */
+    withOutsideDays?: boolean;
+    /** Events to display */
+    events?: ScheduleEventData[];
+    /** Labels override for i18n */
+    labels?: ScheduleLabelsOverride;
+    /** Interaction mode: 'default' allows all interactions, 'static' disables event interactions @default 'default' */
+    mode?: ScheduleMode;
+    /** Function to fully customize event rendering, receives all props that would be passed to the root element including children */
+    renderEvent?: RenderEvent;
+    /** Format for the events list header date @default 'dddd, MMMM D' */
+    eventsHeaderFormat?: DateLabelFormat;
+    /** Placeholder text when no events for selected date @default 'No events' */
+    noEventsText?: string;
+    /** Called when the year back button in the header is clicked */
+    onYearClick?: () => void;
+    /** Called when event is clicked */
+    onEventClick?: (event: ScheduleEventData, e: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Custom header renderer, receives object with mode, date, and default header element */
+    renderHeader?: (input: MobileMonthViewRenderHeaderInput) => React.ReactNode;
+}
+export type MobileMonthViewFactory = Factory<{
+    props: MobileMonthViewProps;
+    ref: HTMLDivElement;
+    stylesNames: MobileMonthViewStylesNames;
+    vars: MobileMonthViewCssVariables;
+}>;
+export declare const MobileMonthView: import("@mantine/core").MantineComponent<{
+    props: MobileMonthViewProps;
+    ref: HTMLDivElement;
+    stylesNames: MobileMonthViewStylesNames;
+    vars: MobileMonthViewCssVariables;
+}>;
+export declare namespace MobileMonthView {
+    type Props = MobileMonthViewProps;
+    type Factory = MobileMonthViewFactory;
+    type StylesNames = MobileMonthViewStylesNames;
+    type CssVariables = MobileMonthViewCssVariables;
+}

package/lib/components/MobileMonthView/get-mobile-month-view-events.d.ts

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

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

@@ -0,0 +1,2 @@
+export { MobileMonthView } from './MobileMonthView';
+export type { MobileMonthViewProps, MobileMonthViewFactory, MobileMonthViewStylesNames, MobileMonthViewCssVariables, MobileMonthViewRenderHeaderInput, } from './MobileMonthView';

package/lib/components/MonthView/MonthView.d.ts

@@ -0,0 +1,103 @@
+import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaProps, StylesApiProps } from '@mantine/core';
+import { ScheduleLabelsOverride } from '../../labels';
+import { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { MoreEventsProps } from '../MoreEvents/MoreEvents';
+import { RenderEvent, RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
+import { MonthYearSelectProps } from '../ScheduleHeader/MonthYearSelect/MonthYearSelect';
+import { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader';
+import { ViewSelectProps } from '../ScheduleHeader/ViewSelect/ViewSelect';
+export type MonthViewStylesNames = 'monthView' | 'monthViewScrollArea' | 'monthViewInner' | 'monthViewWeek' | 'monthViewDay' | 'monthViewDayLabel' | 'monthViewWeekNumber' | 'monthViewWeekday' | 'monthViewWeekdays' | 'monthViewWeekdaysCorner' | 'monthViewEvents' | CombinedScheduleHeaderStylesNames;
+export type MonthViewCssVariables = {
+    monthView: '--month-view-radius';
+};
+export interface MonthViewProps extends BoxProps, StylesApiProps<MonthViewFactory>, ElementProps<'div'> {
+    __staticSelector?: string;
+    /** Date to display, Date object or date string in `YYYY-MM-DD 00:00:00` format */
+    date: Date | string;
+    /** Called with the new date value when a date is selected */
+    onDateChange?: (value: DateStringValue) => void;
+    /** If set, week numbers are displayed in the first column @default false */
+    withWeekNumbers?: boolean;
+    /** If set, weekdays names are displayed in the first row @default true */
+    withWeekDays?: boolean;
+    /** Locale passed down to dayjs, overrides value defined on `DatesProvider` */
+    locale?: string;
+    /** Number 0-6, where 0 – Sunday and 6 – Saturday. @default 1 – Monday */
+    firstDayOfWeek?: DayOfWeek;
+    /** `dayjs` format for weekdays names. By default, the first letter of the weekday. */
+    weekdayFormat?: DateLabelFormat;
+    /** Indices of weekend days, 0-6, where 0 is Sunday and 6 is Saturday. The default value is defined by `DatesProvider`. */
+    weekendDays?: DayOfWeek[];
+    /** Props passed down to the week number button */
+    getWeekNumberProps?: (weekStartDate: DateStringValue) => Record<string, any>;
+    /** Props passed down to the day button */
+    getDayProps?: (date: DateStringValue) => Record<string, any>;
+    /** Called when day is clicked */
+    onDayClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Called with first day of the week when week number is clicked */
+    onWeekNumberClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** If set, always renders 6 weeks in the month view @default true */
+    consistentWeeks?: boolean;
+    /** If set, highlights the current day @default true */
+    highlightToday?: boolean;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default theme.defaultRadius */
+    radius?: MantineRadius;
+    /** If set, days from the previous and next months are displayed to fill the weeks @default true */
+    withOutsideDays?: boolean;
+    /** If set, the header is displayed @default true */
+    withHeader?: boolean;
+    /** Props passed down to `MonthYearSelect` component in the header */
+    monthYearSelectProps?: Partial<MonthYearSelectProps>;
+    /** Called when view level select button is clicked */
+    onViewChange?: (view: ScheduleViewLevel) => void;
+    /** Props passed to previous month control */
+    previousControlProps?: React.ComponentProps<'button'> & DataAttributes;
+    /** Props passed to next month control */
+    nextControlProps?: React.ComponentProps<'button'> & DataAttributes;
+    /** Props passed to today control */
+    todayControlProps?: React.ComponentProps<'button'> & DataAttributes;
+    /** Props passed to view level select */
+    viewSelectProps?: Partial<ViewSelectProps> & DataAttributes;
+    /** Events to display */
+    events?: ScheduleEventData[];
+    /** Props passed down to `MoreEvents` component */
+    moreEventsProps?: Partial<MoreEventsProps>;
+    /** Function to customize event body, `event` object is passed as first argument */
+    renderEventBody?: RenderEventBody;
+    /** Function to fully customize event rendering, receives all props that would be passed to the root element including children */
+    renderEvent?: RenderEvent;
+    /** If true, events can be dragged and dropped @default false */
+    withEventsDragAndDrop?: boolean;
+    /** Called when event is dropped on new date */
+    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;
+    /** Called when event is clicked */
+    onEventClick?: (event: ScheduleEventData, e: React.MouseEvent<HTMLButtonElement>) => void;
+    /** If set, enables drag-to-select day ranges @default false */
+    withDragSlotSelect?: boolean;
+    /** Called when a day range is selected by dragging */
+    onSlotDragEnd?: (rangeStart: DateTimeStringValue, rangeEnd: DateTimeStringValue) => void;
+    /** Labels override for i18n */
+    labels?: ScheduleLabelsOverride;
+    /** Interaction mode: 'default' allows all interactions, 'static' disables event interactions @default default */
+    mode?: ScheduleMode;
+    /** Props passed down to `ScrollArea` component */
+    scrollAreaProps?: Partial<ScrollAreaProps> & DataAttributes;
+}
+export type MonthViewFactory = Factory<{
+    props: MonthViewProps;
+    ref: HTMLDivElement;
+    stylesNames: MonthViewStylesNames;
+    vars: MonthViewCssVariables;
+}>;
+export declare const MonthView: import("@mantine/core").MantineComponent<{
+    props: MonthViewProps;
+    ref: HTMLDivElement;
+    stylesNames: MonthViewStylesNames;
+    vars: MonthViewCssVariables;
+}>;

package/lib/components/MonthView/get-month-view-events/add-event-to-day-groups.d.ts

@@ -0,0 +1,14 @@
+import dayjs from 'dayjs';
+import { MonthPositionedEventData } from '../../../types';
+interface AddEventToDayGroupsInput {
+    positionedEvent: MonthPositionedEventData;
+    eventStart: dayjs.Dayjs;
+    eventEnd: dayjs.Dayjs;
+    groupedByDay: {
+        [date: string]: MonthPositionedEventData[];
+    };
+    eventsAddedToDay: Set<string>;
+    weekIdx: number;
+}
+export declare function addEventToDayGroups({ positionedEvent, eventStart, eventEnd, groupedByDay, eventsAddedToDay, weekIdx, }: AddEventToDayGroupsInput): void;
+export {};

package/lib/components/MonthView/get-month-view-events/calculate-event-position-in-week.d.ts

@@ -0,0 +1,18 @@
+import dayjs from 'dayjs';
+export type HangingStatus = 'none' | 'start' | 'end' | 'both';
+interface CalculateEventPositionInput {
+    eventStart: dayjs.Dayjs;
+    eventEnd: dayjs.Dayjs;
+    weekStart: dayjs.Dayjs;
+    weekEnd: dayjs.Dayjs;
+    isMultiday: boolean;
+}
+interface EventPositionInWeek {
+    startDayIndex: number;
+    daysSpanned: number;
+    startOffset: number;
+    width: number;
+    hanging: HangingStatus;
+}
+export declare function calculateEventPositionInWeek({ eventStart, eventEnd, weekStart, weekEnd, isMultiday, }: CalculateEventPositionInput): EventPositionInWeek;
+export {};

package/lib/components/MonthView/get-month-view-events/find-available-row.d.ts

@@ -0,0 +1,10 @@
+import dayjs from 'dayjs';
+import { MonthPositionedEventData } from '../../../types';
+interface FindAvailableRowInput {
+    existingEvents: MonthPositionedEventData[];
+    startDayIndex: number;
+    daysSpanned: number;
+    weekStart: dayjs.Dayjs;
+}
+export declare function findAvailableRow({ existingEvents, startDayIndex, daysSpanned, weekStart, }: FindAvailableRowInput): number;
+export {};

package/lib/components/MonthView/get-month-view-events/get-month-positioned-events.d.ts

@@ -0,0 +1,27 @@
+import { AnyDateValue, DateStringValue, DayOfWeek, MonthPositionedEventData, ScheduleEventData } from '../../../types';
+interface GetMonthPositionedEventsInput {
+    /** Date (month start) at which events are positioned */
+    date: AnyDateValue;
+    /** List of all events that belong to the given month, extra events must be filtered out before passing to the function */
+    events: ScheduleEventData[];
+    /** First day of the week, 0 - Sunday, 1 - Monday, etc., used to calculate events positions */
+    firstDayOfWeek?: DayOfWeek;
+    /** Range of dates for which events should be displayed (includes outside days if withOutsideDays is true) */
+    range?: {
+        start: DateStringValue;
+        end: DateStringValue;
+    };
+}
+/** Events grouped by week index and by day */
+export interface GroupedMonthEvents {
+    /** Events grouped by week index (index within month) */
+    groupedByWeek: {
+        [weekIndex: string]: MonthPositionedEventData[];
+    };
+    /** Events grouped by day (YYYY-MM-DD format) */
+    groupedByDay: {
+        [date: string]: MonthPositionedEventData[];
+    };
+}
+export declare function getMonthPositionedEvents({ date, events, firstDayOfWeek, range, }: GetMonthPositionedEventsInput): GroupedMonthEvents;
+export {};

package/lib/components/MonthView/get-month-view-events/get-month-view-events.d.ts

@@ -0,0 +1,16 @@
+import { AnyDateValue, DayOfWeek, ScheduleEventData } from '../../../types';
+import { GroupedMonthEvents } from './get-month-positioned-events';
+interface UseMonthViewEventsInput {
+    /** Date (month start) at which events are positioned */
+    date: AnyDateValue;
+    /** List of all events that belong to the given month, extra events must be filtered out before passing to the function */
+    events: ScheduleEventData[] | undefined;
+    /** First day of the week, 0 - Sunday, 1 - Monday, etc., used to calculate events positions */
+    firstDayOfWeek?: DayOfWeek;
+    /** If true, events for outside days are included */
+    withOutsideDays?: boolean;
+    /** If true, month will show events for consistent number of weeks (6) */
+    consistentWeeks?: boolean;
+}
+export declare function getMonthViewEvents({ date, events, firstDayOfWeek, withOutsideDays, consistentWeeks, }: UseMonthViewEventsInput): GroupedMonthEvents;
+export {};

package/lib/components/MonthView/get-month-view-events/get-weeks-in-range.d.ts

@@ -0,0 +1,15 @@
+import dayjs from 'dayjs';
+import { DateStringValue, DayOfWeek } from '../../../types';
+interface GetWeeksInRangeInput {
+    rangeStart: dayjs.Dayjs;
+    rangeEnd: dayjs.Dayjs;
+    firstDayOfWeek: DayOfWeek;
+}
+interface GetWeeksInRangeOutput {
+    weeks: DateStringValue[][];
+    groupedByDay: {
+        [date: string]: any[];
+    };
+}
+export declare function getWeeksInRange({ rangeStart, rangeEnd, firstDayOfWeek, }: GetWeeksInRangeInput): GetWeeksInRangeOutput;
+export {};

package/lib/components/MonthView/handle-month-view-key-down.d.ts

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

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

@@ -0,0 +1,9 @@
+import type { MonthViewCssVariables, MonthViewFactory, MonthViewProps, MonthViewStylesNames } from './MonthView';
+export { MonthView } from './MonthView';
+export type { MonthViewProps, MonthViewFactory, MonthViewStylesNames, MonthViewCssVariables };
+export declare namespace MonthView {
+    type Props = MonthViewProps;
+    type Factory = MonthViewFactory;
+    type StylesNames = MonthViewStylesNames;
+    type CssVariables = MonthViewCssVariables;
+}

package/lib/components/MoreEvents/MoreEvents.d.ts

@@ -0,0 +1,40 @@
+import { BoxProps, ElementProps, Factory, MantineRadius, ModalProps, PopoverProps, StylesApiProps } from '@mantine/core';
+import { ScheduleLabelsOverride } from '../../labels';
+import { ScheduleEventData, ScheduleMode } from '../../types';
+import { RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
+export type MoreEventsDropdownType = 'popover' | 'modal';
+export type MoreEventsStylesNames = 'moreEventsButton' | 'moreEventsList' | 'moreEventsDropdown';
+export interface MoreEventsProps extends BoxProps, StylesApiProps<MoreEventsFactory>, ElementProps<'button'> {
+    /** List of events to display */
+    events: ScheduleEventData[];
+    /** Events count to use for `+X more` label */
+    moreEventsCount: number;
+    /** Key of `theme.radius` or any valid CSS value to set border-radius @default theme.defaultRadius */
+    radius?: MantineRadius;
+    /** Title for the Modal component, ignored if `dropdownType` is not 'modal' */
+    modalTitle?: string;
+    /** Type of dropdown to use for displaying more events @default 'popover' */
+    dropdownType?: MoreEventsDropdownType;
+    /** Props passed down to `Popover` component */
+    popoverProps?: Partial<Omit<PopoverProps, 'children'>>;
+    /** Props passed down to `Modal` component */
+    modalProps?: Partial<Omit<ModalProps, 'children'>>;
+    /** Called when the dropdown is closed */
+    onDropdownClose?: () => void;
+    /** Function to customize event body, `event` object is passed as first argument */
+    renderEventBody?: RenderEventBody;
+    /** Labels override */
+    labels?: ScheduleLabelsOverride;
+    /** Interaction mode: 'default' allows all interactions, 'static' disables event interactions @default default */
+    mode?: ScheduleMode;
+}
+export type MoreEventsFactory = Factory<{
+    props: MoreEventsProps;
+    ref: HTMLButtonElement;
+    stylesNames: MoreEventsStylesNames;
+}>;
+export declare const MoreEvents: import("@mantine/core").MantineComponent<{
+    props: MoreEventsProps;
+    ref: HTMLButtonElement;
+    stylesNames: MoreEventsStylesNames;
+}>;

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

@@ -0,0 +1,2 @@
+export { MoreEvents } from './MoreEvents';
+export type { MoreEventsProps, MoreEventsFactory, MoreEventsStylesNames, MoreEventsDropdownType, } from './MoreEvents';

package/lib/components/Schedule/Schedule.d.ts

@@ -0,0 +1,97 @@
+import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
+import { ScheduleLabelsOverride } from '../../labels';
+import { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { DayViewProps, DayViewStylesNames } from '../DayView/DayView';
+import { MobileMonthViewProps, MobileMonthViewStylesNames } from '../MobileMonthView/MobileMonthView';
+import { MonthViewProps, MonthViewStylesNames } from '../MonthView/MonthView';
+import { RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
+import { WeekViewProps, WeekViewStylesNames } from '../WeekView/WeekView';
+import { YearViewProps, YearViewStylesNames } from '../YearView/YearView';
+export type ScheduleStylesNames = 'root' | 'desktopView' | 'mobileView' | DayViewStylesNames | WeekViewStylesNames | MonthViewStylesNames | YearViewStylesNames | MobileMonthViewStylesNames;
+export type ScheduleLayout = 'default' | 'responsive';
+type ScheduleCommonProps = 'date' | 'onDateChange' | 'events' | 'locale' | 'radius' | 'labels' | 'renderEventBody' | 'withEventsDragAndDrop' | 'onEventDrop' | 'canDragEvent' | 'onEventDragStart' | 'onEventDragEnd' | 'onTimeSlotClick' | 'onAllDaySlotClick' | 'onEventClick' | 'onDayClick' | 'onMonthClick' | 'withDragSlotSelect' | 'onSlotDragEnd' | 'view' | 'onViewChange' | 'mode';
+type ScheduleViewProps<T> = Partial<Omit<T, ScheduleCommonProps>>;
+export interface ScheduleProps extends BoxProps, StylesApiProps<ScheduleFactory>, ElementProps<'div'> {
+    __staticSelector?: string;
+    /** Current date to display (controlled) */
+    date?: Date | DateStringValue;
+    /** Default date (uncontrolled) */
+    defaultDate?: Date | DateStringValue;
+    /** Called when date changes via navigation */
+    onDateChange?: (date: DateStringValue) => void;
+    /** Current view level (controlled) */
+    view?: ScheduleViewLevel;
+    /** Default view level (uncontrolled) */
+    defaultView?: ScheduleViewLevel;
+    /** Called when view level changes */
+    onViewChange?: (view: ScheduleViewLevel) => void;
+    /** Events to display across all views */
+    events?: ScheduleEventData[];
+    /** Locale for date formatting (overrides `DatesProvider`) */
+    locale?: string;
+    /** Key of theme.radius or any valid CSS value to set border-radius */
+    radius?: MantineRadius;
+    /** Labels override for i18n */
+    labels?: ScheduleLabelsOverride;
+    /** Custom event body renderer */
+    renderEventBody?: RenderEventBody;
+    /** Enable drag and drop for events @default false */
+    withEventsDragAndDrop?: boolean;
+    /** Called when event is dropped */
+    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;
+    /** Called when time slot is clicked in DayView/WeekView */
+    onTimeSlotClick?: (slotStart: DateTimeStringValue, slotEnd: DateTimeStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Called when all-day slot is clicked in DayView/WeekView */
+    onAllDaySlotClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Called when day is clicked in MonthView */
+    onDayClick?: (date: DateStringValue, event: React.MouseEvent<HTMLButtonElement>) => void;
+    /** If set, enables drag-to-select slot ranges @default false */
+    withDragSlotSelect?: boolean;
+    /** Called when a slot range is selected by dragging */
+    onSlotDragEnd?: (rangeStart: DateTimeStringValue, rangeEnd: DateTimeStringValue) => void;
+    /** Called when event is clicked in any view */
+    onEventClick?: (event: ScheduleEventData, e: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Interaction mode:
+     * - `'default'` allows all interactions
+     * - `'static'` disables event interactions
+     * @default 'default' */
+    mode?: ScheduleMode;
+    /** Layout mode:
+     * - `'default'` uses same views on all screen sizes
+     * - `'responsive'` switches to YearView/MobileMonthView on small screens
+     * @default 'default' */
+    layout?: ScheduleLayout;
+    /** Props specific to DayView (includes `startTime`, `endTime`, `intervalMinutes`, etc.) */
+    dayViewProps?: ScheduleViewProps<DayViewProps>;
+    /** Props specific to WeekView (includes `startTime`, `endTime`, `intervalMinutes`, etc.) */
+    weekViewProps?: ScheduleViewProps<WeekViewProps>;
+    /** Props specific to MonthView (includes `firstDayOfWeek`, `weekendDays`, etc.) */
+    monthViewProps?: ScheduleViewProps<MonthViewProps>;
+    /** Props specific to YearView (includes `firstDayOfWeek`, `weekendDays`, etc.) */
+    yearViewProps?: ScheduleViewProps<YearViewProps>;
+    /** Props specific to MobileMonthView (used in responsive layout) */
+    mobileMonthViewProps?: ScheduleViewProps<MobileMonthViewProps>;
+}
+export type ScheduleFactory = Factory<{
+    props: ScheduleProps;
+    ref: HTMLDivElement;
+    stylesNames: ScheduleStylesNames;
+}>;
+export declare const Schedule: import("@mantine/core").MantineComponent<{
+    props: ScheduleProps;
+    ref: HTMLDivElement;
+    stylesNames: ScheduleStylesNames;
+}>;
+export declare namespace Schedule {
+    type Props = ScheduleProps;
+    type StylesNames = ScheduleStylesNames;
+    type Factory = ScheduleFactory;
+    type Layout = ScheduleLayout;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { Schedule } from './Schedule';
+export type { ScheduleFactory, ScheduleLayout, ScheduleProps, ScheduleStylesNames, } from './Schedule';

package/lib/components/ScheduleEvent/ScheduleEvent.d.ts

@@ -0,0 +1,54 @@
+import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
+import { ScheduleEventData, ScheduleMode } from '../../types';
+export type ScheduleEventStylesNames = 'event' | 'eventInner';
+export type ScheduleEventVariant = 'filled' | 'light';
+export type ScheduleEventCssVariables = {
+    event: '--event-bg' | '--event-color' | '--event-radius' | '--event-hover';
+};
+export type RenderEventBody = (event: ScheduleEventData<any>) => React.ReactNode;
+export type RenderEvent = (event: ScheduleEventData, props: React.ComponentPropsWithoutRef<'button'> & {
+    children: React.ReactNode;
+}) => React.ReactElement;
+export interface ScheduleEventProps extends BoxProps, StylesApiProps<ScheduleEventFactory>, ElementProps<'button'> {
+    __staticSelector?: string;
+    /** Event to display */
+    event: ScheduleEventData;
+    /** Key of `theme.radius` or any valid CSS value to set border-radius @default theme.defaultRadius */
+    radius?: MantineRadius;
+    /** If set, event has `white-space: nowrap` @default false */
+    nowrap?: boolean;
+    /** If set, event shrinks its font-size with limited height @default false */
+    autoSize?: boolean;
+    /** Event size @default 'sm' */
+    size?: 'sm' | 'md' | (string & {});
+    /** Function to customize event body, `event` object is passed as first argument */
+    renderEventBody?: RenderEventBody;
+    /** Function to fully customize event rendering, receives all props that would be passed to the root element including children */
+    renderEvent?: RenderEvent;
+    /** Event hanging position */
+    hanging?: 'start' | 'end' | 'both' | 'none';
+    /** If true, event can be dragged @default false */
+    draggable?: boolean;
+    /** Called when event drag starts */
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    /** Called when event drag ends */
+    onEventDragEnd?: () => void;
+    /** If true, event is currently being dragged @default false */
+    isDragging?: boolean;
+    /** Interaction mode: 'default' allows all interactions, 'static' disables event interactions @default default */
+    mode?: ScheduleMode;
+}
+export type ScheduleEventFactory = Factory<{
+    props: ScheduleEventProps;
+    ref: HTMLButtonElement;
+    stylesNames: ScheduleEventStylesNames;
+    vars: ScheduleEventCssVariables;
+    variant: ScheduleEventVariant;
+}>;
+export declare const ScheduleEvent: import("@mantine/core").MantineComponent<{
+    props: ScheduleEventProps;
+    ref: HTMLButtonElement;
+    stylesNames: ScheduleEventStylesNames;
+    vars: ScheduleEventCssVariables;
+    variant: ScheduleEventVariant;
+}>;

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

@@ -0,0 +1,2 @@
+export { ScheduleEvent } from './ScheduleEvent';
+export type { ScheduleEventProps, ScheduleEventFactory, ScheduleEventStylesNames, ScheduleEventVariant, ScheduleEventCssVariables, RenderEventBody, } from './ScheduleEvent';

package/lib/components/ScheduleHeader/HeaderControl/HeaderControl.d.ts

@@ -0,0 +1,43 @@
+import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
+import { ScheduleLabelsOverride } from '../../../labels';
+export type HeaderControlStylesNames = 'headerControl';
+export type HeaderControlCssVariables = {
+    headerControl: '--control-radius';
+};
+export interface HeaderControlProps extends BoxProps, StylesApiProps<HeaderControlFactory>, ElementProps<'button'> {
+    __staticSelector?: string;
+    /** Applies active styles */
+    active?: boolean;
+    /** Removes inline padding */
+    square?: boolean;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default theme.defaultRadius */
+    radius?: MantineRadius;
+    /** If set to `false`, the control will not be clickable  */
+    interactive?: boolean;
+    /** Labels override */
+    labels?: ScheduleLabelsOverride;
+}
+export type HeaderControlFactory = Factory<{
+    props: HeaderControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: HeaderControlStylesNames;
+    vars: HeaderControlCssVariables;
+}>;
+export declare const HeaderControl: import("@mantine/core").MantineComponent<{
+    props: HeaderControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: HeaderControlStylesNames;
+    vars: HeaderControlCssVariables;
+}>;
+export declare function ScheduleHeaderNext(props: HeaderControlProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScheduleHeaderNext {
+    var displayName: string;
+}
+export declare function ScheduleHeaderPrevious(props: HeaderControlProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScheduleHeaderPrevious {
+    var displayName: string;
+}
+export declare function ScheduleHeaderToday(props: HeaderControlProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScheduleHeaderToday {
+    var displayName: string;
+}