@mantine-vue/schedule 2.1.0

package/lib/components/ScheduleHeader/ViewSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { ViewSelect } from '../ScheduleHeader';
+export type { ViewSelectProps, ViewSelectStylesNames } from '../ScheduleHeader';

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

@@ -0,0 +1,2 @@
+export * from './ScheduleHeader';
+export * from './ScheduleHeaderBase';

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

@@ -0,0 +1,294 @@
+import { type CSSProperties, type PropType, type SlotsType, type VNodeChild } from 'vue';
+import type { WeekViewProps } from '../../component-props';
+import type { DateLabelFormat, DateStringValue, DayOfWeek } from '../../types';
+import { type EventSlots } from '../shared';
+export interface WeekViewSlots extends EventSlots {
+    /** Scoped alternative to the `renderWeekLabel` prop */
+    weekLabel?: (props: {
+        weekStart: DateStringValue;
+        weekEnd: DateStringValue;
+    }) => VNodeChild;
+}
+export declare const WeekView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    withCurrentTimeIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forceCurrentTimeIndicator: BooleanConstructor;
+    firstDayOfWeek: {
+        type: PropType<DayOfWeek>;
+        default: number;
+    };
+    weekdayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    dayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withWeekNumber: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withAllDaySlots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withWeekNumbers: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    withAllDaySlot: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    allDaySlotsHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    maxAllDayEvents: {
+        type: NumberConstructor;
+        default: number;
+    };
+    weekendDays: {
+        type: PropType<DayOfWeek[]>;
+        default: () => number[];
+    };
+    withWeekendDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    renderWeekLabel: PropType<WeekViewProps["renderWeekLabel"]>;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    slotLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withCurrentTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCurrentTime: PropType<() => import("../..").AnyDateValue>;
+    slotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    highlightBusinessHours: BooleanConstructor;
+    businessHours: PropType<import("../..").BusinessHoursValue>;
+    withEventsDragAndDrop: BooleanConstructor;
+    onEventDrop: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canDragEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    onEventDragStart: PropType<(event: import("../..").ScheduleEventData) => void>;
+    onEventDragEnd: PropType<() => void>;
+    onTimeSlotClick: PropType<(data: import("../../component-props").TimeSlotClickData) => void>;
+    onAllDaySlotClick: PropType<(date: DateStringValue, nativeEvent: MouseEvent) => void>;
+    withDragSlotSelect: BooleanConstructor;
+    onSlotDragEnd: FunctionConstructor;
+    startScrollTime: StringConstructor;
+    onExternalEventDrop: FunctionConstructor;
+    withEventResize: BooleanConstructor;
+    onEventResize: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canResizeEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    date: {
+        type: PropType<Date | DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: DateStringValue) => void>;
+    events: PropType<import("../..").ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    withCurrentTimeIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forceCurrentTimeIndicator: BooleanConstructor;
+    firstDayOfWeek: {
+        type: PropType<DayOfWeek>;
+        default: number;
+    };
+    weekdayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    dayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withWeekNumber: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withAllDaySlots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withWeekNumbers: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    withAllDaySlot: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    allDaySlotsHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    maxAllDayEvents: {
+        type: NumberConstructor;
+        default: number;
+    };
+    weekendDays: {
+        type: PropType<DayOfWeek[]>;
+        default: () => number[];
+    };
+    withWeekendDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    renderWeekLabel: PropType<WeekViewProps["renderWeekLabel"]>;
+    startTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    endTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalMinutes: {
+        type: NumberConstructor;
+        default: number;
+    };
+    slotLabelFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    withCurrentTimeBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCurrentTime: PropType<() => import("../..").AnyDateValue>;
+    slotHeight: {
+        type: PropType<CSSProperties["height"]>;
+        default: number;
+    };
+    highlightBusinessHours: BooleanConstructor;
+    businessHours: PropType<import("../..").BusinessHoursValue>;
+    withEventsDragAndDrop: BooleanConstructor;
+    onEventDrop: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canDragEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    onEventDragStart: PropType<(event: import("../..").ScheduleEventData) => void>;
+    onEventDragEnd: PropType<() => void>;
+    onTimeSlotClick: PropType<(data: import("../../component-props").TimeSlotClickData) => void>;
+    onAllDaySlotClick: PropType<(date: DateStringValue, nativeEvent: MouseEvent) => void>;
+    withDragSlotSelect: BooleanConstructor;
+    onSlotDragEnd: FunctionConstructor;
+    startScrollTime: StringConstructor;
+    onExternalEventDrop: FunctionConstructor;
+    withEventResize: BooleanConstructor;
+    onEventResize: PropType<(data: import("../../component-props").EventDropData) => void>;
+    canResizeEvent: PropType<(event: import("../..").ScheduleEventData) => boolean>;
+    date: {
+        type: PropType<Date | DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: DateStringValue) => void>;
+    events: PropType<import("../..").ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    mode: import("../..").ScheduleMode;
+    firstDayOfWeek: DayOfWeek;
+    weekendDays: DayOfWeek[];
+    withWeekNumbers: boolean;
+    weekdayFormat: DateLabelFormat;
+    startTime: string;
+    endTime: string;
+    intervalMinutes: number;
+    withWeekendDays: boolean;
+    slotHeight: import("csstype").Property.Height<string | number> | undefined;
+    highlightBusinessHours: boolean;
+    withHeader: boolean;
+    recurrenceExpansionLimit: number;
+    withEventsDragAndDrop: boolean;
+    withDragSlotSelect: boolean;
+    withEventResize: boolean;
+    withAllDaySlot: boolean;
+    maxAllDayEvents: number;
+    slotLabelFormat: DateLabelFormat;
+    withCurrentTimeIndicator: boolean;
+    withCurrentTimeBubble: boolean;
+    weekLabelFormat: DateLabelFormat;
+    forceCurrentTimeIndicator: boolean;
+    dayFormat: DateLabelFormat;
+    withWeekNumber: boolean;
+    withAllDaySlots: boolean;
+    allDaySlotsHeight: import("csstype").Property.Height<string | number> | undefined;
+}, SlotsType<WeekViewSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type { WeekViewProps };
+export type WeekViewStylesNames = 'weekView' | 'weekViewRoot' | 'weekViewHeader' | 'weekViewInner' | 'weekViewAllDaySlotsEvents' | 'weekViewAllDaySlots' | 'weekViewAllDaySlotsList' | 'weekViewAllDaySlot' | 'weekViewAllDaySlotsLabel' | 'weekViewScrollArea' | 'weekViewCorner' | 'weekViewSlotLabels' | 'weekViewSlotLabel' | 'weekViewDayLabel' | 'weekViewDayWeekday' | 'weekViewDay' | 'weekViewDayNumber' | 'weekViewDaySlot' | 'weekViewDaySlots' | 'weekViewWeekLabel' | 'weekViewWeekNumber' | 'weekViewBackgroundEvent';

package/lib/components/WeekView/get-week-label/get-week-label.d.ts

@@ -0,0 +1,13 @@
+import type { VNodeChild } from 'vue';
+import { DateLabelFormat, DateStringValue } from '../../../types';
+interface GetWeekLabelInput {
+    weekdays: Date[] | string[];
+    locale: string;
+    weekLabelFormat: DateLabelFormat;
+    renderWeekLabel?: (params: {
+        weekStart: DateStringValue;
+        weekEnd: DateStringValue;
+    }) => VNodeChild;
+}
+export declare function getWeekLabel({ weekdays, locale, weekLabelFormat, renderWeekLabel, }: GetWeekLabelInput): VNodeChild;
+export {};

package/lib/components/WeekView/get-week-view-events/assign-event-rows.d.ts

@@ -0,0 +1,2 @@
+import { ScheduleEventData, WeekPositionedEventData } from '../../../types';
+export declare function assignEventRows(events: WeekPositionedEventData[]): Map<ScheduleEventData, number>;

package/lib/components/WeekView/get-week-view-events/calculate-all-day-event-offset.d.ts

@@ -0,0 +1,11 @@
+import { Dayjs } from 'dayjs';
+import { DateStringValue } from '../../../types';
+interface CalculateAllDayEventOffsetInput {
+    eventStartDate: Dayjs;
+    weekStartDate: Dayjs;
+    weekDays: DateStringValue[];
+    visibleDaysCount: number;
+    hangingStart: boolean;
+}
+export declare function calculateAllDayEventOffset({ eventStartDate, weekStartDate, weekDays, visibleDaysCount, hangingStart, }: CalculateAllDayEventOffsetInput): number;
+export {};

package/lib/components/WeekView/get-week-view-events/calculate-all-day-event-width.d.ts

@@ -0,0 +1,12 @@
+import { Dayjs } from 'dayjs';
+import { DateStringValue } from '../../../types';
+interface CalculateAllDayEventWidthInput {
+    eventStartDate: Dayjs;
+    actualEndDate: Dayjs;
+    weekStartDate: Dayjs;
+    weekEndDate: Dayjs;
+    weekDays: DateStringValue[];
+    visibleDaysCount: number;
+}
+export declare function calculateAllDayEventWidth({ eventStartDate, actualEndDate, weekStartDate, weekEndDate, weekDays, visibleDaysCount, }: CalculateAllDayEventWidthInput): number;
+export {};

package/lib/components/WeekView/get-week-view-events/calculate-event-days.d.ts

@@ -0,0 +1,9 @@
+import { Dayjs } from 'dayjs';
+import { DateStringValue, ScheduleEventData } from '../../../types';
+interface CalculateEventDaysInput {
+    event: ScheduleEventData;
+    weekDays: DateStringValue[];
+    actualEndDate: Dayjs;
+}
+export declare function calculateEventDays({ event, weekDays, actualEndDate }: CalculateEventDaysInput): string[];
+export {};

package/lib/components/WeekView/get-week-view-events/calculate-regular-event-overlaps.d.ts

@@ -0,0 +1,2 @@
+import { WeekPositionedEventData } from '../../../types';
+export declare function calculateRegularEventOverlaps(events: WeekPositionedEventData[]): void;

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

@@ -0,0 +1,14 @@
+import { AnyDateValue, DayOfWeek, ScheduleEventData } from '../../../types';
+export interface FilterWeekViewEventsInput {
+    /** Date (week start) at which events are positioned, used to check if events are all-day */
+    date: AnyDateValue;
+    /** List of all events that belong to the given week, extra events must be filtered out before passing to the function */
+    events: ScheduleEventData[] | undefined;
+    /** Start time of the week view, used to calculate event positions */
+    startTime?: string;
+    /** End time of the week view, used to calculate event positions */
+    endTime?: string;
+    /** First day of the week, 0 - Sunday, 1 - Monday, etc., used to calculate events positions */
+    firstDayOfWeek?: DayOfWeek;
+}
+export declare function filterWeekViewEvents({ date, events, startTime, endTime, firstDayOfWeek, }: FilterWeekViewEventsInput): ScheduleEventData[];

package/lib/components/WeekView/get-week-view-events/find-available-column.d.ts

@@ -0,0 +1,9 @@
+import { DateStringValue, ScheduleEventData } from '../../../types';
+interface FindAvailableColumnInput {
+    columns: Map<string, ScheduleEventData[]>;
+    event: ScheduleEventData;
+    allDay: boolean;
+    allWeekDays: DateStringValue[];
+}
+export declare function findAvailableColumn(input: FindAvailableColumnInput): number;
+export {};

package/lib/components/WeekView/get-week-view-events/get-event-end-date.d.ts

@@ -0,0 +1,3 @@
+import dayjs from 'dayjs';
+import { ScheduleEventData } from '../../../types';
+export declare function getEventEndDate(event: ScheduleEventData): dayjs.Dayjs;

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

@@ -0,0 +1,9 @@
+import { Dayjs } from 'dayjs';
+import { DateStringValue } from '../../../types';
+interface GetHangingStatusInput {
+    eventStartDate: Dayjs;
+    actualEndDate: Dayjs;
+    weekDays: DateStringValue[];
+}
+export declare function getHangingStatus({ eventStartDate, actualEndDate, weekDays, }: GetHangingStatusInput): 'start' | 'end' | 'both' | 'none';
+export {};

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

@@ -0,0 +1,26 @@
+import { AnyDateValue, DateStringValue, DayOfWeek, ScheduleEventData, WeekPositionedEventData } from '../../../types';
+export interface GetWeekPositionedEventsInput {
+    /** Date (week start) at which events are positioned, used to check if events are all-day */
+    date: AnyDateValue;
+    /** List of all events that belong to the given week, extra events must be filtered out before passing to the function */
+    events: ScheduleEventData[];
+    /** Start time of the week view, used to calculate event positions */
+    startTime?: string;
+    /** End time of the week view, used to calculate event positions */
+    endTime?: string;
+    /** Number of minutes per time slot, used to align the canvas to whole slots */
+    intervalMinutes?: number;
+    /** First day of the week, 0 - Sunday, 1 - Monday, etc., used to calculate events positions */
+    firstDayOfWeek?: DayOfWeek;
+    /** Indices of weekend days, 0-6, where 0 is Sunday and 6 is Saturday */
+    weekendDays?: DayOfWeek[];
+    /** If set to false, weekend days are hidden @default true */
+    withWeekendDays?: boolean;
+}
+/** Events grouped by week day date (YYYY-MM-DD 00:00:00) and by columns */
+export interface GroupedWeekEvents {
+    allDayEvents: WeekPositionedEventData[];
+    regularEvents: Record<DateStringValue, WeekPositionedEventData[]>;
+    backgroundEvents: Record<DateStringValue, WeekPositionedEventData[]>;
+}
+export declare function getWeekPositionedEvents({ date, events, startTime, endTime, intervalMinutes, firstDayOfWeek, weekendDays, withWeekendDays, }: GetWeekPositionedEventsInput): GroupedWeekEvents;

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

@@ -0,0 +1,7 @@
+import { ScheduleEventData } from '../../../types';
+import { GetWeekPositionedEventsInput, GroupedWeekEvents } from './get-week-positioned-events';
+interface GetWeekViewEventsInput extends Omit<GetWeekPositionedEventsInput, 'events'> {
+    events: ScheduleEventData[] | undefined;
+}
+export declare function getWeekViewEvents(input: GetWeekViewEventsInput): GroupedWeekEvents;
+export {};

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

@@ -0,0 +1,4 @@
+export * from './WeekView';
+export * from './get-week-label/get-week-label';
+export * from './get-week-view-events/get-week-view-events';
+export * from './get-week-view-events/get-week-positioned-events';

package/lib/components/YearView/YearView.d.ts

@@ -0,0 +1,151 @@
+import { type PropType } from 'vue';
+import type { YearViewProps } from '../../component-props';
+import type { DateLabelFormat, DayOfWeek, ScheduleEventData } from '../../types';
+export declare const YearView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    firstDayOfWeek: {
+        type: PropType<DayOfWeek>;
+        default: number;
+    };
+    weekdayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    weekendDays: {
+        type: PropType<DayOfWeek[]>;
+        default: () => number[];
+    };
+    withWeekNumbers: BooleanConstructor;
+    withWeekDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    consistentWeeks: BooleanConstructor;
+    highlightToday: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withOutsideDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    monthsListFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    getDayProps: PropType<YearViewProps["getDayProps"]>;
+    getWeekNumberProps: PropType<YearViewProps["getWeekNumberProps"]>;
+    onDayClick: PropType<YearViewProps["onDayClick"]>;
+    onMonthClick: PropType<YearViewProps["onMonthClick"]>;
+    onWeekNumberClick: PropType<YearViewProps["onWeekNumberClick"]>;
+    date: {
+        type: PropType<Date | import("../..").DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: import("../..").DateStringValue) => void>;
+    events: PropType<ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    firstDayOfWeek: {
+        type: PropType<DayOfWeek>;
+        default: number;
+    };
+    weekdayFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    weekendDays: {
+        type: PropType<DayOfWeek[]>;
+        default: () => number[];
+    };
+    withWeekNumbers: BooleanConstructor;
+    withWeekDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    consistentWeeks: BooleanConstructor;
+    highlightToday: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withOutsideDays: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    monthsListFormat: {
+        type: PropType<DateLabelFormat>;
+        default: string;
+    };
+    getDayProps: PropType<YearViewProps["getDayProps"]>;
+    getWeekNumberProps: PropType<YearViewProps["getWeekNumberProps"]>;
+    onDayClick: PropType<YearViewProps["onDayClick"]>;
+    onMonthClick: PropType<YearViewProps["onMonthClick"]>;
+    onWeekNumberClick: PropType<YearViewProps["onWeekNumberClick"]>;
+    date: {
+        type: PropType<Date | import("../..").DateStringValue>;
+        required: boolean;
+    };
+    onDateChange: PropType<(date: import("../..").DateStringValue) => void>;
+    events: PropType<ScheduleEventData[]>;
+    locale: StringConstructor;
+    radius: PropType<string | number>;
+    labels: ObjectConstructor;
+    mode: {
+        type: PropType<import("../..").ScheduleMode>;
+        default: string;
+    };
+    withHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onViewChange: PropType<(view: import("../..").ScheduleViewLevel) => void>;
+    previousControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    nextControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    todayControlProps: PropType<import("../../component-props").NativeButtonProps>;
+    viewSelectProps: ObjectConstructor;
+    renderEventBody: PropType<import("../ScheduleEvent").RenderEventBody>;
+    renderEvent: PropType<import("../ScheduleEvent").RenderEvent>;
+    onEventClick: PropType<(event: ScheduleEventData, nativeEvent: MouseEvent) => void>;
+    recurrenceExpansionLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    mode: import("../..").ScheduleMode;
+    firstDayOfWeek: DayOfWeek;
+    weekendDays: DayOfWeek[];
+    consistentWeeks: boolean;
+    highlightToday: boolean;
+    withWeekNumbers: boolean;
+    weekdayFormat: DateLabelFormat;
+    monthsListFormat: DateLabelFormat;
+    withOutsideDays: boolean;
+    withHeader: boolean;
+    recurrenceExpansionLimit: number;
+    withWeekDays: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type { YearViewProps };
+export type YearViewStylesNames = 'yearView' | 'yearViewMonths' | 'yearViewMonth' | 'yearViewWeekdays' | 'yearViewWeek' | 'yearViewWeekNumber' | 'yearViewWeekday' | 'yearViewWeekdaysCorner' | 'yearViewDay' | 'yearViewMonthCaption' | 'yearViewDayIndicators' | 'yearViewDayIndicator';

package/lib/components/YearView/get-year-view-events/get-year-view-events.d.ts

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

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

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

package/lib/components/keyboard-navigation.d.ts

@@ -0,0 +1,7 @@
+export declare function handleGridKeydown({ event, index, columns, total, getControl, }: {
+    event: KeyboardEvent;
+    index: number;
+    columns: number;
+    total: number;
+    getControl: (index: number) => HTMLButtonElement | null;
+}): void;