UNPKG

107 kBTypeScriptView Raw
1import * as preact from 'preact';
2import { ComponentChildren, ComponentType, Context, Ref, Component, VNode, createElement, JSX, ComponentChild, FunctionalComponent, RefObject } from './preact.js';
3import { ViewApi as ViewApi$1 } from './index.js';
4
5type DurationInput = DurationObjectInput | string | number;
6interface DurationObjectInput {
7 years?: number;
8 year?: number;
9 months?: number;
10 month?: number;
11 weeks?: number;
12 week?: number;
13 days?: number;
14 day?: number;
15 hours?: number;
16 hour?: number;
17 minutes?: number;
18 minute?: number;
19 seconds?: number;
20 second?: number;
21 milliseconds?: number;
22 millisecond?: number;
23 ms?: number;
24}
25interface Duration {
26 years: number;
27 months: number;
28 days: number;
29 milliseconds: number;
30 specifiedWeeks?: boolean;
31}
32declare function createDuration(input: DurationInput, unit?: string): Duration | null;
33declare function asCleanDays(dur: Duration): number;
34declare function addDurations(d0: Duration, d1: Duration): {
35 years: number;
36 months: number;
37 days: number;
38 milliseconds: number;
39};
40declare function multiplyDuration(d: Duration, n: number): {
41 years: number;
42 months: number;
43 days: number;
44 milliseconds: number;
45};
46declare function asRoughMinutes(dur: Duration): number;
47declare function asRoughSeconds(dur: Duration): number;
48declare function asRoughMs(dur: Duration): number;
49declare function wholeDivideDurations(numerator: Duration, denominator: Duration): number;
50declare function greatestDurationDenominator(dur: Duration): {
51 unit: string;
52 value: number;
53};
54
55type DateMarker = Date;
56declare function addWeeks(m: DateMarker, n: number): Date;
57declare function addDays(m: DateMarker, n: number): Date;
58declare function addMs(m: DateMarker, n: number): Date;
59declare function diffWeeks(m0: any, m1: any): number;
60declare function diffDays(m0: any, m1: any): number;
61declare function diffDayAndTime(m0: DateMarker, m1: DateMarker): Duration;
62declare function diffWholeWeeks(m0: DateMarker, m1: DateMarker): number;
63declare function diffWholeDays(m0: DateMarker, m1: DateMarker): number;
64declare function startOfDay(m: DateMarker): DateMarker;
65declare function isValidDate(m: DateMarker): boolean;
66
67interface CalendarSystem {
68 getMarkerYear(d: DateMarker): number;
69 getMarkerMonth(d: DateMarker): number;
70 getMarkerDay(d: DateMarker): number;
71 arrayToMarker(arr: number[]): DateMarker;
72 markerToArray(d: DateMarker): number[];
73}
74
75type LocaleCodeArg = string | string[];
76type LocaleSingularArg = LocaleCodeArg | LocaleInput;
77interface Locale {
78 codeArg: LocaleCodeArg;
79 codes: string[];
80 week: {
81 dow: number;
82 doy: number;
83 };
84 simpleNumberFormat: Intl.NumberFormat;
85 options: CalendarOptionsRefined;
86}
87interface LocaleInput extends CalendarOptions {
88 code: string;
89}
90type LocaleInputMap = {
91 [code: string]: LocaleInput;
92};
93interface RawLocaleInfo {
94 map: LocaleInputMap;
95 defaultCode: string;
96}
97
98interface ZonedMarker {
99 marker: DateMarker;
100 timeZoneOffset: number;
101}
102interface ExpandedZonedMarker extends ZonedMarker {
103 array: number[];
104 year: number;
105 month: number;
106 day: number;
107 hour: number;
108 minute: number;
109 second: number;
110 millisecond: number;
111}
112
113interface VerboseFormattingArg {
114 date: ExpandedZonedMarker;
115 start: ExpandedZonedMarker;
116 end?: ExpandedZonedMarker;
117 timeZone: string;
118 localeCodes: string[];
119 defaultSeparator: string;
120}
121type CmdFormatterFunc = (cmd: string, arg: VerboseFormattingArg) => string;
122interface DateFormattingContext {
123 timeZone: string;
124 locale: Locale;
125 calendarSystem: CalendarSystem;
126 computeWeekNumber: (d: DateMarker) => number;
127 weekText: string;
128 weekTextLong: string;
129 cmdFormatter?: CmdFormatterFunc;
130 defaultSeparator: string;
131}
132interface DateFormatter {
133 format(date: ZonedMarker, context: DateFormattingContext): string;
134 formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext, betterDefaultSeparator?: string): string;
135}
136
137interface NativeFormatterOptions extends Intl.DateTimeFormatOptions {
138 week?: 'long' | 'short' | 'narrow' | 'numeric';
139 meridiem?: 'lowercase' | 'short' | 'narrow' | boolean;
140 omitZeroMinute?: boolean;
141 omitCommas?: boolean;
142 separator?: string;
143}
144
145type FuncFormatterFunc = (arg: VerboseFormattingArg) => string;
146
147type FormatterInput = NativeFormatterOptions | string | FuncFormatterFunc;
148declare function createFormatter(input: FormatterInput): DateFormatter;
149
150declare function guid(): string;
151declare function disableCursor(): void;
152declare function enableCursor(): void;
153declare function preventSelection(el: HTMLElement): void;
154declare function allowSelection(el: HTMLElement): void;
155declare function preventContextMenu(el: HTMLElement): void;
156declare function allowContextMenu(el: HTMLElement): void;
157interface OrderSpec<Subject> {
158 field?: string;
159 order?: number;
160 func?: FieldSpecInputFunc<Subject>;
161}
162type FieldSpecInput<Subject> = string | string[] | FieldSpecInputFunc<Subject> | FieldSpecInputFunc<Subject>[];
163type FieldSpecInputFunc<Subject> = (a: Subject, b: Subject) => number;
164declare function parseFieldSpecs<Subject>(input: FieldSpecInput<Subject>): OrderSpec<Subject>[];
165declare function compareByFieldSpecs<Subject>(obj0: Subject, obj1: Subject, fieldSpecs: OrderSpec<Subject>[]): number;
166declare function flexibleCompare(a: any, b: any): number;
167declare function padStart(val: any, len: any): string;
168declare function compareNumbers(a: any, b: any): number;
169declare function isInt(n: any): boolean;
170
171interface ViewApi {
172 calendar: CalendarApi;
173 type: string;
174 title: string;
175 activeStart: Date;
176 activeEnd: Date;
177 currentStart: Date;
178 currentEnd: Date;
179 getOption(name: string): any;
180}
181
182interface EventSourceApi {
183 id: string;
184 url: string;
185 format: string;
186 remove(): void;
187 refetch(): void;
188}
189
190declare abstract class NamedTimeZoneImpl {
191 timeZoneName: string;
192 constructor(timeZoneName: string);
193 abstract offsetForArray(a: number[]): number;
194 abstract timestampToArray(ms: number): number[];
195}
196type NamedTimeZoneImplClass = {
197 new (timeZoneName: string): NamedTimeZoneImpl;
198};
199
200type WeekNumberCalculation = 'local' | 'ISO' | ((m: Date) => number);
201interface DateEnvSettings {
202 timeZone: string;
203 namedTimeZoneImpl?: NamedTimeZoneImplClass;
204 calendarSystem: string;
205 locale: Locale;
206 weekNumberCalculation?: WeekNumberCalculation;
207 firstDay?: number;
208 weekText?: string;
209 weekTextLong?: string;
210 cmdFormatter?: CmdFormatterFunc;
211 defaultSeparator?: string;
212}
213type DateInput = Date | string | number | number[];
214interface DateMarkerMeta {
215 marker: DateMarker;
216 isTimeUnspecified: boolean;
217 forcedTzo: number | null;
218}
219declare class DateEnv {
220 timeZone: string;
221 namedTimeZoneImpl: NamedTimeZoneImpl;
222 canComputeOffset: boolean;
223 calendarSystem: CalendarSystem;
224 locale: Locale;
225 weekDow: number;
226 weekDoy: number;
227 weekNumberFunc: any;
228 weekText: string;
229 weekTextLong: string;
230 cmdFormatter?: CmdFormatterFunc;
231 defaultSeparator: string;
232 constructor(settings: DateEnvSettings);
233 createMarker(input: DateInput): DateMarker;
234 createNowMarker(): DateMarker;
235 createMarkerMeta(input: DateInput): DateMarkerMeta;
236 parse(s: string): {
237 marker: Date;
238 isTimeUnspecified: boolean;
239 forcedTzo: any;
240 };
241 getYear(marker: DateMarker): number;
242 getMonth(marker: DateMarker): number;
243 getDay(marker: DateMarker): number;
244 add(marker: DateMarker, dur: Duration): DateMarker;
245 subtract(marker: DateMarker, dur: Duration): DateMarker;
246 addYears(marker: DateMarker, n: number): Date;
247 addMonths(marker: DateMarker, n: number): Date;
248 diffWholeYears(m0: DateMarker, m1: DateMarker): number;
249 diffWholeMonths(m0: DateMarker, m1: DateMarker): number;
250 greatestWholeUnit(m0: DateMarker, m1: DateMarker): {
251 unit: string;
252 value: number;
253 };
254 countDurationsBetween(m0: DateMarker, m1: DateMarker, d: Duration): number;
255 startOf(m: DateMarker, unit: string): Date;
256 startOfYear(m: DateMarker): DateMarker;
257 startOfMonth(m: DateMarker): DateMarker;
258 startOfWeek(m: DateMarker): DateMarker;
259 computeWeekNumber(marker: DateMarker): number;
260 format(marker: DateMarker, formatter: DateFormatter, dateOptions?: {
261 forcedTzo?: number;
262 }): string;
263 formatRange(start: DateMarker, end: DateMarker, formatter: DateFormatter, dateOptions?: {
264 forcedStartTzo?: number;
265 forcedEndTzo?: number;
266 isEndExclusive?: boolean;
267 defaultSeparator?: string;
268 }): string;
269 formatIso(marker: DateMarker, extraOptions?: any): string;
270 timestampToMarker(ms: number): Date;
271 offsetForMarker(m: DateMarker): number;
272 toDate(m: DateMarker, forcedTzo?: number): Date;
273}
274
275interface DateRangeInput {
276 start?: DateInput;
277 end?: DateInput;
278}
279interface OpenDateRange {
280 start: DateMarker | null;
281 end: DateMarker | null;
282}
283interface DateRange {
284 start: DateMarker;
285 end: DateMarker;
286}
287declare function intersectRanges(range0: OpenDateRange, range1: OpenDateRange): OpenDateRange;
288declare function rangesEqual(range0: OpenDateRange, range1: OpenDateRange): boolean;
289declare function rangesIntersect(range0: OpenDateRange, range1: OpenDateRange): boolean;
290declare function rangeContainsRange(outerRange: OpenDateRange, innerRange: OpenDateRange): boolean;
291declare function rangeContainsMarker(range: OpenDateRange, date: DateMarker | number): boolean;
292
293interface EventInstance {
294 instanceId: string;
295 defId: string;
296 range: DateRange;
297 forcedStartTzo: number | null;
298 forcedEndTzo: number | null;
299}
300type EventInstanceHash = {
301 [instanceId: string]: EventInstance;
302};
303declare function createEventInstance(defId: string, range: DateRange, forcedStartTzo?: number, forcedEndTzo?: number): EventInstance;
304
305interface PointerDragEvent {
306 origEvent: UIEvent;
307 isTouch: boolean;
308 subjectEl: EventTarget;
309 pageX: number;
310 pageY: number;
311 deltaX: number;
312 deltaY: number;
313}
314
315interface EventMutation {
316 datesDelta?: Duration;
317 startDelta?: Duration;
318 endDelta?: Duration;
319 standardProps?: any;
320 extendedProps?: any;
321}
322declare function applyMutationToEventStore(eventStore: EventStore, eventConfigBase: EventUiHash, mutation: EventMutation, context: CalendarContext): EventStore;
323type eventDefMutationApplier = (eventDef: EventDef, mutation: EventMutation, context: CalendarContext) => void;
324
325declare class EventSourceImpl implements EventSourceApi {
326 private context;
327 internalEventSource: EventSource<any>;
328 constructor(context: CalendarContext, internalEventSource: EventSource<any>);
329 remove(): void;
330 refetch(): void;
331 get id(): string;
332 get url(): string;
333 get format(): string;
334}
335
336declare class EventImpl implements EventApi {
337 _context: CalendarContext;
338 _def: EventDef;
339 _instance: EventInstance | null;
340 constructor(context: CalendarContext, def: EventDef, instance?: EventInstance);
341 setProp(name: string, val: any): void;
342 setExtendedProp(name: string, val: any): void;
343 setStart(startInput: DateInput, options?: {
344 granularity?: string;
345 maintainDuration?: boolean;
346 }): void;
347 setEnd(endInput: DateInput | null, options?: {
348 granularity?: string;
349 }): void;
350 setDates(startInput: DateInput, endInput: DateInput | null, options?: {
351 allDay?: boolean;
352 granularity?: string;
353 }): void;
354 moveStart(deltaInput: DurationInput): void;
355 moveEnd(deltaInput: DurationInput): void;
356 moveDates(deltaInput: DurationInput): void;
357 setAllDay(allDay: boolean, options?: {
358 maintainDuration?: boolean;
359 }): void;
360 formatRange(formatInput: FormatterInput): string;
361 mutate(mutation: EventMutation): void;
362 remove(): void;
363 get source(): EventSourceImpl | null;
364 get start(): Date | null;
365 get end(): Date | null;
366 get startStr(): string;
367 get endStr(): string;
368 get id(): string;
369 get groupId(): string;
370 get allDay(): boolean;
371 get title(): string;
372 get url(): string;
373 get display(): string;
374 get startEditable(): boolean;
375 get durationEditable(): boolean;
376 get constraint(): string | EventStore;
377 get overlap(): boolean;
378 get allow(): AllowFunc;
379 get backgroundColor(): string;
380 get borderColor(): string;
381 get textColor(): string;
382 get classNames(): string[];
383 get extendedProps(): Dictionary;
384 toPlainObject(settings?: {
385 collapseExtendedProps?: boolean;
386 collapseColor?: boolean;
387 }): Dictionary;
388 toJSON(): Dictionary;
389}
390declare function buildEventApis(eventStore: EventStore, context: CalendarContext, excludeInstance?: EventInstance): EventImpl[];
391
392interface DateProfile {
393 currentDate: DateMarker;
394 isValid: boolean;
395 validRange: OpenDateRange;
396 renderRange: DateRange;
397 activeRange: DateRange | null;
398 currentRange: DateRange;
399 currentRangeUnit: string;
400 isRangeAllDay: boolean;
401 dateIncrement: Duration;
402 slotMinTime: Duration;
403 slotMaxTime: Duration;
404}
405interface DateProfileGeneratorProps extends DateProfileOptions {
406 dateProfileGeneratorClass: DateProfileGeneratorClass;
407 duration: Duration;
408 durationUnit: string;
409 usesMinMaxTime: boolean;
410 dateEnv: DateEnv;
411 calendarApi: CalendarImpl;
412}
413interface DateProfileOptions {
414 slotMinTime: Duration;
415 slotMaxTime: Duration;
416 showNonCurrentDates?: boolean;
417 dayCount?: number;
418 dateAlignment?: string;
419 dateIncrement?: Duration;
420 hiddenDays?: number[];
421 weekends?: boolean;
422 nowInput?: DateInput | (() => DateInput);
423 validRangeInput?: DateRangeInput | ((this: CalendarImpl, nowDate: Date) => DateRangeInput);
424 visibleRangeInput?: DateRangeInput | ((this: CalendarImpl, nowDate: Date) => DateRangeInput);
425 fixedWeekCount?: boolean;
426}
427type DateProfileGeneratorClass = {
428 new (props: DateProfileGeneratorProps): DateProfileGenerator;
429};
430declare class DateProfileGenerator {
431 protected props: DateProfileGeneratorProps;
432 nowDate: DateMarker;
433 isHiddenDayHash: boolean[];
434 constructor(props: DateProfileGeneratorProps);
435 buildPrev(currentDateProfile: DateProfile, currentDate: DateMarker, forceToValid?: boolean): DateProfile;
436 buildNext(currentDateProfile: DateProfile, currentDate: DateMarker, forceToValid?: boolean): DateProfile;
437 build(currentDate: DateMarker, direction?: any, forceToValid?: boolean): DateProfile;
438 buildValidRange(): OpenDateRange;
439 buildCurrentRangeInfo(date: DateMarker, direction: any): {
440 duration: any;
441 unit: any;
442 range: any;
443 };
444 getFallbackDuration(): Duration;
445 adjustActiveRange(range: DateRange): {
446 start: Date;
447 end: Date;
448 };
449 buildRangeFromDuration(date: DateMarker, direction: any, duration: Duration, unit: any): any;
450 buildRangeFromDayCount(date: DateMarker, direction: any, dayCount: any): {
451 start: Date;
452 end: Date;
453 };
454 buildCustomVisibleRange(date: DateMarker): DateRange;
455 buildRenderRange(currentRange: DateRange, currentRangeUnit: any, isRangeAllDay: any): DateRange;
456 buildDateIncrement(fallback: any): Duration;
457 refineRange(rangeInput: DateRangeInput | undefined): DateRange | null;
458 initHiddenDays(): void;
459 trimHiddenDays(range: DateRange): DateRange | null;
460 isHiddenDay(day: any): boolean;
461 skipHiddenDays(date: DateMarker, inc?: number, isExclusive?: boolean): Date;
462}
463
464interface EventInteractionState {
465 affectedEvents: EventStore;
466 mutatedEvents: EventStore;
467 isEvent: boolean;
468}
469
470interface ViewProps {
471 dateProfile: DateProfile;
472 businessHours: EventStore;
473 eventStore: EventStore;
474 eventUiBases: EventUiHash;
475 dateSelection: DateSpan | null;
476 eventSelection: string;
477 eventDrag: EventInteractionState | null;
478 eventResize: EventInteractionState | null;
479 isHeightAuto: boolean;
480 forPrint: boolean;
481}
482declare function sliceEvents(props: ViewProps & {
483 dateProfile: DateProfile;
484 nextDayThreshold: Duration;
485}, allDay?: boolean): EventRenderRange[];
486
487type ClassNamesInput = string | string[];
488declare function parseClassNames(raw: ClassNamesInput): string[];
489
490type MountArg<ContentArg> = ContentArg & {
491 el: HTMLElement;
492};
493type DidMountHandler<TheMountArg extends {
494 el: HTMLElement;
495}> = (mountArg: TheMountArg) => void;
496type WillUnmountHandler<TheMountArg extends {
497 el: HTMLElement;
498}> = (mountArg: TheMountArg) => void;
499interface ObjCustomContent {
500 html: string;
501 domNodes: any[];
502}
503type CustomContent = ComponentChildren | ObjCustomContent;
504type CustomContentGenerator<RenderProps> = CustomContent | ((renderProps: RenderProps, createElement: any) => (CustomContent | true));
505type ClassNamesGenerator<RenderProps> = ClassNamesInput | ((renderProps: RenderProps) => ClassNamesInput);
506
507type ViewComponentType = ComponentType<ViewProps>;
508type ViewConfigInput = ViewComponentType | ViewOptions;
509type ViewConfigInputHash = {
510 [viewType: string]: ViewConfigInput;
511};
512interface SpecificViewContentArg extends ViewProps {
513 nextDayThreshold: Duration;
514}
515type SpecificViewMountArg = MountArg<SpecificViewContentArg>;
516
517interface ViewSpec {
518 type: string;
519 component: ViewComponentType;
520 duration: Duration;
521 durationUnit: string;
522 singleUnit: string;
523 optionDefaults: ViewOptions;
524 optionOverrides: ViewOptions;
525 buttonTextOverride: string;
526 buttonTextDefault: string;
527 buttonTitleOverride: string | ((...args: any[]) => string);
528 buttonTitleDefault: string | ((...args: any[]) => string);
529}
530type ViewSpecHash = {
531 [viewType: string]: ViewSpec;
532};
533
534interface HandlerFuncTypeHash {
535 [eventName: string]: (...args: any[]) => any;
536}
537declare class Emitter<HandlerFuncs extends HandlerFuncTypeHash> {
538 private handlers;
539 private options;
540 private thisContext;
541 setThisContext(thisContext: any): void;
542 setOptions(options: Partial<HandlerFuncs>): void;
543 on<Prop extends keyof HandlerFuncs>(type: Prop, handler: HandlerFuncs[Prop]): void;
544 off<Prop extends keyof HandlerFuncs>(type: Prop, handler?: HandlerFuncs[Prop]): void;
545 trigger<Prop extends keyof HandlerFuncs>(type: Prop, ...args: Parameters<HandlerFuncs[Prop]>): void;
546 hasHandlers(type: keyof HandlerFuncs): boolean;
547}
548
549declare class ViewImpl implements ViewApi {
550 type: string;
551 private getCurrentData;
552 private dateEnv;
553 constructor(type: string, getCurrentData: () => CalendarData, dateEnv: DateEnv);
554 get calendar(): CalendarApi;
555 get title(): string;
556 get activeStart(): Date;
557 get activeEnd(): Date;
558 get currentStart(): Date;
559 get currentEnd(): Date;
560 getOption(name: string): any;
561}
562
563declare class Theme {
564 classes: any;
565 iconClasses: any;
566 rtlIconClasses: any;
567 baseIconClass: string;
568 iconOverrideOption: any;
569 iconOverrideCustomButtonOption: any;
570 iconOverridePrefix: string;
571 constructor(calendarOptions: CalendarOptionsRefined);
572 setIconOverride(iconOverrideHash: any): void;
573 applyIconOverridePrefix(className: any): any;
574 getClass(key: any): any;
575 getIconClass(buttonName: any, isRtl?: boolean): string;
576 getCustomButtonIconClass(customButtonProps: any): string;
577}
578type ThemeClass = {
579 new (calendarOptions: any): Theme;
580};
581
582interface CalendarDataManagerState {
583 dynamicOptionOverrides: CalendarOptions;
584 currentViewType: string;
585 currentDate: DateMarker;
586 dateProfile: DateProfile;
587 businessHours: EventStore;
588 eventSources: EventSourceHash;
589 eventUiBases: EventUiHash;
590 eventStore: EventStore;
591 renderableEventStore: EventStore;
592 dateSelection: DateSpan | null;
593 eventSelection: string;
594 eventDrag: EventInteractionState | null;
595 eventResize: EventInteractionState | null;
596 selectionConfig: EventUi;
597}
598interface CalendarOptionsData {
599 localeDefaults: CalendarOptions;
600 calendarOptions: CalendarOptionsRefined;
601 toolbarConfig: any;
602 availableRawLocales: any;
603 dateEnv: DateEnv;
604 theme: Theme;
605 pluginHooks: PluginHooks;
606 viewSpecs: ViewSpecHash;
607}
608interface CalendarCurrentViewData {
609 viewSpec: ViewSpec;
610 options: ViewOptionsRefined;
611 viewApi: ViewImpl;
612 dateProfileGenerator: DateProfileGenerator;
613}
614type CalendarDataBase = CalendarOptionsData & CalendarCurrentViewData & CalendarDataManagerState;
615interface CalendarData extends CalendarDataBase {
616 viewTitle: string;
617 calendarApi: CalendarImpl;
618 dispatch: (action: Action) => void;
619 emitter: Emitter<CalendarListeners>;
620 getCurrentData(): CalendarData;
621}
622
623declare class CalendarImpl implements CalendarApi {
624 currentDataManager?: CalendarDataManager;
625 getCurrentData(): CalendarData;
626 dispatch(action: Action): void;
627 get view(): ViewImpl;
628 batchRendering(callback: () => void): void;
629 updateSize(): void;
630 setOption<OptionName extends keyof CalendarOptions>(name: OptionName, val: CalendarOptions[OptionName]): void;
631 getOption<OptionName extends keyof CalendarOptions>(name: OptionName): CalendarOptions[OptionName];
632 getAvailableLocaleCodes(): string[];
633 on<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: CalendarListeners[ListenerName]): void;
634 off<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: CalendarListeners[ListenerName]): void;
635 trigger<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, ...args: Parameters<CalendarListeners[ListenerName]>): void;
636 changeView(viewType: string, dateOrRange?: DateRangeInput | DateInput): void;
637 zoomTo(dateMarker: Date, viewType?: string): void;
638 private getUnitViewSpec;
639 prev(): void;
640 next(): void;
641 prevYear(): void;
642 nextYear(): void;
643 today(): void;
644 gotoDate(zonedDateInput: DateInput): void;
645 incrementDate(deltaInput: DurationInput): void;
646 getDate(): Date;
647 formatDate(d: DateInput, formatter: FormatterInput): string;
648 formatRange(d0: DateInput, d1: DateInput, settings: any): string;
649 formatIso(d: DateInput, omitTime?: boolean): string;
650 select(dateOrObj: DateInput | any, endDate?: DateInput): void;
651 unselect(pev?: PointerDragEvent): void;
652 addEvent(eventInput: EventInput, sourceInput?: EventSourceImpl | string | boolean): EventImpl | null;
653 private triggerEventAdd;
654 getEventById(id: string): EventImpl | null;
655 getEvents(): EventImpl[];
656 removeAllEvents(): void;
657 getEventSources(): EventSourceImpl[];
658 getEventSourceById(id: string): EventSourceImpl | null;
659 addEventSource(sourceInput: EventSourceInput): EventSourceImpl;
660 removeAllEventSources(): void;
661 refetchEvents(): void;
662 scrollToTime(timeInput: DurationInput): void;
663}
664
665type EventSourceSuccessResponseHandler = (this: CalendarImpl, rawData: any, response: any) => EventInput[] | void;
666type EventSourceErrorResponseHandler = (error: Error) => void;
667interface EventSource<Meta> {
668 _raw: any;
669 sourceId: string;
670 sourceDefId: number;
671 meta: Meta;
672 publicId: string;
673 isFetching: boolean;
674 latestFetchId: string;
675 fetchRange: DateRange | null;
676 defaultAllDay: boolean | null;
677 eventDataTransform: EventInputTransformer;
678 ui: EventUi;
679 success: EventSourceSuccessResponseHandler | null;
680 failure: EventSourceErrorResponseHandler | null;
681 extendedProps: Dictionary;
682}
683type EventSourceHash = {
684 [sourceId: string]: EventSource<any>;
685};
686interface EventSourceFetcherRes {
687 rawEvents: EventInput[];
688 response?: Response;
689}
690type EventSourceFetcher<Meta> = (arg: {
691 eventSource: EventSource<Meta>;
692 range: DateRange;
693 isRefetch: boolean;
694 context: CalendarContext;
695}, successCallback: (res: EventSourceFetcherRes) => void, errorCallback: (error: Error) => void) => void;
696
697type Action = {
698 type: 'NOTHING';
699} | // hack
700{
701 type: 'SET_OPTION';
702 optionName: string;
703 rawOptionValue: any;
704} | // TODO: how to link this to CalendarOptions?
705{
706 type: 'PREV';
707} | {
708 type: 'NEXT';
709} | {
710 type: 'CHANGE_DATE';
711 dateMarker: DateMarker;
712} | {
713 type: 'CHANGE_VIEW_TYPE';
714 viewType: string;
715 dateMarker?: DateMarker;
716} | {
717 type: 'SELECT_DATES';
718 selection: DateSpan;
719} | {
720 type: 'UNSELECT_DATES';
721} | {
722 type: 'SELECT_EVENT';
723 eventInstanceId: string;
724} | {
725 type: 'UNSELECT_EVENT';
726} | {
727 type: 'SET_EVENT_DRAG';
728 state: EventInteractionState;
729} | {
730 type: 'UNSET_EVENT_DRAG';
731} | {
732 type: 'SET_EVENT_RESIZE';
733 state: EventInteractionState;
734} | {
735 type: 'UNSET_EVENT_RESIZE';
736} | {
737 type: 'ADD_EVENT_SOURCES';
738 sources: EventSource<any>[];
739} | {
740 type: 'REMOVE_EVENT_SOURCE';
741 sourceId: string;
742} | {
743 type: 'REMOVE_ALL_EVENT_SOURCES';
744} | {
745 type: 'FETCH_EVENT_SOURCES';
746 sourceIds?: string[];
747 isRefetch?: boolean;
748} | // if no sourceIds, fetch all
749{
750 type: 'RECEIVE_EVENTS';
751 sourceId: string;
752 fetchId: string;
753 fetchRange: DateRange | null;
754 rawEvents: EventInput[];
755} | {
756 type: 'RECEIVE_EVENT_ERROR';
757 sourceId: string;
758 fetchId: string;
759 fetchRange: DateRange | null;
760 error: Error;
761} | // need all these?
762{
763 type: 'ADD_EVENTS';
764 eventStore: EventStore;
765} | {
766 type: 'RESET_EVENTS';
767 eventStore: EventStore;
768} | {
769 type: 'RESET_RAW_EVENTS';
770 rawEvents: EventInput[];
771 sourceId: string;
772} | {
773 type: 'MERGE_EVENTS';
774 eventStore: EventStore;
775} | {
776 type: 'REMOVE_EVENTS';
777 eventStore: EventStore;
778} | {
779 type: 'REMOVE_ALL_EVENTS';
780};
781
782interface CalendarDataManagerProps {
783 optionOverrides: CalendarOptions;
784 calendarApi: CalendarImpl;
785 onAction?: (action: Action) => void;
786 onData?: (data: CalendarData) => void;
787}
788type ReducerFunc = (// TODO: rename to CalendarDataInjector. move view-props-manip hook here as well?
789currentState: Dictionary | null, action: Action | null, context: CalendarContext & CalendarDataManagerState) => Dictionary;
790declare class CalendarDataManager {
791 private computeCurrentViewData;
792 private organizeRawLocales;
793 private buildLocale;
794 private buildPluginHooks;
795 private buildDateEnv;
796 private buildTheme;
797 private parseToolbars;
798 private buildViewSpecs;
799 private buildDateProfileGenerator;
800 private buildViewApi;
801 private buildViewUiProps;
802 private buildEventUiBySource;
803 private buildEventUiBases;
804 private parseContextBusinessHours;
805 private buildTitle;
806 emitter: Emitter<Required<RefinedOptionsFromRefiners<Required<CalendarListenerRefiners>>>>;
807 private actionRunner;
808 private props;
809 private state;
810 private data;
811 currentCalendarOptionsInput: CalendarOptions;
812 private currentCalendarOptionsRefined;
813 private currentViewOptionsInput;
814 private currentViewOptionsRefined;
815 currentCalendarOptionsRefiners: any;
816 private stableOptionOverrides;
817 private stableDynamicOptionOverrides;
818 private stableCalendarOptionsData;
819 private optionsForRefining;
820 private optionsForHandling;
821 constructor(props: CalendarDataManagerProps);
822 getCurrentData: () => CalendarData;
823 dispatch: (action: Action) => void;
824 resetOptions(optionOverrides: CalendarOptions, changedOptionNames?: string[]): void;
825 _handleAction(action: Action): void;
826 updateData(): void;
827 computeOptionsData(optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions, calendarApi: CalendarImpl): CalendarOptionsData;
828 processRawCalendarOptions(optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions): {
829 rawOptions: CalendarOptions;
830 refinedOptions: CalendarOptionsRefined;
831 pluginHooks: PluginHooks;
832 availableLocaleData: RawLocaleInfo;
833 localeDefaults: CalendarOptionsRefined;
834 extra: {};
835 };
836 _computeCurrentViewData(viewType: string, optionsData: CalendarOptionsData, optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions): CalendarCurrentViewData;
837 processRawViewOptions(viewSpec: ViewSpec, pluginHooks: PluginHooks, localeDefaults: CalendarOptions, optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions): {
838 rawOptions: ViewOptions;
839 refinedOptions: ViewOptionsRefined;
840 extra: {};
841 };
842}
843
844interface DateSelectionApi extends DateSpanApi {
845 jsEvent: UIEvent;
846 view: ViewApi;
847}
848type DatePointTransform = (dateSpan: DateSpan, context: CalendarContext) => any;
849type DateSpanTransform = (dateSpan: DateSpan, context: CalendarContext) => any;
850type CalendarInteraction = {
851 destroy: () => void;
852};
853type CalendarInteractionClass = {
854 new (context: CalendarContext): CalendarInteraction;
855};
856type OptionChangeHandler = (propValue: any, context: CalendarContext) => void;
857type OptionChangeHandlerMap = {
858 [propName: string]: OptionChangeHandler;
859};
860interface DateSelectArg extends DateSpanApi {
861 jsEvent: MouseEvent | null;
862 view: ViewApi;
863}
864declare function triggerDateSelect(selection: DateSpan, pev: PointerDragEvent | null, context: CalendarContext & {
865 viewApi?: ViewImpl;
866}): void;
867interface DateUnselectArg {
868 jsEvent: MouseEvent;
869 view: ViewApi;
870}
871declare function getDefaultEventEnd(allDay: boolean, marker: DateMarker, context: CalendarContext): DateMarker;
872
873interface ScrollRequest {
874 time?: Duration;
875 [otherProp: string]: any;
876}
877type ScrollRequestHandler = (request: ScrollRequest) => boolean;
878declare class ScrollResponder {
879 private execFunc;
880 private emitter;
881 private scrollTime;
882 private scrollTimeReset;
883 queuedRequest: ScrollRequest;
884 constructor(execFunc: ScrollRequestHandler, emitter: Emitter<CalendarListeners>, scrollTime: Duration, scrollTimeReset: boolean);
885 detach(): void;
886 update(isDatesNew: boolean): void;
887 private fireInitialScroll;
888 private handleScrollRequest;
889 private drain;
890}
891
892declare const ViewContextType: Context<any>;
893type ResizeHandler = (force: boolean) => void;
894interface ViewContext extends CalendarContext {
895 options: ViewOptionsRefined;
896 theme: Theme;
897 isRtl: boolean;
898 dateProfileGenerator: DateProfileGenerator;
899 viewSpec: ViewSpec;
900 viewApi: ViewImpl;
901 addResizeHandler: (handler: ResizeHandler) => void;
902 removeResizeHandler: (handler: ResizeHandler) => void;
903 createScrollResponder: (execFunc: ScrollRequestHandler) => ScrollResponder;
904 registerInteractiveComponent: (component: DateComponent<any>, settingsInput: InteractionSettingsInput) => void;
905 unregisterInteractiveComponent: (component: DateComponent<any>) => void;
906}
907
908declare function filterHash(hash: any, func: any): {};
909declare function mapHash<InputItem, OutputItem>(hash: {
910 [key: string]: InputItem;
911}, func: (input: InputItem, key: string) => OutputItem): {
912 [key: string]: OutputItem;
913};
914declare function isPropsEqual(obj0: any, obj1: any): boolean;
915type EqualityFunc<T> = (a: T, b: T) => boolean;
916type EqualityThing<T> = EqualityFunc<T> | true;
917type EqualityFuncs<ObjType> = {
918 [K in keyof ObjType]?: EqualityThing<ObjType[K]>;
919};
920declare function compareObjs(oldProps: any, newProps: any, equalityFuncs?: EqualityFuncs<any>): boolean;
921declare function collectFromHash<Item>(hash: {
922 [key: string]: Item;
923}, startIndex?: number, endIndex?: number, step?: number): Item[];
924
925declare abstract class PureComponent<Props = Dictionary, State = Dictionary> extends Component<Props, State> {
926 static addPropsEquality: typeof addPropsEquality;
927 static addStateEquality: typeof addStateEquality;
928 static contextType: any;
929 context: ViewContext;
930 propEquality: EqualityFuncs<Props>;
931 stateEquality: EqualityFuncs<State>;
932 debug: boolean;
933 shouldComponentUpdate(nextProps: Props, nextState: State): boolean;
934 safeSetState(newState: Partial<State>): void;
935}
936declare abstract class BaseComponent<Props = Dictionary, State = Dictionary> extends PureComponent<Props, State> {
937 static contextType: any;
938 context: ViewContext;
939}
940declare function addPropsEquality(this: {
941 prototype: {
942 propEquality: any;
943 };
944}, propEquality: any): void;
945declare function addStateEquality(this: {
946 prototype: {
947 stateEquality: any;
948 };
949}, stateEquality: any): void;
950declare function setRef<RefType>(ref: Ref<RefType> | void, current: RefType): void;
951
952interface Point {
953 left: number;
954 top: number;
955}
956interface Rect {
957 left: number;
958 right: number;
959 top: number;
960 bottom: number;
961}
962declare function pointInsideRect(point: Point, rect: Rect): boolean;
963declare function intersectRects(rect1: Rect, rect2: Rect): Rect | false;
964declare function translateRect(rect: Rect, deltaX: number, deltaY: number): Rect;
965declare function constrainPoint(point: Point, rect: Rect): Point;
966declare function getRectCenter(rect: Rect): Point;
967declare function diffPoints(point1: Point, point2: Point): Point;
968
969interface Hit {
970 componentId?: string;
971 context?: ViewContext;
972 dateProfile: DateProfile;
973 dateSpan: DateSpan;
974 dayEl: HTMLElement;
975 rect: Rect;
976 layer: number;
977 largeUnit?: string;
978}
979
980interface Seg {
981 component?: DateComponent<any, any>;
982 isStart: boolean;
983 isEnd: boolean;
984 eventRange?: EventRenderRange;
985 [otherProp: string]: any;
986 el?: never;
987}
988interface EventSegUiInteractionState {
989 affectedInstances: EventInstanceHash;
990 segs: Seg[];
991 isEvent: boolean;
992}
993declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
994 uid: string;
995 prepareHits(): void;
996 queryHit(positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit | null;
997 isValidSegDownEl(el: HTMLElement): boolean;
998 isValidDateDownEl(el: HTMLElement): boolean;
999}
1000
1001declare abstract class Interaction {
1002 component: DateComponent<any>;
1003 isHitComboAllowed: ((hit0: Hit, hit1: Hit) => boolean) | null;
1004 constructor(settings: InteractionSettings);
1005 destroy(): void;
1006}
1007type InteractionClass = {
1008 new (settings: InteractionSettings): Interaction;
1009};
1010interface InteractionSettingsInput {
1011 el: HTMLElement;
1012 useEventCenter?: boolean;
1013 isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
1014}
1015interface InteractionSettings {
1016 component: DateComponent<any>;
1017 el: HTMLElement;
1018 useEventCenter: boolean;
1019 isHitComboAllowed: ((hit0: Hit, hit1: Hit) => boolean) | null;
1020}
1021type InteractionSettingsStore = {
1022 [componenUid: string]: InteractionSettings;
1023};
1024declare function interactionSettingsToStore(settings: InteractionSettings): {
1025 [x: string]: InteractionSettings;
1026};
1027declare const interactionSettingsStore: InteractionSettingsStore;
1028
1029declare class DelayedRunner {
1030 private drainedOption?;
1031 private isRunning;
1032 private isDirty;
1033 private pauseDepths;
1034 private timeoutId;
1035 constructor(drainedOption?: () => void);
1036 request(delay?: number): void;
1037 pause(scope?: string): void;
1038 resume(scope?: string, force?: boolean): void;
1039 isPaused(): number;
1040 tryDrain(): void;
1041 clear(): void;
1042 private clearTimeout;
1043 protected drained(): void;
1044}
1045
1046interface CalendarContentProps extends CalendarData {
1047 forPrint: boolean;
1048 isHeightAuto: boolean;
1049}
1050
1051type eventDragMutationMassager = (mutation: EventMutation, hit0: Hit, hit1: Hit) => void;
1052type EventDropTransformers = (mutation: EventMutation, context: CalendarContext) => Dictionary;
1053type eventIsDraggableTransformer = (val: boolean, eventDef: EventDef, eventUi: EventUi, context: CalendarContext) => boolean;
1054
1055type dateSelectionJoinTransformer = (hit0: Hit, hit1: Hit) => any;
1056
1057declare const DRAG_META_REFINERS: {
1058 startTime: typeof createDuration;
1059 duration: typeof createDuration;
1060 create: BooleanConstructor;
1061 sourceId: StringConstructor;
1062};
1063type DragMetaInput = RawOptionsFromRefiners<typeof DRAG_META_REFINERS> & {
1064 [otherProp: string]: any;
1065};
1066interface DragMeta {
1067 startTime: Duration | null;
1068 duration: Duration | null;
1069 create: boolean;
1070 sourceId: string;
1071 leftoverProps: Dictionary;
1072}
1073declare function parseDragMeta(raw: DragMetaInput): DragMeta;
1074
1075type ExternalDefTransform = (dateSpan: DateSpan, dragMeta: DragMeta) => any;
1076
1077type EventSourceFuncArg = {
1078 start: Date;
1079 end: Date;
1080 startStr: string;
1081 endStr: string;
1082 timeZone: string;
1083};
1084type EventSourceFunc = ((arg: EventSourceFuncArg, successCallback: (eventInputs: EventInput[]) => void, failureCallback: (error: Error) => void) => void) | ((arg: EventSourceFuncArg) => Promise<EventInput[]>);
1085
1086declare const JSON_FEED_EVENT_SOURCE_REFINERS: {
1087 method: StringConstructor;
1088 extraParams: Identity<Dictionary | (() => Dictionary)>;
1089 startParam: StringConstructor;
1090 endParam: StringConstructor;
1091 timeZoneParam: StringConstructor;
1092};
1093
1094declare const EVENT_SOURCE_REFINERS: {
1095 id: StringConstructor;
1096 defaultAllDay: BooleanConstructor;
1097 url: StringConstructor;
1098 format: StringConstructor;
1099 events: Identity<EventInput[] | EventSourceFunc>;
1100 eventDataTransform: Identity<EventInputTransformer>;
1101 success: Identity<EventSourceSuccessResponseHandler>;
1102 failure: Identity<EventSourceErrorResponseHandler>;
1103};
1104type BuiltInEventSourceRefiners = typeof EVENT_SOURCE_REFINERS & typeof JSON_FEED_EVENT_SOURCE_REFINERS;
1105interface EventSourceRefiners extends BuiltInEventSourceRefiners {
1106}
1107type EventSourceInputObject = EventUiInput & RawOptionsFromRefiners<Required<EventSourceRefiners>>;
1108type EventSourceInput = EventSourceInputObject | // object in extended form
1109EventInput[] | EventSourceFunc | // just a function
1110string;
1111type EventSourceRefined = EventUiRefined & RefinedOptionsFromRefiners<Required<EventSourceRefiners>>;
1112
1113interface EventSourceDef<Meta> {
1114 ignoreRange?: boolean;
1115 parseMeta: (refined: EventSourceRefined) => Meta | null;
1116 fetch: EventSourceFetcher<Meta>;
1117}
1118
1119interface ParsedRecurring<RecurringData> {
1120 typeData: RecurringData;
1121 allDayGuess: boolean | null;
1122 duration: Duration | null;
1123}
1124interface RecurringType<RecurringData> {
1125 parse: (refined: EventRefined, dateEnv: DateEnv) => ParsedRecurring<RecurringData> | null;
1126 expand: (typeData: any, framingRange: DateRange, dateEnv: DateEnv) => DateMarker[];
1127}
1128
1129declare abstract class ElementDragging {
1130 emitter: Emitter<any>;
1131 constructor(el: HTMLElement, selector?: string);
1132 destroy(): void;
1133 abstract setIgnoreMove(bool: boolean): void;
1134 setMirrorIsVisible(bool: boolean): void;
1135 setMirrorNeedsRevert(bool: boolean): void;
1136 setAutoScrollEnabled(bool: boolean): void;
1137}
1138type ElementDraggingClass = {
1139 new (el: HTMLElement, selector?: string): ElementDragging;
1140};
1141
1142type CssDimValue = string | number;
1143interface ColProps {
1144 width?: CssDimValue;
1145 minWidth?: CssDimValue;
1146 span?: number;
1147}
1148interface SectionConfig {
1149 outerContent?: VNode;
1150 type: 'body' | 'header' | 'footer';
1151 className?: string;
1152 maxHeight?: number;
1153 liquid?: boolean;
1154 expandRows?: boolean;
1155 syncRowHeights?: boolean;
1156 isSticky?: boolean;
1157}
1158type ChunkConfigContent = (contentProps: ChunkContentCallbackArgs) => VNode;
1159type ChunkConfigRowContent = VNode | ChunkConfigContent;
1160interface ChunkConfig {
1161 elRef?: Ref<HTMLTableCellElement>;
1162 outerContent?: VNode;
1163 content?: ChunkConfigContent;
1164 rowContent?: ChunkConfigRowContent;
1165 scrollerElRef?: Ref<HTMLDivElement>;
1166 tableClassName?: string;
1167}
1168interface ChunkContentCallbackArgs {
1169 tableColGroupNode: VNode;
1170 tableMinWidth: CssDimValue;
1171 clientWidth: number | null;
1172 clientHeight: number | null;
1173 expandRows: boolean;
1174 syncRowHeights: boolean;
1175 rowSyncHeights: number[];
1176 reportRowHeightChange: (rowEl: HTMLElement, isStable: boolean) => void;
1177}
1178declare function computeShrinkWidth(chunkEls: HTMLElement[]): number;
1179interface ScrollerLike {
1180 needsYScrolling(): boolean;
1181 needsXScrolling(): boolean;
1182}
1183declare function getSectionHasLiquidHeight(props: {
1184 liquid: boolean;
1185}, sectionConfig: SectionConfig): boolean;
1186declare function getAllowYScrolling(props: {
1187 liquid: boolean;
1188}, sectionConfig: SectionConfig): boolean;
1189declare function renderChunkContent(sectionConfig: SectionConfig, chunkConfig: ChunkConfig, arg: ChunkContentCallbackArgs, isHeader: boolean): VNode<{}>;
1190declare function isColPropsEqual(cols0: ColProps[], cols1: ColProps[]): boolean;
1191declare function renderMicroColGroup(cols: ColProps[], shrinkWidth?: number): VNode;
1192declare function sanitizeShrinkWidth(shrinkWidth?: number): number;
1193declare function hasShrinkWidth(cols: ColProps[]): boolean;
1194declare function getScrollGridClassNames(liquid: boolean, context: ViewContext): any[];
1195declare function getSectionClassNames(sectionConfig: SectionConfig, wholeTableVGrow: boolean): string[];
1196declare function renderScrollShim(arg: ChunkContentCallbackArgs): createElement.JSX.Element;
1197declare function getStickyHeaderDates(options: BaseOptionsRefined): boolean;
1198declare function getStickyFooterScrollbar(options: BaseOptionsRefined): boolean;
1199
1200interface ScrollGridProps {
1201 elRef?: Ref<any>;
1202 colGroups?: ColGroupConfig[];
1203 sections: ScrollGridSectionConfig[];
1204 liquid: boolean;
1205 forPrint: boolean;
1206 collapsibleWidth: boolean;
1207}
1208interface ScrollGridSectionConfig extends SectionConfig {
1209 key: string;
1210 chunks?: ScrollGridChunkConfig[];
1211}
1212interface ScrollGridChunkConfig extends ChunkConfig {
1213 key: string;
1214}
1215interface ColGroupConfig {
1216 width?: CssDimValue;
1217 cols: ColProps[];
1218}
1219type ScrollGridImpl = {
1220 new (props: ScrollGridProps, context: ViewContext): Component<ScrollGridProps>;
1221};
1222
1223interface PluginDefInput {
1224 name: string;
1225 premiumReleaseDate?: string;
1226 deps?: PluginDef[];
1227 reducers?: ReducerFunc[];
1228 isLoadingFuncs?: ((state: Dictionary) => boolean)[];
1229 contextInit?: (context: CalendarContext) => void;
1230 eventRefiners?: GenericRefiners;
1231 eventDefMemberAdders?: EventDefMemberAdder[];
1232 eventSourceRefiners?: GenericRefiners;
1233 isDraggableTransformers?: eventIsDraggableTransformer[];
1234 eventDragMutationMassagers?: eventDragMutationMassager[];
1235 eventDefMutationAppliers?: eventDefMutationApplier[];
1236 dateSelectionTransformers?: dateSelectionJoinTransformer[];
1237 datePointTransforms?: DatePointTransform[];
1238 dateSpanTransforms?: DateSpanTransform[];
1239 views?: ViewConfigInputHash;
1240 viewPropsTransformers?: ViewPropsTransformerClass[];
1241 isPropsValid?: isPropsValidTester;
1242 externalDefTransforms?: ExternalDefTransform[];
1243 viewContainerAppends?: ViewContainerAppend[];
1244 eventDropTransformers?: EventDropTransformers[];
1245 componentInteractions?: InteractionClass[];
1246 calendarInteractions?: CalendarInteractionClass[];
1247 themeClasses?: {
1248 [themeSystemName: string]: ThemeClass;
1249 };
1250 eventSourceDefs?: EventSourceDef<any>[];
1251 cmdFormatter?: CmdFormatterFunc;
1252 recurringTypes?: RecurringType<any>[];
1253 namedTimeZonedImpl?: NamedTimeZoneImplClass;
1254 initialView?: string;
1255 elementDraggingImpl?: ElementDraggingClass;
1256 optionChangeHandlers?: OptionChangeHandlerMap;
1257 scrollGridImpl?: ScrollGridImpl;
1258 listenerRefiners?: GenericListenerRefiners;
1259 optionRefiners?: GenericRefiners;
1260 propSetHandlers?: {
1261 [propName: string]: (val: any, context: CalendarData) => void;
1262 };
1263}
1264interface PluginHooks {
1265 premiumReleaseDate: Date | undefined;
1266 reducers: ReducerFunc[];
1267 isLoadingFuncs: ((state: Dictionary) => boolean)[];
1268 contextInit: ((context: CalendarContext) => void)[];
1269 eventRefiners: GenericRefiners;
1270 eventDefMemberAdders: EventDefMemberAdder[];
1271 eventSourceRefiners: GenericRefiners;
1272 isDraggableTransformers: eventIsDraggableTransformer[];
1273 eventDragMutationMassagers: eventDragMutationMassager[];
1274 eventDefMutationAppliers: eventDefMutationApplier[];
1275 dateSelectionTransformers: dateSelectionJoinTransformer[];
1276 datePointTransforms: DatePointTransform[];
1277 dateSpanTransforms: DateSpanTransform[];
1278 views: ViewConfigInputHash;
1279 viewPropsTransformers: ViewPropsTransformerClass[];
1280 isPropsValid: isPropsValidTester | null;
1281 externalDefTransforms: ExternalDefTransform[];
1282 viewContainerAppends: ViewContainerAppend[];
1283 eventDropTransformers: EventDropTransformers[];
1284 componentInteractions: InteractionClass[];
1285 calendarInteractions: CalendarInteractionClass[];
1286 themeClasses: {
1287 [themeSystemName: string]: ThemeClass;
1288 };
1289 eventSourceDefs: EventSourceDef<any>[];
1290 cmdFormatter?: CmdFormatterFunc;
1291 recurringTypes: RecurringType<any>[];
1292 namedTimeZonedImpl?: NamedTimeZoneImplClass;
1293 initialView: string;
1294 elementDraggingImpl?: ElementDraggingClass;
1295 optionChangeHandlers: OptionChangeHandlerMap;
1296 scrollGridImpl: ScrollGridImpl | null;
1297 listenerRefiners: GenericListenerRefiners;
1298 optionRefiners: GenericRefiners;
1299 propSetHandlers: {
1300 [propName: string]: (val: any, context: CalendarData) => void;
1301 };
1302}
1303interface PluginDef extends PluginHooks {
1304 id: string;
1305 name: string;
1306 deps: PluginDef[];
1307}
1308type ViewPropsTransformerClass = new () => ViewPropsTransformer;
1309interface ViewPropsTransformer {
1310 transform(viewProps: ViewProps, calendarProps: CalendarContentProps): any;
1311}
1312type ViewContainerAppend = (context: CalendarContext) => ComponentChildren;
1313
1314interface CalendarContext {
1315 dateEnv: DateEnv;
1316 options: BaseOptionsRefined;
1317 pluginHooks: PluginHooks;
1318 emitter: Emitter<CalendarListeners>;
1319 dispatch(action: Action): void;
1320 getCurrentData(): CalendarData;
1321 calendarApi: CalendarImpl;
1322}
1323
1324type EventDefIdMap = {
1325 [publicId: string]: string;
1326};
1327
1328declare const EVENT_REFINERS: {
1329 extendedProps: Identity<Dictionary>;
1330 start: Identity<DateInput>;
1331 end: Identity<DateInput>;
1332 date: Identity<DateInput>;
1333 allDay: BooleanConstructor;
1334 id: StringConstructor;
1335 groupId: StringConstructor;
1336 title: StringConstructor;
1337 url: StringConstructor;
1338 interactive: BooleanConstructor;
1339};
1340type BuiltInEventRefiners = typeof EVENT_REFINERS;
1341interface EventRefiners extends BuiltInEventRefiners {
1342}
1343type EventInput = EventUiInput & RawOptionsFromRefiners<Required<EventRefiners>> & // Required hack
1344{
1345 [extendedProp: string]: any;
1346};
1347type EventRefined = EventUiRefined & RefinedOptionsFromRefiners<Required<EventRefiners>>;
1348interface EventTuple {
1349 def: EventDef;
1350 instance: EventInstance | null;
1351}
1352type EventInputTransformer = (input: EventInput) => EventInput;
1353type EventDefMemberAdder = (refined: EventRefined) => Partial<EventDef>;
1354declare function refineEventDef(raw: EventInput, context: CalendarContext, refiners?: GenericRefiners): {
1355 refined: RefinedOptionsFromRefiners<GenericRefiners>;
1356 extra: Dictionary;
1357};
1358declare function parseEventDef(refined: EventRefined, extra: Dictionary, sourceId: string, allDay: boolean, hasEnd: boolean, context: CalendarContext, defIdMap?: EventDefIdMap): EventDef;
1359
1360interface EventStore {
1361 defs: EventDefHash;
1362 instances: EventInstanceHash;
1363}
1364declare function eventTupleToStore(tuple: EventTuple, eventStore?: EventStore): EventStore;
1365declare function getRelevantEvents(eventStore: EventStore, instanceId: string): EventStore;
1366declare function createEmptyEventStore(): EventStore;
1367declare function mergeEventStores(store0: EventStore, store1: EventStore): EventStore;
1368
1369interface SplittableProps {
1370 businessHours: EventStore | null;
1371 dateSelection: DateSpan | null;
1372 eventStore: EventStore;
1373 eventUiBases: EventUiHash;
1374 eventSelection: string;
1375 eventDrag: EventInteractionState | null;
1376 eventResize: EventInteractionState | null;
1377}
1378declare abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {
1379 private getKeysForEventDefs;
1380 private splitDateSelection;
1381 private splitEventStore;
1382 private splitIndividualUi;
1383 private splitEventDrag;
1384 private splitEventResize;
1385 private eventUiBuilders;
1386 abstract getKeyInfo(props: PropsType): {
1387 [key: string]: {
1388 ui?: EventUi;
1389 businessHours?: EventStore;
1390 };
1391 };
1392 abstract getKeysForDateSpan(dateSpan: DateSpan): string[];
1393 abstract getKeysForEventDef(eventDef: EventDef): string[];
1394 splitProps(props: PropsType): {
1395 [key: string]: SplittableProps;
1396 };
1397 private _splitDateSpan;
1398 private _getKeysForEventDefs;
1399 private _splitEventStore;
1400 private _splitIndividualUi;
1401 private _splitInteraction;
1402}
1403
1404type ConstraintInput = 'businessHours' | string | EventInput | EventInput[];
1405type Constraint = 'businessHours' | string | EventStore | false;
1406type OverlapFunc = ((stillEvent: EventImpl, movingEvent: EventImpl | null) => boolean);
1407type AllowFunc = (span: DateSpanApi, movingEvent: EventImpl | null) => boolean;
1408type isPropsValidTester = (props: SplittableProps, context: CalendarContext) => boolean;
1409
1410declare const EVENT_UI_REFINERS: {
1411 display: StringConstructor;
1412 editable: BooleanConstructor;
1413 startEditable: BooleanConstructor;
1414 durationEditable: BooleanConstructor;
1415 constraint: Identity<any>;
1416 overlap: Identity<boolean>;
1417 allow: Identity<AllowFunc>;
1418 className: typeof parseClassNames;
1419 classNames: typeof parseClassNames;
1420 color: StringConstructor;
1421 backgroundColor: StringConstructor;
1422 borderColor: StringConstructor;
1423 textColor: StringConstructor;
1424};
1425type BuiltInEventUiRefiners = typeof EVENT_UI_REFINERS;
1426interface EventUiRefiners extends BuiltInEventUiRefiners {
1427}
1428type EventUiInput = RawOptionsFromRefiners<Required<EventUiRefiners>>;
1429type EventUiRefined = RefinedOptionsFromRefiners<Required<EventUiRefiners>>;
1430interface EventUi {
1431 display: string | null;
1432 startEditable: boolean | null;
1433 durationEditable: boolean | null;
1434 constraints: Constraint[];
1435 overlap: boolean | null;
1436 allows: AllowFunc[];
1437 backgroundColor: string;
1438 borderColor: string;
1439 textColor: string;
1440 classNames: string[];
1441}
1442type EventUiHash = {
1443 [defId: string]: EventUi;
1444};
1445declare function createEventUi(refined: EventUiRefined, context: CalendarContext): EventUi;
1446declare function combineEventUis(uis: EventUi[]): EventUi;
1447
1448interface EventDef {
1449 defId: string;
1450 sourceId: string;
1451 publicId: string;
1452 groupId: string;
1453 allDay: boolean;
1454 hasEnd: boolean;
1455 recurringDef: {
1456 typeId: number;
1457 typeData: any;
1458 duration: Duration | null;
1459 } | null;
1460 title: string;
1461 url: string;
1462 ui: EventUi;
1463 interactive?: boolean;
1464 extendedProps: Dictionary;
1465}
1466type EventDefHash = {
1467 [defId: string]: EventDef;
1468};
1469
1470interface EventRenderRange extends EventTuple {
1471 ui: EventUi;
1472 range: DateRange;
1473 isStart: boolean;
1474 isEnd: boolean;
1475}
1476declare function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHash, framingRange: DateRange, nextDayThreshold?: Duration): {
1477 bg: EventRenderRange[];
1478 fg: EventRenderRange[];
1479};
1480declare function hasBgRendering(def: EventDef): boolean;
1481declare function getElSeg(el: HTMLElement): Seg | null;
1482declare function sortEventSegs(segs: any, eventOrderSpecs: OrderSpec<EventImpl>[]): Seg[];
1483interface EventContentArg {
1484 event: EventImpl;
1485 timeText: string;
1486 backgroundColor: string;
1487 borderColor: string;
1488 textColor: string;
1489 isDraggable: boolean;
1490 isStartResizable: boolean;
1491 isEndResizable: boolean;
1492 isMirror: boolean;
1493 isStart: boolean;
1494 isEnd: boolean;
1495 isPast: boolean;
1496 isFuture: boolean;
1497 isToday: boolean;
1498 isSelected: boolean;
1499 isDragging: boolean;
1500 isResizing: boolean;
1501 view: ViewApi;
1502}
1503type EventMountArg = MountArg<EventContentArg>;
1504declare function buildSegTimeText(seg: Seg, timeFormat: DateFormatter, context: ViewContext, defaultDisplayEventTime?: boolean, // defaults to true
1505defaultDisplayEventEnd?: boolean, // defaults to true
1506startOverride?: DateMarker, endOverride?: DateMarker): string;
1507declare function getSegMeta(seg: Seg, todayRange: DateRange, nowDate?: DateMarker): {
1508 isPast: boolean;
1509 isFuture: boolean;
1510 isToday: boolean;
1511};
1512declare function buildEventRangeKey(eventRange: EventRenderRange): string;
1513declare function getSegAnchorAttrs(seg: Seg, context: ViewContext): {
1514 tabIndex: number;
1515 onKeyDown(ev: KeyboardEvent): void;
1516} | {
1517 href: string;
1518} | {
1519 href?: undefined;
1520};
1521
1522interface OpenDateSpanInput {
1523 start?: DateInput;
1524 end?: DateInput;
1525 allDay?: boolean;
1526 [otherProp: string]: any;
1527}
1528interface DateSpanInput extends OpenDateSpanInput {
1529 start: DateInput;
1530 end: DateInput;
1531}
1532interface OpenDateSpan {
1533 range: OpenDateRange;
1534 allDay: boolean;
1535 [otherProp: string]: any;
1536}
1537interface DateSpan extends OpenDateSpan {
1538 range: DateRange;
1539}
1540interface RangeApi {
1541 start: Date;
1542 end: Date;
1543 startStr: string;
1544 endStr: string;
1545}
1546interface DateSpanApi extends RangeApi {
1547 allDay: boolean;
1548}
1549interface RangeApiWithTimeZone extends RangeApi {
1550 timeZone: string;
1551}
1552interface DatePointApi {
1553 date: Date;
1554 dateStr: string;
1555 allDay: boolean;
1556}
1557declare function isDateSpansEqual(span0: DateSpan, span1: DateSpan): boolean;
1558
1559type BusinessHoursInput = boolean | EventInput | EventInput[];
1560declare function parseBusinessHours(input: BusinessHoursInput, context: CalendarContext): EventStore;
1561
1562type ElRef = Ref<HTMLElement>;
1563type ElAttrs = JSX.HTMLAttributes & JSX.SVGAttributes & {
1564 ref?: ElRef;
1565} & Record<string, any>;
1566interface ElAttrsProps {
1567 elRef?: ElRef;
1568 elClasses?: string[];
1569 elStyle?: JSX.CSSProperties;
1570 elAttrs?: ElAttrs;
1571}
1572interface ElProps extends ElAttrsProps {
1573 elTag: string;
1574}
1575interface ContentGeneratorProps<RenderProps> {
1576 renderProps: RenderProps;
1577 generatorName: string | undefined;
1578 customGenerator?: CustomContentGenerator<RenderProps>;
1579 defaultGenerator?: (renderProps: RenderProps) => ComponentChild;
1580}
1581declare function buildElAttrs(props: ElAttrsProps, extraClassNames?: string[], elRef?: ElRef): ElAttrs;
1582
1583type ContentContainerProps<RenderProps> = ElAttrsProps & ContentGeneratorProps<RenderProps> & {
1584 elTag?: string;
1585 classNameGenerator: ClassNamesGenerator<RenderProps> | undefined;
1586 didMount: ((renderProps: RenderProps & {
1587 el: HTMLElement;
1588 }) => void) | undefined;
1589 willUnmount: ((renderProps: RenderProps & {
1590 el: HTMLElement;
1591 }) => void) | undefined;
1592 children?: InnerContainerFunc<RenderProps>;
1593};
1594declare class ContentContainer<RenderProps> extends Component<ContentContainerProps<RenderProps>> {
1595 static contextType: preact.Context<number>;
1596 didMountMisfire?: boolean;
1597 context: number;
1598 el: HTMLElement;
1599 InnerContent: any;
1600 render(): ComponentChildren;
1601 handleEl: (el: HTMLElement) => void;
1602 componentDidMount(): void;
1603 componentWillUnmount(): void;
1604}
1605type InnerContainerComponent = FunctionalComponent<ElProps>;
1606type InnerContainerFunc<RenderProps> = (InnerContainer: InnerContainerComponent, renderProps: RenderProps, elAttrs: ElAttrs) => ComponentChildren;
1607
1608interface NowIndicatorContainerProps extends Partial<ElProps> {
1609 isAxis: boolean;
1610 date: DateMarker;
1611 children?: InnerContainerFunc<NowIndicatorContentArg>;
1612}
1613interface NowIndicatorContentArg {
1614 isAxis: boolean;
1615 date: Date;
1616 view: ViewApi;
1617}
1618type NowIndicatorMountArg = MountArg<NowIndicatorContentArg>;
1619declare const NowIndicatorContainer: (props: NowIndicatorContainerProps) => createElement.JSX.Element;
1620
1621interface WeekNumberContainerProps extends ElProps {
1622 date: DateMarker;
1623 defaultFormat: DateFormatter;
1624 children?: InnerContainerFunc<WeekNumberContentArg>;
1625}
1626interface WeekNumberContentArg {
1627 num: number;
1628 text: string;
1629 date: Date;
1630}
1631type WeekNumberMountArg = MountArg<WeekNumberContentArg>;
1632declare const WeekNumberContainer: (props: WeekNumberContainerProps) => createElement.JSX.Element;
1633
1634interface MoreLinkContainerProps extends Partial<ElProps> {
1635 dateProfile: DateProfile;
1636 todayRange: DateRange;
1637 allDayDate: DateMarker | null;
1638 moreCnt: number;
1639 allSegs: Seg[];
1640 hiddenSegs: Seg[];
1641 extraDateSpan?: Dictionary;
1642 alignmentElRef?: RefObject<HTMLElement>;
1643 alignGridTop?: boolean;
1644 forceTimed?: boolean;
1645 popoverContent: () => ComponentChild;
1646 defaultGenerator?: (renderProps: MoreLinkContentArg) => ComponentChild;
1647 children?: InnerContainerFunc<MoreLinkContentArg>;
1648}
1649interface MoreLinkContentArg {
1650 num: number;
1651 text: string;
1652 shortText: string;
1653 view: ViewApi;
1654}
1655type MoreLinkMountArg = MountArg<MoreLinkContentArg>;
1656interface MoreLinkContainerState {
1657 isPopoverOpen: boolean;
1658 popoverId: string;
1659}
1660declare class MoreLinkContainer extends BaseComponent<MoreLinkContainerProps, MoreLinkContainerState> {
1661 private linkEl;
1662 private parentEl;
1663 state: {
1664 isPopoverOpen: boolean;
1665 popoverId: string;
1666 };
1667 render(): createElement.JSX.Element;
1668 componentDidMount(): void;
1669 componentDidUpdate(): void;
1670 handleLinkEl: (linkEl: HTMLElement | null) => void;
1671 updateParentEl(): void;
1672 handleClick: (ev: MouseEvent) => void;
1673 handlePopoverClose: () => void;
1674}
1675declare function computeEarliestSegStart(segs: Seg[]): DateMarker;
1676
1677interface EventSegment {
1678 event: EventApi;
1679 start: Date;
1680 end: Date;
1681 isStart: boolean;
1682 isEnd: boolean;
1683}
1684type MoreLinkAction = MoreLinkSimpleAction | MoreLinkHandler;
1685type MoreLinkSimpleAction = 'popover' | 'week' | 'day' | 'timeGridWeek' | 'timeGridDay' | string;
1686interface MoreLinkArg {
1687 date: Date;
1688 allDay: boolean;
1689 allSegs: EventSegment[];
1690 hiddenSegs: EventSegment[];
1691 jsEvent: UIEvent;
1692 view: ViewApi;
1693}
1694type MoreLinkHandler = (arg: MoreLinkArg) => MoreLinkSimpleAction | void;
1695
1696interface DateMeta {
1697 dow: number;
1698 isDisabled: boolean;
1699 isOther: boolean;
1700 isToday: boolean;
1701 isPast: boolean;
1702 isFuture: boolean;
1703}
1704declare function getDateMeta(date: DateMarker, todayRange?: DateRange, nowDate?: DateMarker, dateProfile?: DateProfile): DateMeta;
1705declare function getDayClassNames(meta: DateMeta, theme: Theme): string[];
1706declare function getSlotClassNames(meta: DateMeta, theme: Theme): string[];
1707
1708interface SlotLaneContentArg extends Partial<DateMeta> {
1709 time?: Duration;
1710 date?: Date;
1711 view: ViewApi;
1712}
1713type SlotLaneMountArg = MountArg<SlotLaneContentArg>;
1714interface SlotLabelContentArg {
1715 level: number;
1716 time: Duration;
1717 date: Date;
1718 view: ViewApi;
1719 text: string;
1720}
1721type SlotLabelMountArg = MountArg<SlotLabelContentArg>;
1722interface AllDayContentArg {
1723 text: string;
1724 view: ViewApi;
1725}
1726type AllDayMountArg = MountArg<AllDayContentArg>;
1727interface DayHeaderContentArg extends DateMeta {
1728 date: Date;
1729 view: ViewApi;
1730 text: string;
1731 [otherProp: string]: any;
1732}
1733type DayHeaderMountArg = MountArg<DayHeaderContentArg>;
1734
1735interface DayCellContentArg extends DateMeta {
1736 date: DateMarker;
1737 view: ViewApi;
1738 dayNumberText: string;
1739 [extraProp: string]: any;
1740}
1741type DayCellMountArg = MountArg<DayCellContentArg>;
1742interface DayCellContainerProps extends Partial<ElProps> {
1743 date: DateMarker;
1744 dateProfile: DateProfile;
1745 todayRange: DateRange;
1746 isMonthStart?: boolean;
1747 showDayNumber?: boolean;
1748 extraRenderProps?: Dictionary;
1749 defaultGenerator?: (renderProps: DayCellContentArg) => ComponentChild;
1750 children?: InnerContainerFunc<DayCellContentArg>;
1751}
1752declare class DayCellContainer extends BaseComponent<DayCellContainerProps> {
1753 refineRenderProps: (arg: DayCellRenderPropsInput) => DayCellContentArg;
1754 render(): createElement.JSX.Element;
1755}
1756declare function hasCustomDayCellContent(options: ViewOptions): boolean;
1757interface DayCellRenderPropsInput {
1758 date: DateMarker;
1759 dateProfile: DateProfile;
1760 todayRange: DateRange;
1761 dateEnv: DateEnv;
1762 viewApi: ViewApi;
1763 monthStartFormat: DateFormatter;
1764 isMonthStart: boolean;
1765 showDayNumber?: boolean;
1766 extraRenderProps?: Dictionary;
1767}
1768
1769interface ViewContainerProps extends Partial<ElProps> {
1770 viewSpec: ViewSpec;
1771 children: ComponentChildren;
1772}
1773interface ViewContentArg {
1774 view: ViewApi;
1775}
1776type ViewMountArg = MountArg<ViewContentArg>;
1777declare class ViewContainer extends BaseComponent<ViewContainerProps> {
1778 render(): createElement.JSX.Element;
1779}
1780
1781interface EventClickArg {
1782 el: HTMLElement;
1783 event: EventImpl;
1784 jsEvent: MouseEvent;
1785 view: ViewApi;
1786}
1787
1788interface EventHoveringArg {
1789 el: HTMLElement;
1790 event: EventImpl;
1791 jsEvent: MouseEvent;
1792 view: ViewApi;
1793}
1794
1795interface ToolbarInput {
1796 left?: string;
1797 center?: string;
1798 right?: string;
1799 start?: string;
1800 end?: string;
1801}
1802interface CustomButtonInput {
1803 text?: string;
1804 hint?: string;
1805 icon?: string;
1806 themeIcon?: string;
1807 bootstrapFontAwesome?: string;
1808 click?(ev: MouseEvent, element: HTMLElement): void;
1809}
1810interface ButtonIconsInput {
1811 prev?: string;
1812 next?: string;
1813 prevYear?: string;
1814 nextYear?: string;
1815 today?: string;
1816 [viewOrCustomButton: string]: string | undefined;
1817}
1818interface ButtonTextCompoundInput {
1819 prev?: string;
1820 next?: string;
1821 prevYear?: string;
1822 nextYear?: string;
1823 today?: string;
1824 month?: string;
1825 week?: string;
1826 day?: string;
1827 [viewOrCustomButton: string]: string | undefined;
1828}
1829interface ButtonHintCompoundInput {
1830 prev?: string | ((...args: any[]) => string);
1831 next?: string | ((...args: any[]) => string);
1832 prevYear?: string | ((...args: any[]) => string);
1833 nextYear?: string | ((...args: any[]) => string);
1834 today?: string | ((...args: any[]) => string);
1835 month?: string | ((...args: any[]) => string);
1836 week?: string | ((...args: any[]) => string);
1837 day?: string | ((...args: any[]) => string);
1838 [viewOrCustomButton: string]: string | ((...args: any[]) => string) | undefined;
1839}
1840
1841type DatesSetArg = RangeApiWithTimeZone & {
1842 view: ViewApi;
1843};
1844
1845interface EventAddArg {
1846 event: EventImpl;
1847 relatedEvents: EventImpl[];
1848 revert: () => void;
1849}
1850interface EventChangeArg {
1851 oldEvent: EventImpl;
1852 event: EventImpl;
1853 relatedEvents: EventImpl[];
1854 revert: () => void;
1855}
1856interface EventDropArg extends EventChangeArg {
1857 el: HTMLElement;
1858 delta: Duration;
1859 jsEvent: MouseEvent;
1860 view: ViewApi$1;
1861}
1862interface EventRemoveArg {
1863 event: EventImpl;
1864 relatedEvents: EventImpl[];
1865 revert: () => void;
1866}
1867
1868declare class Store<Value> {
1869 private handlers;
1870 private currentValue;
1871 set(value: Value): void;
1872 subscribe(handler: (value: Value) => void): void;
1873}
1874
1875type CustomRenderingHandler<RenderProps> = (customRender: CustomRendering<RenderProps>) => void;
1876interface CustomRendering<RenderProps> extends ElProps {
1877 id: string;
1878 isActive: boolean;
1879 containerEl: HTMLElement;
1880 reportNewContainerEl: (el: HTMLElement | null) => void;
1881 generatorName: string;
1882 generatorMeta: any;
1883 renderProps: RenderProps;
1884}
1885declare class CustomRenderingStore<RenderProps> extends Store<Map<string, CustomRendering<RenderProps>>> {
1886 private map;
1887 handle(customRendering: CustomRendering<RenderProps>): void;
1888}
1889
1890interface EventApi {
1891 source: EventSourceApi | null;
1892 start: Date | null;
1893 end: Date | null;
1894 startStr: string;
1895 endStr: string;
1896 id: string;
1897 groupId: string;
1898 allDay: boolean;
1899 title: string;
1900 url: string;
1901 display: string;
1902 startEditable: boolean;
1903 durationEditable: boolean;
1904 constraint: any;
1905 overlap: boolean;
1906 allow: any;
1907 backgroundColor: string;
1908 borderColor: string;
1909 textColor: string;
1910 classNames: string[];
1911 extendedProps: Dictionary;
1912 setProp(name: string, val: any): void;
1913 setExtendedProp(name: string, val: any): void;
1914 setStart(startInput: DateInput, options?: {
1915 granularity?: string;
1916 maintainDuration?: boolean;
1917 }): void;
1918 setEnd(endInput: DateInput | null, options?: {
1919 granularity?: string;
1920 }): void;
1921 setDates(startInput: DateInput, endInput: DateInput | null, options?: {
1922 allDay?: boolean;
1923 granularity?: string;
1924 }): void;
1925 moveStart(deltaInput: DurationInput): void;
1926 moveEnd(deltaInput: DurationInput): void;
1927 moveDates(deltaInput: DurationInput): void;
1928 setAllDay(allDay: boolean, options?: {
1929 maintainDuration?: boolean;
1930 }): void;
1931 formatRange(formatInput: FormatterInput): any;
1932 remove(): void;
1933 toPlainObject(settings?: {
1934 collapseExtendedProps?: boolean;
1935 collapseColor?: boolean;
1936 }): Dictionary;
1937 toJSON(): Dictionary;
1938}
1939
1940interface CalendarApi {
1941 view: ViewApi;
1942 updateSize(): void;
1943 setOption<OptionName extends keyof CalendarOptions>(name: OptionName, val: CalendarOptions[OptionName]): void;
1944 getOption<OptionName extends keyof CalendarOptions>(name: OptionName): CalendarOptions[OptionName];
1945 getAvailableLocaleCodes(): string[];
1946 on<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: CalendarListeners[ListenerName]): void;
1947 off<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: CalendarListeners[ListenerName]): void;
1948 trigger<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, ...args: Parameters<CalendarListeners[ListenerName]>): void;
1949 changeView(viewType: string, dateOrRange?: DateRangeInput | DateInput): void;
1950 zoomTo(dateMarker: Date, viewType?: string): void;
1951 prev(): void;
1952 next(): void;
1953 prevYear(): void;
1954 nextYear(): void;
1955 today(): void;
1956 gotoDate(zonedDateInput: DateInput): void;
1957 incrementDate(deltaInput: DurationInput): void;
1958 getDate(): Date;
1959 formatDate(d: DateInput, formatter: FormatterInput): string;
1960 formatRange(d0: DateInput, d1: DateInput, settings: any): string;
1961 formatIso(d: DateInput, omitTime?: boolean): string;
1962 select(dateOrObj: DateInput | any, endDate?: DateInput): void;
1963 unselect(): void;
1964 addEvent(eventInput: EventInput, sourceInput?: EventSourceApi | string | boolean): EventApi | null;
1965 getEventById(id: string): EventApi | null;
1966 getEvents(): EventApi[];
1967 removeAllEvents(): void;
1968 getEventSources(): EventSourceApi[];
1969 getEventSourceById(id: string): EventSourceApi | null;
1970 addEventSource(sourceInput: EventSourceInput): EventSourceApi;
1971 removeAllEventSources(): void;
1972 refetchEvents(): void;
1973 scrollToTime(timeInput: DurationInput): void;
1974}
1975
1976declare const BASE_OPTION_REFINERS: {
1977 navLinkDayClick: Identity<string | ((this: CalendarApi, date: Date, jsEvent: UIEvent) => void)>;
1978 navLinkWeekClick: Identity<string | ((this: CalendarApi, weekStart: Date, jsEvent: UIEvent) => void)>;
1979 duration: typeof createDuration;
1980 bootstrapFontAwesome: Identity<false | ButtonIconsInput>;
1981 buttonIcons: Identity<false | ButtonIconsInput>;
1982 customButtons: Identity<{
1983 [name: string]: CustomButtonInput;
1984 }>;
1985 defaultAllDayEventDuration: typeof createDuration;
1986 defaultTimedEventDuration: typeof createDuration;
1987 nextDayThreshold: typeof createDuration;
1988 scrollTime: typeof createDuration;
1989 scrollTimeReset: BooleanConstructor;
1990 slotMinTime: typeof createDuration;
1991 slotMaxTime: typeof createDuration;
1992 dayPopoverFormat: typeof createFormatter;
1993 slotDuration: typeof createDuration;
1994 snapDuration: typeof createDuration;
1995 headerToolbar: Identity<false | ToolbarInput>;
1996 footerToolbar: Identity<false | ToolbarInput>;
1997 defaultRangeSeparator: StringConstructor;
1998 titleRangeSeparator: StringConstructor;
1999 forceEventDuration: BooleanConstructor;
2000 dayHeaders: BooleanConstructor;
2001 dayHeaderFormat: typeof createFormatter;
2002 dayHeaderClassNames: Identity<ClassNamesGenerator<DayHeaderContentArg>>;
2003 dayHeaderContent: Identity<CustomContentGenerator<DayHeaderContentArg>>;
2004 dayHeaderDidMount: Identity<DidMountHandler<DayHeaderMountArg>>;
2005 dayHeaderWillUnmount: Identity<WillUnmountHandler<DayHeaderMountArg>>;
2006 dayCellClassNames: Identity<ClassNamesGenerator<DayCellContentArg>>;
2007 dayCellContent: Identity<CustomContentGenerator<DayCellContentArg>>;
2008 dayCellDidMount: Identity<DidMountHandler<DayCellMountArg>>;
2009 dayCellWillUnmount: Identity<WillUnmountHandler<DayCellMountArg>>;
2010 initialView: StringConstructor;
2011 aspectRatio: NumberConstructor;
2012 weekends: BooleanConstructor;
2013 weekNumberCalculation: Identity<WeekNumberCalculation>;
2014 weekNumbers: BooleanConstructor;
2015 weekNumberClassNames: Identity<ClassNamesGenerator<WeekNumberContentArg>>;
2016 weekNumberContent: Identity<CustomContentGenerator<WeekNumberContentArg>>;
2017 weekNumberDidMount: Identity<DidMountHandler<WeekNumberMountArg>>;
2018 weekNumberWillUnmount: Identity<WillUnmountHandler<WeekNumberMountArg>>;
2019 editable: BooleanConstructor;
2020 viewClassNames: Identity<ClassNamesGenerator<ViewContentArg>>;
2021 viewDidMount: Identity<DidMountHandler<ViewMountArg>>;
2022 viewWillUnmount: Identity<WillUnmountHandler<ViewMountArg>>;
2023 nowIndicator: BooleanConstructor;
2024 nowIndicatorClassNames: Identity<ClassNamesGenerator<NowIndicatorContentArg>>;
2025 nowIndicatorContent: Identity<CustomContentGenerator<NowIndicatorContentArg>>;
2026 nowIndicatorDidMount: Identity<DidMountHandler<NowIndicatorMountArg>>;
2027 nowIndicatorWillUnmount: Identity<WillUnmountHandler<NowIndicatorMountArg>>;
2028 showNonCurrentDates: BooleanConstructor;
2029 lazyFetching: BooleanConstructor;
2030 startParam: StringConstructor;
2031 endParam: StringConstructor;
2032 timeZoneParam: StringConstructor;
2033 timeZone: StringConstructor;
2034 locales: Identity<LocaleInput[]>;
2035 locale: Identity<LocaleSingularArg>;
2036 themeSystem: Identity<string>;
2037 dragRevertDuration: NumberConstructor;
2038 dragScroll: BooleanConstructor;
2039 allDayMaintainDuration: BooleanConstructor;
2040 unselectAuto: BooleanConstructor;
2041 dropAccept: Identity<string | ((this: CalendarApi, draggable: any) => boolean)>;
2042 eventOrder: typeof parseFieldSpecs;
2043 eventOrderStrict: BooleanConstructor;
2044 handleWindowResize: BooleanConstructor;
2045 windowResizeDelay: NumberConstructor;
2046 longPressDelay: NumberConstructor;
2047 eventDragMinDistance: NumberConstructor;
2048 expandRows: BooleanConstructor;
2049 height: Identity<CssDimValue>;
2050 contentHeight: Identity<CssDimValue>;
2051 direction: Identity<"ltr" | "rtl">;
2052 weekNumberFormat: typeof createFormatter;
2053 eventResizableFromStart: BooleanConstructor;
2054 displayEventTime: BooleanConstructor;
2055 displayEventEnd: BooleanConstructor;
2056 weekText: StringConstructor;
2057 weekTextLong: StringConstructor;
2058 progressiveEventRendering: BooleanConstructor;
2059 businessHours: Identity<BusinessHoursInput>;
2060 initialDate: Identity<DateInput>;
2061 now: Identity<DateInput | ((this: CalendarApi) => DateInput)>;
2062 eventDataTransform: Identity<EventInputTransformer>;
2063 stickyHeaderDates: Identity<boolean | "auto">;
2064 stickyFooterScrollbar: Identity<boolean | "auto">;
2065 viewHeight: Identity<CssDimValue>;
2066 defaultAllDay: BooleanConstructor;
2067 eventSourceFailure: Identity<(this: CalendarApi, error: any) => void>;
2068 eventSourceSuccess: Identity<(this: CalendarApi, eventsInput: EventInput[], response?: Response) => EventInput[] | void>;
2069 eventDisplay: StringConstructor;
2070 eventStartEditable: BooleanConstructor;
2071 eventDurationEditable: BooleanConstructor;
2072 eventOverlap: Identity<boolean | OverlapFunc>;
2073 eventConstraint: Identity<ConstraintInput>;
2074 eventAllow: Identity<AllowFunc>;
2075 eventBackgroundColor: StringConstructor;
2076 eventBorderColor: StringConstructor;
2077 eventTextColor: StringConstructor;
2078 eventColor: StringConstructor;
2079 eventClassNames: Identity<ClassNamesGenerator<EventContentArg>>;
2080 eventContent: Identity<CustomContentGenerator<EventContentArg>>;
2081 eventDidMount: Identity<DidMountHandler<EventMountArg>>;
2082 eventWillUnmount: Identity<WillUnmountHandler<EventMountArg>>;
2083 selectConstraint: Identity<ConstraintInput>;
2084 selectOverlap: Identity<boolean | OverlapFunc>;
2085 selectAllow: Identity<AllowFunc>;
2086 droppable: BooleanConstructor;
2087 unselectCancel: StringConstructor;
2088 slotLabelFormat: Identity<FormatterInput | FormatterInput[]>;
2089 slotLaneClassNames: Identity<ClassNamesGenerator<SlotLaneContentArg>>;
2090 slotLaneContent: Identity<CustomContentGenerator<SlotLaneContentArg>>;
2091 slotLaneDidMount: Identity<DidMountHandler<SlotLaneMountArg>>;
2092 slotLaneWillUnmount: Identity<WillUnmountHandler<SlotLaneMountArg>>;
2093 slotLabelClassNames: Identity<ClassNamesGenerator<SlotLabelContentArg>>;
2094 slotLabelContent: Identity<CustomContentGenerator<SlotLabelContentArg>>;
2095 slotLabelDidMount: Identity<DidMountHandler<SlotLabelMountArg>>;
2096 slotLabelWillUnmount: Identity<WillUnmountHandler<SlotLabelMountArg>>;
2097 dayMaxEvents: Identity<number | boolean>;
2098 dayMaxEventRows: Identity<number | boolean>;
2099 dayMinWidth: NumberConstructor;
2100 slotLabelInterval: typeof createDuration;
2101 allDayText: StringConstructor;
2102 allDayClassNames: Identity<ClassNamesGenerator<AllDayContentArg>>;
2103 allDayContent: Identity<CustomContentGenerator<AllDayContentArg>>;
2104 allDayDidMount: Identity<DidMountHandler<AllDayMountArg>>;
2105 allDayWillUnmount: Identity<WillUnmountHandler<AllDayMountArg>>;
2106 slotMinWidth: NumberConstructor;
2107 navLinks: BooleanConstructor;
2108 eventTimeFormat: typeof createFormatter;
2109 rerenderDelay: NumberConstructor;
2110 moreLinkText: Identity<string | ((this: CalendarApi, num: number) => string)>;
2111 moreLinkHint: Identity<string | ((this: CalendarApi, num: number) => string)>;
2112 selectMinDistance: NumberConstructor;
2113 selectable: BooleanConstructor;
2114 selectLongPressDelay: NumberConstructor;
2115 eventLongPressDelay: NumberConstructor;
2116 selectMirror: BooleanConstructor;
2117 eventMaxStack: NumberConstructor;
2118 eventMinHeight: NumberConstructor;
2119 eventMinWidth: NumberConstructor;
2120 eventShortHeight: NumberConstructor;
2121 slotEventOverlap: BooleanConstructor;
2122 plugins: Identity<PluginDef[]>;
2123 firstDay: NumberConstructor;
2124 dayCount: NumberConstructor;
2125 dateAlignment: StringConstructor;
2126 dateIncrement: typeof createDuration;
2127 hiddenDays: Identity<number[]>;
2128 fixedWeekCount: BooleanConstructor;
2129 validRange: Identity<DateRangeInput | ((this: CalendarApi, nowDate: Date) => DateRangeInput)>;
2130 visibleRange: Identity<DateRangeInput | ((this: CalendarApi, currentDate: Date) => DateRangeInput)>;
2131 titleFormat: Identity<FormatterInput>;
2132 eventInteractive: BooleanConstructor;
2133 noEventsText: StringConstructor;
2134 viewHint: Identity<string | ((...args: any[]) => string)>;
2135 navLinkHint: Identity<string | ((...args: any[]) => string)>;
2136 closeHint: StringConstructor;
2137 timeHint: StringConstructor;
2138 eventHint: StringConstructor;
2139 moreLinkClick: Identity<MoreLinkAction>;
2140 moreLinkClassNames: Identity<ClassNamesGenerator<MoreLinkContentArg>>;
2141 moreLinkContent: Identity<CustomContentGenerator<MoreLinkContentArg>>;
2142 moreLinkDidMount: Identity<DidMountHandler<MoreLinkMountArg>>;
2143 moreLinkWillUnmount: Identity<WillUnmountHandler<MoreLinkMountArg>>;
2144 monthStartFormat: typeof createFormatter;
2145 handleCustomRendering: Identity<CustomRenderingHandler<any>>;
2146 customRenderingMetaMap: Identity<{
2147 [optionName: string]: any;
2148 }>;
2149 customRenderingReplaces: BooleanConstructor;
2150};
2151type BuiltInBaseOptionRefiners = typeof BASE_OPTION_REFINERS;
2152interface BaseOptionRefiners extends BuiltInBaseOptionRefiners {
2153}
2154type BaseOptions = RawOptionsFromRefiners<// as RawOptions
2155Required<BaseOptionRefiners>>;
2156declare const BASE_OPTION_DEFAULTS: {
2157 eventDisplay: string;
2158 defaultRangeSeparator: string;
2159 titleRangeSeparator: string;
2160 defaultTimedEventDuration: string;
2161 defaultAllDayEventDuration: {
2162 day: number;
2163 };
2164 forceEventDuration: boolean;
2165 nextDayThreshold: string;
2166 dayHeaders: boolean;
2167 initialView: string;
2168 aspectRatio: number;
2169 headerToolbar: {
2170 start: string;
2171 center: string;
2172 end: string;
2173 };
2174 weekends: boolean;
2175 weekNumbers: boolean;
2176 weekNumberCalculation: WeekNumberCalculation;
2177 editable: boolean;
2178 nowIndicator: boolean;
2179 scrollTime: string;
2180 scrollTimeReset: boolean;
2181 slotMinTime: string;
2182 slotMaxTime: string;
2183 showNonCurrentDates: boolean;
2184 lazyFetching: boolean;
2185 startParam: string;
2186 endParam: string;
2187 timeZoneParam: string;
2188 timeZone: string;
2189 locales: any[];
2190 locale: string;
2191 themeSystem: string;
2192 dragRevertDuration: number;
2193 dragScroll: boolean;
2194 allDayMaintainDuration: boolean;
2195 unselectAuto: boolean;
2196 dropAccept: string;
2197 eventOrder: string;
2198 dayPopoverFormat: {
2199 month: string;
2200 day: string;
2201 year: string;
2202 };
2203 handleWindowResize: boolean;
2204 windowResizeDelay: number;
2205 longPressDelay: number;
2206 eventDragMinDistance: number;
2207 expandRows: boolean;
2208 navLinks: boolean;
2209 selectable: boolean;
2210 eventMinHeight: number;
2211 eventMinWidth: number;
2212 eventShortHeight: number;
2213 monthStartFormat: {
2214 month: string;
2215 day: string;
2216 };
2217};
2218type BaseOptionsRefined = DefaultedRefinedOptions<RefinedOptionsFromRefiners<Required<BaseOptionRefiners>>, // Required is a hack for "Index signature is missing"
2219keyof typeof BASE_OPTION_DEFAULTS>;
2220declare const CALENDAR_LISTENER_REFINERS: {
2221 datesSet: Identity<(arg: DatesSetArg) => void>;
2222 eventsSet: Identity<(events: EventApi[]) => void>;
2223 eventAdd: Identity<(arg: EventAddArg) => void>;
2224 eventChange: Identity<(arg: EventChangeArg) => void>;
2225 eventRemove: Identity<(arg: EventRemoveArg) => void>;
2226 windowResize: Identity<(arg: {
2227 view: ViewApi;
2228 }) => void>;
2229 eventClick: Identity<(arg: EventClickArg) => void>;
2230 eventMouseEnter: Identity<(arg: EventHoveringArg) => void>;
2231 eventMouseLeave: Identity<(arg: EventHoveringArg) => void>;
2232 select: Identity<(arg: DateSelectArg) => void>;
2233 unselect: Identity<(arg: DateUnselectArg) => void>;
2234 loading: Identity<(isLoading: boolean) => void>;
2235 _unmount: Identity<() => void>;
2236 _beforeprint: Identity<() => void>;
2237 _afterprint: Identity<() => void>;
2238 _noEventDrop: Identity<() => void>;
2239 _noEventResize: Identity<() => void>;
2240 _resize: Identity<(forced: boolean) => void>;
2241 _scrollRequest: Identity<(arg: any) => void>;
2242};
2243type BuiltInCalendarListenerRefiners = typeof CALENDAR_LISTENER_REFINERS;
2244interface CalendarListenerRefiners extends BuiltInCalendarListenerRefiners {
2245}
2246type CalendarListenersLoose = RefinedOptionsFromRefiners<Required<CalendarListenerRefiners>>;
2247type CalendarListeners = Required<CalendarListenersLoose>;
2248declare const CALENDAR_OPTION_REFINERS: {
2249 buttonText: Identity<ButtonTextCompoundInput>;
2250 buttonHints: Identity<ButtonHintCompoundInput>;
2251 views: Identity<{
2252 [viewId: string]: ViewOptions;
2253 }>;
2254 plugins: Identity<PluginDef[]>;
2255 initialEvents: Identity<EventSourceInput>;
2256 events: Identity<EventSourceInput>;
2257 eventSources: Identity<EventSourceInput[]>;
2258};
2259type BuiltInCalendarOptionRefiners = typeof CALENDAR_OPTION_REFINERS;
2260interface CalendarOptionRefiners extends BuiltInCalendarOptionRefiners {
2261}
2262type CalendarOptions = BaseOptions & CalendarListenersLoose & RawOptionsFromRefiners<Required<CalendarOptionRefiners>>;
2263type CalendarOptionsRefined = BaseOptionsRefined & CalendarListenersLoose & RefinedOptionsFromRefiners<Required<CalendarOptionRefiners>>;
2264declare const VIEW_OPTION_REFINERS: {
2265 [name: string]: any;
2266};
2267type BuiltInViewOptionRefiners = typeof VIEW_OPTION_REFINERS;
2268interface ViewOptionRefiners extends BuiltInViewOptionRefiners {
2269}
2270type ViewOptions = BaseOptions & CalendarListenersLoose & RawOptionsFromRefiners<Required<ViewOptionRefiners>>;
2271type ViewOptionsRefined = BaseOptionsRefined & CalendarListenersLoose & RefinedOptionsFromRefiners<Required<ViewOptionRefiners>>;
2272declare function refineProps<Refiners extends GenericRefiners, Raw extends RawOptionsFromRefiners<Refiners>>(input: Raw, refiners: Refiners): {
2273 refined: RefinedOptionsFromRefiners<Refiners>;
2274 extra: Dictionary;
2275};
2276type GenericRefiners = {
2277 [propName: string]: (input: any) => any;
2278};
2279type GenericListenerRefiners = {
2280 [listenerName: string]: Identity<(this: CalendarApi, ...args: any[]) => void>;
2281};
2282type RawOptionsFromRefiners<Refiners extends GenericRefiners> = {
2283 [Prop in keyof Refiners]?: Refiners[Prop] extends ((input: infer RawType) => infer RefinedType) ? (any extends RawType ? RefinedType : RawType) : never;
2284};
2285type RefinedOptionsFromRefiners<Refiners extends GenericRefiners> = {
2286 [Prop in keyof Refiners]?: Refiners[Prop] extends ((input: any) => infer RefinedType) ? RefinedType : never;
2287};
2288type DefaultedRefinedOptions<RefinedOptions extends Dictionary, DefaultKey extends keyof RefinedOptions> = Required<Pick<RefinedOptions, DefaultKey>> & Partial<Omit<RefinedOptions, DefaultKey>>;
2289type Dictionary = Record<string, any>;
2290type Identity<T = any> = (raw: T) => T;
2291declare function identity<T>(raw: T): T;
2292
2293declare class JsonRequestError extends Error {
2294 response: Response;
2295 constructor(message: string, response: Response);
2296}
2297declare function requestJson<ParsedResponse>(method: string, url: string, params: Dictionary): Promise<[ParsedResponse, Response]>;
2298
2299declare function computeVisibleDayRange(timedRange: OpenDateRange, nextDayThreshold?: Duration): OpenDateRange;
2300declare function isMultiDayRange(range: DateRange): boolean;
2301declare function diffDates(date0: DateMarker, date1: DateMarker, dateEnv: DateEnv, largeUnit?: string): Duration;
2302
2303declare function removeExact(array: any, exactVal: any): number;
2304declare function isArraysEqual(a0: any, a1: any, equalityFunc?: (v0: any, v1: any) => boolean): boolean;
2305
2306declare function memoize<Args extends any[], Res>(workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): (...args: Args) => Res;
2307declare function memoizeObjArg<Arg extends Dictionary, Res>(workerFunc: (arg: Arg) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): (arg: Arg) => Res;
2308type MemoiseArrayFunc<Args extends any[], Res> = (argSets: Args[]) => Res[];
2309declare function memoizeArraylike<Args extends any[], Res>(// used at all?
2310workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): MemoiseArrayFunc<Args, Res>;
2311type MemoizeHashFunc<Args extends any[], Res> = (argHash: {
2312 [key: string]: Args;
2313}) => {
2314 [key: string]: Res;
2315};
2316declare function memoizeHashlike<Args extends any[], Res>(workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): MemoizeHashFunc<Args, Res>;
2317
2318declare function removeElement(el: HTMLElement): void;
2319declare function elementClosest(el: HTMLElement, selector: string): HTMLElement;
2320declare function elementMatches(el: HTMLElement, selector: string): HTMLElement;
2321declare function findElements(container: HTMLElement[] | HTMLElement | NodeListOf<HTMLElement>, selector: string): HTMLElement[];
2322declare function findDirectChildren(parent: HTMLElement[] | HTMLElement, selector?: string): HTMLElement[];
2323declare function applyStyle(el: HTMLElement, props: Dictionary): void;
2324declare function getEventTargetViaRoot(ev: Event): EventTarget;
2325declare function getUniqueDomId(): string;
2326
2327declare function getCanVGrowWithinCell(): boolean;
2328
2329declare function buildNavLinkAttrs(context: ViewContext, dateMarker: DateMarker, viewType?: string, isTabbable?: boolean): {
2330 tabIndex: number;
2331 onKeyDown(ev: KeyboardEvent): void;
2332 onClick: (ev: UIEvent) => void;
2333 title: any;
2334 'data-navlink': string;
2335 'aria-label'?: undefined;
2336} | {
2337 onClick: (ev: UIEvent) => void;
2338 title: any;
2339 'data-navlink': string;
2340 'aria-label'?: undefined;
2341} | {
2342 'aria-label': string;
2343};
2344
2345declare function preventDefault(ev: any): void;
2346declare function whenTransitionDone(el: HTMLElement, callback: (ev: Event) => void): void;
2347
2348interface EdgeInfo {
2349 borderLeft: number;
2350 borderRight: number;
2351 borderTop: number;
2352 borderBottom: number;
2353 scrollbarLeft: number;
2354 scrollbarRight: number;
2355 scrollbarBottom: number;
2356 paddingLeft?: number;
2357 paddingRight?: number;
2358 paddingTop?: number;
2359 paddingBottom?: number;
2360}
2361declare function computeEdges(el: HTMLElement, getPadding?: boolean): EdgeInfo;
2362declare function computeInnerRect(el: any, goWithinPadding?: boolean, doFromWindowViewport?: boolean): {
2363 left: any;
2364 right: number;
2365 top: any;
2366 bottom: number;
2367};
2368declare function computeRect(el: any): Rect;
2369declare function getClippingParents(el: HTMLElement): HTMLElement[];
2370
2371declare function unpromisify<Res>(func: (successCallback: (res: Res) => void, failureCallback: (error: Error) => void) => Promise<Res> | void, normalizedSuccessCallback: (res: Res) => void, normalizedFailureCallback: (error: Error) => void): void;
2372
2373declare class PositionCache {
2374 els: HTMLElement[];
2375 originClientRect: ClientRect;
2376 lefts: any;
2377 rights: any;
2378 tops: any;
2379 bottoms: any;
2380 constructor(originEl: HTMLElement, els: HTMLElement[], isHorizontal: boolean, isVertical: boolean);
2381 buildElHorizontals(originClientLeft: number): void;
2382 buildElVerticals(originClientTop: number): void;
2383 leftToIndex(leftPosition: number): any;
2384 topToIndex(topPosition: number): any;
2385 getWidth(leftIndex: number): number;
2386 getHeight(topIndex: number): number;
2387 similarTo(otherCache: PositionCache): boolean;
2388}
2389
2390declare abstract class ScrollController {
2391 abstract getScrollTop(): number;
2392 abstract getScrollLeft(): number;
2393 abstract setScrollTop(top: number): void;
2394 abstract setScrollLeft(left: number): void;
2395 abstract getClientWidth(): number;
2396 abstract getClientHeight(): number;
2397 abstract getScrollWidth(): number;
2398 abstract getScrollHeight(): number;
2399 getMaxScrollTop(): number;
2400 getMaxScrollLeft(): number;
2401 canScrollVertically(): boolean;
2402 canScrollHorizontally(): boolean;
2403 canScrollUp(): boolean;
2404 canScrollDown(): boolean;
2405 canScrollLeft(): boolean;
2406 canScrollRight(): boolean;
2407}
2408declare class ElementScrollController extends ScrollController {
2409 el: HTMLElement;
2410 constructor(el: HTMLElement);
2411 getScrollTop(): number;
2412 getScrollLeft(): number;
2413 setScrollTop(top: number): void;
2414 setScrollLeft(left: number): void;
2415 getScrollWidth(): number;
2416 getScrollHeight(): number;
2417 getClientHeight(): number;
2418 getClientWidth(): number;
2419}
2420declare class WindowScrollController extends ScrollController {
2421 getScrollTop(): number;
2422 getScrollLeft(): number;
2423 setScrollTop(n: number): void;
2424 setScrollLeft(n: number): void;
2425 getScrollWidth(): number;
2426 getScrollHeight(): number;
2427 getClientHeight(): number;
2428 getClientWidth(): number;
2429}
2430
2431declare function buildIsoString(marker: DateMarker, timeZoneOffset?: number, stripZeroTime?: boolean): string;
2432declare function formatDayString(marker: DateMarker): string;
2433declare function formatIsoMonthStr(marker: DateMarker): string;
2434declare function formatIsoTimeString(marker: DateMarker): string;
2435
2436declare function parse(str: any): {
2437 marker: Date;
2438 isTimeUnspecified: boolean;
2439 timeZoneOffset: any;
2440};
2441
2442interface SegSpan {
2443 start: number;
2444 end: number;
2445}
2446interface SegEntry {
2447 index: number;
2448 thickness?: number;
2449 span: SegSpan;
2450}
2451interface SegInsertion {
2452 level: number;
2453 levelCoord: number;
2454 lateral: number;
2455 touchingLevel: number;
2456 touchingLateral: number;
2457 touchingEntry: SegEntry;
2458 stackCnt: number;
2459}
2460interface SegRect extends SegEntry {
2461 thickness: number;
2462 levelCoord: number;
2463}
2464interface SegEntryGroup {
2465 entries: SegEntry[];
2466 span: SegSpan;
2467}
2468declare class SegHierarchy {
2469 private getEntryThickness;
2470 strictOrder: boolean;
2471 allowReslicing: boolean;
2472 maxCoord: number;
2473 maxStackCnt: number;
2474 levelCoords: number[];
2475 entriesByLevel: SegEntry[][];
2476 stackCnts: {
2477 [entryId: string]: number;
2478 };
2479 constructor(getEntryThickness?: (entry: SegEntry) => number);
2480 addSegs(inputs: SegEntry[]): SegEntry[];
2481 insertEntry(entry: SegEntry, hiddenEntries: SegEntry[]): void;
2482 isInsertionValid(insertion: SegInsertion, entry: SegEntry): boolean;
2483 handleInvalidInsertion(insertion: SegInsertion, entry: SegEntry, hiddenEntries: SegEntry[]): void;
2484 splitEntry(entry: SegEntry, barrier: SegEntry, hiddenEntries: SegEntry[]): void;
2485 insertEntryAt(entry: SegEntry, insertion: SegInsertion): void;
2486 findInsertion(newEntry: SegEntry): SegInsertion;
2487 toRects(): SegRect[];
2488}
2489declare function getEntrySpanEnd(entry: SegEntry): number;
2490declare function buildEntryKey(entry: SegEntry): string;
2491declare function groupIntersectingEntries(entries: SegEntry[]): SegEntryGroup[];
2492declare function intersectSpans(span0: SegSpan, span1: SegSpan): SegSpan | null;
2493declare function binarySearch<Item>(a: Item[], searchVal: number, getItemVal: (item: Item) => number): [number, number];
2494
2495declare const config: any;
2496
2497interface CalendarRootProps {
2498 options: CalendarOptions;
2499 theme: Theme;
2500 emitter: Emitter<CalendarListeners>;
2501 children: (classNames: string[], height: CssDimValue, isHeightAuto: boolean, forPrint: boolean) => ComponentChildren;
2502}
2503interface CalendarRootState {
2504 forPrint: boolean;
2505}
2506declare class CalendarRoot extends BaseComponent<CalendarRootProps, CalendarRootState> {
2507 state: {
2508 forPrint: boolean;
2509 };
2510 render(): ComponentChildren;
2511 componentDidMount(): void;
2512 componentWillUnmount(): void;
2513 handleBeforePrint: () => void;
2514 handleAfterPrint: () => void;
2515}
2516
2517interface DayHeaderProps {
2518 dateProfile: DateProfile;
2519 dates: DateMarker[];
2520 datesRepDistinctDays: boolean;
2521 renderIntro?: (rowKey: string) => VNode;
2522}
2523declare class DayHeader extends BaseComponent<DayHeaderProps> {
2524 createDayHeaderFormatter: (explicitFormat: DateFormatter, datesRepDistinctDays: any, dateCnt: any) => DateFormatter;
2525 render(): createElement.JSX.Element;
2526}
2527
2528declare function computeFallbackHeaderFormat(datesRepDistinctDays: boolean, dayCnt: number): DateFormatter;
2529
2530interface TableDateCellProps {
2531 date: DateMarker;
2532 dateProfile: DateProfile;
2533 todayRange: DateRange;
2534 colCnt: number;
2535 dayHeaderFormat: DateFormatter;
2536 colSpan?: number;
2537 isSticky?: boolean;
2538 extraDataAttrs?: Dictionary;
2539 extraRenderProps?: Dictionary;
2540}
2541declare class TableDateCell extends BaseComponent<TableDateCellProps> {
2542 render(): createElement.JSX.Element;
2543}
2544
2545interface TableDowCellProps {
2546 dow: number;
2547 dayHeaderFormat: DateFormatter;
2548 colSpan?: number;
2549 isSticky?: boolean;
2550 extraRenderProps?: Dictionary;
2551 extraDataAttrs?: Dictionary;
2552 extraClassNames?: string[];
2553}
2554declare class TableDowCell extends BaseComponent<TableDowCellProps> {
2555 render(): createElement.JSX.Element;
2556}
2557
2558interface DaySeriesSeg {
2559 firstIndex: number;
2560 lastIndex: number;
2561 isStart: boolean;
2562 isEnd: boolean;
2563}
2564declare class DaySeriesModel {
2565 cnt: number;
2566 dates: DateMarker[];
2567 indices: number[];
2568 constructor(range: DateRange, dateProfileGenerator: DateProfileGenerator);
2569 sliceRange(range: DateRange): DaySeriesSeg | null;
2570 private getDateDayIndex;
2571}
2572
2573interface DayTableSeg extends Seg {
2574 row: number;
2575 firstCol: number;
2576 lastCol: number;
2577}
2578interface DayTableCell {
2579 key: string;
2580 date: DateMarker;
2581 extraRenderProps?: Dictionary;
2582 extraDataAttrs?: Dictionary;
2583 extraClassNames?: string[];
2584 extraDateSpan?: Dictionary;
2585}
2586declare class DayTableModel {
2587 rowCnt: number;
2588 colCnt: number;
2589 cells: DayTableCell[][];
2590 headerDates: DateMarker[];
2591 private daySeries;
2592 constructor(daySeries: DaySeriesModel, breakOnWeeks: boolean);
2593 private buildCells;
2594 private buildCell;
2595 private buildHeaderDates;
2596 sliceRange(range: DateRange): DayTableSeg[];
2597}
2598
2599interface SliceableProps {
2600 dateSelection: DateSpan;
2601 businessHours: EventStore;
2602 eventStore: EventStore;
2603 eventDrag: EventInteractionState | null;
2604 eventResize: EventInteractionState | null;
2605 eventSelection: string;
2606 eventUiBases: EventUiHash;
2607}
2608interface SlicedProps<SegType extends Seg> {
2609 dateSelectionSegs: SegType[];
2610 businessHourSegs: SegType[];
2611 fgEventSegs: SegType[];
2612 bgEventSegs: SegType[];
2613 eventDrag: EventSegUiInteractionState | null;
2614 eventResize: EventSegUiInteractionState | null;
2615 eventSelection: string;
2616}
2617declare abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
2618 private sliceBusinessHours;
2619 private sliceDateSelection;
2620 private sliceEventStore;
2621 private sliceEventDrag;
2622 private sliceEventResize;
2623 abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): SegType[];
2624 protected forceDayIfListItem: boolean;
2625 sliceProps(props: SliceableProps, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SlicedProps<SegType>;
2626 sliceNowDate(// does not memoize
2627 date: DateMarker, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SegType[];
2628 private _sliceBusinessHours;
2629 private _sliceEventStore;
2630 private _sliceInteraction;
2631 private _sliceDateSpan;
2632 private sliceEventRanges;
2633 private sliceEventRange;
2634}
2635
2636declare function isInteractionValid(interaction: EventInteractionState, dateProfile: DateProfile, context: CalendarContext): boolean;
2637declare function isDateSelectionValid(dateSelection: DateSpan, dateProfile: DateProfile, context: CalendarContext): boolean;
2638declare function isPropsValid(state: SplittableProps, context: CalendarContext, dateSpanMeta?: {}, filterConfig?: any): boolean;
2639
2640type OverflowValue = 'auto' | 'hidden' | 'scroll' | 'visible';
2641interface ScrollerProps {
2642 elRef?: Ref<HTMLElement>;
2643 overflowX: OverflowValue;
2644 overflowY: OverflowValue;
2645 overcomeLeft?: number;
2646 overcomeRight?: number;
2647 overcomeBottom?: number;
2648 maxHeight?: CssDimValue;
2649 liquid?: boolean;
2650 liquidIsAbsolute?: boolean;
2651 children?: ComponentChildren;
2652}
2653declare class Scroller extends BaseComponent<ScrollerProps> implements ScrollerLike {
2654 el: HTMLElement;
2655 render(): createElement.JSX.Element;
2656 handleEl: (el: HTMLElement) => void;
2657 needsXScrolling(): boolean;
2658 needsYScrolling(): boolean;
2659 getXScrollbarWidth(): number;
2660 getYScrollbarWidth(): number;
2661}
2662
2663declare class RefMap<RefType> {
2664 masterCallback?: (val: RefType | null, key: string) => void;
2665 currentMap: {
2666 [key: string]: RefType;
2667 };
2668 private depths;
2669 private callbackMap;
2670 constructor(masterCallback?: (val: RefType | null, key: string) => void);
2671 createRef(key: string | number): (val: RefType) => void;
2672 handleValue: (val: RefType | null, key: string) => void;
2673 collect(startIndex?: number, endIndex?: number, step?: number): RefType[];
2674 getAll(): RefType[];
2675}
2676
2677interface SimpleScrollGridProps {
2678 cols: ColProps[];
2679 sections: SimpleScrollGridSection[];
2680 liquid: boolean;
2681 collapsibleWidth: boolean;
2682 height?: CssDimValue;
2683}
2684interface SimpleScrollGridSection extends SectionConfig {
2685 key: string;
2686 chunk?: ChunkConfig;
2687}
2688interface SimpleScrollGridState {
2689 shrinkWidth: number | null;
2690 forceYScrollbars: boolean;
2691 scrollerClientWidths: {
2692 [key: string]: number;
2693 };
2694 scrollerClientHeights: {
2695 [key: string]: number;
2696 };
2697}
2698declare class SimpleScrollGrid extends BaseComponent<SimpleScrollGridProps, SimpleScrollGridState> {
2699 processCols: (a: any) => any;
2700 renderMicroColGroup: typeof renderMicroColGroup;
2701 scrollerRefs: RefMap<Scroller>;
2702 scrollerElRefs: RefMap<HTMLElement>;
2703 state: SimpleScrollGridState;
2704 render(): VNode;
2705 renderSection(sectionConfig: SimpleScrollGridSection, microColGroupNode: VNode, isHeader: boolean): createElement.JSX.Element;
2706 renderChunkTd(sectionConfig: SimpleScrollGridSection, microColGroupNode: VNode, chunkConfig: ChunkConfig, isHeader: boolean): createElement.JSX.Element;
2707 _handleScrollerEl(scrollerEl: HTMLElement | null, key: string): void;
2708 handleSizing: () => void;
2709 componentDidMount(): void;
2710 componentDidUpdate(): void;
2711 componentWillUnmount(): void;
2712 computeShrinkWidth(): number;
2713 computeScrollerDims(): {
2714 forceYScrollbars: boolean;
2715 scrollerClientWidths: {
2716 [index: string]: number;
2717 };
2718 scrollerClientHeights: {
2719 [index: string]: number;
2720 };
2721 };
2722}
2723
2724interface ScrollbarWidths {
2725 x: number;
2726 y: number;
2727}
2728declare function getScrollbarWidths(): ScrollbarWidths;
2729
2730declare function getIsRtlScrollbarOnLeft(): boolean;
2731
2732interface NowTimerProps {
2733 unit: string;
2734 children: (now: DateMarker, todayRange: DateRange) => ComponentChildren;
2735}
2736interface NowTimerState {
2737 nowDate: DateMarker;
2738 todayRange: DateRange;
2739}
2740declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
2741 static contextType: any;
2742 context: ViewContext;
2743 initialNowDate: DateMarker;
2744 initialNowQueriedMs: number;
2745 timeoutId: any;
2746 constructor(props: NowTimerProps, context: ViewContext);
2747 render(): ComponentChildren;
2748 componentDidMount(): void;
2749 componentDidUpdate(prevProps: NowTimerProps): void;
2750 componentWillUnmount(): void;
2751 private computeTiming;
2752 private setTimeout;
2753 private clearTimeout;
2754}
2755
2756interface StandardEventProps {
2757 elRef?: ElRef;
2758 elClasses?: string[];
2759 seg: Seg;
2760 isDragging: boolean;
2761 isResizing: boolean;
2762 isDateSelecting: boolean;
2763 isSelected: boolean;
2764 isPast: boolean;
2765 isFuture: boolean;
2766 isToday: boolean;
2767 disableDragging?: boolean;
2768 disableResizing?: boolean;
2769 defaultTimeFormat: DateFormatter;
2770 defaultDisplayEventTime?: boolean;
2771 defaultDisplayEventEnd?: boolean;
2772}
2773declare class StandardEvent extends BaseComponent<StandardEventProps> {
2774 render(): createElement.JSX.Element;
2775}
2776
2777interface MinimalEventProps {
2778 seg: Seg;
2779 isDragging: boolean;
2780 isResizing: boolean;
2781 isDateSelecting: boolean;
2782 isSelected: boolean;
2783 isPast: boolean;
2784 isFuture: boolean;
2785 isToday: boolean;
2786}
2787type EventContainerProps = ElProps & MinimalEventProps & {
2788 defaultGenerator: (renderProps: EventContentArg) => ComponentChild;
2789 disableDragging?: boolean;
2790 disableResizing?: boolean;
2791 timeText: string;
2792 children?: InnerContainerFunc<EventContentArg>;
2793};
2794declare class EventContainer extends BaseComponent<EventContainerProps> {
2795 el: HTMLElement;
2796 render(): createElement.JSX.Element;
2797 handleEl: (el: HTMLElement | null) => void;
2798 componentDidUpdate(prevProps: EventContainerProps): void;
2799}
2800
2801interface BgEventProps {
2802 seg: Seg;
2803 isPast: boolean;
2804 isFuture: boolean;
2805 isToday: boolean;
2806}
2807declare class BgEvent extends BaseComponent<BgEventProps> {
2808 render(): createElement.JSX.Element;
2809}
2810declare function renderFill(fillType: string): createElement.JSX.Element;
2811
2812declare function injectStyles(styleText: string): void;
2813
2814export { ViewContentArg as $, AllowFunc as A, BusinessHoursInput as B, CalendarImpl as C, DateInput as D, EventSourceApi as E, FormatterInput as F, WeekNumberMountArg as G, MoreLinkMountArg as H, SlotLaneContentArg as I, JsonRequestError as J, SlotLaneMountArg as K, LocaleInput as L, MoreLinkContentArg as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, SlotLabelContentArg as Q, SlotLabelMountArg as R, SpecificViewContentArg as S, AllDayContentArg as T, AllDayMountArg as U, ViewApi as V, WillUnmountHandler as W, DayHeaderContentArg as X, DayHeaderMountArg as Y, DayCellContentArg as Z, DayCellMountArg as _, CalendarOptions as a, disableCursor as a$, ViewMountArg as a0, EventClickArg as a1, EventHoveringArg as a2, DateSelectArg as a3, DateUnselectArg as a4, WeekNumberCalculation as a5, ToolbarInput as a6, CustomButtonInput as a7, ButtonIconsInput as a8, ButtonTextCompoundInput as a9, CalendarListenerRefiners as aA, BASE_OPTION_DEFAULTS as aB, identity as aC, refineProps as aD, EventDef as aE, EventDefHash as aF, EventInstance as aG, EventInstanceHash as aH, createEventInstance as aI, EventRefined as aJ, EventTuple as aK, EventRefiners as aL, parseEventDef as aM, refineEventDef as aN, parseBusinessHours as aO, OrderSpec as aP, padStart as aQ, isInt as aR, parseFieldSpecs as aS, compareByFieldSpecs as aT, flexibleCompare as aU, preventSelection as aV, allowSelection as aW, preventContextMenu as aX, allowContextMenu as aY, compareNumbers as aZ, enableCursor as a_, EventContentArg as aa, EventMountArg as ab, DatesSetArg as ac, EventAddArg as ad, EventChangeArg as ae, EventDropArg as af, EventRemoveArg as ag, ButtonHintCompoundInput as ah, CustomRenderingHandler as ai, CustomRenderingStore as aj, DateSpanApi as ak, DatePointApi as al, DateSelectionApi as am, Duration as an, EventSegment as ao, MoreLinkAction as ap, MoreLinkSimpleAction as aq, MoreLinkArg as ar, MoreLinkHandler as as, Identity as at, Dictionary as au, BaseOptionRefiners as av, BaseOptionsRefined as aw, ViewOptionsRefined as ax, RawOptionsFromRefiners as ay, RefinedOptionsFromRefiners as az, PluginDef as b, rangeContainsRange as b$, guid as b0, computeVisibleDayRange as b1, isMultiDayRange as b2, diffDates as b3, removeExact as b4, isArraysEqual as b5, MemoizeHashFunc as b6, MemoiseArrayFunc as b7, memoize as b8, memoizeObjArg as b9, createEmptyEventStore as bA, mergeEventStores as bB, getRelevantEvents as bC, eventTupleToStore as bD, EventUiHash as bE, EventUi as bF, combineEventUis as bG, createEventUi as bH, SplittableProps as bI, Splitter as bJ, getDayClassNames as bK, getDateMeta as bL, getSlotClassNames as bM, buildNavLinkAttrs as bN, preventDefault as bO, whenTransitionDone as bP, computeInnerRect as bQ, computeEdges as bR, getClippingParents as bS, computeRect as bT, unpromisify as bU, Emitter as bV, DateRange as bW, rangeContainsMarker as bX, intersectRanges as bY, rangesEqual as bZ, rangesIntersect as b_, memoizeArraylike as ba, memoizeHashlike as bb, Rect as bc, Point as bd, intersectRects as be, pointInsideRect as bf, constrainPoint as bg, getRectCenter as bh, diffPoints as bi, translateRect as bj, mapHash as bk, filterHash as bl, isPropsEqual as bm, compareObjs as bn, collectFromHash as bo, findElements as bp, findDirectChildren as bq, removeElement as br, applyStyle as bs, elementMatches as bt, elementClosest as bu, getEventTargetViaRoot as bv, getUniqueDomId as bw, parseClassNames as bx, getCanVGrowWithinCell as by, EventStore as bz, CalendarApi as c, Interaction as c$, PositionCache as c0, ScrollController as c1, ElementScrollController as c2, WindowScrollController as c3, Theme as c4, ViewContext as c5, ViewContextType as c6, Seg as c7, EventSegUiInteractionState as c8, DateComponent as c9, greatestDurationDenominator as cA, DateEnv as cB, createFormatter as cC, DateFormatter as cD, VerboseFormattingArg as cE, formatIsoTimeString as cF, formatDayString as cG, buildIsoString as cH, formatIsoMonthStr as cI, NamedTimeZoneImpl as cJ, parse as cK, EventSourceDef as cL, EventSourceRefined as cM, EventSourceRefiners as cN, SegSpan as cO, SegRect as cP, SegEntry as cQ, SegInsertion as cR, SegEntryGroup as cS, SegHierarchy as cT, buildEntryKey as cU, getEntrySpanEnd as cV, binarySearch as cW, groupIntersectingEntries as cX, intersectSpans as cY, InteractionSettings as cZ, InteractionSettingsStore as c_, CalendarData as ca, ViewProps as cb, DateProfile as cc, DateProfileGenerator as cd, ViewSpec as ce, DateSpan as cf, isDateSpansEqual as cg, DateMarker as ch, addDays as ci, startOfDay as cj, addMs as ck, addWeeks as cl, diffWeeks as cm, diffWholeWeeks as cn, diffWholeDays as co, diffDayAndTime as cp, diffDays as cq, isValidDate as cr, createDuration as cs, asCleanDays as ct, multiplyDuration as cu, addDurations as cv, asRoughMinutes as cw, asRoughSeconds as cx, asRoughMs as cy, wholeDivideDurations as cz, EventApi as d, getAllowYScrolling as d$, interactionSettingsToStore as d0, interactionSettingsStore as d1, PointerDragEvent as d2, Hit as d3, dateSelectionJoinTransformer as d4, eventDragMutationMassager as d5, EventDropTransformers as d6, ElementDragging as d7, config as d8, RecurringType as d9, Slicer as dA, EventMutation as dB, applyMutationToEventStore as dC, Constraint as dD, isPropsValid as dE, isInteractionValid as dF, isDateSelectionValid as dG, requestJson as dH, BaseComponent as dI, setRef as dJ, DelayedRunner as dK, ScrollGridProps as dL, ScrollGridSectionConfig as dM, ColGroupConfig as dN, ScrollGridChunkConfig as dO, SimpleScrollGridSection as dP, SimpleScrollGrid as dQ, ScrollerLike as dR, ColProps as dS, ChunkContentCallbackArgs as dT, ChunkConfigRowContent as dU, ChunkConfigContent as dV, hasShrinkWidth as dW, renderMicroColGroup as dX, getScrollGridClassNames as dY, getSectionClassNames as dZ, getSectionHasLiquidHeight as d_, DragMetaInput as da, DragMeta as db, parseDragMeta as dc, ViewPropsTransformer as dd, Action as de, CalendarContext as df, CalendarContentProps as dg, CalendarRoot as dh, DayHeader as di, computeFallbackHeaderFormat as dj, TableDateCell as dk, TableDowCell as dl, DaySeriesModel as dm, EventInteractionState as dn, sliceEventStore as dp, hasBgRendering as dq, getElSeg as dr, buildSegTimeText as ds, sortEventSegs as dt, getSegMeta as du, buildEventRangeKey as dv, getSegAnchorAttrs as dw, DayTableCell as dx, DayTableModel as dy, SlicedProps as dz, EventRenderRange as e, renderChunkContent as e0, computeShrinkWidth as e1, sanitizeShrinkWidth as e2, isColPropsEqual as e3, renderScrollShim as e4, getStickyFooterScrollbar as e5, getStickyHeaderDates as e6, OverflowValue as e7, Scroller as e8, getScrollbarWidths as e9, buildEventApis as eA, ElProps as eB, buildElAttrs as eC, InnerContainerFunc as eD, ContentContainer as eE, CustomRendering as eF, RefMap as ea, getIsRtlScrollbarOnLeft as eb, NowTimer as ec, ScrollRequest as ed, ScrollResponder as ee, MountArg as ef, StandardEvent as eg, NowIndicatorContainer as eh, DayCellContainer as ei, hasCustomDayCellContent as ej, MinimalEventProps as ek, EventContainer as el, renderFill as em, BgEvent as en, WeekNumberContainerProps as eo, WeekNumberContainer as ep, MoreLinkContainer as eq, computeEarliestSegStart as er, ViewContainerProps as es, ViewContainer as et, DatePointTransform as eu, DateSpanTransform as ev, triggerDateSelect as ew, getDefaultEventEnd as ex, injectStyles as ey, EventImpl as ez, CalendarListeners as f, DurationInput as g, DateSpanInput as h, DateRangeInput as i, EventSourceInput as j, EventSourceFunc as k, EventSourceFuncArg as l, EventInput as m, EventInputTransformer as n, CssDimValue as o, LocaleSingularArg as p, ConstraintInput as q, ViewComponentType as r, sliceEvents as s, SpecificViewMountArg as t, ClassNamesGenerator as u, CustomContentGenerator as v, DidMountHandler as w, NowIndicatorContentArg as x, NowIndicatorMountArg as y, WeekNumberContentArg as z };