@mantine-vue/schedule 3.4.0 → 3.6.0

package/lib/component-props.d.ts

@@ -2,7 +2,7 @@ import type { CSSProperties, HTMLAttributes, VNodeChild } from 'vue';
 import type { EmitsToProps } from '@mantine-vue/core';
 import type { ViewSelectEmits, ViewSelectProps } from './components/ScheduleHeader/ViewSelect/ViewSelect.types';
 import type { ScheduleLabelsOverride } from './labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from './types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from './types';
 import type { BusinessHoursValue } from './utils';
 /**
  * Native attributes accepted by the header controls and the other button-like elements
@@ -99,7 +99,8 @@ export interface BaseViewOwnProps {
      */
     recurrenceExpansionLimit?: number;
     /**
-     * If set, background events can be focused and clicked. Has no effect in static mode.
+     * If set, background events can be focused and clicked. Combined with event resize, timed
+     * background events can also be resized. Has no effect in static mode.
      * @default false
      */
     withInteractiveBackgroundEvents?: boolean;
@@ -176,6 +177,12 @@ export interface TimeViewOwnProps extends BaseViewOwnProps {
      * @default () => true
      */
     canDragEvent?: (event: ScheduleEventData) => boolean;
+    /** Returns false to reject a candidate internal event drop. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Returns false to reject a candidate external drop. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Rejects drops that overlap other events. */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * If set, dragging across time slots selects a range.
      * @default false
@@ -199,6 +206,8 @@ export interface TimeViewOwnProps extends BaseViewOwnProps {
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Returns false to reject a candidate resize. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
 }
 /**
  * Events emitted by every schedule view. Not a component of its own: `DayViewEmits`,
@@ -233,6 +242,8 @@ export interface TimeViewEmits extends BaseViewEmits {
     externalEventDrop: [dataTransfer: DataTransfer, dropDateTime: DateTimeStringValue];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    /** Emitted when a drop or resize is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 /** Scoped slots that mirror the `renderEvent` and `renderEventBody` props. */
 export interface EventSlots {

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

@@ -2,13 +2,13 @@ import type { CSSProperties } from 'vue';
 import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventSlots, ForwardedProps, TimeViewEmits, TimeViewOwnProps } from '../../component-props';
-import type { DateLabelFormat } from '../../types';
+import type { DateLabelFormat, ScheduleEventOverlapMode } from '../../types';
 import type { CurrentTimeIndicatorStylesNames } from '../CurrentTimeIndicator/CurrentTimeIndicator.types';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames, ScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
 import type { MonthYearSelectStylesNames } from '../ScheduleHeader/MonthYearSelect/MonthYearSelect.types';
-export type DayViewOwnStylesNames = 'dayView' | 'dayViewInner' | 'dayViewScrollArea' | 'dayViewAllDay' | 'dayViewAllDayEvents' | 'dayViewSlot' | 'dayViewSlots' | 'dayViewTimeSlots' | 'dayViewSlotLabel' | 'dayViewSlotLabels' | 'dayViewBackgroundEvent';
+export type DayViewOwnStylesNames = 'dayView' | 'dayViewInner' | 'dayViewScrollArea' | 'dayViewAllDay' | 'dayViewAllDayEvents' | 'dayViewSlot' | 'dayViewSlots' | 'dayViewTimeSlots' | 'dayViewSlotLabel' | 'dayViewSlotLabels' | 'dayViewBackgroundEvent' | 'dayViewBackgroundEventResizeHandle';
 /**
  * `DayView` forwards `classNames` and `styles` to the components it renders, so their
  * selectors are part of its Styles API. The month/year select is excluded because the day
@@ -16,11 +16,15 @@ export type DayViewOwnStylesNames = 'dayView' | 'dayViewInner' | 'dayViewScrollA
  */
 export type DayViewStylesNames = DayViewOwnStylesNames | MoreEventsStylesNames | ScheduleEventStylesNames | Exclude<CombinedScheduleHeaderStylesNames, MonthYearSelectStylesNames> | CurrentTimeIndicatorStylesNames | ScheduleHeaderStylesNames;
 export type DayViewCssVariables = {
-    dayView: '--day-view-radius' | '--day-view-slot-height' | '--day-view-all-day-slot-height';
+    dayView: '--day-view-radius' | '--day-view-slot-height' | '--day-view-all-day-slot-height' | '--event-raise-delay' | '--event-z-index' | '--event-z-index-raised';
 };
 export type DayViewSlots = EventSlots;
 /** Props declared by `DayView` itself. See `DayViewProps` for the full public type. */
 export interface DayViewOwnProps extends TimeViewOwnProps, StylesApiProps<DayViewFactory> {
+    /** Determines how overlapping events are laid out. @default 'columns' */
+    eventOverlapMode?: ScheduleEventOverlapMode;
+    /** Time in ms before a hovered cascade event is raised above covering events. @default 600 */
+    eventOverlapRaiseDelay?: number;
     /**
      * Length of one time slot in minutes.
      * @default 15

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

@@ -31,6 +31,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DayVie
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dropDateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<DayViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -43,6 +44,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DayVie
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dropDateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, import("../..").EventSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -1,4 +1,4 @@
-import { AnyDateValue, DayPositionedEventData, ScheduleEventData } from '../../../types';
+import { AnyDateValue, DayPositionedEventData, ScheduleEventData, ScheduleEventOverlapMode } from '../../../types';
 interface GetDayPositionedEventsInput {
     /** Date at which events are positioned, used to check if events are all-day */
     date: AnyDateValue;
@@ -10,6 +10,8 @@ interface GetDayPositionedEventsInput {
     endTime?: string;
     /** Number of minutes per time slot, used to align the canvas to whole slots */
     intervalMinutes?: number;
+    /** Determines how overlapping events are laid out. @default 'columns' */
+    eventOverlapMode?: ScheduleEventOverlapMode;
 }
-export declare function getDayPositionedEvents({ events, startTime, endTime, intervalMinutes, date, }: GetDayPositionedEventsInput): DayPositionedEventData[];
+export declare function getDayPositionedEvents({ events, startTime, endTime, intervalMinutes, date, eventOverlapMode, }: GetDayPositionedEventsInput): DayPositionedEventData[];
 export {};

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

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

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

@@ -1,7 +1,7 @@
 import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { BaseViewEmits, BaseViewOwnProps, EventDropData, EventSlots, ForwardedProps, NativeButtonProps } from '../../component-props';
-import type { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData } from '../../types';
+import type { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, PreventEventOverlap } from '../../types';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
@@ -78,6 +78,12 @@ export interface MonthViewOwnProps extends BaseViewOwnProps, StylesApiProps<Mont
      * @default () => true
      */
     canDragEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** If set, drops that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * If set, items dragged in from outside the schedule can be dropped on a day, which emits
      * `externalEventDrop`. Enabling event drag and drop turns this on as well.
@@ -113,6 +119,8 @@ export interface MonthViewEmits extends BaseViewEmits {
     externalEventDrop: [dataTransfer: DataTransfer, date: DateStringValue];
     /** Emitted when a day range is selected by dragging. */
     slotDragEnd: [rangeStart: DateTimeStringValue, rangeEnd: DateTimeStringValue];
+    /** Emitted when a drop is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type MonthViewFactory = Factory<{
     props: Omit<MonthViewProps, 'rootRef'>;

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

@@ -36,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<MonthV
     eventDrop: (data: import("../..").EventDropData) => any;
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, date: string) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     weekNumberClick: (date: string, nativeEvent: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<MonthViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
@@ -47,6 +48,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<MonthV
     onEventDrop?: ((data: import("../..").EventDropData) => any) | undefined;
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, date: string) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     onWeekNumberClick?: ((date: string, nativeEvent: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, import("../..").EventSlots>;
 type __VLS_WithSlots<T, S> = T & {

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

@@ -0,0 +1,7 @@
+interface ReserveRowInput {
+    nextRowByDay: number[];
+    startDayIndex: number;
+    daysSpanned: number;
+}
+export declare function reserveRow({ nextRowByDay, startDayIndex, daysSpanned }: ReserveRowInput): number;
+export {};

package/lib/components/ResourcesDayView/ResourcesDayView.types.d.ts

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { BusinessHoursValue } from '../../utils';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
@@ -266,6 +266,14 @@ export interface ResourcesDayViewOwnProps extends StylesApiProps<ResourcesDayVie
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * Maximum number of instances generated per recurring series.
      * @default 2000
@@ -302,6 +310,7 @@ export interface ResourcesDayViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesDayViewFactory = Factory<{
     props: Omit<ResourcesDayViewProps, 'rootRef'>;

package/lib/components/ResourcesDayView/ResourcesDayView.vue.d.ts

@@ -34,6 +34,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("./ResourcesDayView.types").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("./ResourcesDayView.types").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesDayViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -45,6 +46,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("./ResourcesDayView.types").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("./ResourcesDayView.types").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesDayViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -1,3 +1,2 @@
 export * from './ResourcesDayView';
-export * from './get-overlap-clusters/get-overlap-clusters';
 export * from './get-resources-day-view-events/get-resources-day-view-events';

package/lib/components/ResourcesMonthView/ResourcesMonthView.types.d.ts

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventSlots, EventDropData, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
@@ -170,6 +170,14 @@ export interface ResourcesMonthViewOwnProps extends StylesApiProps<ResourcesMont
     withEventResize?: boolean;
     /** Returns whether the given event may be resized. @default () => true */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * If set, items dragged in from outside the schedule can be dropped on a day cell, which emits
      * `externalEventDrop`. Enabling event drag and drop turns this on as well.
@@ -227,6 +235,7 @@ export interface ResourcesMonthViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event resize gesture completes. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesMonthViewFactory = Factory<{
     props: Omit<ResourcesMonthViewProps, 'rootRef'>;

package/lib/components/ResourcesMonthView/ResourcesMonthView.vue.d.ts

@@ -36,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesMonthViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onDayClick?: ((data: import("./ResourcesMonthView.types").ResourcesMonthViewDayClickData) => any) | undefined;
@@ -47,6 +48,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesMonthViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/lib/components/ResourcesSchedule/ResourcesSchedule.types.d.ts

@@ -3,7 +3,7 @@ import type { BoxProps, Factory } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup } from '../../types';
+import type { DateStringValue, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup } from '../../types';
 import type { ResourceExternalDropData, ResourceSlotDragEndData, ResourceTimeSlotClickData, ResourceViewDropData, ResourcesDayViewProps, ResourcesDayViewStylesNames } from '../ResourcesDayView/ResourcesDayView.types';
 import type { ResourcesMonthViewDayClickData, ResourcesMonthViewProps, ResourcesMonthViewStylesNames } from '../ResourcesMonthView/ResourcesMonthView.types';
 import type { ResourcesWeekViewProps, ResourcesWeekViewStylesNames } from '../ResourcesWeekView/ResourcesWeekView.types';
@@ -106,6 +106,14 @@ export interface ResourcesScheduleOwnProps extends StylesApiProps<ResourcesSched
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
     /** If set, background events can be focused and clicked in day and week views. */
     withInteractiveBackgroundEvents?: boolean;
     /**
@@ -149,6 +157,7 @@ export interface ResourcesScheduleEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesScheduleFactory = Factory<{
     props: Omit<ResourcesScheduleProps, 'rootRef'>;

package/lib/components/ResourcesSchedule/ResourcesSchedule.vue.d.ts

@@ -21,6 +21,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     "update:view": (view: ResourcesScheduleViewLevel) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesScheduleOwnProps> & Readonly<{
     "onUpdate:date"?: ((date: string) => any) | undefined;
@@ -35,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     "onUpdate:view"?: ((view: ResourcesScheduleViewLevel) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesScheduleSlots>;
 type __VLS_WithSlots<T, S> = T & {

package/lib/components/ResourcesWeekView/ResourcesWeekView.types.d.ts

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { BusinessHoursValue } from '../../utils';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
@@ -247,6 +247,14 @@ export interface ResourcesWeekViewOwnProps extends StylesApiProps<ResourcesWeekV
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * Maximum number of instances generated per recurring series.
      * @default 2000
@@ -308,6 +316,7 @@ export interface ResourcesWeekViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesWeekViewFactory = Factory<{
     props: Omit<ResourcesWeekViewProps, 'rootRef'>;

package/lib/components/ResourcesWeekView/ResourcesWeekView.vue.d.ts

@@ -39,6 +39,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesWeekViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -50,6 +51,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesWeekViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -3,7 +3,7 @@ import type { BoxProps, Factory } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, RenderEventBody, TimeSlotClickData } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import type { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, PreventEventOverlap, ScheduleMode, ScheduleViewLevel } from '../../types';
 import type { DayViewEmits, DayViewProps, DayViewStylesNames } from '../DayView/DayView.types';
 import type { MobileMonthViewHeaderPayload, MobileMonthViewEmits, MobileMonthViewProps, MobileMonthViewStylesNames } from '../MobileMonthView/MobileMonthView.types';
 import type { MonthViewEmits, MonthViewProps, MonthViewStylesNames } from '../MonthView/MonthView.types';
@@ -88,7 +88,15 @@ export interface ScheduleOwnProps extends StylesApiProps<ScheduleFactory> {
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
-    /** If set, background events can be focused and clicked in day, week and month views. */
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** If set, background events can be focused and clicked. Combined with event resize, timed background events in day and week views can also be resized. */
     withInteractiveBackgroundEvents?: boolean;
     /**
      * Maximum number of instances generated per recurring series.
@@ -144,6 +152,8 @@ export interface ScheduleEmits {
     externalEventDrop: [dataTransfer: DataTransfer, dateTime: DateTimeStringValue];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    /** Emitted when a drop or resize is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ScheduleFactory = Factory<{
     props: Omit<ScheduleProps, 'rootRef'>;

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

@@ -24,6 +24,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Schedu
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     monthClick: (month: string) => any;
     "update:view": (view: ScheduleViewLevel) => any;
 }, string, import("vue").PublicProps, Readonly<ScheduleOwnProps> & Readonly<{
@@ -40,6 +41,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Schedu
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     onMonthClick?: ((month: string) => any) | undefined;
     "onUpdate:view"?: ((view: ScheduleViewLevel) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScheduleSlots>;

package/lib/components/ScheduleBackgroundEvent/ScheduleBackgroundEvent.types.d.ts

@@ -2,6 +2,7 @@ import type { VNodeChild } from 'vue';
 import type { BoxProps } from '@mantine-vue/core';
 import type { RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleEventData } from '../../types';
+export type ScheduleBackgroundEventResizeEdge = 'top' | 'bottom' | 'start' | 'end';
 export interface ScheduleBackgroundEventOwnProps {
     /** Background event to display. */
     event: ScheduleEventData;
@@ -11,11 +12,22 @@ export interface ScheduleBackgroundEventOwnProps {
     renderEvent?: RenderEvent;
     /** Function to customize event body. */
     renderEventBody?: RenderEventBody;
+    /** If set, resize handles are rendered on both edges. */
+    withResize?: boolean;
+    /** Axis along which the event is resized. @default 'vertical' */
+    resizeAxis?: 'vertical' | 'horizontal';
+    /** Props passed to both resize handles. */
+    resizeHandleProps?: Record<string, any>;
+    /** Whether this event is currently being resized. */
+    isResizing?: boolean;
+    /** Edge currently being dragged. */
+    activeResizeEdge?: ScheduleBackgroundEventResizeEdge | null;
 }
 export interface ScheduleBackgroundEventProps extends Omit<BoxProps, keyof ScheduleBackgroundEventOwnProps>, ScheduleBackgroundEventOwnProps {
 }
 export interface ScheduleBackgroundEventEmits {
     eventClick: [event: ScheduleEventData, nativeEvent: MouseEvent];
+    resizeStart: [edge: ScheduleBackgroundEventResizeEdge, nativeEvent: PointerEvent];
 }
 export interface ScheduleBackgroundEventSlots {
     default?: (props: {

package/lib/components/ScheduleBackgroundEvent/ScheduleBackgroundEvent.vue.d.ts

@@ -1,8 +1,10 @@
 import type { ScheduleBackgroundEventOwnProps, ScheduleBackgroundEventSlots } from './ScheduleBackgroundEvent.types';
 type __VLS_Slots = ScheduleBackgroundEventSlots;
 declare const __VLS_base: import("vue").DefineComponent<ScheduleBackgroundEventOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    resizeStart: (edge: import("./ScheduleBackgroundEvent.types").ScheduleBackgroundEventResizeEdge, nativeEvent: PointerEvent) => any;
     eventClick: (event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<ScheduleBackgroundEventOwnProps> & Readonly<{
+    onResizeStart?: ((edge: import("./ScheduleBackgroundEvent.types").ScheduleBackgroundEventResizeEdge, nativeEvent: PointerEvent) => any) | undefined;
     onEventClick?: ((event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/lib/components/WeekView/WeekView.types.d.ts

@@ -2,18 +2,18 @@ import type { CSSProperties, VNodeChild } from 'vue';
 import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventSlots, ForwardedProps, TimeViewEmits, TimeViewOwnProps } from '../../component-props';
-import type { DateLabelFormat, DateStringValue, DayOfWeek } from '../../types';
+import type { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventOverlapMode } from '../../types';
 import type { CurrentTimeIndicatorStylesNames } from '../CurrentTimeIndicator/CurrentTimeIndicator.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
-export type WeekViewOwnStylesNames = 'weekView' | 'weekViewRoot' | 'weekViewHeader' | 'weekViewInner' | 'weekViewAllDaySlotsEvents' | 'weekViewAllDaySlots' | 'weekViewAllDaySlotsList' | 'weekViewAllDaySlotsLabel' | 'weekViewScrollArea' | 'weekViewCorner' | 'weekViewSlotLabels' | 'weekViewSlotLabel' | 'weekViewDayLabel' | 'weekViewDayWeekday' | 'weekViewDay' | 'weekViewDayNumber' | 'weekViewDaySlot' | 'weekViewDaySlots' | 'weekViewWeekLabel' | 'weekViewWeekNumber' | 'weekViewBackgroundEvent';
+export type WeekViewOwnStylesNames = 'weekView' | 'weekViewRoot' | 'weekViewHeader' | 'weekViewInner' | 'weekViewAllDaySlotsEvents' | 'weekViewAllDaySlots' | 'weekViewAllDaySlotsList' | 'weekViewAllDaySlotsLabel' | 'weekViewScrollArea' | 'weekViewCorner' | 'weekViewSlotLabels' | 'weekViewSlotLabel' | 'weekViewDayLabel' | 'weekViewDayWeekday' | 'weekViewDay' | 'weekViewDayNumber' | 'weekViewDaySlot' | 'weekViewDaySlots' | 'weekViewWeekLabel' | 'weekViewWeekNumber' | 'weekViewBackgroundEvent' | 'weekViewBackgroundEventResizeHandle';
 /**
  * `WeekView` forwards `classNames` and `styles` to the components it renders, so their
  * selectors are part of its Styles API.
  */
 export type WeekViewStylesNames = WeekViewOwnStylesNames | ScheduleEventStylesNames | CurrentTimeIndicatorStylesNames | CombinedScheduleHeaderStylesNames;
 export type WeekViewCssVariables = {
-    weekView: '--week-view-radius' | '--week-view-slot-height' | '--week-view-all-day-slots-height';
+    weekView: '--week-view-radius' | '--week-view-slot-height' | '--week-view-all-day-slots-height' | '--event-raise-delay' | '--event-z-index' | '--event-z-index-raised';
 };
 /** Range covered by the label shown in the week header. */
 export interface WeekLabelPayload {
@@ -31,6 +31,10 @@ export interface WeekViewSlots extends EventSlots {
 }
 /** Props declared by `WeekView` itself. See `WeekViewProps` for the full public type. */
 export interface WeekViewOwnProps extends TimeViewOwnProps, StylesApiProps<WeekViewFactory> {
+    /** Determines how overlapping events are laid out. @default 'columns' */
+    eventOverlapMode?: ScheduleEventOverlapMode;
+    /** Time in ms before a hovered cascade event is raised above covering events. @default 600 */
+    eventOverlapRaiseDelay?: number;
     /**
      * Length of one time slot in minutes.
      * @default 60

package/lib/components/WeekView/WeekView.vue.d.ts

@@ -40,6 +40,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WeekVi
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dropDateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<WeekViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -52,6 +53,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WeekVi
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dropDateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WeekViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/lib/components/WeekView/get-week-view-events/get-week-positioned-events.d.ts

@@ -1,4 +1,4 @@
-import { AnyDateValue, DateStringValue, DayOfWeek, ScheduleEventData, WeekPositionedEventData } from '../../../types';
+import { AnyDateValue, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleEventOverlapMode, WeekPositionedEventData } from '../../../types';
 export interface GetWeekPositionedEventsInput {
     /** Date (week start) at which events are positioned, used to check if events are all-day */
     date: AnyDateValue;
@@ -16,6 +16,8 @@ export interface GetWeekPositionedEventsInput {
     weekendDays?: DayOfWeek[];
     /** If set to false, weekend days are hidden @default true */
     withWeekendDays?: boolean;
+    /** Determines how overlapping events are laid out. @default 'columns' */
+    eventOverlapMode?: ScheduleEventOverlapMode;
 }
 /** Events grouped by week day date (YYYY-MM-DD 00:00:00) and by columns */
 export interface GroupedWeekEvents {
@@ -23,4 +25,4 @@ export interface GroupedWeekEvents {
     regularEvents: Record<DateStringValue, WeekPositionedEventData[]>;
     backgroundEvents: Record<DateStringValue, WeekPositionedEventData[]>;
 }
-export declare function getWeekPositionedEvents({ date, events, startTime, endTime, intervalMinutes, firstDayOfWeek, weekendDays, withWeekendDays, }: GetWeekPositionedEventsInput): GroupedWeekEvents;
+export declare function getWeekPositionedEvents({ date, events, startTime, endTime, intervalMinutes, firstDayOfWeek, weekendDays, withWeekendDays, eventOverlapMode, }: GetWeekPositionedEventsInput): GroupedWeekEvents;

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

@@ -1,5 +1,5 @@
 import type { EventDropData } from '../component-props';
-import type { ScheduleEventData, ScheduleMode } from '../types';
+import type { PreventEventOverlap, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode } from '../types';
 type ResizeEdge = 'top' | 'bottom';
 interface HandleResizeStartInput {
     event: ScheduleEventData;
@@ -19,14 +19,22 @@ export interface UseEventResizeInput {
     resizeIntervalMinutes?: () => number | undefined;
     onEventResize: (data: EventDropData) => void;
     canResizeEvent: () => ((event: ScheduleEventData) => boolean) | undefined;
+    withBackgroundEvents?: () => boolean;
+    events?: () => ScheduleEventData[];
+    preventEventOverlap?: () => PreventEventOverlap | undefined;
+    canResizeEventTo?: () => ((data: ScheduleCanResizeEventToData) => boolean) | undefined;
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
 }
 export declare function useEventResize(input: UseEventResizeInput): {
     handleResizeStart: ({ event, edge, container, originalTop, originalHeight, eventDate, pointerEvent, }: HandleResizeStartInput) => void;
-    getResizePosition: (eventId: string | number) => {
+    isResizing: import("vue").ComputedRef<boolean>;
+    resizingEventId: import("vue").ComputedRef<string | number | null>;
+    getResizePosition: (eventId: string | number, eventDate?: string) => {
         top: number;
         height: number;
     } | null;
     isResizableEvent: (event: ScheduleEventData) => boolean;
     wasResizing: () => boolean;
+    resizeValid: import("vue").ComputedRef<boolean>;
 };
 export {};