@mantine-vue/schedule 3.1.0 → 3.2.0

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

@@ -0,0 +1,50 @@
+import type { ScheduleViewLevel } from '../../types';
+import type { ScheduleSlots } from './Schedule.types';
+import type { ScheduleOwnProps } from './Schedule.types';
+declare const defaultProps: {
+    defaultView: "week";
+    mode: "default";
+    recurrenceExpansionLimit: number;
+    layout: "default";
+};
+export { defaultProps };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScheduleOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:date": (date: string) => any;
+    dateChange: (date: string) => any;
+    dayClick: (date: string, nativeEvent: MouseEvent) => any;
+    eventDragStart: (event: import("../..").ScheduleEventData) => any;
+    eventDragEnd: () => any;
+    eventClick: (event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => any;
+    viewChange: (view: ScheduleViewLevel) => any;
+    eventDrop: (data: import("../..").EventDropData) => any;
+    timeSlotClick: (data: import("../..").TimeSlotClickData) => any;
+    allDaySlotClick: (date: string, nativeEvent: MouseEvent) => any;
+    slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
+    externalEventDrop: (dataTransfer: DataTransfer, dateTime: string) => any;
+    eventResize: (data: import("../..").EventDropData) => any;
+    monthClick: (month: string) => any;
+    "update:view": (view: ScheduleViewLevel) => any;
+}, string, import("vue").PublicProps, Readonly<ScheduleOwnProps> & Readonly<{
+    "onUpdate:date"?: ((date: string) => any) | undefined;
+    onDateChange?: ((date: string) => any) | undefined;
+    onDayClick?: ((date: string, nativeEvent: MouseEvent) => any) | undefined;
+    onEventDragStart?: ((event: import("../..").ScheduleEventData) => any) | undefined;
+    onEventDragEnd?: (() => any) | undefined;
+    onEventClick?: ((event: import("../..").ScheduleEventData, nativeEvent: MouseEvent) => any) | undefined;
+    onViewChange?: ((view: ScheduleViewLevel) => any) | undefined;
+    onEventDrop?: ((data: import("../..").EventDropData) => any) | undefined;
+    onTimeSlotClick?: ((data: import("../..").TimeSlotClickData) => any) | undefined;
+    onAllDaySlotClick?: ((date: string, nativeEvent: MouseEvent) => any) | undefined;
+    onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
+    onExternalEventDrop?: ((dataTransfer: DataTransfer, dateTime: string) => any) | undefined;
+    onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onMonthClick?: ((month: string) => any) | undefined;
+    "onUpdate:view"?: ((view: ScheduleViewLevel) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScheduleSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/ScheduleEvent/ScheduleEvent.d.ts

@@ -1,88 +1,11 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-import type { ScheduleEventProps, ScheduleEventRenderProps, RenderEvent, RenderEventBody } from '../../component-props';
-import type { ScheduleEventData, ScheduleMode } from '../../types';
-export interface ScheduleEventSlots {
-    /** Fallback body content (used when `renderEventBody`/`eventBody` are not provided) */
-    default?: () => VNodeChild;
-    /** Scoped alternative to the `renderEventBody` prop */
-    eventBody?: (props: {
-        event: ScheduleEventData;
-    }) => VNodeChild;
-    /** Scoped alternative to the `renderEvent` prop */
-    event?: (props: ScheduleEventRenderProps & {
-        event: ScheduleEventData;
-    }) => VNodeChild;
-}
-export declare const ScheduleEvent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    event: {
-        type: PropType<ScheduleEventData>;
-        required: true;
-    };
-    radius: {
-        type: PropType<string | number>;
-        default: string;
-    };
-    nowrap: BooleanConstructor;
-    autoSize: BooleanConstructor;
-    size: {
-        type: StringConstructor;
-        default: string;
-    };
-    renderEventBody: PropType<RenderEventBody>;
-    renderEvent: PropType<RenderEvent>;
-    hanging: PropType<ScheduleEventProps["hanging"]>;
-    draggable: BooleanConstructor;
-    onEventDragStart: PropType<(event: ScheduleEventData) => void>;
-    onEventDragEnd: PropType<() => void>;
-    isDragging: BooleanConstructor;
-    mode: {
-        type: PropType<ScheduleMode>;
-        default: string;
-    };
-    withResize: BooleanConstructor;
-    onResizeStart: PropType<(edge: "top" | "bottom", event: PointerEvent) => void>;
-    isResizing: BooleanConstructor;
-}>, () => string | number | true | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}> | import("vue").VNodeArrayChildren, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    event: {
-        type: PropType<ScheduleEventData>;
-        required: true;
-    };
-    radius: {
-        type: PropType<string | number>;
-        default: string;
-    };
-    nowrap: BooleanConstructor;
-    autoSize: BooleanConstructor;
-    size: {
-        type: StringConstructor;
-        default: string;
-    };
-    renderEventBody: PropType<RenderEventBody>;
-    renderEvent: PropType<RenderEvent>;
-    hanging: PropType<ScheduleEventProps["hanging"]>;
-    draggable: BooleanConstructor;
-    onEventDragStart: PropType<(event: ScheduleEventData) => void>;
-    onEventDragEnd: PropType<() => void>;
-    isDragging: BooleanConstructor;
-    mode: {
-        type: PropType<ScheduleMode>;
-        default: string;
-    };
-    withResize: BooleanConstructor;
-    onResizeStart: PropType<(edge: "top" | "bottom", event: PointerEvent) => void>;
-    isResizing: BooleanConstructor;
-}>> & Readonly<{}>, {
-    size: string;
-    mode: ScheduleMode;
-    draggable: boolean;
-    nowrap: boolean;
-    radius: string | number;
-    autoSize: boolean;
-    isDragging: boolean;
-    withResize: boolean;
-    isResizing: boolean;
-}, SlotsType<ScheduleEventSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export type { RenderEvent, RenderEventBody, ScheduleEventProps };
-export type ScheduleEventStylesNames = 'event' | 'eventInner' | 'eventResizeHandle';
+export declare const ScheduleEvent: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./ScheduleEvent.types").ScheduleEventProps, "rootRef">;
+    slots: import("./ScheduleEvent.types").ScheduleEventSlots;
+    emits: import("./ScheduleEvent.types").ScheduleEventEmits;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./ScheduleEvent.types").ScheduleEventStylesNames;
+    vars: import("./ScheduleEvent.types").ScheduleEventCssVariables;
+}>;
+export type { RenderEvent, RenderEventBody, ScheduleEventRenderProps } from '../../component-props';
+export type { ScheduleEventCssVariables, ScheduleEventEmits, ScheduleEventFactory, ScheduleEventHanging, ScheduleEventOwnProps, ScheduleEventProps, ScheduleEventResizeEdge, ScheduleEventSlots, ScheduleEventStylesNames, } from './ScheduleEvent.types';

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

@@ -0,0 +1,109 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { RenderEvent, RenderEventBody, ScheduleEventRenderProps } from '../../component-props';
+import type { ScheduleEventData, ScheduleMode } from '../../types';
+export type ScheduleEventStylesNames = 'event' | 'eventInner' | 'eventResizeHandle';
+export type ScheduleEventCssVariables = {
+    event: '--event-color' | '--event-bg' | '--event-hover' | '--event-radius';
+};
+/** Edge of the week or month the event continues past. */
+export type ScheduleEventHanging = 'start' | 'end' | 'both' | 'none';
+/** Edge of an event grabbed by a resize handle. */
+export type ScheduleEventResizeEdge = 'top' | 'bottom';
+export interface ScheduleEventSlots {
+    /** Fallback body, used when neither `renderEventBody` nor the `eventBody` slot is set. */
+    default?: () => VNodeChild;
+    /** Replaces the body of the event. Takes precedence over `renderEventBody`. */
+    eventBody?: (props: {
+        event: ScheduleEventData;
+    }) => VNodeChild;
+    /** Replaces the event entirely, root element included. Takes precedence over `renderEvent`. */
+    event?: (props: ScheduleEventRenderProps & {
+        event: ScheduleEventData;
+    }) => VNodeChild;
+}
+/** Props declared by `ScheduleEvent` itself. See `ScheduleEventProps` for the full public type. */
+export interface ScheduleEventOwnProps extends StylesApiProps<ScheduleEventFactory> {
+    /** Event rendered by the component. */
+    event: ScheduleEventData;
+    /**
+     * Key of `theme.radius` or any valid CSS value to set `border-radius`.
+     * @default 'sm'
+     */
+    radius?: string | number;
+    /**
+     * If set, the event title is truncated to a single line instead of wrapping.
+     * @default false
+     */
+    nowrap?: boolean;
+    /**
+     * If set, the event stretches to fill the box it is positioned in. Used by the
+     * time-axis views, where position and size come from inline styles.
+     * @default false
+     */
+    autoSize?: boolean;
+    /**
+     * Controls font size and padding.
+     * @default 'sm'
+     */
+    size?: 'sm' | 'md' | (string & {});
+    /**
+     * Replaces the body of the event. Can also be set with the `eventBody` slot,
+     * which takes precedence over the prop.
+     */
+    renderEventBody?: RenderEventBody;
+    /**
+     * Replaces the event entirely, root element included. Can also be set with the
+     * `event` slot, which takes precedence over the prop.
+     */
+    renderEvent?: RenderEvent;
+    /** Edge of the week or month the event continues past, used to flatten that corner. */
+    hanging?: ScheduleEventHanging;
+    /**
+     * If set, the event can be picked up with native drag and drop.
+     * @default false
+     */
+    draggable?: boolean;
+    /**
+     * If set, the event is marked as being dragged. Set by the parent view while a drag
+     * driven by something other than this event is in progress.
+     * @default false
+     */
+    isDragging?: boolean;
+    /**
+     * Interaction mode. `static` removes the event from the tab order and disables
+     * clicking, dragging and resizing.
+     * @default 'default'
+     */
+    mode?: ScheduleMode;
+    /**
+     * If set, resize handles are rendered on the top and bottom edges.
+     * @default false
+     */
+    withResize?: boolean;
+    /**
+     * If set, the event is marked as being resized.
+     * @default false
+     */
+    isResizing?: boolean;
+}
+export interface ScheduleEventProps extends Omit<BoxProps, keyof ScheduleEventOwnProps>, ScheduleEventOwnProps {
+}
+export interface ScheduleEventEmits {
+    /** Emitted when a native drag of this event starts. */
+    eventDragStart: [event: ScheduleEventData];
+    /** Emitted when a native drag of this event ends. */
+    eventDragEnd: [];
+    /** Emitted when a resize handle is pressed. */
+    resizeStart: [edge: ScheduleEventResizeEdge, event: PointerEvent];
+}
+export type ScheduleEventFactory = Factory<{
+    props: Omit<ScheduleEventProps, 'rootRef'>;
+    slots: ScheduleEventSlots;
+    emits: ScheduleEventEmits;
+    ref: HTMLButtonElement;
+    element: 'button';
+    stylesNames: ScheduleEventStylesNames;
+    vars: ScheduleEventCssVariables;
+}>;

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

@@ -0,0 +1,24 @@
+import type { ScheduleEventOwnProps, ScheduleEventResizeEdge, ScheduleEventSlots } from './ScheduleEvent.types';
+declare const defaultProps: {
+    readonly radius: "sm";
+    readonly size: "sm";
+    readonly mode: "default";
+};
+declare const varsResolver: (theme: import("@mantine-vue/core").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+export { defaultProps, varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScheduleEventOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    eventDragStart: (event: import("../..").ScheduleEventData) => any;
+    eventDragEnd: () => any;
+    resizeStart: (edge: ScheduleEventResizeEdge, event: PointerEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ScheduleEventOwnProps> & Readonly<{
+    onEventDragStart?: ((event: import("../..").ScheduleEventData) => any) | undefined;
+    onEventDragEnd?: (() => any) | undefined;
+    onResizeStart?: ((edge: ScheduleEventResizeEdge, event: PointerEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScheduleEventSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,36 @@
+export declare const HeaderControl: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./HeaderControl.types").HeaderControlProps, "rootRef">;
+    slots: import("./HeaderControl.types").HeaderControlSlots;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./HeaderControl.types").HeaderControlStylesNames;
+    vars: import("./HeaderControl.types").HeaderControlCssVariables;
+}>;
+/** `HeaderControl` preset that navigates to the next period. */
+export declare const ScheduleHeaderNext: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./HeaderControl.types").HeaderControlProps, "rootRef">;
+    slots: import("./HeaderControl.types").HeaderControlSlots;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./HeaderControl.types").HeaderControlStylesNames;
+    vars: import("./HeaderControl.types").HeaderControlCssVariables;
+}>;
+/** `HeaderControl` preset that navigates to the previous period. */
+export declare const ScheduleHeaderPrevious: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./HeaderControl.types").HeaderControlProps, "rootRef">;
+    slots: import("./HeaderControl.types").HeaderControlSlots;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./HeaderControl.types").HeaderControlStylesNames;
+    vars: import("./HeaderControl.types").HeaderControlCssVariables;
+}>;
+/** `HeaderControl` preset that navigates to today. */
+export declare const ScheduleHeaderToday: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./HeaderControl.types").HeaderControlProps, "rootRef">;
+    slots: import("./HeaderControl.types").HeaderControlSlots;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./HeaderControl.types").HeaderControlStylesNames;
+    vars: import("./HeaderControl.types").HeaderControlCssVariables;
+}>;
+export type { HeaderControlCssVariables, HeaderControlFactory, HeaderControlOwnProps, HeaderControlProps, HeaderControlSlots, HeaderControlStylesNames, } from './HeaderControl.types';

package/lib/components/ScheduleHeader/HeaderControl/HeaderControl.types.d.ts

@@ -0,0 +1,44 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { ScheduleLabelsOverride } from '../../../labels';
+export type HeaderControlStylesNames = 'headerControl';
+export type HeaderControlCssVariables = {
+    headerControl: '--control-radius';
+};
+export interface HeaderControlSlots {
+    /** Control content. */
+    default?: () => VNodeChild;
+}
+/** Props declared by `HeaderControl` itself. See `HeaderControlProps` for the full public type. */
+export interface HeaderControlOwnProps extends StylesApiProps<HeaderControlFactory> {
+    /**
+     * If set, the control is rendered in its active state.
+     * @default false
+     */
+    active?: boolean;
+    /**
+     * If set, horizontal padding is removed so the control renders as a square.
+     * @default false
+     */
+    square?: boolean;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`. */
+    radius?: string | number;
+    /**
+     * If set to `false`, the control is not clickable and is removed from the tab order.
+     * @default true
+     */
+    interactive?: boolean;
+    /** Label overrides, merged over the ones provided by the surrounding `ScheduleHeader`. */
+    labels?: ScheduleLabelsOverride;
+}
+export interface HeaderControlProps extends Omit<BoxProps, keyof HeaderControlOwnProps>, HeaderControlOwnProps {
+}
+export type HeaderControlFactory = Factory<{
+    props: Omit<HeaderControlProps, 'rootRef'>;
+    slots: HeaderControlSlots;
+    ref: HTMLButtonElement;
+    element: 'button';
+    stylesNames: HeaderControlStylesNames;
+    vars: HeaderControlCssVariables;
+}>;

package/lib/components/ScheduleHeader/HeaderControl/HeaderControl.vue.d.ts

@@ -0,0 +1,14 @@
+import type { HeaderControlOwnProps, HeaderControlSlots } from './HeaderControl.types';
+declare const defaultProps: {
+    readonly interactive: true;
+};
+declare const varsResolver: (theme: import("@mantine-vue/core").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+export { defaultProps, varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<HeaderControlOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderControlOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, HeaderControlSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/ScheduleHeader/HeaderControl/ScheduleHeaderNext.vue.d.ts

@@ -0,0 +1,11 @@
+import type { HeaderControlOwnProps, HeaderControlSlots } from './HeaderControl.types';
+type __VLS_Slots = HeaderControlSlots;
+declare const __VLS_base: import("vue").DefineComponent<HeaderControlOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderControlOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/ScheduleHeader/HeaderControl/ScheduleHeaderPrevious.vue.d.ts

@@ -0,0 +1,11 @@
+import type { HeaderControlOwnProps, HeaderControlSlots } from './HeaderControl.types';
+type __VLS_Slots = HeaderControlSlots;
+declare const __VLS_base: import("vue").DefineComponent<HeaderControlOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderControlOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/ScheduleHeader/HeaderControl/ScheduleHeaderToday.vue.d.ts

@@ -0,0 +1,11 @@
+import type { HeaderControlOwnProps, HeaderControlSlots } from './HeaderControl.types';
+type __VLS_Slots = HeaderControlSlots;
+declare const __VLS_base: import("vue").DefineComponent<HeaderControlOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderControlOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,2 +1 @@
-export { HeaderControl, ScheduleHeaderNext, ScheduleHeaderPrevious, ScheduleHeaderToday, } from '../ScheduleHeader';
-export type { HeaderControlProps, HeaderControlStylesNames } from '../ScheduleHeader';
+export * from './HeaderControl';

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

@@ -0,0 +1,8 @@
+export declare const MonthYearSelect: import("@mantine-vue/core").MantineComponent<{
+    props: Omit<import("./MonthYearSelect.types").MonthYearSelectProps, "rootRef">;
+    emits: import("./MonthYearSelect.types").MonthYearSelectEmits;
+    ref: HTMLButtonElement;
+    element: "button";
+    stylesNames: import("./MonthYearSelect.types").MonthYearSelectStylesNames;
+}>;
+export type { MonthYearSelectEmits, MonthYearSelectFactory, MonthYearSelectOwnProps, MonthYearSelectProps, MonthYearSelectStylesNames, } from './MonthYearSelect.types';

package/lib/components/ScheduleHeader/MonthYearSelect/MonthYearSelect.types.d.ts

@@ -0,0 +1,70 @@
+import type { BoxProps, Factory } from '@mantine-vue/core';
+import type { StylesApiProps } from '@mantine-vue/core/styles-api';
+import type { NativeButtonProps } from '../../../component-props';
+import type { ScheduleLabelsOverride } from '../../../labels';
+import type { DateLabelFormat } from '../../../types';
+export type MonthYearSelectStylesNames = 'monthYearSelectTarget' | 'monthYearSelectDropdown' | 'monthYearSelectControl' | 'monthYearSelectList' | 'monthYearSelectLabel';
+/** Props declared by `MonthYearSelect` itself. See `MonthYearSelectProps` for the full public type. */
+export interface MonthYearSelectOwnProps extends StylesApiProps<MonthYearSelectFactory> {
+    /**
+     * Locale passed down to `dayjs` when formatting the label and the month list.
+     * @default 'en'
+     */
+    locale?: string;
+    /**
+     * First year offered by the dropdown.
+     * @default current year - 5
+     */
+    startYear?: number;
+    /**
+     * Last year offered by the dropdown.
+     * @default current year + 5
+     */
+    endYear?: number;
+    /** Selected year, bound with `v-model:year-value`. */
+    yearValue?: number;
+    /** Selected month index, `0` – January. Bound with `v-model:month-value`. */
+    monthValue?: number;
+    /**
+     * Format of the month entries in the dropdown.
+     * @default 'MMMM'
+     */
+    monthsListFormat?: DateLabelFormat;
+    /**
+     * Format of the target control label.
+     * @default 'MMMM YYYY' when `withMonths` is set, 'YYYY' otherwise
+     */
+    labelFormat?: DateLabelFormat;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`. */
+    radius?: string | number;
+    /** Returns extra props for the control of the given year. */
+    getYearControlProps?: (year: number) => NativeButtonProps;
+    /** Returns extra props for the control of the given month. */
+    getMonthControlProps?: (month: number) => NativeButtonProps;
+    /**
+     * If set, the dropdown lists months next to the years.
+     * @default true
+     */
+    withMonths?: boolean;
+    /** Label overrides, merged over the ones provided by the surrounding `ScheduleHeader`. */
+    labels?: ScheduleLabelsOverride;
+}
+export interface MonthYearSelectProps extends Omit<BoxProps, keyof MonthYearSelectOwnProps>, MonthYearSelectOwnProps {
+}
+export interface MonthYearSelectEmits {
+    /** Emitted when a year is picked, bound with `v-model:year-value`. */
+    'update:yearValue': [year: number];
+    /** Emitted when a month is picked, bound with `v-model:month-value`. */
+    'update:monthValue': [month: number];
+    /** Emitted when a year is picked. */
+    yearChange: [year: number];
+    /** Emitted when a month is picked. */
+    monthChange: [month: number];
+}
+export type MonthYearSelectFactory = Factory<{
+    props: Omit<MonthYearSelectProps, 'rootRef'>;
+    emits: MonthYearSelectEmits;
+    ref: HTMLButtonElement;
+    element: 'button';
+    stylesNames: MonthYearSelectStylesNames;
+}>;

package/lib/components/ScheduleHeader/MonthYearSelect/MonthYearSelect.vue.d.ts

@@ -0,0 +1,21 @@
+import type { MonthYearSelectOwnProps } from './MonthYearSelect.types';
+declare const defaultProps: {
+    readonly monthsListFormat: "MMMM";
+    readonly withMonths: true;
+};
+/** Fallback radius of the dropdown, so it follows the schedule radius when one is set. */
+declare const DEFAULT_DROPDOWN_RADIUS = "var(--schedule-radius, var(--mantine-radius-default))";
+export { defaultProps, DEFAULT_DROPDOWN_RADIUS };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<MonthYearSelectOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:yearValue": (year: number) => any;
+    "update:monthValue": (month: number) => any;
+    yearChange: (year: number) => any;
+    monthChange: (month: number) => any;
+}, string, import("vue").PublicProps, Readonly<MonthYearSelectOwnProps> & Readonly<{
+    "onUpdate:yearValue"?: ((year: number) => any) | undefined;
+    "onUpdate:monthValue"?: ((month: number) => any) | undefined;
+    onYearChange?: ((year: number) => any) | undefined;
+    onMonthChange?: ((month: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,2 +1 @@
-export { MonthYearSelect } from '../ScheduleHeader';
-export type { MonthYearSelectProps, MonthYearSelectStylesNames } from '../ScheduleHeader';
+export * from './MonthYearSelect';

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

@@ -0,0 +1,12 @@
+import { type ComputedRef } from 'vue';
+import type { ScheduleLabelsOverride } from '../../labels';
+/**
+ * Shares the header's `labels` with the compound components rendered inside it.
+ * A getter is provided rather than the value so the labels stay reactive.
+ */
+export declare function provideScheduleHeaderLabels(labels: () => ScheduleLabelsOverride | undefined): void;
+/**
+ * Merges a control's own `labels` over the ones provided by the surrounding `ScheduleHeader`,
+ * so overriding a single key does not drop the rest. Must be called during `setup`.
+ */
+export declare function useScheduleHeaderLabels(override: () => ScheduleLabelsOverride | undefined): ComputedRef<ScheduleLabelsOverride | undefined>;