@fullcalendar/core 6.1.15 → 7.0.0-beta.1

package/internal-common.d.ts

@@ -1,6 +1,7 @@
 import * as preact from 'preact';
-import { ComponentChildren, ComponentType, Context, Ref, Component, VNode, createElement, JSX, ComponentChild, FunctionalComponent, RefObject } from './preact.js';
+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 {
@@ -476,7 +477,6 @@ interface ViewProps {
     eventSelection: string;
     eventDrag: EventInteractionState | null;
     eventResize: EventInteractionState | null;
-    isHeightAuto: boolean;
     forPrint: boolean;
 }
 declare function sliceEvents(props: ViewProps & {
@@ -486,6 +486,7 @@ declare function sliceEvents(props: ViewProps & {
 
 type ClassNamesInput = string | string[];
 declare function parseClassNames(raw: ClassNamesInput): string[];
+declare function fracToCssDim(frac: number): string;
 
 type MountArg<ContentArg> = ContentArg & {
     el: HTMLElement;
@@ -870,27 +871,7 @@ interface DateUnselectArg {
 }
 declare function getDefaultEventEnd(allDay: boolean, marker: DateMarker, context: CalendarContext): DateMarker;
 
-interface ScrollRequest {
-    time?: Duration;
-    [otherProp: string]: any;
-}
-type ScrollRequestHandler = (request: ScrollRequest) => boolean;
-declare class ScrollResponder {
-    private execFunc;
-    private emitter;
-    private scrollTime;
-    private scrollTimeReset;
-    queuedRequest: ScrollRequest;
-    constructor(execFunc: ScrollRequestHandler, emitter: Emitter<CalendarListeners>, scrollTime: Duration, scrollTimeReset: boolean);
-    detach(): void;
-    update(isDatesNew: boolean): void;
-    private fireInitialScroll;
-    private handleScrollRequest;
-    private drain;
-}
-
 declare const ViewContextType: Context<any>;
-type ResizeHandler = (force: boolean) => void;
 interface ViewContext extends CalendarContext {
     options: ViewOptionsRefined;
     theme: Theme;
@@ -898,9 +879,6 @@ interface ViewContext extends CalendarContext {
     dateProfileGenerator: DateProfileGenerator;
     viewSpec: ViewSpec;
     viewApi: ViewImpl;
-    addResizeHandler: (handler: ResizeHandler) => void;
-    removeResizeHandler: (handler: ResizeHandler) => void;
-    createScrollResponder: (execFunc: ScrollRequestHandler) => ScrollResponder;
     registerInteractiveComponent: (component: DateComponent<any>, settingsInput: InteractionSettingsInput) => void;
     unregisterInteractiveComponent: (component: DateComponent<any>) => void;
 }
@@ -978,16 +956,13 @@ interface Hit {
 }
 
 interface Seg {
-    component?: DateComponent<any, any>;
+    eventRange?: EventRenderRange;
     isStart: boolean;
     isEnd: boolean;
-    eventRange?: EventRenderRange;
-    [otherProp: string]: any;
-    el?: never;
 }
-interface EventSegUiInteractionState {
+interface EventSegUiInteractionState<S = Seg> {
     affectedInstances: EventInstanceHash;
-    segs: Seg[];
+    segs: S[];
     isEvent: boolean;
 }
 declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
@@ -1026,26 +1001,8 @@ declare function interactionSettingsToStore(settings: InteractionSettings): {
 };
 declare const interactionSettingsStore: InteractionSettingsStore;
 
-declare class DelayedRunner {
-    private drainedOption?;
-    private isRunning;
-    private isDirty;
-    private pauseDepths;
-    private timeoutId;
-    constructor(drainedOption?: () => void);
-    request(delay?: number): void;
-    pause(scope?: string): void;
-    resume(scope?: string, force?: boolean): void;
-    isPaused(): number;
-    tryDrain(): void;
-    clear(): void;
-    private clearTimeout;
-    protected drained(): void;
-}
-
 interface CalendarContentProps extends CalendarData {
     forPrint: boolean;
-    isHeightAuto: boolean;
 }
 
 type eventDragMutationMassager = (mutation: EventMutation, hit0: Hit, hit1: Hit) => void;
@@ -1139,86 +1096,24 @@ type ElementDraggingClass = {
     new (el: HTMLElement, selector?: string): ElementDragging;
 };
 
-type CssDimValue = string | number;
-interface ColProps {
-    width?: CssDimValue;
-    minWidth?: CssDimValue;
-    span?: number;
-}
-interface SectionConfig {
-    outerContent?: VNode;
-    type: 'body' | 'header' | 'footer';
-    className?: string;
-    maxHeight?: number;
-    liquid?: boolean;
-    expandRows?: boolean;
-    syncRowHeights?: boolean;
-    isSticky?: boolean;
-}
-type ChunkConfigContent = (contentProps: ChunkContentCallbackArgs) => VNode;
-type ChunkConfigRowContent = VNode | ChunkConfigContent;
-interface ChunkConfig {
-    elRef?: Ref<HTMLTableCellElement>;
-    outerContent?: VNode;
-    content?: ChunkConfigContent;
-    rowContent?: ChunkConfigRowContent;
-    scrollerElRef?: Ref<HTMLDivElement>;
-    tableClassName?: string;
-}
-interface ChunkContentCallbackArgs {
-    tableColGroupNode: VNode;
-    tableMinWidth: CssDimValue;
-    clientWidth: number | null;
-    clientHeight: number | null;
-    expandRows: boolean;
-    syncRowHeights: boolean;
-    rowSyncHeights: number[];
-    reportRowHeightChange: (rowEl: HTMLElement, isStable: boolean) => void;
-}
-declare function computeShrinkWidth(chunkEls: HTMLElement[]): number;
-interface ScrollerLike {
-    needsYScrolling(): boolean;
-    needsXScrolling(): boolean;
-}
-declare function getSectionHasLiquidHeight(props: {
-    liquid: boolean;
-}, sectionConfig: SectionConfig): boolean;
-declare function getAllowYScrolling(props: {
-    liquid: boolean;
-}, sectionConfig: SectionConfig): boolean;
-declare function renderChunkContent(sectionConfig: SectionConfig, chunkConfig: ChunkConfig, arg: ChunkContentCallbackArgs, isHeader: boolean): VNode<{}>;
-declare function isColPropsEqual(cols0: ColProps[], cols1: ColProps[]): boolean;
-declare function renderMicroColGroup(cols: ColProps[], shrinkWidth?: number): VNode;
-declare function sanitizeShrinkWidth(shrinkWidth?: number): number;
-declare function hasShrinkWidth(cols: ColProps[]): boolean;
-declare function getScrollGridClassNames(liquid: boolean, context: ViewContext): any[];
-declare function getSectionClassNames(sectionConfig: SectionConfig, wholeTableVGrow: boolean): string[];
-declare function renderScrollShim(arg: ChunkContentCallbackArgs): createElement.JSX.Element;
-declare function getStickyHeaderDates(options: BaseOptionsRefined): boolean;
-declare function getStickyFooterScrollbar(options: BaseOptionsRefined): boolean;
-
-interface ScrollGridProps {
-    elRef?: Ref<any>;
-    colGroups?: ColGroupConfig[];
-    sections: ScrollGridSectionConfig[];
-    liquid: boolean;
-    forPrint: boolean;
-    collapsibleWidth: boolean;
-}
-interface ScrollGridSectionConfig extends SectionConfig {
-    key: string;
-    chunks?: ScrollGridChunkConfig[];
+interface ScrollerInterface {
+    x: number;
+    y: number;
+    scrollTo(options: {
+        x?: number;
+        y?: number;
+    }): void;
+    addScrollEndListener(handler: (x: number, y: number) => void): void;
+    removeScrollEndListener(handler: (x: number, y: number) => void): void;
 }
-interface ScrollGridChunkConfig extends ChunkConfig {
-    key: string;
+
+interface ScrollerSyncerClass {
+    new (horizontal?: boolean): ScrollerSyncerInterface;
 }
-interface ColGroupConfig {
-    width?: CssDimValue;
-    cols: ColProps[];
+interface ScrollerSyncerInterface extends ScrollerInterface {
+    handleChildren(scrollers: ScrollerInterface[]): void;
+    destroy(): void;
 }
-type ScrollGridImpl = {
-    new (props: ScrollGridProps, context: ViewContext): Component<ScrollGridProps>;
-};
 
 interface PluginDefInput {
     name: string;
@@ -1254,7 +1149,7 @@ interface PluginDefInput {
     initialView?: string;
     elementDraggingImpl?: ElementDraggingClass;
     optionChangeHandlers?: OptionChangeHandlerMap;
-    scrollGridImpl?: ScrollGridImpl;
+    scrollerSyncerClass?: ScrollerSyncerClass;
     listenerRefiners?: GenericListenerRefiners;
     optionRefiners?: GenericRefiners;
     propSetHandlers?: {
@@ -1293,7 +1188,7 @@ interface PluginHooks {
     initialView: string;
     elementDraggingImpl?: ElementDraggingClass;
     optionChangeHandlers: OptionChangeHandlerMap;
-    scrollGridImpl: ScrollGridImpl | null;
+    scrollerSyncerClass: ScrollerSyncerClass | null;
     listenerRefiners: GenericListenerRefiners;
     optionRefiners: GenericRefiners;
     propSetHandlers: {
@@ -1371,9 +1266,9 @@ interface SplittableProps {
     dateSelection: DateSpan | null;
     eventStore: EventStore;
     eventUiBases: EventUiHash;
-    eventSelection: string;
     eventDrag: EventInteractionState | null;
     eventResize: EventInteractionState | null;
+    eventSelection: string;
 }
 declare abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {
     private getKeysForEventDefs;
@@ -1478,8 +1373,8 @@ declare function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHa
     fg: EventRenderRange[];
 };
 declare function hasBgRendering(def: EventDef): boolean;
-declare function getElSeg(el: HTMLElement): Seg | null;
-declare function sortEventSegs(segs: any, eventOrderSpecs: OrderSpec<EventImpl>[]): Seg[];
+declare function getElEventRange(el: HTMLElement): EventRenderRange | null;
+declare function sortEventSegs<S extends Seg>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
 interface EventContentArg {
     event: EventImpl;
     timeText: string;
@@ -1501,16 +1396,16 @@ interface EventContentArg {
     view: ViewApi;
 }
 type EventMountArg = MountArg<EventContentArg>;
-declare function buildSegTimeText(seg: Seg, timeFormat: DateFormatter, context: ViewContext, defaultDisplayEventTime?: boolean, // defaults to true
+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 getSegMeta(seg: Seg, todayRange: DateRange, nowDate?: DateMarker): {
+declare function getEventRangeMeta(eventRange: EventRenderRange, todayRange: DateRange, nowDate?: DateMarker): {
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
 };
 declare function buildEventRangeKey(eventRange: EventRenderRange): string;
-declare function getSegAnchorAttrs(seg: Seg, context: ViewContext): {
+declare function getEventRangeAnchorAttrs(eventRange: EventRenderRange, context: ViewContext): {
     tabIndex: number;
     onKeyDown(ev: KeyboardEvent): void;
 } | {
@@ -1556,6 +1451,25 @@ interface DatePointApi {
 }
 declare function isDateSpansEqual(span0: DateSpan, span1: DateSpan): boolean;
 
+type CssDimValue = string | number;
+declare function getIsHeightAuto(options: {
+    height?: CssDimValue;
+    viewHeight?: CssDimValue;
+}): boolean;
+declare function getStickyHeaderDates(options: {
+    height?: CssDimValue;
+    viewHeight?: CssDimValue;
+    stickyHeaderDates?: boolean | 'auto';
+}): boolean;
+declare function getStickyFooterScrollbar(options: {
+    height?: CssDimValue;
+    viewHeight?: CssDimValue;
+    stickyFooterScrollbar?: boolean | 'auto';
+}): boolean;
+declare function getScrollerSyncerClass(pluginHooks: {
+    scrollerSyncerClass: ScrollerSyncerClass | null;
+}): ScrollerSyncerClass;
+
 type BusinessHoursInput = boolean | EventInput | EventInput[];
 declare function parseBusinessHours(input: BusinessHoursInput, context: CalendarContext): EventStore;
 
@@ -1635,8 +1549,7 @@ interface MoreLinkContainerProps extends Partial<ElProps> {
     dateProfile: DateProfile;
     todayRange: DateRange;
     allDayDate: DateMarker | null;
-    moreCnt: number;
-    allSegs: Seg[];
+    segs: Seg[];
     hiddenSegs: Seg[];
     extraDateSpan?: Dictionary;
     alignmentElRef?: RefObject<HTMLElement>;
@@ -2041,8 +1954,6 @@ declare const BASE_OPTION_REFINERS: {
     dropAccept: Identity<string | ((this: CalendarApi, draggable: any) => boolean)>;
     eventOrder: typeof parseFieldSpecs;
     eventOrderStrict: BooleanConstructor;
-    handleWindowResize: BooleanConstructor;
-    windowResizeDelay: NumberConstructor;
     longPressDelay: NumberConstructor;
     eventDragMinDistance: NumberConstructor;
     expandRows: BooleanConstructor;
@@ -2200,8 +2111,6 @@ declare const BASE_OPTION_DEFAULTS: {
         day: string;
         year: string;
     };
-    handleWindowResize: boolean;
-    windowResizeDelay: number;
     longPressDelay: number;
     eventDragMinDistance: number;
     expandRows: boolean;
@@ -2223,9 +2132,6 @@ declare const CALENDAR_LISTENER_REFINERS: {
     eventAdd: Identity<(arg: EventAddArg) => void>;
     eventChange: Identity<(arg: EventChangeArg) => void>;
     eventRemove: Identity<(arg: EventRemoveArg) => void>;
-    windowResize: Identity<(arg: {
-        view: ViewApi;
-    }) => void>;
     eventClick: Identity<(arg: EventClickArg) => void>;
     eventMouseEnter: Identity<(arg: EventHoveringArg) => void>;
     eventMouseLeave: Identity<(arg: EventHoveringArg) => void>;
@@ -2237,8 +2143,7 @@ declare const CALENDAR_LISTENER_REFINERS: {
     _afterprint: Identity<() => void>;
     _noEventDrop: Identity<() => void>;
     _noEventResize: Identity<() => void>;
-    _resize: Identity<(forced: boolean) => void>;
-    _scrollRequest: Identity<(arg: any) => void>;
+    _timeScrollRequest: Identity<(time: Duration) => void>;
 };
 type BuiltInCalendarListenerRefiners = typeof CALENDAR_LISTENER_REFINERS;
 interface CalendarListenerRefiners extends BuiltInCalendarListenerRefiners {
@@ -2324,7 +2229,20 @@ declare function applyStyle(el: HTMLElement, props: Dictionary): void;
 declare function getEventTargetViaRoot(ev: Event): EventTarget;
 declare function getUniqueDomId(): string;
 
-declare function getCanVGrowWithinCell(): boolean;
+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;
+declare function afterSize(callback: () => void): void;
 
 declare function buildNavLinkAttrs(context: ViewContext, dateMarker: DateMarker, viewType?: string, isTabbable?: boolean): {
     tabIndex: number;
@@ -2445,8 +2363,10 @@ interface SegSpan {
 }
 interface SegEntry {
     index: number;
-    thickness?: number;
+    seg?: Seg;
+    segGroup?: SegGroup;
     span: SegSpan;
+    thickness?: number;
 }
 interface SegInsertion {
     level: number;
@@ -2461,9 +2381,10 @@ interface SegRect extends SegEntry {
     thickness: number;
     levelCoord: number;
 }
-interface SegEntryGroup {
-    entries: SegEntry[];
+interface SegGroup {
+    key: string;
     span: SegSpan;
+    segs: Seg[];
 }
 declare class SegHierarchy {
     private getEntryThickness;
@@ -2476,19 +2397,19 @@ declare class SegHierarchy {
     stackCnts: {
         [entryId: string]: number;
     };
-    constructor(getEntryThickness?: (entry: SegEntry) => number);
+    constructor(getEntryThickness?: (entry: SegEntry) => number | undefined);
     addSegs(inputs: SegEntry[]): SegEntry[];
     insertEntry(entry: SegEntry, hiddenEntries: SegEntry[]): void;
-    isInsertionValid(insertion: SegInsertion, entry: SegEntry): boolean;
+    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): SegInsertion;
+    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[]): SegEntryGroup[];
+declare function groupIntersectingEntries(entries: SegEntry[]): SegGroup[];
 declare function intersectSpans(span0: SegSpan, span1: SegSpan): SegSpan | null;
 declare function binarySearch<Item>(a: Item[], searchVal: number, getItemVal: (item: Item) => number): [number, number];
 
@@ -2498,15 +2419,13 @@ interface CalendarRootProps {
     options: CalendarOptions;
     theme: Theme;
     emitter: Emitter<CalendarListeners>;
-    children: (classNames: string[], height: CssDimValue, isHeightAuto: boolean, forPrint: boolean) => ComponentChildren;
+    children: (classNames: string[], height: CssDimValue | undefined, forPrint: boolean) => ComponentChildren;
 }
 interface CalendarRootState {
     forPrint: boolean;
 }
 declare class CalendarRoot extends BaseComponent<CalendarRootProps, CalendarRootState> {
-    state: {
-        forPrint: boolean;
-    };
+    state: CalendarRootState;
     render(): ComponentChildren;
     componentDidMount(): void;
     componentWillUnmount(): void;
@@ -2514,47 +2433,6 @@ declare class CalendarRoot extends BaseComponent<CalendarRootProps, CalendarRoot
     handleAfterPrint: () => void;
 }
 
-interface DayHeaderProps {
-    dateProfile: DateProfile;
-    dates: DateMarker[];
-    datesRepDistinctDays: boolean;
-    renderIntro?: (rowKey: string) => VNode;
-}
-declare class DayHeader extends BaseComponent<DayHeaderProps> {
-    createDayHeaderFormatter: (explicitFormat: DateFormatter, datesRepDistinctDays: any, dateCnt: any) => DateFormatter;
-    render(): createElement.JSX.Element;
-}
-
-declare function computeFallbackHeaderFormat(datesRepDistinctDays: boolean, dayCnt: number): DateFormatter;
-
-interface TableDateCellProps {
-    date: DateMarker;
-    dateProfile: DateProfile;
-    todayRange: DateRange;
-    colCnt: number;
-    dayHeaderFormat: DateFormatter;
-    colSpan?: number;
-    isSticky?: boolean;
-    extraDataAttrs?: Dictionary;
-    extraRenderProps?: Dictionary;
-}
-declare class TableDateCell extends BaseComponent<TableDateCellProps> {
-    render(): createElement.JSX.Element;
-}
-
-interface TableDowCellProps {
-    dow: number;
-    dayHeaderFormat: DateFormatter;
-    colSpan?: number;
-    isSticky?: boolean;
-    extraRenderProps?: Dictionary;
-    extraDataAttrs?: Dictionary;
-    extraClassNames?: string[];
-}
-declare class TableDowCell extends BaseComponent<TableDowCellProps> {
-    render(): createElement.JSX.Element;
-}
-
 interface DaySeriesSeg {
     firstIndex: number;
     lastIndex: number;
@@ -2586,16 +2464,75 @@ interface DayTableCell {
 declare class DayTableModel {
     rowCnt: number;
     colCnt: number;
-    cells: DayTableCell[][];
+    cellRows: DayTableCell[][];
     headerDates: DateMarker[];
     private daySeries;
     constructor(daySeries: DaySeriesModel, breakOnWeeks: boolean);
-    private buildCells;
+    buildCells(): any[];
     private buildCell;
     private buildHeaderDates;
     sliceRange(range: DateRange): DayTableSeg[];
 }
 
+declare class ScrollListener {
+    el: HTMLElement;
+    emitter: Emitter<any>;
+    private isScrolling;
+    private isTouching;
+    private isRecentlyWheeled;
+    private isRecentlyScrolled;
+    private wheelWaiter;
+    private scrollWaiter;
+    constructor(el: HTMLElement);
+    destroy(): void;
+    private startScroll;
+    endScroll(): void;
+    private handleScroll;
+    private _handleScrollWaited;
+    private handleWheel;
+    private _handleWheelWaited;
+    private handleTouchStart;
+    private handleTouchEnd;
+}
+
+interface ScrollerProps {
+    vertical?: boolean;
+    horizontal?: boolean;
+    hideScrollbars?: boolean;
+    children: ComponentChildren;
+    elClassNames?: string[];
+    elStyle?: Dictionary$1;
+    widthRef?: Ref<number>;
+    heightRef?: Ref<number>;
+    leftScrollbarWidthRef?: Ref<number>;
+    rightScrollbarWidthRef?: Ref<number>;
+    bottomScrollbarWidthRef?: Ref<number>;
+}
+declare class Scroller extends DateComponent$1<ScrollerProps> implements ScrollerInterface {
+    private elRef;
+    listener: ScrollListener;
+    private disconnectSize?;
+    private currentWidth;
+    private currentHeight;
+    private currentLeftScrollbarWidth;
+    private currentRightScrollbarWidth;
+    private currentBottomScrollbarWidth;
+    render(): createElement.JSX.Element;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    endScroll(): void;
+    get x(): number;
+    get y(): number;
+    scrollTo({ x, y }: {
+        x?: number;
+        y?: number;
+    }): void;
+    addScrollEndListener(handler: (x: number, y: number) => void): void;
+    removeScrollEndListener(handler: (x: number, y: number) => void): void;
+}
+declare function getNormalizedScrollX(el: HTMLElement, isRtl: boolean): number;
+declare function setNormalizedScrollX(el: HTMLElement, isRtl: boolean, x: number): void;
+
 interface SliceableProps {
     dateSelection: DateSpan;
     businessHours: EventStore;
@@ -2610,8 +2547,8 @@ interface SlicedProps<SegType extends Seg> {
     businessHourSegs: SegType[];
     fgEventSegs: SegType[];
     bgEventSegs: SegType[];
-    eventDrag: EventSegUiInteractionState | null;
-    eventResize: EventSegUiInteractionState | null;
+    eventDrag: EventSegUiInteractionState<SegType> | null;
+    eventResize: EventSegUiInteractionState<SegType> | null;
     eventSelection: string;
 }
 declare abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
@@ -2637,88 +2574,21 @@ declare function isInteractionValid(interaction: EventInteractionState, dateProf
 declare function isDateSelectionValid(dateSelection: DateSpan, dateProfile: DateProfile, context: CalendarContext): boolean;
 declare function isPropsValid(state: SplittableProps, context: CalendarContext, dateSpanMeta?: {}, filterConfig?: any): boolean;
 
-type OverflowValue = 'auto' | 'hidden' | 'scroll' | 'visible';
-interface ScrollerProps {
-    elRef?: Ref<HTMLElement>;
-    overflowX: OverflowValue;
-    overflowY: OverflowValue;
-    overcomeLeft?: number;
-    overcomeRight?: number;
-    overcomeBottom?: number;
-    maxHeight?: CssDimValue;
-    liquid?: boolean;
-    liquidIsAbsolute?: boolean;
-    children?: ComponentChildren;
-}
-declare class Scroller extends BaseComponent<ScrollerProps> implements ScrollerLike {
-    el: HTMLElement;
-    render(): createElement.JSX.Element;
-    handleEl: (el: HTMLElement) => void;
-    needsXScrolling(): boolean;
-    needsYScrolling(): boolean;
-    getXScrollbarWidth(): number;
-    getYScrollbarWidth(): number;
-}
-
-declare class RefMap<RefType> {
-    masterCallback?: (val: RefType | null, key: string) => void;
-    currentMap: {
-        [key: string]: RefType;
-    };
-    private depths;
-    private callbackMap;
-    constructor(masterCallback?: (val: RefType | null, key: string) => void);
-    createRef(key: string | number): (val: RefType) => void;
-    handleValue: (val: RefType | null, key: string) => void;
-    collect(startIndex?: number, endIndex?: number, step?: number): RefType[];
-    getAll(): RefType[];
-}
-
-interface SimpleScrollGridProps {
-    cols: ColProps[];
-    sections: SimpleScrollGridSection[];
-    liquid: boolean;
-    collapsibleWidth: boolean;
-    height?: CssDimValue;
-}
-interface SimpleScrollGridSection extends SectionConfig {
-    key: string;
-    chunk?: ChunkConfig;
-}
-interface SimpleScrollGridState {
-    shrinkWidth: number | null;
-    forceYScrollbars: boolean;
-    scrollerClientWidths: {
-        [key: string]: number;
-    };
-    scrollerClientHeights: {
-        [key: string]: number;
-    };
-}
-declare class SimpleScrollGrid extends BaseComponent<SimpleScrollGridProps, SimpleScrollGridState> {
-    processCols: (a: any) => any;
-    renderMicroColGroup: typeof renderMicroColGroup;
-    scrollerRefs: RefMap<Scroller>;
-    scrollerElRefs: RefMap<HTMLElement>;
-    state: SimpleScrollGridState;
-    render(): VNode;
-    renderSection(sectionConfig: SimpleScrollGridSection, microColGroupNode: VNode, isHeader: boolean): createElement.JSX.Element;
-    renderChunkTd(sectionConfig: SimpleScrollGridSection, microColGroupNode: VNode, chunkConfig: ChunkConfig, isHeader: boolean): createElement.JSX.Element;
-    _handleScrollerEl(scrollerEl: HTMLElement | null, key: string): void;
-    handleSizing: () => void;
-    componentDidMount(): void;
-    componentDidUpdate(): void;
-    componentWillUnmount(): void;
-    computeShrinkWidth(): number;
-    computeScrollerDims(): {
-        forceYScrollbars: boolean;
-        scrollerClientWidths: {
-            [index: string]: number;
-        };
-        scrollerClientHeights: {
-            [index: string]: number;
-        };
-    };
+declare class DelayedRunner {
+    private drainedOption?;
+    private isRunning;
+    private isDirty;
+    private pauseDepths;
+    private timeoutId;
+    constructor(drainedOption?: () => void);
+    request(delay?: number): void;
+    pause(scope?: string): void;
+    resume(scope?: string, force?: boolean): void;
+    isPaused(): number;
+    tryDrain(): void;
+    clear(): void;
+    private clearTimeout;
+    protected drained(): void;
 }
 
 interface ScrollbarWidths {
@@ -2727,6 +2597,16 @@ interface ScrollbarWidths {
 }
 declare function getScrollbarWidths(): ScrollbarWidths;
 
+declare class RefMap<K, V> {
+    masterCallback?: (val: V, key: K) => void;
+    rev: string;
+    current: Map<K, V>;
+    private callbacks;
+    constructor(masterCallback?: (val: V, key: K) => void);
+    createRef(key: K): (val: V) => void;
+    handleValue: (val: V, key: K) => void;
+}
+
 declare function getIsRtlScrollbarOnLeft(): boolean;
 
 interface NowTimerProps {
@@ -2756,7 +2636,9 @@ declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
 interface StandardEventProps {
     elRef?: ElRef;
     elClasses?: string[];
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2769,13 +2651,17 @@ interface StandardEventProps {
     defaultTimeFormat: DateFormatter;
     defaultDisplayEventTime?: boolean;
     defaultDisplayEventEnd?: boolean;
+    startOverride?: DateMarker;
+    endOverride?: DateMarker;
 }
 declare class StandardEvent extends BaseComponent<StandardEventProps> {
     render(): createElement.JSX.Element;
 }
 
 interface MinimalEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2799,7 +2685,9 @@ declare class EventContainer extends BaseComponent<EventContainerProps> {
 }
 
 interface BgEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
@@ -2811,4 +2699,4 @@ declare function renderFill(fillType: string): createElement.JSX.Element;
 
 declare function injectStyles(styleText: string): void;
 
-export { 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 };
+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 };