@mantine-vue/schedule 2.1.0

package/lib/component-props.d.ts

@@ -0,0 +1,265 @@
+import type { CSSProperties, HTMLAttributes, PropType, VNodeChild } from 'vue';
+import type { ScheduleLabelsOverride } from './labels';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from './types';
+import type { BusinessHoursValue } from './utils';
+export type NativeButtonProps = HTMLAttributes & Record<`data-${string}`, unknown>;
+export type RenderEventBody = (event: ScheduleEventData) => VNodeChild;
+export type RenderEvent = (event: ScheduleEventData, props: ScheduleEventRenderProps) => VNodeChild;
+export interface ScheduleEventRenderProps extends NativeButtonProps {
+    children?: VNodeChild;
+}
+export interface EventDropData {
+    eventId: string | number;
+    newStart: DateTimeStringValue;
+    newEnd: DateTimeStringValue;
+    event: ScheduleEventData;
+}
+export interface TimeSlotClickData {
+    slotStart: DateTimeStringValue;
+    slotEnd: DateTimeStringValue;
+    nativeEvent: MouseEvent;
+}
+export interface BaseViewProps extends HTMLAttributes {
+    date: Date | DateStringValue;
+    onDateChange?: (date: DateStringValue) => void;
+    events?: ScheduleEventData[];
+    locale?: string;
+    radius?: string | number;
+    labels?: ScheduleLabelsOverride;
+    mode?: ScheduleMode;
+    withHeader?: boolean;
+    onViewChange?: (view: ScheduleViewLevel) => void;
+    previousControlProps?: NativeButtonProps;
+    nextControlProps?: NativeButtonProps;
+    todayControlProps?: NativeButtonProps;
+    viewSelectProps?: Partial<ViewSelectProps>;
+    renderEventBody?: RenderEventBody;
+    renderEvent?: RenderEvent;
+    onEventClick?: (event: ScheduleEventData, nativeEvent: MouseEvent) => void;
+    recurrenceExpansionLimit?: number;
+}
+export interface TimeViewProps extends BaseViewProps {
+    startTime?: string;
+    endTime?: string;
+    intervalMinutes?: number;
+    slotLabelFormat?: DateLabelFormat;
+    withCurrentTimeIndicator?: boolean;
+    withCurrentTimeBubble?: boolean;
+    getCurrentTime?: () => AnyDateValue;
+    slotHeight?: CSSProperties['height'];
+    highlightBusinessHours?: boolean;
+    businessHours?: BusinessHoursValue;
+    withEventsDragAndDrop?: boolean;
+    onEventDrop?: (data: EventDropData) => void;
+    canDragEvent?: (event: ScheduleEventData) => boolean;
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    onEventDragEnd?: () => void;
+    onTimeSlotClick?: (data: TimeSlotClickData) => void;
+    onAllDaySlotClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    withDragSlotSelect?: boolean;
+    onSlotDragEnd?: (rangeStart: DateTimeStringValue, rangeEnd: DateTimeStringValue) => void;
+    startScrollTime?: string;
+    onExternalEventDrop?: (dataTransfer: DataTransfer, dropDateTime: DateTimeStringValue) => void;
+    withEventResize?: boolean;
+    onEventResize?: (data: EventDropData) => void;
+    canResizeEvent?: (event: ScheduleEventData) => boolean;
+}
+export interface DayViewProps extends TimeViewProps {
+    headerFormat?: DateLabelFormat;
+    withAllDaySlot?: boolean;
+    allDaySlotHeight?: CSSProperties['height'];
+    maxAllDayEvents?: number;
+    moreEventsProps?: Partial<MoreEventsProps>;
+}
+export interface WeekViewProps extends TimeViewProps {
+    firstDayOfWeek?: DayOfWeek;
+    weekdayFormat?: DateLabelFormat;
+    dayFormat?: DateLabelFormat;
+    withWeekNumber?: boolean;
+    withAllDaySlots?: boolean;
+    /** @deprecated Use withWeekNumber */
+    withWeekNumbers?: boolean;
+    /** @deprecated Use withAllDaySlots */
+    withAllDaySlot?: boolean;
+    allDaySlotsHeight?: CSSProperties['height'];
+    maxAllDayEvents?: number;
+    weekendDays?: DayOfWeek[];
+    withWeekendDays?: boolean;
+    forceCurrentTimeIndicator?: boolean;
+    weekLabelFormat?: DateLabelFormat;
+    renderWeekLabel?: (input: {
+        weekStart: DateStringValue;
+        weekEnd: DateStringValue;
+    }) => string;
+}
+export interface MonthViewProps extends BaseViewProps {
+    firstDayOfWeek?: DayOfWeek;
+    weekdayFormat?: DateLabelFormat;
+    weekendDays?: DayOfWeek[];
+    withWeekNumbers?: boolean;
+    withWeekDays?: boolean;
+    consistentWeeks?: boolean;
+    highlightToday?: boolean;
+    withOutsideDays?: boolean;
+    maxEventsPerDay?: number;
+    getDayProps?: (date: DateStringValue) => NativeButtonProps;
+    getWeekNumberProps?: (weekStartDate: DateStringValue) => NativeButtonProps;
+    onDayClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    onWeekNumberClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    withEventsDragAndDrop?: boolean;
+    onEventDrop?: (data: EventDropData) => void;
+    canDragEvent?: (event: ScheduleEventData) => boolean;
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    onEventDragEnd?: () => void;
+    onExternalEventDrop?: (dataTransfer: DataTransfer, date: DateStringValue) => void;
+    withDragSlotSelect?: boolean;
+    onSlotDragEnd?: (rangeStart: DateStringValue, rangeEnd: DateStringValue) => void;
+}
+export interface YearViewProps extends BaseViewProps {
+    firstDayOfWeek?: DayOfWeek;
+    weekdayFormat?: DateLabelFormat;
+    weekendDays?: DayOfWeek[];
+    withWeekNumbers?: boolean;
+    withWeekDays?: boolean;
+    consistentWeeks?: boolean;
+    highlightToday?: boolean;
+    withOutsideDays?: boolean;
+    monthsListFormat?: DateLabelFormat;
+    getDayProps?: (date: DateStringValue) => NativeButtonProps;
+    getWeekNumberProps?: (weekStartDate: DateStringValue) => NativeButtonProps;
+    onDayClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    onMonthClick?: (month: DateStringValue) => void;
+    onWeekNumberClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+}
+export interface MobileMonthViewProps extends MonthViewProps {
+    selectedDate?: Date | DateStringValue | null;
+    defaultSelectedDate?: Date | DateStringValue | null;
+    onSelectedDateChange?: (date: DateStringValue | null) => void;
+    eventsHeaderFormat?: DateLabelFormat;
+    onYearClick?: () => void;
+    renderHeader?: (input: {
+        mode: ScheduleMode;
+        date: Date | DateStringValue;
+        defaultHeader: VNodeChild;
+    }) => VNodeChild;
+}
+export interface ViewSelectProps extends Omit<HTMLAttributes, 'onChange'> {
+    views?: readonly ScheduleViewLevel[];
+    value?: ScheduleViewLevel;
+    onChange?: (value: ScheduleViewLevel) => void;
+    radius?: string | number;
+    labels?: ScheduleLabelsOverride;
+}
+export interface MonthYearSelectProps extends HTMLAttributes {
+    locale?: string;
+    startYear?: number;
+    endYear?: number;
+    yearValue?: number;
+    monthValue?: number;
+    onYearChange?: (year: number) => void;
+    onMonthChange?: (month: number) => void;
+    monthsListFormat?: DateLabelFormat;
+    labelFormat?: DateLabelFormat;
+    radius?: string | number;
+    getYearControlProps?: (year: number) => NativeButtonProps;
+    getMonthControlProps?: (month: number) => NativeButtonProps;
+    withMonths?: boolean;
+    labels?: ScheduleLabelsOverride;
+}
+export interface ScheduleHeaderProps extends HTMLAttributes {
+    labels?: ScheduleLabelsOverride;
+}
+export interface HeaderControlProps extends NativeButtonProps {
+    active?: boolean;
+    square?: boolean;
+    radius?: string | number;
+    interactive?: boolean;
+    labels?: ScheduleLabelsOverride;
+}
+export interface ScheduleEventProps extends NativeButtonProps {
+    event: ScheduleEventData;
+    radius?: string | number;
+    nowrap?: boolean;
+    autoSize?: boolean;
+    size?: 'sm' | 'md' | (string & {});
+    renderEventBody?: RenderEventBody;
+    renderEvent?: RenderEvent;
+    hanging?: 'start' | 'end' | 'both' | 'none';
+    draggable?: boolean;
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    onEventDragEnd?: () => void;
+    isDragging?: boolean;
+    mode?: ScheduleMode;
+    withResize?: boolean;
+    onResizeStart?: (edge: 'top' | 'bottom', event: PointerEvent) => void;
+    isResizing?: boolean;
+}
+export type MoreEventsDropdownType = 'popover' | 'modal';
+export interface MoreEventsProps extends NativeButtonProps {
+    events: ScheduleEventData[];
+    moreEventsCount: number;
+    radius?: string | number;
+    modalTitle?: string;
+    dropdownType?: MoreEventsDropdownType;
+    popoverProps?: Record<string, unknown>;
+    modalProps?: Record<string, unknown>;
+    onDropdownClose?: () => void;
+    renderEventBody?: RenderEventBody;
+    renderEvent?: RenderEvent;
+    labels?: ScheduleLabelsOverride;
+    mode?: ScheduleMode;
+    onEventClick?: (event: ScheduleEventData, nativeEvent: MouseEvent) => void;
+}
+export interface CurrentTimeIndicatorProps extends HTMLAttributes {
+    color?: string;
+    startOffset?: string;
+    endOffset?: string;
+    topOffset?: string;
+    timeBubbleStartOffset?: string;
+    withTimeBubble?: boolean;
+    withThumb?: boolean;
+    currentTimeFormat?: DateLabelFormat;
+    locale?: string;
+    startTime?: string;
+    endTime?: string;
+    intervalMinutes?: number;
+    getCurrentTime?: () => AnyDateValue;
+}
+export interface ScheduleProps extends HTMLAttributes {
+    date?: Date | DateStringValue;
+    defaultDate?: Date | DateStringValue;
+    onDateChange?: (date: DateStringValue) => void;
+    view?: ScheduleViewLevel;
+    defaultView?: ScheduleViewLevel;
+    onViewChange?: (view: ScheduleViewLevel) => void;
+    events?: ScheduleEventData[];
+    locale?: string;
+    radius?: string | number;
+    labels?: ScheduleLabelsOverride;
+    renderEventBody?: RenderEventBody;
+    withEventsDragAndDrop?: boolean;
+    onEventDrop?: (data: EventDropData) => void;
+    canDragEvent?: (event: ScheduleEventData) => boolean;
+    onEventDragStart?: (event: ScheduleEventData) => void;
+    onEventDragEnd?: () => void;
+    onTimeSlotClick?: (data: TimeSlotClickData) => void;
+    onAllDaySlotClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    onEventClick?: (event: ScheduleEventData, nativeEvent: MouseEvent) => void;
+    onDayClick?: (date: DateStringValue, nativeEvent: MouseEvent) => void;
+    onMonthClick?: (month: DateStringValue) => void;
+    withDragSlotSelect?: boolean;
+    onSlotDragEnd?: (rangeStart: string, rangeEnd: string) => void;
+    mode?: ScheduleMode;
+    onExternalEventDrop?: (dataTransfer: DataTransfer, dateTime: string) => void;
+    withEventResize?: boolean;
+    onEventResize?: (data: EventDropData) => void;
+    canResizeEvent?: (event: ScheduleEventData) => boolean;
+    recurrenceExpansionLimit?: number;
+    layout?: 'default' | 'responsive';
+    dayViewProps?: Partial<DayViewProps>;
+    weekViewProps?: Partial<WeekViewProps>;
+    monthViewProps?: Partial<MonthViewProps>;
+    yearViewProps?: Partial<YearViewProps>;
+    mobileMonthViewProps?: Partial<MobileMonthViewProps>;
+}
+export declare const objectProp: PropType<Record<string, unknown>>;

package/lib/components/CurrentTimeIndicator/CurrentTimeIndicator.d.ts

@@ -0,0 +1,114 @@
+import { type PropType } from 'vue';
+import type { CurrentTimeIndicatorProps } from '../../component-props';
+import type { AnyDateValue, DateLabelFormat } from '../../types';
+export declare const CurrentTimeIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    startOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    endOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    topOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeBubbleStartOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    withTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withThumb: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    currentTimeFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    locale: StringConstructor;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    getCurrentTime: PropType<() => AnyDateValue>;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    startOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    endOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    topOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeBubbleStartOffset: {
+        type: StringConstructor;
+        default: string;
+    };
+    withTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withThumb: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    currentTimeFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    locale: StringConstructor;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    getCurrentTime: PropType<() => AnyDateValue>;
+}>> & Readonly<{}>, {
+    color: string;
+    startTime: string;
+    endTime: string;
+    intervalMinutes: number;
+    startOffset: string;
+    endOffset: string;
+    topOffset: string;
+    timeBubbleStartOffset: string;
+    withTimeBubble: boolean;
+    withThumb: boolean;
+    currentTimeFormat: DateLabelFormat;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type { CurrentTimeIndicatorProps };
+export type CurrentTimeIndicatorStylesNames = 'currentTimeIndicator' | 'currentTimeIndicatorLine' | 'currentTimeIndicatorThumb' | 'currentTimeIndicatorTimeBubble';

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

@@ -0,0 +1 @@
+export * from './CurrentTimeIndicator';

package/lib/components/DayView/DayView.d.ts

@@ -0,0 +1,212 @@
+import { type CSSProperties, type PropType, type SlotsType } from 'vue';
+import type { DayViewProps, MoreEventsProps } from '../../component-props';
+import type { DateLabelFormat } from '../../types';
+import { type EventSlots } from '../shared';
+export declare const DayView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    headerFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withAllDaySlot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allDaySlotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    maxAllDayEvents: {
+        type: NumberConstructor;
+        default: number;
+    };
+    moreEventsProps: PropType<Partial<MoreEventsProps>>;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    slotLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withCurrentTimeIndicator: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    withCurrentTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCurrentTime: PropType<() => import("../..").AnyDateValue>;
+    slotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    highlightBusinessHours: BooleanConstructor;
+    businessHours: PropType<import("../..").BusinessHoursValue>;
+    withEventsDragAndDrop: BooleanConstructor;
+    onEventDrop: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canDragEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    onEventDragStart: PropType<(event: import("../..").ScheduleEventData) => void>;
+    onEventDragEnd: PropType<() => void>;
+    onTimeSlotClick: PropType<(data: import("../../component-props").TimeSlotClickData) => void>;
+    onAllDaySlotClick: PropType<(date: import("../..").DateStringValue, nativeEvent: MouseEvent) => void>;
+    withDragSlotSelect: BooleanConstructor;
+    onSlotDragEnd: FunctionConstructor;
+    startScrollTime: StringConstructor;
+    onExternalEventDrop: FunctionConstructor;
+    withEventResize: BooleanConstructor;
+    onEventResize: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canResizeEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    date: {
+        type: PropType<Date | import("../..").DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: import("../..").DateStringValue) => void>;
+    events: PropType<import("../..").ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    headerFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withAllDaySlot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allDaySlotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    maxAllDayEvents: {
+        type: NumberConstructor;
+        default: number;
+    };
+    moreEventsProps: PropType<Partial<MoreEventsProps>>;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    slotLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withCurrentTimeIndicator: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    withCurrentTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCurrentTime: PropType<() => import("../..").AnyDateValue>;
+    slotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    highlightBusinessHours: BooleanConstructor;
+    businessHours: PropType<import("../..").BusinessHoursValue>;
+    withEventsDragAndDrop: BooleanConstructor;
+    onEventDrop: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canDragEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    onEventDragStart: PropType<(event: import("../..").ScheduleEventData) => void>;
+    onEventDragEnd: PropType<() => void>;
+    onTimeSlotClick: PropType<(data: import("../../component-props").TimeSlotClickData) => void>;
+    onAllDaySlotClick: PropType<(date: import("../..").DateStringValue, nativeEvent: MouseEvent) => void>;
+    withDragSlotSelect: BooleanConstructor;
+    onSlotDragEnd: FunctionConstructor;
+    startScrollTime: StringConstructor;
+    onExternalEventDrop: FunctionConstructor;
+    withEventResize: BooleanConstructor;
+    onEventResize: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canResizeEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    date: {
+        type: PropType<Date | import("../..").DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: import("../..").DateStringValue) => void>;
+    events: PropType<import("../..").ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    mode: import("../..").ScheduleMode;
+    startTime: string;
+    endTime: string;
+    intervalMinutes: number;
+    slotHeight: import("csstype").Property.Height<string | number> | undefined;
+    highlightBusinessHours: boolean;
+    withHeader: boolean;
+    recurrenceExpansionLimit: number;
+    withEventsDragAndDrop: boolean;
+    withDragSlotSelect: boolean;
+    withEventResize: boolean;
+    headerFormat: DateLabelFormat;
+    withAllDaySlot: boolean;
+    allDaySlotHeight: import("csstype").Property.Height<string | number> | undefined;
+    maxAllDayEvents: number;
+    slotLabelFormat: DateLabelFormat;
+    withCurrentTimeIndicator: boolean;
+    withCurrentTimeBubble: boolean;
+}, SlotsType<EventSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type { DayViewProps };
+export type DayViewStylesNames = 'dayView' | 'dayViewInner' | 'dayViewScrollArea' | 'dayViewAllDay' | 'dayViewAllDayEvents' | 'dayViewSlot' | 'dayViewSlots' | 'dayViewTimeSlots' | 'dayViewSlotLabel' | 'dayViewSlotLabels' | 'dayViewBackgroundEvent';

package/lib/components/DayView/get-day-view-events/get-day-positioned-events.d.ts

@@ -0,0 +1,15 @@
+import { AnyDateValue, DayPositionedEventData, ScheduleEventData } from '../../../types';
+interface GetDayPositionedEventsInput {
+    /** Date at which events are positioned, used to check if events are all-day */
+    date: AnyDateValue;
+    /** List of all events that belong to the given date, extra events must be filtered out before passing to the function */
+    events: ScheduleEventData[];
+    /** Start time of the day view, used to calculate event positions */
+    startTime?: string;
+    /** End time of the day view, used to calculate event positions */
+    endTime?: string;
+    /** Number of minutes per time slot, used to align the canvas to whole slots */
+    intervalMinutes?: number;
+}
+export declare function getDayPositionedEvents({ events, startTime, endTime, intervalMinutes, date, }: GetDayPositionedEventsInput): DayPositionedEventData[];
+export {};

package/lib/components/DayView/get-day-view-events/get-day-view-events.d.ts

@@ -0,0 +1,15 @@
+import { AnyDateValue, DayPositionedEventData, ScheduleEventData } from '../../../types';
+interface GetDayViewEventsInput {
+    events: ScheduleEventData[] | undefined;
+    date: AnyDateValue;
+    startTime?: string;
+    endTime?: string;
+    intervalMinutes?: number;
+}
+export declare function getDayViewEvents({ events, date, startTime, endTime, intervalMinutes, }: GetDayViewEventsInput): {
+    allDayEvents: DayPositionedEventData[];
+    regularEvents: DayPositionedEventData[];
+    backgroundTimedEvents: DayPositionedEventData[];
+    backgroundAllDayEvents: DayPositionedEventData[];
+};
+export {};

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

@@ -0,0 +1,3 @@
+export * from './DayView';
+export * from './get-day-view-events/get-day-view-events';
+export * from './get-day-view-events/get-day-positioned-events';

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

@@ -0,0 +1,11 @@
+import { type InjectionKey } from 'vue';
+import type { DropTarget, ScheduleEventData } from '../../types';
+export interface DragContextValue {
+    draggedEvent: ScheduleEventData | null;
+    dragOverTarget: DropTarget | null;
+    isDragging: boolean;
+    isSlotDragging: boolean;
+}
+export declare const DragContext: InjectionKey<DragContextValue>;
+export declare function provideDragContext(value: DragContextValue): void;
+export declare function useDragContext(): DragContextValue;

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

@@ -0,0 +1 @@
+export * from './DragContext';