6526 lines
313 KiB
TypeScript
6526 lines
313 KiB
TypeScript
|
|
|
|
|
|
import { validateTimestamp } from './util/timestamp.js';
|
|
import type { PropType } from 'vue';
|
|
import type { CalendarCategory, CalendarCategoryTextFunction, CalendarDayBodySlotScope, CalendarDaySlotScope, CalendarEvent, CalendarEventParsed, CalendarTimestamp } from './types.js';
|
|
import type { EventProp, GenericProps, JSXComponent } from '../../util/index.js';
|
|
interface VCalendarRenderProps {
|
|
start: CalendarTimestamp;
|
|
end: CalendarTimestamp;
|
|
component: JSXComponent & {
|
|
filterProps: <T>(props: T) => Partial<T>;
|
|
};
|
|
maxDays: number;
|
|
categories: CalendarCategory[];
|
|
}
|
|
interface EventSlotScope {
|
|
event: CalendarEvent;
|
|
outside: boolean;
|
|
singline: boolean;
|
|
overlapsNoon: boolean;
|
|
formatTime: (withTime: CalendarTimestamp, ampm: boolean) => string;
|
|
timeSummary: () => string;
|
|
eventSummary: () => JSX.Element;
|
|
eventParsed: CalendarEventParsed;
|
|
day: CalendarDaySlotScope;
|
|
start: boolean;
|
|
end: boolean;
|
|
timed: boolean;
|
|
}
|
|
interface DaySlotScope extends CalendarTimestamp {
|
|
outside: boolean;
|
|
index: number;
|
|
week: CalendarTimestamp[];
|
|
}
|
|
interface DayHeaderSlotScope extends CalendarTimestamp {
|
|
index: number;
|
|
week: CalendarTimestamp[];
|
|
}
|
|
interface CalendarDayCategorySlotScope extends CalendarDayBodySlotScope {
|
|
category: CalendarCategory;
|
|
}
|
|
export declare const VCalendar: {
|
|
new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
} & {
|
|
end?: string | number | Date | undefined;
|
|
firstDayOfWeek?: string | number | undefined;
|
|
firstDayOfYear?: string | number | undefined;
|
|
locale?: string | undefined;
|
|
now?: string | undefined;
|
|
eventTextColor?: string | import("./types.js").CalendarEventColorFunction | undefined;
|
|
modelValue?: string | number | Date | undefined;
|
|
categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
}, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
} & Omit<Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly shortIntervals: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getScrollPush" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "init" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "onResize" | "pane" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollPush" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly categories: string | CalendarCategory[];
|
|
readonly categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
readonly categoryForInvalid: string;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "parsedCategories" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "categoryText" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly minWeeks: number;
|
|
readonly monthFormat?: import("./types.js").CalendarFormatter | undefined;
|
|
readonly showWeek: boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly showMonthOnFirst: boolean;
|
|
readonly shortMonths: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "dayFormatter" | "days" | "effectiveWeekdays" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getStartOfWeek" | "getWeekNumber" | "isOutside" | "locale" | "monthFormatter" | "parsedEnd" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "times" | "todayWeek" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "locale" | "monthFormat" | "now" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps>, `$${any}`> & {
|
|
_allExposed: {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
};
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slot:category" | "v-slot:day-body" | "v-slot:day-header" | "v-slot:day-label" | "v-slot:day-label-header" | "v-slot:day-month" | "v-slot:interval-header" | "v-slots" | `${Uncapitalize<Capitalize<string>>}:date` | `${Uncapitalize<Capitalize<string>>}:day` | `${Uncapitalize<Capitalize<string>>}:dayCategory` | `${Uncapitalize<Capitalize<string>>}:event` | `${Uncapitalize<Capitalize<string>>}:interval` | `${Uncapitalize<Capitalize<string>>}:more` | `${Uncapitalize<Capitalize<string>>}:time` | `${Uncapitalize<Capitalize<string>>}:timeCategory`>, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
}, true, {}, import("vue").SlotsType<Partial<{
|
|
category: (arg: CalendarDayCategorySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
day: (arg: DaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-body': (arg: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-header': (arg: DayHeaderSlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-label': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-label-header': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-month': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
event: (arg: EventSlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
interval: (arg: CalendarDayCategorySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'interval-header': () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
|
|
P: {};
|
|
B: {};
|
|
D: {};
|
|
C: {};
|
|
M: {};
|
|
Defaults: {};
|
|
}, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
} & {
|
|
end?: string | number | Date | undefined;
|
|
firstDayOfWeek?: string | number | undefined;
|
|
firstDayOfYear?: string | number | undefined;
|
|
locale?: string | undefined;
|
|
now?: string | undefined;
|
|
eventTextColor?: string | import("./types.js").CalendarEventColorFunction | undefined;
|
|
modelValue?: string | number | Date | undefined;
|
|
categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
}, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
} & Omit<Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly shortIntervals: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getScrollPush" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "init" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "onResize" | "pane" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollPush" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly categories: string | CalendarCategory[];
|
|
readonly categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
readonly categoryForInvalid: string;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "parsedCategories" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "categoryText" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly minWeeks: number;
|
|
readonly monthFormat?: import("./types.js").CalendarFormatter | undefined;
|
|
readonly showWeek: boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly showMonthOnFirst: boolean;
|
|
readonly shortMonths: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "dayFormatter" | "days" | "effectiveWeekdays" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getStartOfWeek" | "getWeekNumber" | "isOutside" | "locale" | "monthFormatter" | "parsedEnd" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "times" | "todayWeek" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "locale" | "monthFormat" | "now" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps>, `$${any}`> & {
|
|
_allExposed: {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
};
|
|
}, {}, {}, {}, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
}>;
|
|
__isFragment?: never;
|
|
__isTeleport?: never;
|
|
__isSuspense?: never;
|
|
} & import("vue").ComponentOptionsBase<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
} & {
|
|
end?: string | number | Date | undefined;
|
|
firstDayOfWeek?: string | number | undefined;
|
|
firstDayOfYear?: string | number | undefined;
|
|
locale?: string | undefined;
|
|
now?: string | undefined;
|
|
eventTextColor?: string | import("./types.js").CalendarEventColorFunction | undefined;
|
|
modelValue?: string | number | Date | undefined;
|
|
categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
}, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
} & Omit<Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly shortIntervals: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
shortWeekdays: boolean;
|
|
shortIntervals: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortIntervals: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getScrollPush" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "init" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "onResize" | "pane" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollPush" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("dayFormat" | "firstInterval" | "hideHeader" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "shortIntervals" | "shortWeekdays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly maxDays: number;
|
|
readonly intervalHeight: string | number;
|
|
readonly intervalWidth: string | number;
|
|
readonly intervalMinutes: string | number;
|
|
readonly firstInterval: string | number;
|
|
readonly firstTime?: import("./util/timestamp.js").VTime | undefined;
|
|
readonly intervalCount: string | number;
|
|
readonly intervalFormat: import("./types.js").CalendarFormatter;
|
|
readonly intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
readonly showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
readonly categories: string | CalendarCategory[];
|
|
readonly categoryText?: string | CalendarCategoryTextFunction | undefined;
|
|
readonly categoryForInvalid: string;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
maxDays: number;
|
|
intervalHeight: string | number;
|
|
intervalWidth: string | number;
|
|
intervalMinutes: string | number;
|
|
firstInterval: string | number;
|
|
intervalCount: string | number;
|
|
intervalFormat: import("./types.js").CalendarFormatter;
|
|
intervalStyle: (interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
showIntervalLabel: (interval: CalendarTimestamp) => boolean;
|
|
categories: string | CalendarCategory[];
|
|
categoryForInvalid: string;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
intervalHeight: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalWidth: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalMinutes: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstInterval: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
firstTime: {
|
|
type: PropType<import("./util/timestamp.js").VTime>;
|
|
validate: typeof import("./util/timestamp.js").validateTime;
|
|
};
|
|
intervalCount: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
};
|
|
intervalFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
intervalStyle: {
|
|
type: PropType<(interval: CalendarTimestamp) => import("vue").StyleValue>;
|
|
default: null;
|
|
};
|
|
showIntervalLabel: {
|
|
type: PropType<(interval: CalendarTimestamp) => boolean>;
|
|
default: null;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: PropType<string | CalendarCategoryTextFunction>;
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>, "bodyHeight" | "dayFormatter" | "days" | "effectiveWeekdays" | "firstMinute" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getSlotScope" | "getStartOfWeek" | "getTimestampAtEvent" | "getWeekNumber" | "intervalFormatter" | "intervalStyleDefault" | "intervals" | "locale" | "minutesToPixels" | "parsedCategories" | "parsedEnd" | "parsedFirstInterval" | "parsedFirstTime" | "parsedIntervalCount" | "parsedIntervalHeight" | "parsedIntervalMinutes" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "scrollAreaRef" | "scrollToTime" | "showIntervalLabelDefault" | "timeDelta" | "timeToY" | "times" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "categoryText" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "firstTime" | "locale" | "now" | ("categories" | "categoryForInvalid" | "dayFormat" | "firstInterval" | "intervalCount" | "intervalFormat" | "intervalHeight" | "intervalMinutes" | "intervalStyle" | "intervalWidth" | "maxDays" | "showIntervalLabel" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps> | Omit<{
|
|
$: import("vue").ComponentInternalInstance;
|
|
$data: {};
|
|
$props: Partial<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<{
|
|
readonly start: string | number | Date;
|
|
readonly end?: string | number | Date | undefined;
|
|
readonly weekdays: string | number[];
|
|
readonly firstDayOfWeek?: string | number | undefined;
|
|
readonly firstDayOfYear?: string | number | undefined;
|
|
readonly weekdayFormat: import("./types.js").CalendarFormatter;
|
|
readonly dayFormat: import("./types.js").CalendarFormatter;
|
|
readonly locale?: string | undefined;
|
|
readonly now?: string | undefined;
|
|
readonly type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
readonly minWeeks: number;
|
|
readonly monthFormat?: import("./types.js").CalendarFormatter | undefined;
|
|
readonly showWeek: boolean;
|
|
readonly color?: string | undefined;
|
|
readonly shortWeekdays: boolean;
|
|
readonly showMonthOnFirst: boolean;
|
|
readonly shortMonths: boolean;
|
|
readonly hideHeader: boolean;
|
|
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays">;
|
|
$attrs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$refs: {
|
|
[x: string]: unknown;
|
|
};
|
|
$slots: Readonly<{
|
|
[name: string]: import("vue").Slot<any> | undefined;
|
|
}>;
|
|
$root: import("vue").ComponentPublicInstance | null;
|
|
$parent: import("vue").ComponentPublicInstance | null;
|
|
$host: Element | null;
|
|
$emit: (event: string, ...args: any[]) => void;
|
|
$el: any;
|
|
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
|
|
beforeCreate?: (() => void)[] | (() => void);
|
|
created?: (() => void)[] | (() => void);
|
|
beforeMount?: (() => void)[] | (() => void);
|
|
mounted?: (() => void)[] | (() => void);
|
|
beforeUpdate?: (() => void)[] | (() => void);
|
|
updated?: (() => void)[] | (() => void);
|
|
activated?: (() => void)[] | (() => void);
|
|
deactivated?: (() => void)[] | (() => void);
|
|
beforeDestroy?: (() => void)[] | (() => void);
|
|
beforeUnmount?: (() => void)[] | (() => void);
|
|
destroyed?: (() => void)[] | (() => void);
|
|
unmounted?: (() => void)[] | (() => void);
|
|
renderTracked?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
renderTriggered?: ((e: import("vue").DebuggerEvent) => void)[] | ((e: import("vue").DebuggerEvent) => void);
|
|
errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[] | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void);
|
|
};
|
|
$forceUpdate: () => void;
|
|
$nextTick: typeof import("vue").nextTick;
|
|
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
|
|
} & Readonly<{
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
minWeeks: number;
|
|
showWeek: boolean;
|
|
shortWeekdays: boolean;
|
|
showMonthOnFirst: boolean;
|
|
shortMonths: boolean;
|
|
hideHeader: boolean;
|
|
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
minWeeks: {
|
|
validate: typeof import("./util/timestamp.js").validateNumber;
|
|
default: number;
|
|
};
|
|
monthFormat: PropType<import("./types.js").CalendarFormatter>;
|
|
showWeek: BooleanConstructor;
|
|
color: StringConstructor;
|
|
shortWeekdays: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
showMonthOnFirst: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
shortMonths: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
hideHeader: BooleanConstructor;
|
|
}>>, "dayFormatter" | "days" | "effectiveWeekdays" | "getColorProps" | "getEndOfWeek" | "getFormatter" | "getRelativeClasses" | "getStartOfWeek" | "getWeekNumber" | "isOutside" | "locale" | "monthFormatter" | "parsedEnd" | "parsedStart" | "parsedValue" | "parsedWeekdays" | "times" | "todayWeek" | "updateTimes" | "weekdayFormatter" | "weekdaySkips" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays")> & import("vue").ShallowUnwrapRef<{
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
}> & {} & import("vue").ComponentCustomProperties & {}, "color" | "end" | "firstDayOfWeek" | "firstDayOfYear" | "locale" | "monthFormat" | "now" | ("dayFormat" | "hideHeader" | "minWeeks" | "shortMonths" | "shortWeekdays" | "showMonthOnFirst" | "showWeek" | "start" | "type" | "weekdayFormat" | "weekdays") | keyof import("vue").AllowedComponentProps | keyof import("vue").VNodeProps>, `$${any}`> & {
|
|
_allExposed: {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
scrollPush: import("vue").Ref<number, number>;
|
|
pane: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
|
|
init: () => void;
|
|
onResize: () => void;
|
|
getScrollPush: () => number;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
scrollAreaRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
|
|
parsedFirstInterval: import("vue").ComputedRef<number>;
|
|
parsedIntervalMinutes: import("vue").ComputedRef<number>;
|
|
parsedIntervalCount: import("vue").ComputedRef<number>;
|
|
parsedIntervalHeight: import("vue").ComputedRef<number>;
|
|
parsedFirstTime: import("vue").ComputedRef<number | false>;
|
|
firstMinute: import("vue").ComputedRef<number>;
|
|
bodyHeight: import("vue").ComputedRef<number>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
intervals: import("vue").ComputedRef<CalendarTimestamp[][]>;
|
|
intervalFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
showIntervalLabelDefault: (interval: CalendarTimestamp) => boolean;
|
|
intervalStyleDefault: (_interval: CalendarTimestamp) => import("vue").StyleValue;
|
|
getTimestampAtEvent: (e: Event, day: CalendarTimestamp) => CalendarTimestamp;
|
|
getSlotScope: (timestamp: CalendarTimestamp) => CalendarDayBodySlotScope;
|
|
scrollToTime: (time: import("./util/timestamp.js").VTime) => boolean;
|
|
minutesToPixels: (minutes: number) => number;
|
|
timeToY: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDateOrClamp?: CalendarTimestamp | boolean) => number | false;
|
|
timeDelta: (time: import("./util/timestamp.js").VTime | CalendarTimestamp, targetDate?: CalendarTimestamp) => number | false;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
todayWeek: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
monthFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
isOutside: (day: CalendarTimestamp) => boolean;
|
|
} | {
|
|
times: {
|
|
now: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
today: {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
};
|
|
};
|
|
locale: {
|
|
name: string;
|
|
decimalSeparator: import("vue").ShallowRef<string>;
|
|
messages: import("vue").Ref<import("../../types.js").LocaleMessages, import("../../types.js").LocaleMessages>;
|
|
current: import("vue").Ref<string, string>;
|
|
fallback: import("vue").Ref<string, string>;
|
|
t: (key: string, ...params: unknown[]) => string;
|
|
n: (value: number) => string;
|
|
provide: (props: import("../../types.js").LocaleOptions) => import("../../types.js").LocaleInstance;
|
|
isRtl: import("vue").Ref<boolean, boolean>;
|
|
rtl: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
|
|
rtlClasses: import("vue").Ref<string, string>;
|
|
};
|
|
parsedValue: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedWeekdays: import("vue").ComputedRef<number[]>;
|
|
effectiveWeekdays: import("vue").ComputedRef<number[]>;
|
|
weekdaySkips: import("vue").ComputedRef<number[]>;
|
|
parsedStart: import("vue").ComputedRef<CalendarTimestamp>;
|
|
parsedEnd: import("vue").ComputedRef<CalendarTimestamp>;
|
|
days: import("vue").ComputedRef<CalendarTimestamp[]>;
|
|
dayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
weekdayFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
getColorProps: (colors: {
|
|
background?: import("../../composables/color.js").ColorValue;
|
|
text?: import("../../composables/color.js").ColorValue;
|
|
}) => {
|
|
class: string[];
|
|
style: import("vue").CSSProperties;
|
|
};
|
|
getRelativeClasses: (timestamp: CalendarTimestamp, outside?: boolean) => {
|
|
'v-present': boolean;
|
|
'v-past': boolean;
|
|
'v-future': boolean;
|
|
'v-outside': boolean;
|
|
};
|
|
getWeekNumber: (timestamp: CalendarTimestamp) => number;
|
|
getStartOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getEndOfWeek: (timestamp: CalendarTimestamp) => CalendarTimestamp;
|
|
getFormatter: (options: Intl.DateTimeFormatOptions) => import("./types.js").CalendarFormatter;
|
|
updateTimes: () => void;
|
|
noEvents: import("vue").ComputedRef<boolean>;
|
|
parsedEvents: import("vue").ComputedRef<CalendarEventParsed[]>;
|
|
parsedEventOverlapThreshold: import("vue").ComputedRef<number>;
|
|
eventTimedFunction: import("vue").ComputedRef<import("./types.js").CalendarEventTimedFunction>;
|
|
eventCategoryFunction: import("vue").ComputedRef<import("./types.js").CalendarEventCategoryFunction>;
|
|
eventTextColorFunction: import("vue").ComputedRef<import("./types.js").CalendarEventColorFunction>;
|
|
eventNameFunction: import("vue").ComputedRef<import("./types.js").CalendarEventNameFunction>;
|
|
eventModeFunction: import("vue").ComputedRef<import("./types.js").CalendarEventOverlapMode>;
|
|
eventColorFunction: (e: CalendarEvent) => string | undefined;
|
|
eventsRef: import("vue").Ref<HTMLElement[], HTMLElement[]>;
|
|
updateEventVisibility: () => void;
|
|
getEventsMap: () => {
|
|
[date: string]: {
|
|
parent: HTMLElement;
|
|
more: HTMLElement | null;
|
|
events: HTMLElement[];
|
|
};
|
|
};
|
|
genDayEvent: ({ event }: import("./types.js").CalendarEventVisual, day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genTimedEvent: ({ event, left, width }: import("./types.js").CalendarEventVisual, day: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}> | false;
|
|
genEvent: (event: CalendarEventParsed, scopeInput: import("./composables/calendarWithEvents.js").VEventScopeInput, timedEvent: boolean, data: Record<string, unknown>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genName: (eventSummary: () => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genPlaceholder: (day: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
genMore: (day: CalendarDaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>;
|
|
getVisibleEvents: () => CalendarEventParsed[];
|
|
isEventForCategory: (event: CalendarEventParsed, category: CalendarCategory) => boolean;
|
|
getEventsForDay: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayAll: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getEventsForDayTimed: (day: CalendarDaySlotScope) => CalendarEventParsed[];
|
|
getScopedSlots: () => any;
|
|
lastStart: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
lastEnd: import("vue").Ref<{
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null, CalendarTimestamp | {
|
|
date: string;
|
|
time: string;
|
|
year: number;
|
|
month: number;
|
|
day: number;
|
|
weekday: number;
|
|
hour: number;
|
|
minute: number;
|
|
hasDay: boolean;
|
|
hasTime: boolean;
|
|
past: boolean;
|
|
present: boolean;
|
|
future: boolean;
|
|
category?: CalendarCategory;
|
|
} | null>;
|
|
parsedCategoryDays: import("vue").ComputedRef<number>;
|
|
renderProps: import("vue").ComputedRef<VCalendarRenderProps>;
|
|
eventWeekdays: import("vue").ComputedRef<number[]>;
|
|
categoryMode: import("vue").ComputedRef<boolean>;
|
|
title: import("vue").ComputedRef<string>;
|
|
monthLongFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
monthShortFormatter: import("vue").ComputedRef<import("./types.js").CalendarFormatter>;
|
|
parsedCategories: import("vue").ComputedRef<CalendarCategory[]>;
|
|
checkChange: () => void;
|
|
move: (amount?: number) => void;
|
|
next: (amount?: number) => void;
|
|
prev: (amount?: number) => void;
|
|
getCategoryList: (categories: CalendarCategory[]) => CalendarCategory[];
|
|
};
|
|
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slot:category" | "v-slot:day-body" | "v-slot:day-header" | "v-slot:day-label" | "v-slot:day-label-header" | "v-slot:day-month" | "v-slot:interval-header" | "v-slots" | `${Uncapitalize<Capitalize<string>>}:date` | `${Uncapitalize<Capitalize<string>>}:day` | `${Uncapitalize<Capitalize<string>>}:dayCategory` | `${Uncapitalize<Capitalize<string>>}:event` | `${Uncapitalize<Capitalize<string>>}:interval` | `${Uncapitalize<Capitalize<string>>}:more` | `${Uncapitalize<Capitalize<string>>}:time` | `${Uncapitalize<Capitalize<string>>}:timeCategory`>, string, {
|
|
start: string | number | Date;
|
|
weekdays: string | number[];
|
|
weekdayFormat: import("./types.js").CalendarFormatter;
|
|
dayFormat: import("./types.js").CalendarFormatter;
|
|
type: "4day" | "category" | "custom-daily" | "custom-weekly" | "day" | "month" | "week";
|
|
events: CalendarEvent[];
|
|
eventStart: string;
|
|
eventEnd: string;
|
|
eventTimed: string | import("./types.js").CalendarEventTimedFunction;
|
|
eventCategory: string | import("./types.js").CalendarEventCategoryFunction;
|
|
eventHeight: number;
|
|
eventColor: string | import("./types.js").CalendarEventColorFunction;
|
|
eventName: string | import("./types.js").CalendarEventNameFunction;
|
|
eventOverlapThreshold: string | number;
|
|
eventOverlapMode: "column" | "stack" | import("./types.js").CalendarEventOverlapMode;
|
|
eventMore: boolean;
|
|
eventMoreText: string;
|
|
eventRipple: boolean | Record<string, any>;
|
|
eventMarginBottom: number;
|
|
categoryDays: string | number;
|
|
categories: string | CalendarCategory[];
|
|
maxDays: number;
|
|
categoryHideDynamic: boolean;
|
|
categoryShowAll: boolean;
|
|
categoryForInvalid: string;
|
|
}, {}, string, import("vue").SlotsType<Partial<{
|
|
category: (arg: CalendarDayCategorySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
day: (arg: DaySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-body': (arg: CalendarDayBodySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-header': (arg: DayHeaderSlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-label': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-label-header': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'day-month': (arg: CalendarTimestamp) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
event: (arg: EventSlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
interval: (arg: CalendarDayCategorySlotScope) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
'interval-header': () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
[key: string]: any;
|
|
}>[];
|
|
}>>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new (props: {
|
|
[key: `on${Capitalize<string>}:date`]: EventProp<[Event, CalendarTimestamp]>;
|
|
[key: `on${Capitalize<string>}:dayCategory`]: EventProp<[Event, CalendarDayCategorySlotScope]>;
|
|
[key: `on${Capitalize<string>}:day`]: EventProp<[Event, CalendarDayBodySlotScope]>;
|
|
[key: `on${Capitalize<string>}:event`]: EventProp<[Event, EventSlotScope]>;
|
|
[key: `on${Capitalize<string>}:interval`]: EventProp<[Event, CalendarTimestamp]>;
|
|
[key: `on${Capitalize<string>}:more`]: EventProp<[Event, CalendarDaySlotScope]>;
|
|
[key: `on${Capitalize<string>}:timeCategory`]: EventProp<[Event, CalendarDayCategorySlotScope]>;
|
|
[key: `on${Capitalize<string>}:time`]: EventProp<[Event, CalendarDayBodySlotScope]>;
|
|
}, slots: {
|
|
'category': CalendarDayCategorySlotScope;
|
|
'day': DaySlotScope;
|
|
'day-body': CalendarDayBodySlotScope;
|
|
'day-header': DayHeaderSlotScope;
|
|
'day-label': CalendarTimestamp;
|
|
'day-label-header': CalendarTimestamp;
|
|
'day-month': CalendarTimestamp;
|
|
'event': EventSlotScope;
|
|
'interval': CalendarDayCategorySlotScope;
|
|
'interval-header': never;
|
|
}) => GenericProps<typeof props, typeof slots>) & import("../../util/index.js").FilterPropsOptions<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
events: {
|
|
type: PropType<CalendarEvent[]>;
|
|
default: () => never[];
|
|
};
|
|
eventStart: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventEnd: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventTimed: {
|
|
type: PropType<string | import("./types.js").CalendarEventTimedFunction>;
|
|
default: string;
|
|
};
|
|
eventCategory: {
|
|
type: PropType<string | import("./types.js").CalendarEventCategoryFunction>;
|
|
default: string;
|
|
};
|
|
eventHeight: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
eventColor: {
|
|
type: PropType<string | import("./types.js").CalendarEventColorFunction>;
|
|
default: string;
|
|
};
|
|
eventTextColor: {
|
|
type: PropType<string | import("./types.js").CalendarEventColorFunction>;
|
|
};
|
|
eventName: {
|
|
type: PropType<string | import("./types.js").CalendarEventNameFunction>;
|
|
default: string;
|
|
};
|
|
eventOverlapThreshold: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
};
|
|
eventOverlapMode: {
|
|
type: PropType<'stack' | 'column' | import("./types.js").CalendarEventOverlapMode>;
|
|
default: string;
|
|
validate: (mode: any) => boolean;
|
|
};
|
|
eventMore: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
eventMoreText: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventRipple: {
|
|
type: (BooleanConstructor | ObjectConstructor)[];
|
|
default: null;
|
|
};
|
|
eventMarginBottom: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
modelValue: {
|
|
type: PropType<string | number | Date>;
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
categoryDays: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: (x: any) => boolean;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: {
|
|
type: PropType<string | CalendarCategoryTextFunction>;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
categoryHideDynamic: {
|
|
type: BooleanConstructor;
|
|
};
|
|
categoryShowAll: {
|
|
type: BooleanConstructor;
|
|
};
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}, import("vue").ExtractPropTypes<{
|
|
start: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
default: () => string;
|
|
};
|
|
end: {
|
|
type: (DateConstructor | NumberConstructor | StringConstructor)[];
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
weekdays: {
|
|
type: PropType<number[] | string>;
|
|
default: () => number[];
|
|
validate: typeof import("./util/timestamp.js").validateWeekdays;
|
|
};
|
|
firstDayOfWeek: (NumberConstructor | StringConstructor)[];
|
|
firstDayOfYear: (NumberConstructor | StringConstructor)[];
|
|
weekdayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
dayFormat: {
|
|
type: PropType<import("./types.js").CalendarFormatter>;
|
|
default: null;
|
|
};
|
|
locale: StringConstructor;
|
|
now: {
|
|
type: StringConstructor;
|
|
validator: typeof validateTimestamp;
|
|
};
|
|
type: {
|
|
type: PropType<'month' | 'week' | 'day' | '4day' | 'custom-weekly' | 'custom-daily' | 'category'>;
|
|
default: string;
|
|
};
|
|
events: {
|
|
type: PropType<CalendarEvent[]>;
|
|
default: () => never[];
|
|
};
|
|
eventStart: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventEnd: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventTimed: {
|
|
type: PropType<string | import("./types.js").CalendarEventTimedFunction>;
|
|
default: string;
|
|
};
|
|
eventCategory: {
|
|
type: PropType<string | import("./types.js").CalendarEventCategoryFunction>;
|
|
default: string;
|
|
};
|
|
eventHeight: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
eventColor: {
|
|
type: PropType<string | import("./types.js").CalendarEventColorFunction>;
|
|
default: string;
|
|
};
|
|
eventTextColor: {
|
|
type: PropType<string | import("./types.js").CalendarEventColorFunction>;
|
|
};
|
|
eventName: {
|
|
type: PropType<string | import("./types.js").CalendarEventNameFunction>;
|
|
default: string;
|
|
};
|
|
eventOverlapThreshold: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
};
|
|
eventOverlapMode: {
|
|
type: PropType<'stack' | 'column' | import("./types.js").CalendarEventOverlapMode>;
|
|
default: string;
|
|
validate: (mode: any) => boolean;
|
|
};
|
|
eventMore: {
|
|
type: BooleanConstructor;
|
|
default: boolean;
|
|
};
|
|
eventMoreText: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
eventRipple: {
|
|
type: (BooleanConstructor | ObjectConstructor)[];
|
|
default: null;
|
|
};
|
|
eventMarginBottom: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
modelValue: {
|
|
type: PropType<string | number | Date>;
|
|
validate: typeof validateTimestamp;
|
|
};
|
|
categoryDays: {
|
|
type: (NumberConstructor | StringConstructor)[];
|
|
default: number;
|
|
validate: (x: any) => boolean;
|
|
};
|
|
categories: {
|
|
type: PropType<CalendarCategory[] | string>;
|
|
default: string;
|
|
};
|
|
categoryText: {
|
|
type: PropType<string | CalendarCategoryTextFunction>;
|
|
};
|
|
maxDays: {
|
|
type: NumberConstructor;
|
|
default: number;
|
|
};
|
|
categoryHideDynamic: {
|
|
type: BooleanConstructor;
|
|
};
|
|
categoryShowAll: {
|
|
type: BooleanConstructor;
|
|
};
|
|
categoryForInvalid: {
|
|
type: StringConstructor;
|
|
default: string;
|
|
};
|
|
}>>;
|
|
export type VCalendar = InstanceType<typeof VCalendar>;
|
|
|