@sdata/web-vue 1.18.0 → 2.1.0

package/es/calendar/core/i18n.d.ts

@@ -0,0 +1 @@
+export function createCalendarTexts(calendarLang?: object): object;

package/es/calendar/core/i18n.js

@@ -0,0 +1,72 @@
+/**
+ * Calendar i18n helpers.
+ *
+ * After `initializeDateLocale()` has been called (from config.js), the active
+ * dayjs locale contains month names, weekday names, AM/PM labels, etc.
+ * This module extracts that data into the shape the calendar runtime expects,
+ * merging it with UI text from the library's SDLang `calendar` section.
+ */
+
+import { dayjs } from '../../_utils/date';
+
+/**
+ * Reorders a dayjs weekday array from Sun-first [Sun, Mon, …, Sat]
+ * to the calendar's Mon-first [Mon, …, Sun].
+ */
+const reorderSunToMon = (arr) => [arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[0]];
+
+/**
+ * Builds the calendar `texts` object from the currently active dayjs locale
+ * and the library's SDLang calendar section.
+ *
+ * Must be called **after** `initializeDateLocale()` so that the dayjs locale
+ * data is loaded and set.
+ *
+ * @param {object} [calendarLang] — The `calendar` section from SDLang (from `useI18n().i18nMessage.value.calendar`).
+ * @returns {object} Calendar texts ready to merge into `calendar.texts`.
+ */
+export const createCalendarTexts = (calendarLang) => {
+  const localeData = dayjs.Ls[dayjs.locale()] || dayjs.Ls.en;
+
+  // Weekday names — reordered from dayjs Sun-first to calendar Mon-first.
+  const weekDays = reorderSunToMon(localeData.weekdays || []);
+  const weekDaysShort = reorderSunToMon(localeData.weekdaysShort || []);
+  const weekDaysMin = reorderSunToMon(
+    localeData.weekdaysMin || localeData.weekdaysShort?.map((d) => d.slice(0, 2)) || [],
+  );
+
+  // Month names (already 0-indexed Jan–Dec in dayjs).
+  const months = localeData.months || [];
+
+  // AM / PM from dayjs locale.
+  let am = 'am';
+  let pm = 'pm';
+  if (typeof localeData.meridiem === 'function') {
+    am = localeData.meridiem(0, 0, false);
+    pm = localeData.meridiem(12, 0, false);
+  }
+
+  return {
+    weekDays,
+    weekDaysShort,
+    weekDaysMin,
+    months,
+    am,
+    pm,
+    // UI text from library locale, with English fallbacks.
+    today: calendarLang?.today || 'Today',
+    allDay: calendarLang?.allDay || 'All Day',
+    noEvent: calendarLang?.noEvent || 'No Event',
+    deleteEvent: calendarLang?.deleteEvent || 'Delete',
+    createEvent: calendarLang?.createEvent || 'Create an event',
+    years: calendarLang?.view?.years || 'Years',
+    year: calendarLang?.view?.year || 'Year',
+    month: calendarLang?.view?.month || 'Month',
+    week: calendarLang?.view?.week || 'Week',
+    day: calendarLang?.view?.day || 'Day',
+    days: calendarLang?.view?.days || 'Days',
+    // Used by view.js to determine month-before-day ordering.
+    dateFormat: 'dddd MMMM D, YYYY',
+    truncations: true,
+  };
+};

package/es/calendar/core/index.d.ts

@@ -0,0 +1,112 @@
+export const globalState: {
+    texts: {
+        weekDays: any[];
+        weekDaysShort: never[];
+        weekDaysMin: never[];
+        months: any[];
+        years: string;
+        year: string;
+        month: string;
+        week: string;
+        day: string;
+        days: string;
+        today: string;
+        noEvent: string;
+        allDay: string;
+        deleteEvent: string;
+        createEvent: string;
+        dateFormat: string;
+        am: string;
+        pm: string;
+        truncations: boolean;
+    };
+    dateUtils: {
+        addDays: (date: any, days: any) => Date;
+        subtractDays: (date: any, days: any) => Date;
+        addHours: (date: any, hours: any) => Date;
+        subtractHours: (date: any, hours: any) => Date;
+        addMinutes: (date: any, minutes: any) => Date;
+        subtractMinutes: (date: any, minutes: any) => Date;
+        snapToInterval: (input: number | Date, interval: number) => number | void;
+        getWeek: (date: any) => number;
+        isToday: (date: any) => boolean;
+        isSameDate: (date1: any, date2: any) => boolean;
+        isInRange: (date: any, rangeStart: any, rangeEnd: any) => boolean;
+        isLeapYear: (date: any) => boolean | 0;
+        getPreviousFirstDayOfWeek: (date: any) => Date;
+        stringToDate: (date: any) => Date;
+        dateToMinutes: (date: any) => any;
+        countDays: (start: any, end: any) => number;
+        datesInSameTimeStep: (date1: any, date2: any, timeStep: any) => boolean;
+        isValid: (date: any) => any;
+        formatDate: (date: Date, format?: string, _txts?: Object) => string;
+        formatDateLite: (date: any) => string;
+        formatTime: (date: Date | number, format?: string, _txts?: Object, round?: boolean) => string;
+        formatTimeLite: (date: any) => string;
+        formatMinutes: (minutes: any) => string;
+        updateTexts: () => void;
+    };
+};
+export function useCalendar({ props, emit, attrs, calendarEl, scrollbarRef, uid, prefixCls }: object): {
+    uid: any;
+    prefixCls: any;
+    emit: any;
+    texts: {
+        weekDays: any[];
+        weekDaysShort: never[];
+        weekDaysMin: never[];
+        months: any[];
+        years: string;
+        year: string;
+        month: string;
+        week: string;
+        day: string;
+        days: string;
+        today: string;
+        noEvent: string;
+        allDay: string;
+        deleteEvent: string;
+        createEvent: string;
+        dateFormat: string;
+        am: string;
+        pm: string;
+        truncations: boolean;
+    };
+    dateUtils: {
+        addDays: (date: any, days: any) => Date;
+        subtractDays: (date: any, days: any) => Date;
+        addHours: (date: any, hours: any) => Date;
+        subtractHours: (date: any, hours: any) => Date;
+        addMinutes: (date: any, minutes: any) => Date;
+        subtractMinutes: (date: any, minutes: any) => Date;
+        snapToInterval: (input: number | Date, interval: number) => number | void;
+        getWeek: (date: any) => number;
+        isToday: (date: any) => boolean;
+        isSameDate: (date1: any, date2: any) => boolean;
+        isInRange: (date: any, rangeStart: any, rangeEnd: any) => boolean;
+        isLeapYear: (date: any) => boolean | 0;
+        getPreviousFirstDayOfWeek: (date: any) => Date;
+        stringToDate: (date: any) => Date;
+        dateToMinutes: (date: any) => any;
+        countDays: (start: any, end: any) => number;
+        datesInSameTimeStep: (date1: any, date2: any, timeStep: any) => boolean;
+        isValid: (date: any) => any;
+        formatDate: (date: Date, format?: string, _txts?: Object) => string;
+        formatDateLite: (date: any) => string;
+        formatTime: (date: Date | number, format?: string, _txts?: Object, round?: boolean) => string;
+        formatTimeLite: (date: any) => string;
+        formatMinutes: (minutes: any) => string;
+        updateTexts: () => void;
+    };
+    now: Date;
+    config: {};
+    eventsManager: {};
+    view: {};
+    dnd: {};
+    touch: {
+        isDraggingCell: boolean;
+        isDraggingEvent: boolean;
+        isResizingEvent: boolean;
+        currentHoveredCell: null;
+    };
+};

package/es/calendar/core/index.js

@@ -0,0 +1,66 @@
+import { reactive } from 'vue';
+
+import { useDragAndDrop } from '../modules/drag-and-drop';
+import { createDateUtils } from '../utils/date';
+import { defaults, useConfig } from './config';
+import { useEvents } from './events';
+import { useView } from './view';
+
+// Shared global reactive store: common to all the sd-calendar instances.
+export const globalState = reactive({
+  texts: { ...defaults.texts }, // Make texts reactive before a locale is loaded.
+  dateUtils: createDateUtils(), // Date utils using the library's dayjs.
+});
+
+/**
+ * This is the main composable of the calendar - the heart :)
+ * It is used one single time, from the index.vue and it's inject-provided to all the components.
+ *
+ * GLOBAL IMPORTANT NOTES
+ * ----------------------
+ * - There is no (and there shouldn't be) any use of Date prototypes in the codebase: even if using them
+ *   would simplify things a lot, the user may choose to disable them and nothing would work anymore.
+ *
+ * - Computed variables should only manage one thing (or a small group of vars) at a time:
+ *   Every recomputing can become very expensive when handling a large amount of cells per view
+ *   with a large amount of calendar events. So the more a computed is specific, the less it will have
+ *   expensive impact.
+ *   E.g. we definitely don't want that switching locale, or xs/sm prop would redraw the cells and
+ *   recalculate all the events rendering in each cell.
+ *
+ * @param {object} props The Vue props definition from the root sd-calendar component (index.vue).
+ * @param {function} emit The Vue emit function from the root sd-calendar component (index.vue).
+ */
+export const useCalendar = ({ props, emit, attrs, calendarEl, scrollbarRef, uid, prefixCls }) => {
+  // This reactive store is the one and only source of truth.
+  const state = reactive({
+    uid, // The sd-calendar instance unique ID, used for dnd source-target identification.
+    prefixCls,
+    emit,
+    texts: { ...globalState.texts }, // Make texts reactive before a locale is loaded.
+    // The date utils composable.
+    // A class/composable is needed in order to access the user locale in all the methods, and
+    // independently of other potential Calendar instances on the same page.
+    dateUtils: { ...globalState.dateUtils },
+    now: new Date(),
+    config: {},
+    eventsManager: {},
+    view: {}, // At any time this object will be filled with current view details and visible events.
+    dnd: {}, // Drag and drop module.
+    // stores the gesture related states. E.g. dragging event, resizing event, etc.
+    touch: {
+      isDraggingCell: false,
+      isDraggingEvent: false,
+      isResizingEvent: false,
+      currentHoveredCell: null, // Track the cell currently being hovered during event resizing.
+    },
+  });
+
+  state.dateUtils = createDateUtils();
+  state.config = useConfig(state, props, attrs);
+  state.eventsManager = useEvents(state);
+  state.view = useView(state, calendarEl, scrollbarRef);
+  state.dnd = useDragAndDrop(state);
+
+  return state;
+};

package/es/calendar/core/props-definitions.d.ts

@@ -0,0 +1,263 @@
+export const minutesInADay: number;
+export namespace props {
+    namespace allDayEvents {
+        export let type: BooleanConstructor;
+        let _default: boolean;
+        export { _default as default };
+    }
+    namespace stackEvents {
+        let type_1: BooleanConstructor;
+        export { type_1 as type };
+        let _default_1: boolean;
+        export { _default_1 as default };
+    }
+    namespace businessHours {
+        let type_2: ObjectConstructor;
+        export { type_2 as type };
+        function _default_2(): {};
+        export { _default_2 as default };
+    }
+    namespace clickToNavigate {
+        let type_3: BooleanConstructor;
+        export { type_3 as type };
+        let _default_3: undefined;
+        export { _default_3 as default };
+    }
+    namespace currentTimeLabel {
+        let type_4: BooleanConstructor;
+        export { type_4 as type };
+        let _default_4: boolean;
+        export { _default_4 as default };
+    }
+    namespace datePicker {
+        let type_5: BooleanConstructor;
+        export { type_5 as type };
+        let _default_5: boolean;
+        export { _default_5 as default };
+    }
+    namespace disableDays {
+        let type_6: ArrayConstructor;
+        export { type_6 as type };
+        function _default_6(): never[];
+        export { _default_6 as default };
+    }
+    namespace editableEvents {
+        let type_7: (ObjectConstructor | BooleanConstructor)[];
+        export { type_7 as type };
+        let _default_7: boolean;
+        export { _default_7 as default };
+    }
+    namespace eventCreateMinDrag {
+        let type_8: NumberConstructor;
+        export { type_8 as type };
+        let _default_8: number;
+        export { _default_8 as default };
+    }
+    namespace events {
+        let type_9: ArrayConstructor;
+        export { type_9 as type };
+        function _default_9(): never[];
+        export { _default_9 as default };
+    }
+    namespace eventCount {
+        let type_10: (ArrayConstructor | BooleanConstructor)[];
+        export { type_10 as type };
+        let _default_10: boolean;
+        export { _default_10 as default };
+    }
+    namespace eventsOnMonthView {
+        let type_11: BooleanConstructor;
+        export { type_11 as type };
+        let _default_11: boolean;
+        export { _default_11 as default };
+    }
+    namespace hideWeekdays {
+        let type_12: ArrayConstructor;
+        export { type_12 as type };
+        function _default_12(): never[];
+        export { _default_12 as default };
+    }
+    namespace hideWeekends {
+        let type_13: BooleanConstructor;
+        export { type_13 as type };
+        let _default_13: boolean;
+        export { _default_13 as default };
+    }
+    namespace horizontal {
+        let type_14: BooleanConstructor;
+        export { type_14 as type };
+        let _default_14: boolean;
+        export { _default_14 as default };
+    }
+    namespace locale {
+        let type_15: StringConstructor;
+        export { type_15 as type };
+        let _default_15: string;
+        export { _default_15 as default };
+    }
+    namespace maxDate {
+        let type_16: (StringConstructor | DateConstructor)[];
+        export { type_16 as type };
+        let _default_16: string;
+        export { _default_16 as default };
+    }
+    namespace minDate {
+        let type_17: (StringConstructor | DateConstructor)[];
+        export { type_17 as type };
+        let _default_17: string;
+        export { _default_17 as default };
+    }
+    namespace multidayEvents {
+        let type_18: BooleanConstructor;
+        export { type_18 as type };
+        let _default_18: boolean;
+        export { _default_18 as default };
+    }
+    namespace selectedDate {
+        let type_19: (StringConstructor | DateConstructor)[];
+        export { type_19 as type };
+        let _default_19: string;
+        export { _default_19 as default };
+    }
+    namespace sm {
+        let type_20: BooleanConstructor;
+        export { type_20 as type };
+        let _default_20: boolean;
+        export { _default_20 as default };
+    }
+    namespace specialHours {
+        let type_21: ObjectConstructor;
+        export { type_21 as type };
+        function _default_21(): {};
+        export { _default_21 as default };
+    }
+    namespace schedules {
+        let type_22: ArrayConstructor;
+        export { type_22 as type };
+        function _default_22(): never[];
+        export { _default_22 as default };
+    }
+    namespace snapToInterval {
+        let type_23: NumberConstructor;
+        export { type_23 as type };
+        let _default_23: number;
+        export { _default_23 as default };
+    }
+    namespace startWeekOnSunday {
+        let type_24: BooleanConstructor;
+        export { type_24 as type };
+        let _default_24: boolean;
+        export { _default_24 as default };
+    }
+    namespace theme {
+        let type_25: (StringConstructor | BooleanConstructor)[];
+        export { type_25 as type };
+        let _default_25: string;
+        export { _default_25 as default };
+    }
+    namespace time {
+        let type_26: BooleanConstructor;
+        export { type_26 as type };
+        let _default_26: boolean;
+        export { _default_26 as default };
+    }
+    namespace timeAtCursor {
+        let type_27: BooleanConstructor;
+        export { type_27 as type };
+        let _default_27: boolean;
+        export { _default_27 as default };
+    }
+    namespace timeCellHeight {
+        let type_28: NumberConstructor;
+        export { type_28 as type };
+        let _default_28: number;
+        export { _default_28 as default };
+    }
+    namespace timeFormat {
+        let type_29: StringConstructor;
+        export { type_29 as type };
+        let _default_29: string;
+        export { _default_29 as default };
+    }
+    namespace timeFrom {
+        let type_30: NumberConstructor;
+        export { type_30 as type };
+        let _default_30: number;
+        export { _default_30 as default };
+    }
+    namespace timeStep {
+        let type_31: NumberConstructor;
+        export { type_31 as type };
+        let _default_31: number;
+        export { _default_31 as default };
+    }
+    namespace timeTo {
+        let type_32: NumberConstructor;
+        export { type_32 as type };
+        export { minutesInADay as default };
+    }
+    namespace titleBar {
+        let type_33: BooleanConstructor;
+        export { type_33 as type };
+        let _default_32: boolean;
+        export { _default_32 as default };
+    }
+    namespace todayButton {
+        let type_34: BooleanConstructor;
+        export { type_34 as type };
+        let _default_33: boolean;
+        export { _default_33 as default };
+    }
+    namespace twelveHour {
+        let type_35: BooleanConstructor;
+        export { type_35 as type };
+        let _default_34: boolean;
+        export { _default_34 as default };
+    }
+    namespace view {
+        let type_36: StringConstructor;
+        export { type_36 as type };
+        let _default_35: string;
+        export { _default_35 as default };
+    }
+    namespace viewDate {
+        let type_37: (StringConstructor | DateConstructor)[];
+        export { type_37 as type };
+        let _default_36: string;
+        export { _default_36 as default };
+    }
+    namespace viewDayOffset {
+        let type_38: NumberConstructor;
+        export { type_38 as type };
+        let _default_37: number;
+        export { _default_37 as default };
+    }
+    namespace views {
+        let type_39: (ObjectConstructor | ArrayConstructor)[];
+        export { type_39 as type };
+    }
+    namespace viewsBar {
+        let type_40: BooleanConstructor;
+        export { type_40 as type };
+        let _default_38: boolean;
+        export { _default_38 as default };
+    }
+    namespace watchRealTime {
+        let type_41: BooleanConstructor;
+        export { type_41 as type };
+        let _default_39: boolean;
+        export { _default_39 as default };
+    }
+    namespace weekNumbers {
+        let type_42: BooleanConstructor;
+        export { type_42 as type };
+        let _default_40: boolean;
+        export { _default_40 as default };
+    }
+    namespace xs {
+        let type_43: BooleanConstructor;
+        export { type_43 as type };
+        let _default_41: boolean;
+        export { _default_41 as default };
+    }
+}

package/es/calendar/core/props-definitions.js

@@ -0,0 +1,70 @@
+export const minutesInADay = 24 * 60; // Don't do the maths every time.
+
+export const props = {
+  allDayEvents: { type: Boolean, default: false }, // Display all-day events in a fixed top bar on the day, days & week views.
+  stackEvents: { type: Boolean, default: false },
+  // Alias for specialHours when specialHours is empty; same shape. Kept as separate prop for clearer naming (e.g. business hours).
+  businessHours: { type: Object, default: () => ({}) },
+  clickToNavigate: { type: Boolean, default: undefined }, // Setting to false will force it off on date-picker.
+  currentTimeLabel: { type: Boolean, default: false }, // Show or hide the current time label in the time column.
+  datePicker: { type: Boolean, default: false }, // Shorthand for xs: true, views: [month, year, years], clickToNavigate: true.
+  disableDays: { type: Array, default: () => [] }, // Array of specific dates to disable.
+  // Can be true false or a finer grain permissions object like:
+  // { drag: bool, resize: bool, resizeX: bool, create: bool, delete: bool }
+  editableEvents: { type: [Boolean, Object], default: false },
+  // Minimum drag distance in pixels to create an event (prevents accidental event creation when trying to navigate).
+  eventCreateMinDrag: { type: Number, default: 15 }, // The minimum drag distance in pixels to create an event.
+  // The array of events to display in Calendar.
+  // Can hold just the view events and be updated or the full array of all events available.
+  events: { type: Array, default: () => [] },
+  // Displays an events counter in each cell on month view or year view.
+  // Can be a boolean or an array of views to display the event count on.
+  eventCount: { type: [Boolean, Array], default: false },
+  eventsOnMonthView: { type: Boolean, default: false }, // Displays events in full on month view.
+  hideWeekdays: { type: Array, default: () => [] }, // An array of strings. Possible values: 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'.
+  hideWeekends: { type: Boolean, default: false }, // Show or hide both Saturday and Sunday in days, week and month views.
+  horizontal: { type: Boolean, default: false }, // Show the calendar timeline horizontally.
+  // en-us is the default and fallback if locale is not supported.
+  // The locale can also be provided externally to avoid using Promises.
+  locale: { type: String, default: '' }, // A language to use for all the texts.
+  maxDate: { type: [String, Date], default: '' }, // Mostly for date pickers, sets a maximum date for cell interactions.
+  minDate: { type: [String, Date], default: '' }, // Mostly for date pickers, sets a minimum date for cell interactions.
+  multidayEvents: { type: Boolean, default: true }, // Allow events to span multiple days.
+  // A 2-way binding that highlights the selected date in the calendar but does not navigate to it.
+  selectedDate: { type: [String, Date], default: '' }, // The selected date in the calendar !== viewDate.
+  sm: { type: Boolean, default: false }, // Small size (truncates texts + specific styles).
+  specialHours: { type: Object, default: () => ({}) }, // Highlight special time ranges per weekday, with optional schedule-specific overrides.
+  schedules: { type: Array, default: () => [] }, // Split a day in different persons/rooms/locations schedules.
+  snapToInterval: { type: Number, default: 0 }, // Snap the event start and end to a specific interval in minutes.
+  startWeekOnSunday: { type: Boolean, default: false }, // Shows Sunday before Monday in days, week and month views.
+  theme: { type: [String, Boolean], default: 'default' }, // Only adds a CSS class when set to default.
+  time: { type: Boolean, default: true }, // Show or hide the time column.
+  timeAtCursor: { type: Boolean, default: false }, // Show or hide the "time at cursor" line.
+  timeCellHeight: { type: Number, default: 40 }, // In pixels.
+  timeFormat: { type: String, default: '' }, // Overrides the default time format.
+  timeFrom: { type: Number, default: 0 }, // Start time of the time column, in minutes.
+  timeStep: { type: Number, default: 60 }, // Step amount for the time in the time column, in minutes.
+  timeTo: { type: Number, default: minutesInADay }, // End time of the time column, in minutes.
+  titleBar: { type: Boolean, default: true }, // Show or hide the header title bar.
+  todayButton: { type: Boolean, default: true }, // Show or hide the header today button.
+  twelveHour: { type: Boolean, default: false }, // 12 or 24 hour format are respectively written like 1pm and 13:00.
+  // Sets the calendar view to one of: 'day', 'days', 'week', 'month', 'year', 'years'. Default 'week' or 'month' if datePicker.
+  // Gets updated on view navigation.
+  view: { type: String, default: '' },
+  viewDate: { type: [String, Date], default: '' }, // The view will automatically set its start and end to present this date.
+  // Only available for month and day views, this will shift the start of the view (left or right) by x days (signed integer).
+  viewDayOffset: { type: Number, default: 0 },
+  // The list of all the view that will be available in this calendar.
+  // Default for normal layout: ['day', 'days', 'week', 'month', 'year', 'years'] }.
+  // Default for date picker layout: ['month', 'year', 'years'].
+  views: { type: [Array, Object] },
+  viewsBar: { type: Boolean, default: true }, // Show or hide the headers view selection bar.
+  watchRealTime: { type: Boolean, default: false }, // More expensive, so only trigger on demand.
+  weekNumbers: { type: Boolean, default: false }, // Show the weeks numbers in a column on month view.
+  xs: { type: Boolean, default: false }, // Extra small size for date pickers (truncates texts + specific styles).
+
+  // TODO:
+  // minEventWidth: { type: Number, default: 0 },
+  // minScheduleWidth: { type: Number, default: 0 },
+  // overlapsPerTimeStep: { type: Boolean, default: false },
+};

package/es/calendar/core/view.d.ts

@@ -0,0 +1,60 @@
+export function useView({ config, dateUtils, emit, texts, eventsManager }: {
+    config: any;
+    dateUtils: any;
+    emit: any;
+    texts: any;
+    eventsManager: any;
+}, calendarEl: any, scrollbarRef: any): {
+    now: import("vue").Ref<Date, Date>;
+    id: import("vue").Ref<any, any>;
+    broaderView: import("vue").ComputedRef<string>;
+    narrowerView: import("vue").ComputedRef<string>;
+    title: import("vue").ComputedRef<any>;
+    titleWeekInfo: import("vue").ComputedRef<{
+        text: any;
+        number: any;
+    } | null>;
+    viewDate: import("vue").Ref<Date, Date>;
+    start: import("vue").ComputedRef<any>;
+    end: import("vue").ComputedRef<Date>;
+    extendedStart: import("vue").ComputedRef<any>;
+    extendedEnd: import("vue").ComputedRef<any>;
+    firstCellDate: import("vue").ComputedRef<any>;
+    lastCellDate: import("vue").ComputedRef<Date>;
+    containsToday: import("vue").ComputedRef<boolean>;
+    nowLine: any;
+    selectedDate: import("vue").Ref<any, any>;
+    cellDates: import("vue").ComputedRef<({
+        start: any;
+        startFormatted: any;
+        end: Date;
+    } | {
+        start: Date;
+        end: Date;
+        startFormatted?: undefined;
+    })[]>;
+    cols: import("vue").ComputedRef<any>;
+    rows: import("vue").ComputedRef<any>;
+    events: import("vue").ComputedRef<any>;
+    transitionDirection: import("vue").Ref<string, string>;
+    switch: (id: any, date: any) => void;
+    broader: () => void;
+    narrower: () => void;
+    previous: () => void;
+    next: () => void;
+    navigate: (forward?: bool) => void;
+    goToToday: () => void;
+    updateViewDate: (date: Date, emitUpdate?: boolean, forceUpdate?: boolean) => void;
+    updateSelectedDate: (date: any, emitUpdate?: boolean) => void;
+    scrollToCurrentTime: () => void;
+    scrollToTime: (minutes: any) => void;
+    scrollTop: () => void;
+    createEvent: any;
+    deleteEvent: any;
+    readonly isDay: boolean;
+    readonly isDays: boolean;
+    readonly isWeek: boolean;
+    readonly isMonth: boolean;
+    readonly isYear: boolean;
+    readonly isYears: boolean;
+};