react-big-schedule 8.1.0 → 9.0.1

package/dist/components/AgendaEventItem.d.ts

@@ -0,0 +1,10 @@
+import type { EventPopoverCallbacks, SchedulerEvent } from '../types';
+import type SchedulerData from './SchedulerData';
+export interface AgendaEventItemProps extends EventPopoverCallbacks {
+    schedulerData: SchedulerData;
+    eventItem: SchedulerEvent;
+    isStart: boolean;
+    isEnd: boolean;
+}
+declare function AgendaEventItem(props: AgendaEventItemProps): import("react").JSX.Element;
+export default AgendaEventItem;

package/dist/components/AgendaEventItem.js

@@ -1,84 +1,36 @@
-import { Popover } from 'antd';
-import PropTypes from 'prop-types';
-import EventItemPopover from './EventItemPopover';
 import { jsx as _jsx } from "react/jsx-runtime";
+import EventItemPopover from './EventItemPopover';
+import Popover from './ui/Popover';
 function AgendaEventItem(props) {
-  const {
-    eventItem,
-    isStart,
-    isEnd,
-    eventItemClick,
-    schedulerData,
-    eventItemTemplateResolver
-  } = props;
-  const {
-    config,
-    behaviors
-  } = schedulerData;
-  let roundCls = 'round-none';
-  if (isStart && isEnd) {
-    roundCls = 'round-all';
-  } else if (isStart) {
-    roundCls = 'round-head';
-  } else if (isEnd) {
-    roundCls = 'round-tail';
-  }
-  const backgroundColor = eventItem.bgColor || config.defaultEventBgColor;
-  const titleText = behaviors.getEventTextFunc(schedulerData, eventItem);
-  const eventItemStyle = {
-    height: config.eventItemHeight,
-    maxWidth: config.agendaMaxEventWidth,
-    backgroundColor
-  };
-  let eventItemTemplate = /*#__PURE__*/_jsx("div", {
-    className: `${roundCls} event-item`,
-    style: eventItemStyle,
-    children: /*#__PURE__*/_jsx("span", {
-      style: {
-        marginLeft: '10px',
-        lineHeight: `${config.eventItemHeight}px`
-      },
-      children: titleText
-    })
-  }, eventItem.id);
-  if (eventItemTemplateResolver) {
-    eventItemTemplate = eventItemTemplateResolver(schedulerData, eventItem, backgroundColor, isStart, isEnd, 'event-item', config.eventItemHeight, config.agendaMaxEventWidth);
-  }
-  const handleClick = () => eventItemClick?.(schedulerData, eventItem);
-  const eventLink = /*#__PURE__*/_jsx("button", {
-    type: "button",
-    className: "day-event rbs-txt-btn-dis",
-    onClick: handleClick,
-    children: eventItemTemplate
-  });
-  const content = /*#__PURE__*/_jsx(EventItemPopover, {
-    ...props,
-    title: eventItem.title,
-    startTime: eventItem.start,
-    endTime: eventItem.end,
-    statusColor: backgroundColor
-  });
-  return config.eventItemPopoverEnabled ? /*#__PURE__*/_jsx(Popover, {
-    placement: "bottomLeft",
-    content: content,
-    trigger: "hover",
-    overlayClassName: "scheduler-agenda-event-popover",
-    children: eventLink
-  }) : /*#__PURE__*/_jsx("span", {
-    children: eventLink
-  });
+    const { eventItem, isStart, isEnd, eventItemClick, schedulerData, eventItemTemplateResolver } = props;
+    const { config, behaviors } = schedulerData;
+    let roundCls = 'round-none';
+    if (isStart && isEnd) {
+        roundCls = 'round-all';
+    }
+    else if (isStart) {
+        roundCls = 'round-head';
+    }
+    else if (isEnd) {
+        roundCls = 'round-tail';
+    }
+    const backgroundColor = eventItem.bgColor || config.defaultEventBgColor;
+    const titleText = behaviors.getEventTextFunc(schedulerData, eventItem);
+    const eventItemStyle = {
+        height: config.eventItemHeight,
+        maxWidth: config.agendaMaxEventWidth,
+        backgroundColor,
+    };
+    let eventItemTemplate = (_jsx("div", { className: `${roundCls} event-item`, style: eventItemStyle, children: _jsx("span", { style: {
+                marginLeft: '10px',
+                lineHeight: `${config.eventItemHeight}px`,
+            }, children: titleText }) }, eventItem.id));
+    if (eventItemTemplateResolver) {
+        eventItemTemplate = eventItemTemplateResolver(schedulerData, eventItem, backgroundColor, isStart, isEnd, 'event-item', config.eventItemHeight, config.agendaMaxEventWidth);
+    }
+    const handleClick = () => eventItemClick?.(schedulerData, eventItem);
+    const eventLink = (_jsx("button", { type: "button", className: "day-event rbs-txt-btn-dis", onClick: handleClick, children: eventItemTemplate }));
+    const content = (_jsx(EventItemPopover, { ...props, title: eventItem.title, startTime: eventItem.start, endTime: eventItem.end, statusColor: backgroundColor }));
+    return config.eventItemPopoverEnabled ? (_jsx(Popover, { placement: "bottomLeft", content: content, trigger: "hover", className: "scheduler-agenda-event-popover", children: eventLink })) : (_jsx("span", { children: eventLink }));
 }
-AgendaEventItem.propTypes = {
-  schedulerData: PropTypes.object.isRequired,
-  eventItem: PropTypes.object.isRequired,
-  isStart: PropTypes.bool.isRequired,
-  isEnd: PropTypes.bool.isRequired,
-  subtitleGetter: PropTypes.func,
-  eventItemClick: PropTypes.func,
-  viewEventClick: PropTypes.func,
-  viewEventText: PropTypes.string,
-  viewEvent2Click: PropTypes.func,
-  viewEvent2Text: PropTypes.string,
-  eventItemTemplateResolver: PropTypes.func
-};
-export default AgendaEventItem;
+export default AgendaEventItem;

package/dist/components/AgendaResourceEvents.d.ts

@@ -0,0 +1,10 @@
+import type { EventPopoverCallbacks, RenderItem, SlotClickedFunc, SlotItemTemplateResolver } from '../types';
+import type SchedulerData from './SchedulerData';
+export interface AgendaResourceEventsProps extends EventPopoverCallbacks {
+    schedulerData: SchedulerData;
+    resourceEvents: RenderItem;
+    slotClickedFunc?: SlotClickedFunc;
+    slotItemTemplateResolver?: SlotItemTemplateResolver;
+}
+declare function AgendaResourceEvents(props: AgendaResourceEventsProps): import("react").JSX.Element;
+export default AgendaResourceEvents;

package/dist/components/AgendaResourceEvents.js

@@ -1,96 +1,42 @@
-import PropTypes from 'prop-types';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
 import { DATE_FORMAT } from '../config/default';
+import { toDate } from '../helper/behaviors';
 import AgendaEventItem from './AgendaEventItem';
-import { createElement as _createElement } from "react";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 function AgendaResourceEvents(props) {
-  const {
-    schedulerData,
-    resourceEvents,
-    slotClickedFunc,
-    slotItemTemplateResolver
-  } = props;
-  const {
-    startDate,
-    endDate,
-    config,
-    localeDayjs
-  } = schedulerData;
-  const width = schedulerData.getResourceTableWidth() - 2;
-  const events = resourceEvents.headerItems.flatMap(item => {
-    const start = localeDayjs(new Date(startDate));
-    const end = localeDayjs(endDate).add(1, 'days');
-    const headerStart = localeDayjs(new Date(item.start));
-    const headerEnd = localeDayjs(new Date(item.end));
-    // compare calendar dates: dayjs objects are never === each other
-    if (start.format(DATE_FORMAT) === headerStart.format(DATE_FORMAT) && end.format(DATE_FORMAT) === headerEnd.format(DATE_FORMAT)) {
-      return item.events.map(evt => {
-        const durationStart = localeDayjs(new Date(startDate));
-        const durationEnd = localeDayjs(endDate).add(1, 'days');
-        const eventStart = localeDayjs(evt.eventItem.start);
-        const eventEnd = localeDayjs(evt.eventItem.end);
-        const isStart = eventStart >= durationStart;
-        const isEnd = eventEnd < durationEnd;
-        return /*#__PURE__*/_createElement(AgendaEventItem, {
-          ...props,
-          key: evt.eventItem.id,
-          eventItem: evt.eventItem,
-          isStart: isStart,
-          isEnd: isEnd
-        });
-      });
-    }
-    return [];
-  });
-  const slotItemContent = slotClickedFunc ? /*#__PURE__*/_jsx("button", {
-    className: "rbs-txt-btn-dis",
-    type: "button",
-    onClick: () => slotClickedFunc(schedulerData, resourceEvents),
-    children: resourceEvents.slotName
-  }) : /*#__PURE__*/_jsx("span", {
-    children: resourceEvents.slotName
-  });
-  let slotItem = /*#__PURE__*/_jsx("div", {
-    style: {
-      width
-    },
-    title: resourceEvents.slotTitle || resourceEvents.slotName,
-    className: "overflow-text header2-text",
-    children: slotItemContent
-  });
-  if (slotItemTemplateResolver) {
-    const temp = slotItemTemplateResolver(schedulerData, resourceEvents, slotClickedFunc, width, 'overflow-text header2-text');
-    if (temp) {
-      slotItem = temp;
+    const { schedulerData, resourceEvents, slotClickedFunc, slotItemTemplateResolver } = props;
+    const { startDate, endDate, config, localeDayjs } = schedulerData;
+    const width = schedulerData.getResourceTableWidth() - 2;
+    const events = resourceEvents.headerItems.flatMap(item => {
+        const start = localeDayjs(toDate(startDate));
+        const end = localeDayjs(endDate).add(1, 'days');
+        const headerStart = localeDayjs(toDate(item.start));
+        const headerEnd = localeDayjs(toDate(item.end));
+        // compare calendar dates: dayjs objects are never === each other
+        if (start.format(DATE_FORMAT) === headerStart.format(DATE_FORMAT) &&
+            end.format(DATE_FORMAT) === headerEnd.format(DATE_FORMAT)) {
+            return item.events
+                .filter((evt) => evt !== undefined)
+                .map(evt => {
+                const durationStart = localeDayjs(toDate(startDate));
+                const durationEnd = localeDayjs(endDate).add(1, 'days');
+                const eventStart = localeDayjs(evt.eventItem.start);
+                const eventEnd = localeDayjs(evt.eventItem.end);
+                const isStart = eventStart >= durationStart;
+                const isEnd = eventEnd < durationEnd;
+                return (_createElement(AgendaEventItem, { ...props, key: evt.eventItem.id, eventItem: evt.eventItem, isStart: isStart, isEnd: isEnd }));
+            });
+        }
+        return [];
+    });
+    const slotItemContent = slotClickedFunc ? (_jsx("button", { className: "rbs-txt-btn-dis", type: "button", onClick: () => slotClickedFunc(schedulerData, resourceEvents), children: resourceEvents.slotName })) : (_jsx("span", { children: resourceEvents.slotName }));
+    let slotItem = (_jsx("div", { style: { width }, title: resourceEvents.slotTitle || resourceEvents.slotName, className: "overflow-text header2-text", children: slotItemContent }));
+    if (slotItemTemplateResolver) {
+        const temp = slotItemTemplateResolver(schedulerData, resourceEvents, slotClickedFunc, width, 'overflow-text header2-text');
+        if (temp) {
+            slotItem = temp;
+        }
     }
-  }
-  return /*#__PURE__*/_jsxs("tr", {
-    style: {
-      minHeight: config.eventItemLineHeight + 2
-    },
-    children: [/*#__PURE__*/_jsx("td", {
-      "data-resource-id": resourceEvents.slotId,
-      children: slotItem
-    }), /*#__PURE__*/_jsx("td", {
-      children: /*#__PURE__*/_jsx("div", {
-        className: "day-event-container",
-        children: events
-      })
-    })]
-  });
+    return (_jsxs("tr", { style: { minHeight: config.eventItemLineHeight + 2 }, children: [_jsx("td", { "data-resource-id": resourceEvents.slotId, children: slotItem }), _jsx("td", { children: _jsx("div", { className: "day-event-container", children: events }) })] }));
 }
-AgendaResourceEvents.propTypes = {
-  schedulerData: PropTypes.object.isRequired,
-  resourceEvents: PropTypes.object.isRequired,
-  subtitleGetter: PropTypes.func,
-  eventItemClick: PropTypes.func,
-  viewEventClick: PropTypes.func,
-  viewEventText: PropTypes.string,
-  viewEvent2Click: PropTypes.func,
-  viewEvent2Text: PropTypes.string,
-  slotClickedFunc: PropTypes.func,
-  slotItemTemplateResolver: PropTypes.func,
-  eventItemTemplateResolver: PropTypes.func,
-  eventItemPopoverTemplateResolver: PropTypes.func
-};
-export default AgendaResourceEvents;
+export default AgendaResourceEvents;

package/dist/components/AgendaView.d.ts

@@ -0,0 +1,9 @@
+import type { EventPopoverCallbacks, SlotClickedFunc, SlotItemTemplateResolver } from '../types';
+import type SchedulerData from './SchedulerData';
+export interface AgendaViewProps extends EventPopoverCallbacks {
+    schedulerData: SchedulerData;
+    slotClickedFunc?: SlotClickedFunc;
+    slotItemTemplateResolver?: SlotItemTemplateResolver;
+}
+declare function AgendaView(props: AgendaViewProps): import("react").JSX.Element;
+export default AgendaView;

package/dist/components/AgendaView.js

@@ -1,72 +1,13 @@
-import PropTypes from 'prop-types';
-import AgendaResourceEvents from './AgendaResourceEvents';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import AgendaResourceEvents from './AgendaResourceEvents';
 function AgendaView(props) {
-  const {
-    schedulerData
-  } = props;
-  const {
-    config,
-    renderData
-  } = schedulerData;
-  const agendaResourceTableWidth = schedulerData.getResourceTableWidth();
-  const tableHeaderHeight = schedulerData.getTableHeaderHeight();
-  const resourceName = schedulerData.isEventPerspective ? config.taskName : config.resourceName;
-  const {
-    agendaViewHeader
-  } = config;
-  const resourceEventsList = renderData.map(item => /*#__PURE__*/_jsx(AgendaResourceEvents, {
-    resourceEvents: item,
-    schedulerData: schedulerData,
-    subtitleGetter: props.subtitleGetter,
-    eventItemClick: props.eventItemClick,
-    viewEventClick: props.viewEventClick,
-    viewEventText: props.viewEventText,
-    viewEvent2Click: props.viewEvent2Click,
-    viewEvent2Text: props.viewEvent2Text,
-    slotClickedFunc: props.slotClickedFunc,
-    slotItemTemplateResolver: props.slotItemTemplateResolver,
-    eventItemTemplateResolver: props.eventItemTemplateResolver,
-    eventItemPopoverTemplateResolver: props.eventItemPopoverTemplateResolver
-  }, item.slotId));
-  return /*#__PURE__*/_jsx("tr", {
-    children: /*#__PURE__*/_jsx("td", {
-      children: /*#__PURE__*/_jsxs("table", {
-        className: "scheduler-table",
-        children: [/*#__PURE__*/_jsx("thead", {
-          children: /*#__PURE__*/_jsxs("tr", {
-            style: {
-              height: tableHeaderHeight
-            },
-            children: [/*#__PURE__*/_jsx("th", {
-              style: {
-                width: agendaResourceTableWidth
-              },
-              className: "header3-text",
-              children: resourceName
-            }), /*#__PURE__*/_jsx("th", {
-              className: "header3-text",
-              children: agendaViewHeader
-            })]
-          })
-        }), /*#__PURE__*/_jsx("tbody", {
-          children: resourceEventsList
-        })]
-      })
-    })
-  });
+    const { schedulerData } = props;
+    const { config, renderData } = schedulerData;
+    const agendaResourceTableWidth = schedulerData.getResourceTableWidth();
+    const tableHeaderHeight = schedulerData.getTableHeaderHeight();
+    const resourceName = schedulerData.isEventPerspective ? config.taskName : config.resourceName;
+    const { agendaViewHeader } = config;
+    const resourceEventsList = renderData.map(item => (_jsx(AgendaResourceEvents, { resourceEvents: item, schedulerData: schedulerData, subtitleGetter: props.subtitleGetter, eventItemClick: props.eventItemClick, viewEventClick: props.viewEventClick, viewEventText: props.viewEventText, viewEvent2Click: props.viewEvent2Click, viewEvent2Text: props.viewEvent2Text, slotClickedFunc: props.slotClickedFunc, slotItemTemplateResolver: props.slotItemTemplateResolver, eventItemTemplateResolver: props.eventItemTemplateResolver, eventItemPopoverTemplateResolver: props.eventItemPopoverTemplateResolver }, item.slotId)));
+    return (_jsx("tr", { children: _jsx("td", { children: _jsxs("table", { className: "scheduler-table", children: [_jsx("thead", { children: _jsxs("tr", { style: { height: tableHeaderHeight }, children: [_jsx("th", { style: { width: agendaResourceTableWidth }, className: "header3-text", children: resourceName }), _jsx("th", { className: "header3-text", children: agendaViewHeader })] }) }), _jsx("tbody", { children: resourceEventsList })] }) }) }));
 }
-AgendaView.propTypes = {
-  schedulerData: PropTypes.object.isRequired,
-  subtitleGetter: PropTypes.func,
-  eventItemClick: PropTypes.func,
-  viewEventClick: PropTypes.func,
-  viewEventText: PropTypes.string,
-  viewEvent2Click: PropTypes.func,
-  viewEvent2Text: PropTypes.string,
-  slotClickedFunc: PropTypes.func,
-  slotItemTemplateResolver: PropTypes.func,
-  eventItemTemplateResolver: PropTypes.func,
-  eventItemPopoverTemplateResolver: PropTypes.func
-};
-export default AgendaView;
+export default AgendaView;

package/dist/components/BodyView.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type SchedulerData from './SchedulerData';
+export interface BodyViewProps {
+    schedulerData: SchedulerData;
+    /** Changes whenever schedulerData mutates, so the memoised view re-renders. */
+    schedulerDataVersion?: number;
+}
+/** Render the table body (<tbody>) with one row per visible slot and one cell per header. */
+declare function BodyView({ schedulerData }: BodyViewProps): React.JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof BodyView>;
+export default _default;

package/dist/components/BodyView.js

@@ -1,70 +1,39 @@
-import PropTypes from 'prop-types';
-import React from 'react';
-
-/**
- * Render the table body (<tbody>) containing resource rows and cells based on schedulerData.
- * @param {object} schedulerData - Scheduler state and helpers. Expected properties used: `renderData` (array of row descriptors with `slotId`, `render`, `rowHeight`, `groupOnly`, `nonWorkingTime`), `headers` (array of header descriptors with `time` and `nonWorkingTime`), `config` (including `nonWorkingTimeBodyBgColor` and `groupOnlySlotColor`), `behaviors` (optional `getNonAgendaViewBodyCellBgColorFunc`), `getContentCellWidth()` and `isVerticalResourceView()`.
- * @returns {JSX.Element} The rendered `<tbody>` element containing a `<tr>` per rendered row and `<td>` cells for each header with computed inline styles.
- */
 import { jsx as _jsx } from "react/jsx-runtime";
-function BodyView({
-  schedulerData
-}) {
-  const {
-    renderData,
-    headers,
-    config,
-    behaviors
-  } = schedulerData;
-  const width = schedulerData.getContentCellWidth();
-  const tableRows = renderData.filter(o => o.render).map(row => {
-    const {
-      slotId,
-      groupOnly,
-      rowHeight
-    } = row;
-    const rowCells = headers.map(header => {
-      // vertical view: every header shares one time, the resource id tells the columns apart
-      const key = `${slotId}_${header.id ?? header.time}`;
-      const style = {
-        width,
-        minWidth: width
-      };
-      const isVertical = schedulerData.isVerticalResourceView();
-      if (isVertical) {
-        if (row.nonWorkingTime) {
-          style.backgroundColor = config.nonWorkingTimeBodyBgColor;
-        }
-      } else if (header.nonWorkingTime) {
-        style.backgroundColor = config.nonWorkingTimeBodyBgColor;
-      }
-      if (groupOnly) {
-        style.backgroundColor = config.groupOnlySlotColor;
-      }
-      if (behaviors.getNonAgendaViewBodyCellBgColorFunc) {
-        const cellBgColor = behaviors.getNonAgendaViewBodyCellBgColorFunc(schedulerData, slotId, header);
-        if (cellBgColor) {
-          style.backgroundColor = cellBgColor;
-        }
-      }
-      return /*#__PURE__*/_jsx("td", {
-        style: style,
-        children: /*#__PURE__*/_jsx("div", {})
-      }, key);
+import React from 'react';
+/** Render the table body (<tbody>) with one row per visible slot and one cell per header. */
+function BodyView({ schedulerData }) {
+    const { renderData, headers, config, behaviors } = schedulerData;
+    const width = schedulerData.getContentCellWidth();
+    const tableRows = renderData
+        .filter(o => o.render)
+        .map(row => {
+        const { slotId, groupOnly, rowHeight } = row;
+        const rowCells = headers.map(header => {
+            // vertical view: every header shares one time, the resource id tells the columns apart
+            const key = `${slotId}_${header.id ?? header.time}`;
+            const style = { width, minWidth: width };
+            const isVertical = schedulerData.isVerticalResourceView();
+            if (isVertical) {
+                if (row.nonWorkingTime) {
+                    style.backgroundColor = config.nonWorkingTimeBodyBgColor;
+                }
+            }
+            else if (header.nonWorkingTime) {
+                style.backgroundColor = config.nonWorkingTimeBodyBgColor;
+            }
+            if (groupOnly) {
+                style.backgroundColor = config.groupOnlySlotColor;
+            }
+            if (behaviors.getNonAgendaViewBodyCellBgColorFunc) {
+                const cellBgColor = behaviors.getNonAgendaViewBodyCellBgColorFunc(schedulerData, slotId, header);
+                if (cellBgColor) {
+                    style.backgroundColor = cellBgColor;
+                }
+            }
+            return (_jsx("td", { style: style, children: _jsx("div", {}) }, key));
+        });
+        return (_jsx("tr", { style: { height: rowHeight }, children: rowCells }, slotId));
     });
-    return /*#__PURE__*/_jsx("tr", {
-      style: {
-        height: rowHeight
-      },
-      children: rowCells
-    }, slotId);
-  });
-  return /*#__PURE__*/_jsx("tbody", {
-    children: tableRows
-  });
+    return _jsx("tbody", { children: tableRows });
 }
-BodyView.propTypes = {
-  schedulerData: PropTypes.object.isRequired,
-  schedulerDataVersion: PropTypes.number
-};
-export default /*#__PURE__*/React.memo(BodyView);
+export default React.memo(BodyView);

package/dist/components/DnDContext.d.ts

@@ -0,0 +1,48 @@
+import type { DropTargetHookSpec, DropTargetMonitor } from 'react-dnd';
+import { CellUnit } from '../config/default';
+import type { Id, RenderItem, SchedulerConfig } from '../types';
+import type DnDSource from './DnDSource';
+import type { DnDAction, DragItem, DropResult, Identifier } from './DnDSource';
+import type SchedulerData from './SchedulerData';
+/** The drop-target component: exposes the row element and (optionally) a drop preview setter. */
+export interface DropTargetComponent {
+    eventContainer: HTMLElement | null;
+    setDropPreview?: (preview: DropPreview) => void;
+}
+/** Box shown while dragging, in px relative to the row. */
+export interface DropPreview {
+    left: number;
+    width: number;
+}
+/** Props the component owning the drop target passes to getDropOptions. */
+export interface DnDContextProps {
+    schedulerData: SchedulerData;
+    resourceEvents: RenderItem;
+    movingEvent?(schedulerData: SchedulerData, slotId: Id, slotName: string | undefined, start: string, end: string, action: DnDAction, type: Identifier, item: DragItem): void;
+}
+type DropMonitor = DropTargetMonitor<DragItem, DropResult>;
+export default class DnDContext {
+    sourceMap: Map<Identifier, DnDSource>;
+    config?: SchedulerConfig;
+    constructor(sources: DnDSource[]);
+    extractInitialTimes: (monitor: DropMonitor, pos: {
+        x: number;
+        y: number;
+    }, cellWidth: number, resourceEvents: RenderItem, cellUnit: CellUnit, localeDayjs: SchedulerData['localeDayjs']) => {
+        initialStart: string;
+        initialEnd: string;
+    };
+    getVerticalMove: (props: DnDContextProps, monitor: DropMonitor, component: DropTargetComponent) => DropResult | null;
+    getDropPreview: (resourceEvents: RenderItem, cellWidth: number, firstIndex: number, start?: string, end?: string) => DropPreview;
+    getDropSpec: () => {
+        drop: (props: DnDContextProps, monitor: DropMonitor, component: DropTargetComponent) => DropResult | undefined;
+        hover: (props: DnDContextProps, monitor: DropMonitor, component: DropTargetComponent) => void;
+        canDrop: (props: DnDContextProps, monitor: DropMonitor) => boolean;
+    };
+    getDropOptions: (props: DnDContextProps, component: DropTargetComponent) => DropTargetHookSpec<DragItem, DropResult, {
+        isOver: boolean;
+        canDrop: boolean;
+    }>;
+    getDndSource: (dndType?: string) => DnDSource | undefined;
+}
+export {};