sprintify-ui 0.10.13 → 0.10.15

package/dist/types/components/BaseGantt.vue.d.ts

@@ -1,4 +1,5 @@
-import { GanttRow } from '@/services/gantt/types';
+import { GanttRow, GanttRowFormatted, Group, Tick, NowLine } from '@/services/gantt/types';
+import { slate } from 'tailwindcss/colors';
 type __VLS_Props = {
     rows: GanttRow[];
     rowHeight?: number;
@@ -6,416 +7,1136 @@ type __VLS_Props = {
     maxHeight?: number;
     includeToday?: boolean;
 };
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        sidebarItem?(_: {
-            row: {
-                id: number | string;
-                name: string;
-                meta?: Record<string, unknown> | undefined;
-                items: {
-                    id: number | string;
-                    start: {
-                        get: (unit: keyof import("luxon").DateTime) => number;
-                        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
-                        readonly isValid: boolean;
-                        readonly invalidReason: string | null;
-                        readonly invalidExplanation: string | null;
-                        readonly locale: string | null;
-                        readonly numberingSystem: string | null;
-                        readonly outputCalendar: string | null;
-                        readonly zone: {
-                            readonly type: string;
-                            readonly name: string;
-                            readonly isUniversal: boolean;
-                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
-                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
-                            offset: (ts: number) => number;
-                            equals: (other: import("luxon").Zone) => boolean;
-                            readonly isValid: boolean;
-                        };
-                        readonly zoneName: string | null;
-                        readonly year: number;
-                        readonly quarter: number;
-                        readonly month: number;
-                        readonly day: number;
-                        readonly hour: number;
-                        readonly minute: number;
-                        readonly second: number;
-                        readonly millisecond: number;
-                        readonly weekYear: number;
-                        readonly weekNumber: number;
-                        readonly weekday: number;
-                        readonly isWeekend: boolean;
-                        readonly localWeekday: number;
-                        readonly localWeekNumber: number;
-                        readonly localWeekYear: number;
-                        readonly ordinal: number;
-                        readonly monthShort: string | null;
-                        readonly monthLong: string | null;
-                        readonly weekdayShort: string | null;
-                        readonly weekdayLong: string | null;
-                        readonly offset: number;
-                        readonly offsetNameShort: string | null;
-                        readonly offsetNameLong: string | null;
-                        readonly isOffsetFixed: boolean | null;
-                        readonly isInDST: boolean;
-                        readonly isInLeapYear: boolean;
-                        readonly daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
-                        readonly daysInYear: number;
-                        readonly weeksInWeekYear: number;
-                        readonly weeksInLocalWeekYear: number;
-                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
-                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
-                        toLocal: () => import("luxon").DateTime<boolean>;
-                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
-                        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
-                        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
-                        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
-                        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
-                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
-                        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
-                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
-                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
-                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
-                        toISOWeekDate: () => string | null;
-                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                        toRFC2822: () => string | null;
-                        toHTTP: () => string | null;
-                        toSQLDate: () => string | null;
-                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
-                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
-                        toString: () => string;
-                        valueOf: () => number;
-                        toMillis: () => number;
-                        toSeconds: () => number;
-                        toUnixInteger: () => number;
-                        toJSON: () => string | null;
-                        toBSON: () => Date;
-                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
-                            includeConfig?: IncludeConfig | undefined;
-                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
-                        toJSDate: () => Date;
-                        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
-                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
-                        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
-                        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
-                        equals: (other: import("luxon").DateTime) => boolean;
-                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
-                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
-                    };
-                    end: {
-                        get: (unit: keyof import("luxon").DateTime) => number;
-                        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
-                        readonly isValid: boolean;
-                        readonly invalidReason: string | null;
-                        readonly invalidExplanation: string | null;
-                        readonly locale: string | null;
-                        readonly numberingSystem: string | null;
-                        readonly outputCalendar: string | null;
-                        readonly zone: {
-                            readonly type: string;
-                            readonly name: string;
-                            readonly isUniversal: boolean;
-                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
-                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
-                            offset: (ts: number) => number;
-                            equals: (other: import("luxon").Zone) => boolean;
-                            readonly isValid: boolean;
-                        };
-                        readonly zoneName: string | null;
-                        readonly year: number;
-                        readonly quarter: number;
-                        readonly month: number;
-                        readonly day: number;
-                        readonly hour: number;
-                        readonly minute: number;
-                        readonly second: number;
-                        readonly millisecond: number;
-                        readonly weekYear: number;
-                        readonly weekNumber: number;
-                        readonly weekday: number;
-                        readonly isWeekend: boolean;
-                        readonly localWeekday: number;
-                        readonly localWeekNumber: number;
-                        readonly localWeekYear: number;
-                        readonly ordinal: number;
-                        readonly monthShort: string | null;
-                        readonly monthLong: string | null;
-                        readonly weekdayShort: string | null;
-                        readonly weekdayLong: string | null;
-                        readonly offset: number;
-                        readonly offsetNameShort: string | null;
-                        readonly offsetNameLong: string | null;
-                        readonly isOffsetFixed: boolean | null;
-                        readonly isInDST: boolean;
-                        readonly isInLeapYear: boolean;
-                        readonly daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
-                        readonly daysInYear: number;
-                        readonly weeksInWeekYear: number;
-                        readonly weeksInLocalWeekYear: number;
-                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
-                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
-                        toLocal: () => import("luxon").DateTime<boolean>;
-                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
-                        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
-                        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
-                        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
-                        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
-                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
-                        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
-                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
-                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
-                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
-                        toISOWeekDate: () => string | null;
-                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                        toRFC2822: () => string | null;
-                        toHTTP: () => string | null;
-                        toSQLDate: () => string | null;
-                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
-                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
-                        toString: () => string;
-                        valueOf: () => number;
-                        toMillis: () => number;
-                        toSeconds: () => number;
-                        toUnixInteger: () => number;
-                        toJSON: () => string | null;
-                        toBSON: () => Date;
-                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
-                            includeConfig?: IncludeConfig | undefined;
-                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
-                        toJSDate: () => Date;
-                        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
-                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
-                        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
-                        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
-                        equals: (other: import("luxon").DateTime) => boolean;
-                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
-                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
-                    };
-                    name: string;
-                    meta?: Record<string, unknown> | undefined;
-                    color: string;
-                    milliseconds: number;
-                    x: number;
-                    y: number;
-                    width: number;
-                    height: number;
-                }[];
+declare const SIDEBAR_WIDTH = 120;
+declare const HEADER_HEIGHT = 40;
+declare const contentRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+declare const itemsRef: import("vue").Ref<HTMLUListElement | null, HTMLUListElement | null>;
+declare const width: import("vue").Ref<number, number>;
+declare const height: import("vue").Ref<number, number>;
+declare const rowsInternal: import("vue").Ref<{
+    id: number | string;
+    name: string;
+    meta?: Record<string, unknown> | undefined;
+    items: {
+        id: number | string;
+        start: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        end: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        name: string;
+        meta?: Record<string, unknown> | undefined;
+        color: string;
+        milliseconds: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+}[], GanttRowFormatted[] | {
+    id: number | string;
+    name: string;
+    meta?: Record<string, unknown> | undefined;
+    items: {
+        id: number | string;
+        start: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        end: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        name: string;
+        meta?: Record<string, unknown> | undefined;
+        color: string;
+        milliseconds: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+}[]>;
+declare const groups: import("vue").Ref<{
+    date: {
+        get: (unit: keyof import("luxon").DateTime) => number;
+        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+        readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+        readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+        readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+        readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly zone: import("luxon").Zone<IsValid>;
+        readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+        readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+        readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+        readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+        readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+        readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+        readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+        readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+        readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly isInLeapYear: boolean;
+        readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+        readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+        readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+        toLocal: () => import("luxon").DateTime<boolean>;
+        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+        toISOWeekDate: () => string | null;
+        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toRFC2822: () => string | null;
+        toHTTP: () => string | null;
+        toSQLDate: () => string | null;
+        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toString: () => string;
+        valueOf: () => number;
+        toMillis: () => number;
+        toSeconds: () => number;
+        toUnixInteger: () => number;
+        toJSON: () => string | null;
+        toBSON: () => Date;
+        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+            includeConfig?: IncludeConfig | undefined;
+        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+        toJSDate: () => Date;
+        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+        equals: (other: import("luxon").DateTime) => boolean;
+        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+    };
+    x: number;
+    width: number;
+    label: string;
+    labelX: number;
+    labelTextAnchor: "start" | "middle" | "end";
+}[], Group[] | {
+    date: {
+        get: (unit: keyof import("luxon").DateTime) => number;
+        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+        readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+        readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+        readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+        readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly zone: import("luxon").Zone<IsValid>;
+        readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+        readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+        readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+        readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+        readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+        readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+        readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+        readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+        readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly isInLeapYear: boolean;
+        readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+        readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+        readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+        toLocal: () => import("luxon").DateTime<boolean>;
+        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+        toISOWeekDate: () => string | null;
+        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toRFC2822: () => string | null;
+        toHTTP: () => string | null;
+        toSQLDate: () => string | null;
+        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toString: () => string;
+        valueOf: () => number;
+        toMillis: () => number;
+        toSeconds: () => number;
+        toUnixInteger: () => number;
+        toJSON: () => string | null;
+        toBSON: () => Date;
+        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+            includeConfig?: IncludeConfig | undefined;
+        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+        toJSDate: () => Date;
+        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+        equals: (other: import("luxon").DateTime) => boolean;
+        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+    };
+    x: number;
+    width: number;
+    label: string;
+    labelX: number;
+    labelTextAnchor: "start" | "middle" | "end";
+}[]>;
+declare const ticks: import("vue").Ref<{
+    date: {
+        get: (unit: keyof import("luxon").DateTime) => number;
+        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+        readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+        readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+        readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+        readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly zone: import("luxon").Zone<IsValid>;
+        readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+        readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+        readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+        readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+        readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+        readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+        readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+        readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+        readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly isInLeapYear: boolean;
+        readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+        readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+        readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+        toLocal: () => import("luxon").DateTime<boolean>;
+        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+        toISOWeekDate: () => string | null;
+        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toRFC2822: () => string | null;
+        toHTTP: () => string | null;
+        toSQLDate: () => string | null;
+        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toString: () => string;
+        valueOf: () => number;
+        toMillis: () => number;
+        toSeconds: () => number;
+        toUnixInteger: () => number;
+        toJSON: () => string | null;
+        toBSON: () => Date;
+        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+            includeConfig?: IncludeConfig | undefined;
+        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+        toJSDate: () => Date;
+        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+        equals: (other: import("luxon").DateTime) => boolean;
+        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+    };
+    x: number;
+    width: number;
+    label: string;
+    align: "start" | "middle" | string;
+    thick: boolean;
+}[], Tick[] | {
+    date: {
+        get: (unit: keyof import("luxon").DateTime) => number;
+        getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+        readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+        readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+        readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+        readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly zone: import("luxon").Zone<IsValid>;
+        readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+        readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+        readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+        readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+        readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+        readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+        readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+        readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+        readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+        readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+        readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+        readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+        readonly isInLeapYear: boolean;
+        readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+        readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+        readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+        toLocal: () => import("luxon").DateTime<boolean>;
+        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+        reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+        setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+        set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+        plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+        toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+        toISOWeekDate: () => string | null;
+        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+        toRFC2822: () => string | null;
+        toHTTP: () => string | null;
+        toSQLDate: () => string | null;
+        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+        toString: () => string;
+        valueOf: () => number;
+        toMillis: () => number;
+        toSeconds: () => number;
+        toUnixInteger: () => number;
+        toJSON: () => string | null;
+        toBSON: () => Date;
+        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+            includeConfig?: IncludeConfig | undefined;
+        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+        toJSDate: () => Date;
+        diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+        until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+        hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+        equals: (other: import("luxon").DateTime) => boolean;
+        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+    };
+    x: number;
+    width: number;
+    label: string;
+    align: "start" | "middle" | string;
+    thick: boolean;
+}[]>;
+declare const nowLine: import("vue").Ref<{
+    x: number;
+} | null, NowLine | {
+    x: number;
+} | null>;
+declare const scrollX: import("vue").Ref<number, number>;
+declare const scrollY: import("vue").Ref<number, number>;
+declare const currentGroup: import("vue").ComputedRef<Group | undefined>;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {
+    row: {
+        id: number | string;
+        name: string;
+        meta?: Record<string, unknown> | undefined;
+        items: {
+            id: number | string;
+            start: {
+                get: (unit: keyof import("luxon").DateTime) => number;
+                getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+                readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+                readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+                readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+                readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly zone: import("luxon").Zone<IsValid>;
+                readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+                readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+                readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+                readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+                readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+                readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+                readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+                readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+                readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+                readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+                readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+                readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+                readonly isInLeapYear: boolean;
+                readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+                readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+                readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+                readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+                toLocal: () => import("luxon").DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+                setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+                toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+                until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+                hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: import("luxon").DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
             };
-        }): any;
-        item?(_: {
-            item: {
-                id: number | string;
-                start: {
-                    get: (unit: keyof import("luxon").DateTime) => number;
-                    getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
-                    readonly isValid: boolean;
-                    readonly invalidReason: string | null;
-                    readonly invalidExplanation: string | null;
-                    readonly locale: string | null;
-                    readonly numberingSystem: string | null;
-                    readonly outputCalendar: string | null;
-                    readonly zone: {
-                        readonly type: string;
-                        readonly name: string;
-                        readonly isUniversal: boolean;
-                        offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
-                        formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
-                        offset: (ts: number) => number;
-                        equals: (other: import("luxon").Zone) => boolean;
-                        readonly isValid: boolean;
-                    };
-                    readonly zoneName: string | null;
-                    readonly year: number;
-                    readonly quarter: number;
-                    readonly month: number;
-                    readonly day: number;
-                    readonly hour: number;
-                    readonly minute: number;
-                    readonly second: number;
-                    readonly millisecond: number;
-                    readonly weekYear: number;
-                    readonly weekNumber: number;
-                    readonly weekday: number;
-                    readonly isWeekend: boolean;
-                    readonly localWeekday: number;
-                    readonly localWeekNumber: number;
-                    readonly localWeekYear: number;
-                    readonly ordinal: number;
-                    readonly monthShort: string | null;
-                    readonly monthLong: string | null;
-                    readonly weekdayShort: string | null;
-                    readonly weekdayLong: string | null;
-                    readonly offset: number;
-                    readonly offsetNameShort: string | null;
-                    readonly offsetNameLong: string | null;
-                    readonly isOffsetFixed: boolean | null;
-                    readonly isInDST: boolean;
-                    readonly isInLeapYear: boolean;
-                    readonly daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
-                    readonly daysInYear: number;
-                    readonly weeksInWeekYear: number;
-                    readonly weeksInLocalWeekYear: number;
-                    resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
-                    toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
-                    toLocal: () => import("luxon").DateTime<boolean>;
-                    setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
-                    reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
-                    setLocale: (locale: string) => import("luxon").DateTime<boolean>;
-                    set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
-                    plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                    minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                    startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
-                    endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
-                    toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
-                    toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
-                    toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
-                    toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                    toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
-                    toISOWeekDate: () => string | null;
-                    toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                    toRFC2822: () => string | null;
-                    toHTTP: () => string | null;
-                    toSQLDate: () => string | null;
-                    toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
-                    toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
-                    toString: () => string;
-                    valueOf: () => number;
-                    toMillis: () => number;
-                    toSeconds: () => number;
-                    toUnixInteger: () => number;
-                    toJSON: () => string | null;
-                    toBSON: () => Date;
-                    toObject: <IncludeConfig extends boolean | undefined>(opts?: {
-                        includeConfig?: IncludeConfig | undefined;
-                    } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
-                    toJSDate: () => Date;
-                    diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
-                    diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
-                    until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
-                    hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
-                    equals: (other: import("luxon").DateTime) => boolean;
-                    toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
-                    toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
-                };
-                end: {
-                    get: (unit: keyof import("luxon").DateTime) => number;
-                    getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
-                    readonly isValid: boolean;
-                    readonly invalidReason: string | null;
-                    readonly invalidExplanation: string | null;
-                    readonly locale: string | null;
-                    readonly numberingSystem: string | null;
-                    readonly outputCalendar: string | null;
-                    readonly zone: {
-                        readonly type: string;
-                        readonly name: string;
-                        readonly isUniversal: boolean;
-                        offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
-                        formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
-                        offset: (ts: number) => number;
-                        equals: (other: import("luxon").Zone) => boolean;
-                        readonly isValid: boolean;
-                    };
-                    readonly zoneName: string | null;
-                    readonly year: number;
-                    readonly quarter: number;
-                    readonly month: number;
-                    readonly day: number;
-                    readonly hour: number;
-                    readonly minute: number;
-                    readonly second: number;
-                    readonly millisecond: number;
-                    readonly weekYear: number;
-                    readonly weekNumber: number;
-                    readonly weekday: number;
-                    readonly isWeekend: boolean;
-                    readonly localWeekday: number;
-                    readonly localWeekNumber: number;
-                    readonly localWeekYear: number;
-                    readonly ordinal: number;
-                    readonly monthShort: string | null;
-                    readonly monthLong: string | null;
-                    readonly weekdayShort: string | null;
-                    readonly weekdayLong: string | null;
-                    readonly offset: number;
-                    readonly offsetNameShort: string | null;
-                    readonly offsetNameLong: string | null;
-                    readonly isOffsetFixed: boolean | null;
-                    readonly isInDST: boolean;
-                    readonly isInLeapYear: boolean;
-                    readonly daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
-                    readonly daysInYear: number;
-                    readonly weeksInWeekYear: number;
-                    readonly weeksInLocalWeekYear: number;
-                    resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
-                    toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
-                    toLocal: () => import("luxon").DateTime<boolean>;
-                    setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
-                    reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
-                    setLocale: (locale: string) => import("luxon").DateTime<boolean>;
-                    set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
-                    plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                    minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
-                    startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
-                    endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
-                    toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
-                    toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
-                    toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
-                    toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                    toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
-                    toISOWeekDate: () => string | null;
-                    toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
-                    toRFC2822: () => string | null;
-                    toHTTP: () => string | null;
-                    toSQLDate: () => string | null;
-                    toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
-                    toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
-                    toString: () => string;
-                    valueOf: () => number;
-                    toMillis: () => number;
-                    toSeconds: () => number;
-                    toUnixInteger: () => number;
-                    toJSON: () => string | null;
-                    toBSON: () => Date;
-                    toObject: <IncludeConfig extends boolean | undefined>(opts?: {
-                        includeConfig?: IncludeConfig | undefined;
-                    } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
-                    toJSDate: () => Date;
-                    diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
-                    diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
-                    until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
-                    hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
-                    equals: (other: import("luxon").DateTime) => boolean;
-                    toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
-                    toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
-                };
-                name: string;
-                meta?: Record<string, unknown> | undefined;
-                color: string;
-                milliseconds: number;
-                x: number;
-                y: number;
-                width: number;
-                height: number;
+            end: {
+                get: (unit: keyof import("luxon").DateTime) => number;
+                getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+                readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+                readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+                readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+                readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly zone: import("luxon").Zone<IsValid>;
+                readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+                readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+                readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+                readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+                readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+                readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+                readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+                readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+                readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+                readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+                readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+                readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+                readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+                readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+                readonly isInLeapYear: boolean;
+                readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+                readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+                readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+                readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+                toLocal: () => import("luxon").DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+                setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+                toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+                until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+                hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: import("luxon").DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
             };
-        }): any;
+            name: string;
+            meta?: Record<string, unknown> | undefined;
+            color: string;
+            milliseconds: number;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }[];
     };
-    refs: {
-        contentRef: HTMLDivElement;
-        itemsRef: HTMLUListElement;
+}, __VLS_3: {
+    item: {
+        id: number | string;
+        start: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        end: {
+            get: (unit: keyof import("luxon").DateTime) => number;
+            getPossibleOffsets: () => import("luxon").DateTime<boolean>[];
+            readonly isValid: import("luxon/src/_util").IfValid<true, false, IsValid>;
+            readonly invalidReason: import("luxon/src/_util").IfValid<null, string, IsValid>;
+            readonly invalidExplanation: import("luxon/src/_util").IfValid<null, string | null, IsValid>;
+            readonly locale: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly numberingSystem: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly outputCalendar: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly zone: import("luxon").Zone<IsValid>;
+            readonly zoneName: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly year: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly quarter: import("luxon/src/_util").IfValid<import("luxon").QuarterNumbers, typeof NaN, IsValid>;
+            readonly month: import("luxon/src/_util").IfValid<import("luxon").MonthNumbers, typeof NaN, IsValid>;
+            readonly day: import("luxon/src/_util").IfValid<import("luxon").DayNumbers, typeof NaN, IsValid>;
+            readonly hour: import("luxon/src/_util").IfValid<import("luxon").HourNumbers, typeof NaN, IsValid>;
+            readonly minute: import("luxon/src/_util").IfValid<import("luxon").MinuteNumbers, typeof NaN, IsValid>;
+            readonly second: import("luxon/src/_util").IfValid<import("luxon").SecondNumbers, typeof NaN, IsValid>;
+            readonly millisecond: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly weekNumber: import("luxon/src/_util").IfValid<import("luxon").WeekNumbers, typeof NaN, IsValid>;
+            readonly weekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly isWeekend: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly localWeekday: import("luxon/src/_util").IfValid<import("luxon").WeekdayNumbers, typeof NaN, IsValid>;
+            readonly localWeekNumber: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly localWeekYear: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly ordinal: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly monthShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly monthLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly weekdayLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offset: import("luxon/src/_util").IfValid<number, typeof NaN, IsValid>;
+            readonly offsetNameShort: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly offsetNameLong: import("luxon/src/_util").IfValid<string, null, IsValid>;
+            readonly isOffsetFixed: import("luxon/src/_util").IfValid<boolean, null, IsValid>;
+            readonly isInDST: import("luxon/src/_util").IfValid<boolean, false, IsValid>;
+            readonly isInLeapYear: boolean;
+            readonly daysInMonth: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInMonth, undefined, IsValid>;
+            readonly daysInYear: import("luxon/src/_util").IfValid<import("luxon").PossibleDaysInYear, typeof NaN, IsValid>;
+            readonly weeksInWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            readonly weeksInLocalWeekYear: import("luxon/src/_util").IfValid<import("luxon").PossibleWeeksInYear, typeof NaN, IsValid>;
+            resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+            toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => import("luxon").DateTime<boolean>;
+            toLocal: () => import("luxon").DateTime<boolean>;
+            setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+            reconfigure: (properties: import("luxon").LocaleOptions) => import("luxon").DateTime<boolean>;
+            setLocale: (locale: string) => import("luxon").DateTime<boolean>;
+            set: (values: import("luxon").DateObjectUnits) => import("luxon").DateTime<boolean>;
+            plus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            minus: (duration: import("luxon").DurationLike) => import("luxon").DateTime<boolean>;
+            startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => import("luxon").DateTime<boolean>;
+            endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => import("luxon").DateTime<boolean>;
+            toFormat: (fmt: string, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+            toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+            toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+            toISOWeekDate: () => string | null;
+            toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+            toRFC2822: () => string | null;
+            toHTTP: () => string | null;
+            toSQLDate: () => string | null;
+            toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+            toString: () => string;
+            valueOf: () => number;
+            toMillis: () => number;
+            toSeconds: () => number;
+            toUnixInteger: () => number;
+            toJSON: () => string | null;
+            toBSON: () => Date;
+            toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                includeConfig?: IncludeConfig | undefined;
+            } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+            toJSDate: () => Date;
+            diff: (otherDateTime: import("luxon").DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+            diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("luxon/src/_util").Valid>;
+            until: (otherDateTime: import("luxon").DateTime) => import("luxon").Interval<true> | import("luxon").DateTime<false>;
+            hasSame: (otherDateTime: import("luxon").DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+            equals: (other: import("luxon").DateTime) => boolean;
+            toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+            toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+        };
+        name: string;
+        meta?: Record<string, unknown> | undefined;
+        color: string;
+        milliseconds: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
     };
-    rootEl: HTMLDivElement;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    sidebarItem?: (props: typeof __VLS_1) => any;
+} & {
+    item?: (props: typeof __VLS_3) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {
+    slate: typeof slate;
+    SIDEBAR_WIDTH: typeof SIDEBAR_WIDTH;
+    HEADER_HEIGHT: typeof HEADER_HEIGHT;
+    contentRef: typeof contentRef;
+    itemsRef: typeof itemsRef;
+    width: typeof width;
+    height: typeof height;
+    rowsInternal: typeof rowsInternal;
+    groups: typeof groups;
+    ticks: typeof ticks;
+    nowLine: typeof nowLine;
+    scrollX: typeof scrollX;
+    scrollY: typeof scrollY;
+    currentGroup: typeof currentGroup;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "item:click": (...args: any[]) => void;
+    "row:click": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onItem:click"?: ((...args: any[]) => any) | undefined;
+    "onRow:click"?: ((...args: any[]) => any) | undefined;
+}>, {
+    maxHeight: number;
+    rowHeight: number;
+    rowPadding: number;
+    includeToday: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "item:click": (...args: any[]) => void;
     "row:click": (...args: any[]) => void;
@@ -427,10 +1148,10 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     rowHeight: number;
     rowPadding: number;
     includeToday: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };