@fullcalendar/core 7.0.0-beta.1 → 7.0.0-beta.4

package/internal-common.d.ts

@@ -1,7 +1,6 @@
 import * as preact from 'preact';
 import { ComponentChildren, ComponentType, Context, Ref, Component, JSX, ComponentChild, FunctionalComponent, createElement, RefObject } from './preact.js';
 import { ViewApi as ViewApi$1 } from './index.js';
-import { DateComponent as DateComponent$1, Dictionary as Dictionary$1 } from './internal.js';
 
 type DurationInput = DurationObjectInput | string | number;
 interface DurationObjectInput {
@@ -478,6 +477,8 @@ interface ViewProps {
     eventDrag: EventInteractionState | null;
     eventResize: EventInteractionState | null;
     forPrint: boolean;
+    labelId: string | undefined;
+    labelStr: string | undefined;
 }
 declare function sliceEvents(props: ViewProps & {
     dateProfile: DateProfile;
@@ -485,6 +486,8 @@ declare function sliceEvents(props: ViewProps & {
 }, allDay?: boolean): EventRenderRange[];
 
 type ClassNamesInput = string | string[];
+type Falsy = false | null | undefined;
+declare function joinClassNames(...args: (string | number | Falsy)[]): string;
 declare function parseClassNames(raw: ClassNamesInput): string[];
 declare function fracToCssDim(frac: number): string;
 
@@ -571,15 +574,78 @@ declare class Theme {
     iconOverridePrefix: string;
     constructor(calendarOptions: CalendarOptionsRefined);
     setIconOverride(iconOverrideHash: any): void;
-    applyIconOverridePrefix(className: any): any;
-    getClass(key: any): any;
-    getIconClass(buttonName: any, isRtl?: boolean): string;
+    applyIconOverridePrefix(className: string): string;
+    getClassName(key: string): any;
+    getIconClass(buttonName: string, isRtl?: boolean): string;
     getCustomButtonIconClass(customButtonProps: any): string;
 }
 type ThemeClass = {
     new (calendarOptions: any): Theme;
 };
 
+interface ToolbarModel {
+    sectionWidgets: {
+        start: ToolbarWidget[][];
+        center: ToolbarWidget[][];
+        end: ToolbarWidget[][];
+    };
+    viewsWithButtons: string[];
+    hasTitle: boolean;
+}
+interface ToolbarWidget {
+    buttonName: string;
+    buttonClick?: any;
+    buttonIcon?: any;
+    buttonText?: any;
+    buttonHint?: string | ((navUnit: string) => string);
+    isView?: boolean;
+}
+interface ToolbarInput {
+    left?: string;
+    center?: string;
+    right?: string;
+    start?: string;
+    end?: string;
+}
+interface CustomButtonInput {
+    text?: string;
+    hint?: string;
+    icon?: string;
+    themeIcon?: string;
+    bootstrapFontAwesome?: string;
+    click?(ev: MouseEvent, element: HTMLElement): void;
+}
+interface ButtonIconsInput {
+    prev?: string;
+    next?: string;
+    prevYear?: string;
+    nextYear?: string;
+    today?: string;
+    [viewOrCustomButton: string]: string | undefined;
+}
+interface ButtonTextCompoundInput {
+    prev?: string;
+    next?: string;
+    prevYear?: string;
+    nextYear?: string;
+    today?: string;
+    month?: string;
+    week?: string;
+    day?: string;
+    [viewOrCustomButton: string]: string | undefined;
+}
+interface ButtonHintCompoundInput {
+    prev?: string | ((...args: any[]) => string);
+    next?: string | ((...args: any[]) => string);
+    prevYear?: string | ((...args: any[]) => string);
+    nextYear?: string | ((...args: any[]) => string);
+    today?: string | ((...args: any[]) => string);
+    month?: string | ((...args: any[]) => string);
+    week?: string | ((...args: any[]) => string);
+    day?: string | ((...args: any[]) => string);
+    [viewOrCustomButton: string]: string | ((...args: any[]) => string) | undefined;
+}
+
 interface CalendarDataManagerState {
     dynamicOptionOverrides: CalendarOptions;
     currentViewType: string;
@@ -599,7 +665,9 @@ interface CalendarDataManagerState {
 interface CalendarOptionsData {
     localeDefaults: CalendarOptions;
     calendarOptions: CalendarOptionsRefined;
-    toolbarConfig: any;
+    toolbarConfig: {
+        [toolbarName: string]: ToolbarModel;
+    };
     availableRawLocales: any;
     dateEnv: DateEnv;
     theme: Theme;
@@ -909,7 +977,6 @@ declare abstract class PureComponent<Props = Dictionary, State = Dictionary> ext
     stateEquality: EqualityFuncs<State>;
     debug: boolean;
     shouldComponentUpdate(nextProps: Props, nextState: State): boolean;
-    safeSetState(newState: Partial<State>): void;
 }
 declare abstract class BaseComponent<Props = Dictionary, State = Dictionary> extends PureComponent<Props, State> {
     static contextType: any;
@@ -955,14 +1022,9 @@ interface Hit {
     largeUnit?: string;
 }
 
-interface Seg {
-    eventRange?: EventRenderRange;
-    isStart: boolean;
-    isEnd: boolean;
-}
-interface EventSegUiInteractionState<S = Seg> {
+interface EventSegUiInteractionState<S> {
     affectedInstances: EventInstanceHash;
-    segs: S[];
+    segs: (S & EventRangeProps)[];
     isEvent: boolean;
 }
 declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
@@ -986,6 +1048,7 @@ interface InteractionSettingsInput {
     el: HTMLElement;
     useEventCenter?: boolean;
     isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
+    disableHits?: boolean;
 }
 interface InteractionSettings {
     component: DateComponent<any>;
@@ -1087,7 +1150,7 @@ declare abstract class ElementDragging {
     emitter: Emitter<any>;
     constructor(el: HTMLElement, selector?: string);
     destroy(): void;
-    abstract setIgnoreMove(bool: boolean): void;
+    abstract cancel(): void;
     setMirrorIsVisible(bool: boolean): void;
     setMirrorNeedsRevert(bool: boolean): void;
     setAutoScrollEnabled(bool: boolean): void;
@@ -1103,8 +1166,16 @@ interface ScrollerInterface {
         x?: number;
         y?: number;
     }): void;
-    addScrollEndListener(handler: (x: number, y: number) => void): void;
-    removeScrollEndListener(handler: (x: number, y: number) => void): void;
+    addScrollEndListener(handler: (arg: {
+        x: number;
+        y: number;
+        isUser: boolean;
+    }) => void): void;
+    removeScrollEndListener(handler: (arg: {
+        x: number;
+        y: number;
+        isUser: boolean;
+    }) => void): void;
 }
 
 interface ScrollerSyncerClass {
@@ -1368,13 +1439,17 @@ interface EventRenderRange extends EventTuple {
     isStart: boolean;
     isEnd: boolean;
 }
+interface EventRangeProps {
+    eventRange: EventRenderRange;
+}
+declare function getEventKey(seg: EventRangeProps): string;
 declare function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHash, framingRange: DateRange, nextDayThreshold?: Duration): {
     bg: EventRenderRange[];
     fg: EventRenderRange[];
 };
 declare function hasBgRendering(def: EventDef): boolean;
 declare function getElEventRange(el: HTMLElement): EventRenderRange | null;
-declare function sortEventSegs<S extends Seg>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
+declare function sortEventSegs<S extends EventRangeProps>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
 interface EventContentArg {
     event: EventImpl;
     timeText: string;
@@ -1396,23 +1471,20 @@ interface EventContentArg {
     view: ViewApi;
 }
 type EventMountArg = MountArg<EventContentArg>;
-declare function buildEventRangeTimeText(eventRange: EventRenderRange, timeFormat: DateFormatter, context: ViewContext, defaultDisplayEventTime?: boolean, // defaults to true
-defaultDisplayEventEnd?: boolean, // defaults to true
-startOverride?: DateMarker, endOverride?: DateMarker): string;
+declare function buildEventRangeTimeText(timeFormat: DateFormatter, eventRange: EventRenderRange, // timed/whole-day span
+slicedStart: DateMarker | undefined, // view-sliced timed/whole-day span
+slicedEnd: DateMarker | undefined, // view-sliced timed/whole-day span
+isStart: boolean, isEnd: boolean, context: ViewContext, defaultDisplayEventTime?: boolean, defaultDisplayEventEnd?: boolean): string;
 declare function getEventRangeMeta(eventRange: EventRenderRange, todayRange: DateRange, nowDate?: DateMarker): {
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
 };
 declare function buildEventRangeKey(eventRange: EventRenderRange): string;
-declare function getEventRangeAnchorAttrs(eventRange: EventRenderRange, context: ViewContext): {
-    tabIndex: number;
-    onKeyDown(ev: KeyboardEvent): void;
-} | {
-    href: string;
-} | {
-    href?: undefined;
-};
+declare function getEventTagAndAttrs(eventRange: EventRenderRange, context: ViewContext): [
+    tag: string,
+    attrs: any
+];
 
 interface OpenDateSpanInput {
     start?: DateInput;
@@ -1478,13 +1550,13 @@ type ElAttrs = JSX.HTMLAttributes & JSX.SVGAttributes & {
     ref?: ElRef;
 } & Record<string, any>;
 interface ElAttrsProps {
+    attrs?: ElAttrs;
+    className?: string;
+    style?: JSX.CSSProperties;
     elRef?: ElRef;
-    elClasses?: string[];
-    elStyle?: JSX.CSSProperties;
-    elAttrs?: ElAttrs;
 }
 interface ElProps extends ElAttrsProps {
-    elTag: string;
+    tag: string;
 }
 interface ContentGeneratorProps<RenderProps> {
     renderProps: RenderProps;
@@ -1492,10 +1564,10 @@ interface ContentGeneratorProps<RenderProps> {
     customGenerator?: CustomContentGenerator<RenderProps>;
     defaultGenerator?: (renderProps: RenderProps) => ComponentChild;
 }
-declare function buildElAttrs(props: ElAttrsProps, extraClassNames?: string[], elRef?: ElRef): ElAttrs;
+declare function buildElAttrs(props: ElAttrsProps, className?: string, elRef?: ElRef): ElAttrs;
 
 type ContentContainerProps<RenderProps> = ElAttrsProps & ContentGeneratorProps<RenderProps> & {
-    elTag?: string;
+    tag?: string;
     classNameGenerator: ClassNamesGenerator<RenderProps> | undefined;
     didMount: ((renderProps: RenderProps & {
         el: HTMLElement;
@@ -1517,7 +1589,10 @@ declare class ContentContainer<RenderProps> extends Component<ContentContainerPr
     componentWillUnmount(): void;
 }
 type InnerContainerComponent = FunctionalComponent<ElProps>;
-type InnerContainerFunc<RenderProps> = (InnerContainer: InnerContainerComponent, renderProps: RenderProps, elAttrs: ElAttrs) => ComponentChildren;
+type InnerContainerFunc<RenderProps> = (InnerContainer: InnerContainerComponent, renderProps: RenderProps, attrs: ElAttrs) => ComponentChildren;
+declare function renderText(renderProps: {
+    text: string;
+}): ComponentChild;
 
 interface NowIndicatorContainerProps extends Partial<ElProps> {
     isAxis: boolean;
@@ -1545,15 +1620,15 @@ interface WeekNumberContentArg {
 type WeekNumberMountArg = MountArg<WeekNumberContentArg>;
 declare const WeekNumberContainer: (props: WeekNumberContainerProps) => createElement.JSX.Element;
 
-interface MoreLinkContainerProps extends Partial<ElProps> {
+interface MoreLinkContainerProps extends Partial<ElAttrsProps> {
     dateProfile: DateProfile;
     todayRange: DateRange;
     allDayDate: DateMarker | null;
-    segs: Seg[];
-    hiddenSegs: Seg[];
-    extraDateSpan?: Dictionary;
-    alignmentElRef?: RefObject<HTMLElement>;
-    alignGridTop?: boolean;
+    segs: EventRangeProps[];
+    hiddenSegs: EventRangeProps[];
+    dateSpanProps?: Dictionary;
+    alignElRef?: RefObject<HTMLElement>;
+    alignParentTop?: string;
     forceTimed?: boolean;
     popoverContent: () => ComponentChild;
     defaultGenerator?: (renderProps: MoreLinkContentArg) => ComponentChild;
@@ -1585,7 +1660,6 @@ declare class MoreLinkContainer extends BaseComponent<MoreLinkContainerProps, Mo
     handleClick: (ev: MouseEvent) => void;
     handlePopoverClose: () => void;
 }
-declare function computeEarliestSegStart(segs: Seg[]): DateMarker;
 
 interface EventSegment {
     event: EventApi;
@@ -1615,8 +1689,8 @@ interface DateMeta {
     isFuture: boolean;
 }
 declare function getDateMeta(date: DateMarker, todayRange?: DateRange, nowDate?: DateMarker, dateProfile?: DateProfile): DateMeta;
-declare function getDayClassNames(meta: DateMeta, theme: Theme): string[];
-declare function getSlotClassNames(meta: DateMeta, theme: Theme): string[];
+declare function getDayClassName(meta: DateMeta): string;
+declare function getSlotClassName(meta: DateMeta): string;
 
 interface SlotLaneContentArg extends Partial<DateMeta> {
     time?: Duration;
@@ -1639,8 +1713,8 @@ interface AllDayContentArg {
 type AllDayMountArg = MountArg<AllDayContentArg>;
 interface DayHeaderContentArg extends DateMeta {
     date: Date;
-    view: ViewApi;
     text: string;
+    view: ViewApi;
     [otherProp: string]: any;
 }
 type DayHeaderMountArg = MountArg<DayHeaderContentArg>;
@@ -1654,11 +1728,10 @@ interface DayCellContentArg extends DateMeta {
 type DayCellMountArg = MountArg<DayCellContentArg>;
 interface DayCellContainerProps extends Partial<ElProps> {
     date: DateMarker;
-    dateProfile: DateProfile;
-    todayRange: DateRange;
+    dateMeta: DateMeta;
     isMonthStart?: boolean;
     showDayNumber?: boolean;
-    extraRenderProps?: Dictionary;
+    renderProps?: Dictionary;
     defaultGenerator?: (renderProps: DayCellContentArg) => ComponentChild;
     children?: InnerContainerFunc<DayCellContentArg>;
 }
@@ -1669,18 +1742,18 @@ declare class DayCellContainer extends BaseComponent<DayCellContainerProps> {
 declare function hasCustomDayCellContent(options: ViewOptions): boolean;
 interface DayCellRenderPropsInput {
     date: DateMarker;
-    dateProfile: DateProfile;
-    todayRange: DateRange;
+    dateMeta: DateMeta;
     dateEnv: DateEnv;
     viewApi: ViewApi;
     monthStartFormat: DateFormatter;
     isMonthStart: boolean;
     showDayNumber?: boolean;
-    extraRenderProps?: Dictionary;
+    renderProps?: Dictionary;
 }
 
 interface ViewContainerProps extends Partial<ElProps> {
     viewSpec: ViewSpec;
+    attrs?: any;
     children: ComponentChildren;
 }
 interface ViewContentArg {
@@ -1705,52 +1778,6 @@ interface EventHoveringArg {
     view: ViewApi;
 }
 
-interface ToolbarInput {
-    left?: string;
-    center?: string;
-    right?: string;
-    start?: string;
-    end?: string;
-}
-interface CustomButtonInput {
-    text?: string;
-    hint?: string;
-    icon?: string;
-    themeIcon?: string;
-    bootstrapFontAwesome?: string;
-    click?(ev: MouseEvent, element: HTMLElement): void;
-}
-interface ButtonIconsInput {
-    prev?: string;
-    next?: string;
-    prevYear?: string;
-    nextYear?: string;
-    today?: string;
-    [viewOrCustomButton: string]: string | undefined;
-}
-interface ButtonTextCompoundInput {
-    prev?: string;
-    next?: string;
-    prevYear?: string;
-    nextYear?: string;
-    today?: string;
-    month?: string;
-    week?: string;
-    day?: string;
-    [viewOrCustomButton: string]: string | undefined;
-}
-interface ButtonHintCompoundInput {
-    prev?: string | ((...args: any[]) => string);
-    next?: string | ((...args: any[]) => string);
-    prevYear?: string | ((...args: any[]) => string);
-    nextYear?: string | ((...args: any[]) => string);
-    today?: string | ((...args: any[]) => string);
-    month?: string | ((...args: any[]) => string);
-    week?: string | ((...args: any[]) => string);
-    day?: string | ((...args: any[]) => string);
-    [viewOrCustomButton: string]: string | ((...args: any[]) => string) | undefined;
-}
-
 type DatesSetArg = RangeApiWithTimeZone & {
     view: ViewApi;
 };
@@ -1954,6 +1981,7 @@ declare const BASE_OPTION_REFINERS: {
     dropAccept: Identity<string | ((this: CalendarApi, draggable: any) => boolean)>;
     eventOrder: typeof parseFieldSpecs;
     eventOrderStrict: BooleanConstructor;
+    eventSlicing: BooleanConstructor;
     longPressDelay: NumberConstructor;
     eventDragMinDistance: NumberConstructor;
     expandRows: BooleanConstructor;
@@ -2014,6 +2042,7 @@ declare const BASE_OPTION_REFINERS: {
     allDayContent: Identity<CustomContentGenerator<AllDayContentArg>>;
     allDayDidMount: Identity<DidMountHandler<AllDayMountArg>>;
     allDayWillUnmount: Identity<WillUnmountHandler<AllDayMountArg>>;
+    timedText: StringConstructor;
     slotMinWidth: NumberConstructor;
     navLinks: BooleanConstructor;
     eventTimeFormat: typeof createFormatter;
@@ -2043,10 +2072,11 @@ declare const BASE_OPTION_REFINERS: {
     eventInteractive: BooleanConstructor;
     noEventsText: StringConstructor;
     viewHint: Identity<string | ((...args: any[]) => string)>;
+    viewChangeHint: StringConstructor;
     navLinkHint: Identity<string | ((...args: any[]) => string)>;
     closeHint: StringConstructor;
-    timeHint: StringConstructor;
-    eventHint: StringConstructor;
+    eventsHint: StringConstructor;
+    headingLevel: NumberConstructor;
     moreLinkClick: Identity<MoreLinkAction>;
     moreLinkClassNames: Identity<ClassNamesGenerator<MoreLinkContentArg>>;
     moreLinkContent: Identity<CustomContentGenerator<MoreLinkContentArg>>;
@@ -2123,6 +2153,7 @@ declare const BASE_OPTION_DEFAULTS: {
         month: string;
         day: string;
     };
+    headingLevel: number;
 };
 type BaseOptionsRefined = DefaultedRefinedOptions<RefinedOptionsFromRefiners<Required<BaseOptionRefiners>>, // Required is a hack for "Index signature is missing"
 keyof typeof BASE_OPTION_DEFAULTS>;
@@ -2202,7 +2233,6 @@ declare class JsonRequestError extends Error {
 declare function requestJson<ParsedResponse>(method: string, url: string, params: Dictionary): Promise<[ParsedResponse, Response]>;
 
 declare function computeVisibleDayRange(timedRange: OpenDateRange, nextDayThreshold?: Duration): OpenDateRange;
-declare function isMultiDayRange(range: DateRange): boolean;
 declare function diffDates(date0: DateMarker, date1: DateMarker, dateEnv: DateEnv, largeUnit?: string): Duration;
 
 declare function removeExact(array: any, exactVal: any): number;
@@ -2220,44 +2250,33 @@ type MemoizeHashFunc<Args extends any[], Res> = (argHash: {
 };
 declare function memoizeHashlike<Args extends any[], Res>(workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): MemoizeHashFunc<Args, Res>;
 
-declare function removeElement(el: HTMLElement): void;
-declare function elementClosest(el: HTMLElement, selector: string): HTMLElement;
-declare function elementMatches(el: HTMLElement, selector: string): HTMLElement;
-declare function findElements(container: HTMLElement[] | HTMLElement | NodeListOf<HTMLElement>, selector: string): HTMLElement[];
-declare function findDirectChildren(parent: HTMLElement[] | HTMLElement, selector?: string): HTMLElement[];
 declare function applyStyle(el: HTMLElement, props: Dictionary): void;
 declare function getEventTargetViaRoot(ev: Event): EventTarget;
 declare function getUniqueDomId(): string;
 
-declare function setStateDimMap<State>(component: Component<unknown, State>, key: keyof State, newMap: {
-    [key: string]: number;
-}): void;
-declare function isDimMapsEqual(oldMap: {
-    [key: string]: number;
-}, newMap: {
-    [key: string]: number;
-}): boolean;
 declare function isDimsEqual(v0: number | undefined, v1: number): boolean;
 
-declare function watchSize(el: HTMLElement, callback: (width: number, height: number) => void): () => void;
-declare function watchWidth(el: HTMLElement, callback: (width: number) => void): () => void;
-declare function watchHeight(el: HTMLElement, callback: (height: number) => void): () => void;
+type SizeCallback = (width: number, height: number) => void;
+type DisconnectSize = () => void;
+type WatchSize = (el: HTMLElement, callback: SizeCallback, client?: boolean, watchWidth?: boolean, watchHeight?: boolean) => DisconnectSize;
 declare function afterSize(callback: () => void): void;
+declare const watchSize: WatchSize;
+declare function watchWidth(el: HTMLElement, callback: (width: number) => void): DisconnectSize;
+declare function watchHeight(el: HTMLElement, callback: (height: number) => void): DisconnectSize;
 
-declare function buildNavLinkAttrs(context: ViewContext, dateMarker: DateMarker, viewType?: string, isTabbable?: boolean): {
+declare function buildDateStr(context: ViewContext, dateMarker: DateMarker, viewType?: string): string;
+declare function buildNavLinkAttrs(context: ViewContext, dateMarker: DateMarker, viewType?: string, dateStr?: string, isTabbable?: boolean): {
     tabIndex: number;
     onKeyDown(ev: KeyboardEvent): void;
     onClick: (ev: UIEvent) => void;
-    title: any;
+    role: any;
+    'aria-label': any;
     'data-navlink': string;
-    'aria-label'?: undefined;
 } | {
     onClick: (ev: UIEvent) => void;
-    title: any;
+    role: any;
+    'aria-label': any;
     'data-navlink': string;
-    'aria-label'?: undefined;
-} | {
-    'aria-label': string;
 };
 
 declare function preventDefault(ev: any): void;
@@ -2357,60 +2376,65 @@ declare function parse(str: any): {
     timeZoneOffset: any;
 };
 
-interface SegSpan {
+interface CoordSpan {
     start: number;
-    end: number;
+    size: number;
 }
-interface SegEntry {
-    index: number;
-    seg?: Seg;
-    segGroup?: SegGroup;
-    span: SegSpan;
-    thickness?: number;
+interface CoordRange {
+    start: number;
+    end: number;
 }
-interface SegInsertion {
-    level: number;
-    levelCoord: number;
-    lateral: number;
-    touchingLevel: number;
-    touchingLateral: number;
-    touchingEntry: SegEntry;
-    stackCnt: number;
+interface SlicedCoordRange extends CoordRange {
+    isStart: boolean;
+    isEnd: boolean;
 }
-interface SegRect extends SegEntry {
+declare function getCoordRangeEnd(r: CoordRange): number;
+declare function computeEarliestStart(segs: EventRangeProps[]): DateMarker;
+declare function computeLatestEnd(segs: EventRangeProps[]): DateMarker;
+
+type EventSeg<R extends SlicedCoordRange> = R & EventRangeProps & {
+    isSlice?: boolean;
+};
+type EventPlacement<R extends SlicedCoordRange> = EventSeg<R> & {
     thickness: number;
+    depth: number;
+    isSlice: boolean;
+    isZombie: boolean;
+};
+interface EventInsertion<R extends SlicedCoordRange> {
+    levelIndex: number;
     levelCoord: number;
+    lateralIndex: number;
+    touchingPlacement: EventPlacement<R> | undefined;
+    depth: number;
 }
-interface SegGroup {
-    key: string;
-    span: SegSpan;
-    segs: Seg[];
-}
-declare class SegHierarchy {
-    private getEntryThickness;
+declare class SegHierarchy<R extends SlicedCoordRange> {
+    private getSegThickness;
     strictOrder: boolean;
-    allowReslicing: boolean;
-    maxCoord: number;
-    maxStackCnt: number;
+    private maxCoord;
+    private maxDepth;
+    private hiddenConsumes;
+    private allowSlicing;
+    placementsByLevel: EventPlacement<R>[][];
     levelCoords: number[];
-    entriesByLevel: SegEntry[][];
-    stackCnts: {
-        [entryId: string]: number;
-    };
-    constructor(getEntryThickness?: (entry: SegEntry) => number | undefined);
-    addSegs(inputs: SegEntry[]): SegEntry[];
-    insertEntry(entry: SegEntry, hiddenEntries: SegEntry[]): void;
-    isInsertionValid(insertion: SegInsertion, entry: SegEntry, entryThickness: number): boolean;
-    handleInvalidInsertion(insertion: SegInsertion, entry: SegEntry, hiddenEntries: SegEntry[]): void;
-    splitEntry(entry: SegEntry, barrier: SegEntry, hiddenEntries: SegEntry[]): void;
-    insertEntryAt(entry: SegEntry, insertion: SegInsertion): void;
-    findInsertion(newEntry: SegEntry, newEntryThickness: number): SegInsertion;
-    toRects(): SegRect[];
-}
-declare function getEntrySpanEnd(entry: SegEntry): number;
-declare function buildEntryKey(entry: SegEntry): string;
-declare function groupIntersectingEntries(entries: SegEntry[]): SegGroup[];
-declare function intersectSpans(span0: SegSpan, span1: SegSpan): SegSpan | null;
+    hiddenSegs: EventSeg<R>[];
+    constructor(segs: EventSeg<R>[], getSegThickness: (seg: EventSeg<R>) => number | undefined, strictOrder: boolean, // HACK
+    maxCoord: number | undefined, maxDepth: number | undefined, hiddenConsumes?: boolean, // hidden segs also hide the touchingPlacement?
+    allowSlicing?: boolean);
+    private insertSeg;
+    private isInsertionValid;
+    private splitSeg;
+    private insertSegAt;
+    findInsertion(seg: CoordRange, segThickness: number): EventInsertion<R>;
+    traverseSegs(handler: (seg: EventPlacement<R>, levelCoord: number) => void): void;
+}
+interface SegInternalGroup<R extends SlicedCoordRange> extends CoordRange {
+    segs: EventSeg<R>[];
+}
+interface SegGroup<R extends SlicedCoordRange> extends SegInternalGroup<R> {
+    key: string;
+}
+declare function groupIntersectingSegs<R extends SlicedCoordRange>(segs: EventSeg<R>[]): SegGroup<R>[];
 declare function binarySearch<Item>(a: Item[], searchVal: number, getItemVal: (item: Item) => number): [number, number];
 
 declare const config: any;
@@ -2433,33 +2457,25 @@ declare class CalendarRoot extends BaseComponent<CalendarRootProps, CalendarRoot
     handleAfterPrint: () => void;
 }
 
-interface DaySeriesSeg {
-    firstIndex: number;
-    lastIndex: number;
-    isStart: boolean;
-    isEnd: boolean;
-}
 declare class DaySeriesModel {
     cnt: number;
     dates: DateMarker[];
     indices: number[];
     constructor(range: DateRange, dateProfileGenerator: DateProfileGenerator);
-    sliceRange(range: DateRange): DaySeriesSeg | null;
+    sliceRange(range: DateRange): SlicedCoordRange | null;
     private getDateDayIndex;
 }
 
-interface DayTableSeg extends Seg {
+interface DayGridRange extends SlicedCoordRange {
     row: number;
-    firstCol: number;
-    lastCol: number;
 }
 interface DayTableCell {
     key: string;
     date: DateMarker;
-    extraRenderProps?: Dictionary;
-    extraDataAttrs?: Dictionary;
-    extraClassNames?: string[];
-    extraDateSpan?: Dictionary;
+    renderProps?: Dictionary;
+    attrs?: Dictionary;
+    className?: string;
+    dateSpanProps?: Dictionary;
 }
 declare class DayTableModel {
     rowCnt: number;
@@ -2471,26 +2487,33 @@ declare class DayTableModel {
     buildCells(): any[];
     private buildCell;
     private buildHeaderDates;
-    sliceRange(range: DateRange): DayTableSeg[];
+    sliceRange(range: DateRange): DayGridRange[];
 }
 
 declare class ScrollListener {
     el: HTMLElement;
     emitter: Emitter<any>;
-    private isScrolling;
-    private isTouching;
-    private isRecentlyWheeled;
-    private isRecentlyScrolled;
     private wheelWaiter;
     private scrollWaiter;
+    private isScroll;
+    private isScrollRecent;
+    private isWheelRecent;
+    private isMouseDown;
+    private isTouchDown;
+    private isMouse;
+    private isTouch;
+    private isWheel;
     constructor(el: HTMLElement);
     destroy(): void;
     private startScroll;
     endScroll(): void;
+    private getIsUser;
     private handleScroll;
-    private _handleScrollWaited;
+    private handleScrollWait;
     private handleWheel;
-    private _handleWheelWaited;
+    private handleWheelWait;
+    private handleMouseDown;
+    private handleMouseUp;
     private handleTouchStart;
     private handleTouchEnd;
 }
@@ -2500,26 +2523,23 @@ interface ScrollerProps {
     horizontal?: boolean;
     hideScrollbars?: boolean;
     children: ComponentChildren;
-    elClassNames?: string[];
-    elStyle?: Dictionary$1;
-    widthRef?: Ref<number>;
-    heightRef?: Ref<number>;
-    leftScrollbarWidthRef?: Ref<number>;
-    rightScrollbarWidthRef?: Ref<number>;
+    className?: string;
+    style?: Dictionary;
+    clientWidthRef?: Ref<number>;
+    clientHeightRef?: Ref<number>;
+    endScrollbarWidthRef?: Ref<number>;
     bottomScrollbarWidthRef?: Ref<number>;
 }
-declare class Scroller extends DateComponent$1<ScrollerProps> implements ScrollerInterface {
-    private elRef;
+declare class Scroller extends DateComponent<ScrollerProps> implements ScrollerInterface {
+    private el?;
     listener: ScrollListener;
     private disconnectSize?;
-    private currentWidth;
-    private currentHeight;
-    private currentLeftScrollbarWidth;
-    private currentRightScrollbarWidth;
+    private currentClientWidth;
+    private currentClientHeight;
+    private currentEndScrollbarWidth;
     private currentBottomScrollbarWidth;
     render(): createElement.JSX.Element;
-    componentDidMount(): void;
-    componentWillUnmount(): void;
+    handleEl: (el: HTMLDivElement | null) => void;
     endScroll(): void;
     get x(): number;
     get y(): number;
@@ -2527,8 +2547,16 @@ declare class Scroller extends DateComponent$1<ScrollerProps> implements Scrolle
         x?: number;
         y?: number;
     }): void;
-    addScrollEndListener(handler: (x: number, y: number) => void): void;
-    removeScrollEndListener(handler: (x: number, y: number) => void): void;
+    addScrollEndListener(handler: (arg: {
+        x: number;
+        y: number;
+        isUser: boolean;
+    }) => void): void;
+    removeScrollEndListener(handler: (arg: {
+        x: number;
+        y: number;
+        isUser: boolean;
+    }) => void): void;
 }
 declare function getNormalizedScrollX(el: HTMLElement, isRtl: boolean): number;
 declare function setNormalizedScrollX(el: HTMLElement, isRtl: boolean, x: number): void;
@@ -2542,26 +2570,26 @@ interface SliceableProps {
     eventSelection: string;
     eventUiBases: EventUiHash;
 }
-interface SlicedProps<SegType extends Seg> {
-    dateSelectionSegs: SegType[];
-    businessHourSegs: SegType[];
-    fgEventSegs: SegType[];
-    bgEventSegs: SegType[];
-    eventDrag: EventSegUiInteractionState<SegType> | null;
-    eventResize: EventSegUiInteractionState<SegType> | null;
+interface SlicedProps<R> {
+    fgEventSegs: (R & EventRangeProps)[];
+    bgEventSegs: (R & EventRangeProps)[];
+    businessHourSegs: (R & EventRangeProps)[];
+    dateSelectionSegs: (R & EventRangeProps)[];
+    eventDrag: EventSegUiInteractionState<R> | null;
+    eventResize: EventSegUiInteractionState<R> | null;
     eventSelection: string;
 }
-declare abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
+declare abstract class Slicer<R, ExtraArgs extends any[] = []> {
     private sliceBusinessHours;
     private sliceDateSelection;
     private sliceEventStore;
     private sliceEventDrag;
     private sliceEventResize;
-    abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): SegType[];
+    abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): R[];
     protected forceDayIfListItem: boolean;
-    sliceProps(props: SliceableProps, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SlicedProps<SegType>;
+    sliceProps(props: SliceableProps, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SlicedProps<R>;
     sliceNowDate(// does not memoize
-    date: DateMarker, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SegType[];
+    date: DateMarker, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): R[];
     private _sliceBusinessHours;
     private _sliceEventStore;
     private _sliceInteraction;
@@ -2635,8 +2663,10 @@ declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
 
 interface StandardEventProps {
     elRef?: ElRef;
-    elClasses?: string[];
+    className?: string;
     eventRange: EventRenderRange;
+    slicedStart?: DateMarker;
+    slicedEnd?: DateMarker;
     isStart: boolean;
     isEnd: boolean;
     isDragging: boolean;
@@ -2651,8 +2681,6 @@ interface StandardEventProps {
     defaultTimeFormat: DateFormatter;
     defaultDisplayEventTime?: boolean;
     defaultDisplayEventEnd?: boolean;
-    startOverride?: DateMarker;
-    endOverride?: DateMarker;
 }
 declare class StandardEvent extends BaseComponent<StandardEventProps> {
     render(): createElement.JSX.Element;
@@ -2660,6 +2688,8 @@ declare class StandardEvent extends BaseComponent<StandardEventProps> {
 
 interface MinimalEventProps {
     eventRange: EventRenderRange;
+    slicedStart?: DateMarker;
+    slicedEnd?: DateMarker;
     isStart: boolean;
     isEnd: boolean;
     isDragging: boolean;
@@ -2699,4 +2729,17 @@ declare function renderFill(fillType: string): createElement.JSX.Element;
 
 declare function injectStyles(styleText: string): void;
 
-export { DayCellMountArg as $, AllowFunc as A, BusinessHoursInput as B, CalendarImpl as C, DateInput as D, EventSourceApi as E, FormatterInput as F, WeekNumberContentArg as G, WeekNumberMountArg as H, MoreLinkMountArg as I, JsonRequestError as J, SlotLaneContentArg as K, LocaleInput as L, MoreLinkContentArg as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, SlotLaneMountArg as Q, SlotLabelContentArg as R, SpecificViewContentArg as S, SlotLabelMountArg as T, AllDayContentArg as U, ViewApi as V, WillUnmountHandler as W, AllDayMountArg as X, DayHeaderContentArg as Y, DayHeaderMountArg as Z, DayCellContentArg as _, CalendarOptions as a, enableCursor as a$, ViewContentArg as a0, ViewMountArg as a1, EventClickArg as a2, EventHoveringArg as a3, DateSelectArg as a4, DateUnselectArg as a5, WeekNumberCalculation as a6, ToolbarInput as a7, CustomButtonInput as a8, ButtonIconsInput as a9, RefinedOptionsFromRefiners as aA, CalendarListenerRefiners as aB, BASE_OPTION_DEFAULTS as aC, identity as aD, refineProps as aE, EventDef as aF, EventDefHash as aG, EventInstance as aH, EventInstanceHash as aI, createEventInstance as aJ, EventRefined as aK, EventTuple as aL, EventRefiners as aM, parseEventDef as aN, refineEventDef as aO, parseBusinessHours as aP, OrderSpec as aQ, padStart as aR, isInt as aS, parseFieldSpecs as aT, compareByFieldSpecs as aU, flexibleCompare as aV, preventSelection as aW, allowSelection as aX, preventContextMenu as aY, allowContextMenu as aZ, compareNumbers as a_, ButtonTextCompoundInput as aa, EventContentArg as ab, EventMountArg as ac, DatesSetArg as ad, EventAddArg as ae, EventChangeArg as af, EventDropArg as ag, EventRemoveArg as ah, ButtonHintCompoundInput as ai, CustomRenderingHandler as aj, CustomRenderingStore as ak, DateSpanApi as al, DatePointApi as am, DateSelectionApi as an, Duration as ao, EventSegment as ap, MoreLinkAction as aq, MoreLinkSimpleAction as ar, MoreLinkArg as as, MoreLinkHandler as at, Identity as au, Dictionary as av, BaseOptionRefiners as aw, BaseOptionsRefined as ax, ViewOptionsRefined as ay, RawOptionsFromRefiners as az, PluginDef as b, getClippingParents as b$, disableCursor as b0, guid as b1, computeVisibleDayRange as b2, isMultiDayRange as b3, diffDates as b4, removeExact as b5, isArraysEqual as b6, MemoizeHashFunc as b7, MemoiseArrayFunc as b8, memoize as b9, EventStore as bA, createEmptyEventStore as bB, mergeEventStores as bC, getRelevantEvents as bD, eventTupleToStore as bE, EventUiHash as bF, EventUi as bG, combineEventUis as bH, createEventUi as bI, SplittableProps as bJ, Splitter as bK, getDayClassNames as bL, getDateMeta as bM, getSlotClassNames as bN, DateMeta as bO, setStateDimMap as bP, isDimMapsEqual as bQ, isDimsEqual as bR, watchSize as bS, watchWidth as bT, watchHeight as bU, afterSize as bV, buildNavLinkAttrs as bW, preventDefault as bX, whenTransitionDone as bY, computeInnerRect as bZ, computeEdges as b_, memoizeObjArg as ba, memoizeArraylike as bb, memoizeHashlike as bc, Rect as bd, Point as be, intersectRects as bf, pointInsideRect as bg, constrainPoint as bh, getRectCenter as bi, diffPoints as bj, translateRect as bk, mapHash as bl, filterHash as bm, isPropsEqual as bn, compareObjs as bo, collectFromHash as bp, findElements as bq, findDirectChildren as br, removeElement as bs, applyStyle as bt, elementMatches as bu, elementClosest as bv, getEventTargetViaRoot as bw, getUniqueDomId as bx, parseClassNames as by, fracToCssDim as bz, CalendarApi as c, SegGroup as c$, computeRect as c0, unpromisify as c1, Emitter as c2, DateRange as c3, rangeContainsMarker as c4, intersectRanges as c5, rangesEqual as c6, rangesIntersect as c7, rangeContainsRange as c8, PositionCache as c9, isValidDate as cA, createDuration as cB, asCleanDays as cC, multiplyDuration as cD, addDurations as cE, asRoughMinutes as cF, asRoughSeconds as cG, asRoughMs as cH, wholeDivideDurations as cI, greatestDurationDenominator as cJ, DateEnv as cK, createFormatter as cL, DateFormatter as cM, VerboseFormattingArg as cN, formatIsoTimeString as cO, formatDayString as cP, buildIsoString as cQ, formatIsoMonthStr as cR, NamedTimeZoneImpl as cS, parse as cT, EventSourceDef as cU, EventSourceRefined as cV, EventSourceRefiners as cW, SegSpan as cX, SegRect as cY, SegEntry as cZ, SegInsertion as c_, ScrollController as ca, ElementScrollController as cb, WindowScrollController as cc, Theme as cd, ViewContext as ce, ViewContextType as cf, Seg as cg, EventSegUiInteractionState as ch, DateComponent as ci, CalendarData as cj, ViewProps as ck, DateProfile as cl, DateProfileGenerator as cm, ViewSpec as cn, DateSpan as co, isDateSpansEqual as cp, DateMarker as cq, addDays as cr, startOfDay as cs, addMs as ct, addWeeks as cu, diffWeeks as cv, diffWholeWeeks as cw, diffWholeDays as cx, diffDayAndTime as cy, diffDays as cz, EventApi as d, getIsRtlScrollbarOnLeft as d$, SegHierarchy as d0, buildEntryKey as d1, getEntrySpanEnd as d2, binarySearch as d3, groupIntersectingEntries as d4, intersectSpans as d5, InteractionSettings as d6, InteractionSettingsStore as d7, Interaction as d8, interactionSettingsToStore as d9, buildEventRangeKey as dA, getEventRangeAnchorAttrs as dB, DayTableCell as dC, DayTableModel as dD, Scroller as dE, getNormalizedScrollX as dF, setNormalizedScrollX as dG, SlicedProps as dH, Slicer as dI, EventMutation as dJ, applyMutationToEventStore as dK, Constraint as dL, isPropsValid as dM, isInteractionValid as dN, isDateSelectionValid as dO, requestJson as dP, BaseComponent as dQ, setRef as dR, DelayedRunner as dS, getStickyFooterScrollbar as dT, getStickyHeaderDates as dU, getIsHeightAuto as dV, getScrollerSyncerClass as dW, ScrollerInterface as dX, ScrollerSyncerInterface as dY, getScrollbarWidths as dZ, RefMap as d_, interactionSettingsStore as da, PointerDragEvent as db, Hit as dc, dateSelectionJoinTransformer as dd, eventDragMutationMassager as de, EventDropTransformers as df, ElementDragging as dg, config as dh, RecurringType as di, DragMetaInput as dj, DragMeta as dk, parseDragMeta as dl, ViewPropsTransformer as dm, Action as dn, CalendarContext as dp, CalendarContentProps as dq, CalendarRoot as dr, DaySeriesModel as ds, EventInteractionState as dt, sliceEventStore as du, hasBgRendering as dv, getElEventRange as dw, buildEventRangeTimeText as dx, sortEventSegs as dy, getEventRangeMeta as dz, EventRenderRange as e, NowTimer as e0, MountArg as e1, StandardEvent as e2, NowIndicatorContainer as e3, DayCellContainer as e4, hasCustomDayCellContent as e5, MinimalEventProps as e6, EventContainer as e7, renderFill as e8, BgEvent as e9, WeekNumberContainerProps as ea, WeekNumberContainer as eb, MoreLinkContainer as ec, computeEarliestSegStart as ed, ViewContainerProps as ee, ViewContainer as ef, DatePointTransform as eg, DateSpanTransform as eh, triggerDateSelect as ei, getDefaultEventEnd as ej, injectStyles as ek, EventImpl as el, buildEventApis as em, ElProps as en, buildElAttrs as eo, InnerContainerFunc as ep, ContentContainer as eq, CustomRendering as er, CalendarListeners as f, ViewOptions as g, DurationInput as h, DateSpanInput as i, DateRangeInput as j, EventSourceInput as k, EventSourceFunc as l, EventSourceFuncArg as m, EventInput as n, EventInputTransformer as o, CssDimValue as p, LocaleSingularArg as q, ConstraintInput as r, sliceEvents as s, ViewComponentType as t, SpecificViewMountArg as u, ClassNamesGenerator as v, CustomContentGenerator as w, DidMountHandler as x, NowIndicatorContentArg as y, NowIndicatorMountArg as z };
+interface StickyFooterScrollbarProps {
+    canvasWidth: CssDimValue;
+    scrollerRef?: Ref<Scroller>;
+    scrollbarWidthRef?: Ref<number>;
+}
+declare class StickyFooterScrollbar extends BaseComponent<StickyFooterScrollbarProps> {
+    rootElRef: preact.RefObject<HTMLDivElement>;
+    disconnectHeight?: () => void;
+    render(): createElement.JSX.Element;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+}
+
+export { DayCellMountArg as $, AllowFunc as A, BusinessHoursInput as B, CalendarImpl as C, DateInput as D, EventSourceApi as E, FormatterInput as F, WeekNumberContentArg as G, WeekNumberMountArg as H, MoreLinkMountArg as I, JsonRequestError as J, SlotLaneContentArg as K, LocaleInput as L, MoreLinkContentArg as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, SlotLaneMountArg as Q, SlotLabelContentArg as R, SpecificViewContentArg as S, SlotLabelMountArg as T, AllDayContentArg as U, ViewApi as V, WillUnmountHandler as W, AllDayMountArg as X, DayHeaderContentArg as Y, DayHeaderMountArg as Z, DayCellContentArg as _, CalendarOptions as a, enableCursor as a$, ViewContentArg as a0, ViewMountArg as a1, EventClickArg as a2, EventHoveringArg as a3, DateSelectArg as a4, DateUnselectArg as a5, WeekNumberCalculation as a6, ToolbarInput as a7, CustomButtonInput as a8, ButtonIconsInput as a9, RefinedOptionsFromRefiners as aA, CalendarListenerRefiners as aB, BASE_OPTION_DEFAULTS as aC, identity as aD, refineProps as aE, EventDef as aF, EventDefHash as aG, EventInstance as aH, EventInstanceHash as aI, createEventInstance as aJ, EventRefined as aK, EventTuple as aL, EventRefiners as aM, parseEventDef as aN, refineEventDef as aO, parseBusinessHours as aP, OrderSpec as aQ, padStart as aR, isInt as aS, parseFieldSpecs as aT, compareByFieldSpecs as aU, flexibleCompare as aV, preventSelection as aW, allowSelection as aX, preventContextMenu as aY, allowContextMenu as aZ, compareNumbers as a_, ButtonTextCompoundInput as aa, EventContentArg as ab, EventMountArg as ac, DatesSetArg as ad, EventAddArg as ae, EventChangeArg as af, EventDropArg as ag, EventRemoveArg as ah, ButtonHintCompoundInput as ai, CustomRenderingHandler as aj, CustomRenderingStore as ak, DateSpanApi as al, DatePointApi as am, DateSelectionApi as an, Duration as ao, EventSegment as ap, MoreLinkAction as aq, MoreLinkSimpleAction as ar, MoreLinkArg as as, MoreLinkHandler as at, Identity as au, Dictionary as av, BaseOptionRefiners as aw, BaseOptionsRefined as ax, ViewOptionsRefined as ay, RawOptionsFromRefiners as az, PluginDef as b, intersectRanges as b$, disableCursor as b0, guid as b1, computeVisibleDayRange as b2, diffDates as b3, removeExact as b4, isArraysEqual as b5, MemoizeHashFunc as b6, MemoiseArrayFunc as b7, memoize as b8, memoizeObjArg as b9, EventUiHash as bA, EventUi as bB, combineEventUis as bC, createEventUi as bD, SplittableProps as bE, Splitter as bF, getDayClassName as bG, getDateMeta as bH, getSlotClassName as bI, DateMeta as bJ, isDimsEqual as bK, watchSize as bL, watchWidth as bM, watchHeight as bN, afterSize as bO, buildNavLinkAttrs as bP, buildDateStr as bQ, preventDefault as bR, whenTransitionDone as bS, computeInnerRect as bT, computeEdges as bU, getClippingParents as bV, computeRect as bW, unpromisify as bX, Emitter as bY, DateRange as bZ, rangeContainsMarker 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, applyStyle as bp, getEventTargetViaRoot as bq, getUniqueDomId as br, joinClassNames as bs, parseClassNames as bt, fracToCssDim as bu, EventStore as bv, createEmptyEventStore as bw, mergeEventStores as bx, getRelevantEvents as by, eventTupleToStore as bz, CalendarApi as c, PointerDragEvent as c$, rangesEqual as c0, rangesIntersect as c1, rangeContainsRange as c2, PositionCache as c3, ScrollController as c4, ElementScrollController as c5, WindowScrollController as c6, Theme as c7, ViewContext as c8, ViewContextType as c9, asRoughMs as cA, wholeDivideDurations as cB, greatestDurationDenominator as cC, DateEnv as cD, createFormatter as cE, DateFormatter as cF, VerboseFormattingArg as cG, formatIsoTimeString as cH, formatDayString as cI, buildIsoString as cJ, formatIsoMonthStr as cK, NamedTimeZoneImpl as cL, parse as cM, EventSourceDef as cN, EventSourceRefined as cO, EventSourceRefiners as cP, EventPlacement as cQ, EventInsertion as cR, SegHierarchy as cS, SegGroup as cT, groupIntersectingSegs as cU, binarySearch as cV, InteractionSettings as cW, InteractionSettingsStore as cX, Interaction as cY, interactionSettingsToStore as cZ, interactionSettingsStore as c_, EventSegUiInteractionState as ca, DateComponent as cb, CalendarData as cc, ViewProps as cd, DateProfile as ce, DateProfileGenerator as cf, ViewSpec as cg, DateSpan as ch, isDateSpansEqual as ci, DateMarker as cj, addDays as ck, startOfDay as cl, addMs as cm, addWeeks as cn, diffWeeks as co, diffWholeWeeks as cp, diffWholeDays as cq, diffDayAndTime as cr, diffDays as cs, isValidDate as ct, createDuration as cu, asCleanDays as cv, multiplyDuration as cw, addDurations as cx, asRoughMinutes as cy, asRoughSeconds as cz, EventApi as d, renderFill as d$, Hit as d0, dateSelectionJoinTransformer as d1, eventDragMutationMassager as d2, EventDropTransformers as d3, ElementDragging as d4, config as d5, RecurringType as d6, DragMetaInput as d7, DragMeta as d8, parseDragMeta as d9, EventMutation as dA, applyMutationToEventStore as dB, Constraint as dC, isPropsValid as dD, isInteractionValid as dE, isDateSelectionValid as dF, requestJson as dG, BaseComponent as dH, setRef as dI, DelayedRunner as dJ, getStickyFooterScrollbar as dK, getStickyHeaderDates as dL, getIsHeightAuto as dM, getScrollerSyncerClass as dN, ScrollerInterface as dO, ScrollerSyncerInterface as dP, getScrollbarWidths as dQ, RefMap as dR, getIsRtlScrollbarOnLeft as dS, NowTimer as dT, MountArg as dU, StandardEvent as dV, NowIndicatorContainer as dW, DayCellContainer as dX, hasCustomDayCellContent as dY, MinimalEventProps as dZ, EventContainer as d_, ViewPropsTransformer as da, Action as db, CalendarContext as dc, CalendarContentProps as dd, CalendarRoot as de, DaySeriesModel as df, EventInteractionState as dg, sliceEventStore as dh, hasBgRendering as di, getElEventRange as dj, buildEventRangeTimeText as dk, sortEventSegs as dl, getEventRangeMeta as dm, buildEventRangeKey as dn, getEventTagAndAttrs as dp, EventRangeProps as dq, getEventKey as dr, DayTableCell as ds, DayGridRange as dt, DayTableModel as du, Scroller as dv, getNormalizedScrollX as dw, setNormalizedScrollX as dx, SlicedProps as dy, Slicer as dz, EventRenderRange as e, BgEvent as e0, WeekNumberContainerProps as e1, WeekNumberContainer as e2, MoreLinkContainer as e3, ViewContainerProps as e4, ViewContainer as e5, DatePointTransform as e6, DateSpanTransform as e7, triggerDateSelect as e8, getDefaultEventEnd as e9, injectStyles as ea, EventImpl as eb, buildEventApis as ec, ElProps as ed, buildElAttrs as ee, InnerContainerFunc as ef, ContentContainer as eg, renderText as eh, CustomRendering as ei, CoordRange as ej, CoordSpan as ek, SlicedCoordRange as el, computeEarliestStart as em, computeLatestEnd as en, getCoordRangeEnd as eo, StickyFooterScrollbar as ep, CalendarListeners as f, ViewOptions as g, DurationInput as h, DateSpanInput as i, DateRangeInput as j, EventSourceInput as k, EventSourceFunc as l, EventSourceFuncArg as m, EventInput as n, EventInputTransformer as o, CssDimValue as p, LocaleSingularArg as q, ConstraintInput as r, sliceEvents as s, ViewComponentType as t, SpecificViewMountArg as u, ClassNamesGenerator as v, CustomContentGenerator as w, DidMountHandler as x, NowIndicatorContentArg as y, NowIndicatorMountArg as z };