@fullcalendar/core 7.0.0-beta.0 → 7.0.0-beta.3

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 {
@@ -485,6 +484,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,9 +572,9 @@ 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 = {
@@ -909,7 +910,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,17 +955,9 @@ interface Hit {
     largeUnit?: string;
 }
 
-interface Seg {
-    component?: DateComponent<any, any>;
-    isStart: boolean;
-    isEnd: boolean;
-    eventRange?: EventRenderRange;
-    [otherProp: string]: any;
-    el?: never;
-}
-interface EventSegUiInteractionState {
+interface EventSegUiInteractionState<S> {
     affectedInstances: EventInstanceHash;
-    segs: Seg[];
+    segs: (S & EventRangeProps)[];
     isEvent: boolean;
 }
 declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
@@ -989,6 +981,7 @@ interface InteractionSettingsInput {
     el: HTMLElement;
     useEventCenter?: boolean;
     isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
+    disableHits?: boolean;
 }
 interface InteractionSettings {
     component: DateComponent<any>;
@@ -1106,13 +1099,15 @@ interface ScrollerInterface {
         x?: number;
         y?: number;
     }): void;
+    addScrollEndListener(handler: (x: number, y: number) => void): void;
+    removeScrollEndListener(handler: (x: number, y: number) => void): void;
 }
 
 interface ScrollerSyncerClass {
     new (horizontal?: boolean): ScrollerSyncerInterface;
 }
 interface ScrollerSyncerInterface extends ScrollerInterface {
-    handleChildren(scrollers: ScrollerInterface[], isRtl: boolean): void;
+    handleChildren(scrollers: ScrollerInterface[]): void;
     destroy(): void;
 }
 
@@ -1369,13 +1364,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 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 EventRangeProps>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
 interface EventContentArg {
     event: EventImpl;
     timeText: string;
@@ -1397,22 +1396,21 @@ interface EventContentArg {
     view: ViewApi;
 }
 type EventMountArg = MountArg<EventContentArg>;
-declare function buildSegTimeText(seg: Seg, 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 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 getSegAnchorAttrs(seg: Seg, context: ViewContext): {
+declare function getEventRangeAnchorAttrs(eventRange: EventRenderRange, context: ViewContext): {
     tabIndex: number;
     onKeyDown(ev: KeyboardEvent): void;
 } | {
     href: string;
-} | {
-    href?: undefined;
 };
 
 interface OpenDateSpanInput {
@@ -1479,13 +1477,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;
@@ -1493,10 +1491,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;
@@ -1518,7 +1516,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;
@@ -1550,11 +1551,11 @@ interface MoreLinkContainerProps extends Partial<ElProps> {
     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;
@@ -1586,7 +1587,6 @@ declare class MoreLinkContainer extends BaseComponent<MoreLinkContainerProps, Mo
     handleClick: (ev: MouseEvent) => void;
     handlePopoverClose: () => void;
 }
-declare function computeEarliestSegStart(segs: Seg[]): DateMarker;
 
 interface EventSegment {
     event: EventApi;
@@ -1616,8 +1616,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;
@@ -1640,8 +1640,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>;
@@ -1659,7 +1659,7 @@ interface DayCellContainerProps extends Partial<ElProps> {
     todayRange: DateRange;
     isMonthStart?: boolean;
     showDayNumber?: boolean;
-    extraRenderProps?: Dictionary;
+    renderProps?: Dictionary;
     defaultGenerator?: (renderProps: DayCellContentArg) => ComponentChild;
     children?: InnerContainerFunc<DayCellContentArg>;
 }
@@ -1677,7 +1677,7 @@ interface DayCellRenderPropsInput {
     monthStartFormat: DateFormatter;
     isMonthStart: boolean;
     showDayNumber?: boolean;
-    extraRenderProps?: Dictionary;
+    renderProps?: Dictionary;
 }
 
 interface ViewContainerProps extends Partial<ElProps> {
@@ -1955,6 +1955,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;
@@ -2196,14 +2197,7 @@ type Dictionary = Record<string, any>;
 type Identity<T = any> = (raw: T) => T;
 declare function identity<T>(raw: T): T;
 
-declare class JsonRequestError extends Error {
-    response: Response;
-    constructor(message: string, response: Response);
-}
-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;
@@ -2221,29 +2215,19 @@ 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): {
     tabIndex: number;
@@ -2358,60 +2342,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;
@@ -2434,33 +2423,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;
@@ -2472,7 +2453,28 @@ 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;
+    constructor(el: HTMLElement);
+    destroy(): void;
+    private startScroll;
+    endScroll(): void;
+    private handleScroll;
+    private _handleScrollWaited;
+    private handleWheel;
+    private _handleWheelWaited;
+    private handleTouchStart;
+    private handleTouchEnd;
 }
 
 interface ScrollerProps {
@@ -2480,32 +2482,32 @@ 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;
-    get el(): HTMLElement;
+    handleEl: (el: HTMLDivElement | null) => 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;
@@ -2519,26 +2521,26 @@ interface SliceableProps {
     eventSelection: string;
     eventUiBases: EventUiHash;
 }
-interface SlicedProps<SegType extends Seg> {
-    dateSelectionSegs: SegType[];
-    businessHourSegs: SegType[];
-    fgEventSegs: SegType[];
-    bgEventSegs: SegType[];
-    eventDrag: EventSegUiInteractionState | null;
-    eventResize: EventSegUiInteractionState | 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;
@@ -2551,6 +2553,12 @@ 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;
 
+declare class JsonRequestError extends Error {
+    response: Response;
+    constructor(message: string, response: Response);
+}
+declare function requestJson<ParsedResponse>(method: string, url: string, params: Dictionary): Promise<[ParsedResponse, Response]>;
+
 declare class DelayedRunner {
     private drainedOption?;
     private isRunning;
@@ -2610,18 +2618,14 @@ declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
     private clearTimeout;
 }
 
-declare class ScrollResponder<T> {
-    private _handleScroll;
-    protected queuedScroll?: T;
-    constructor(_handleScroll: (scroll: T) => boolean);
-    handleScroll: (scroll: T) => void;
-    drain(): void;
-}
-
 interface StandardEventProps {
     elRef?: ElRef;
-    elClasses?: string[];
-    seg: Seg;
+    className?: string;
+    eventRange: EventRenderRange;
+    slicedStart?: DateMarker;
+    slicedEnd?: DateMarker;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2640,7 +2644,11 @@ declare class StandardEvent extends BaseComponent<StandardEventProps> {
 }
 
 interface MinimalEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    slicedStart?: DateMarker;
+    slicedEnd?: DateMarker;
+    isStart: boolean;
+    isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
     isDateSelecting: boolean;
@@ -2664,7 +2672,9 @@ declare class EventContainer extends BaseComponent<EventContainerProps> {
 }
 
 interface BgEventProps {
-    seg: Seg;
+    eventRange: EventRenderRange;
+    isStart: boolean;
+    isEnd: boolean;
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
@@ -2676,4 +2686,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, getSegAnchorAttrs 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, getElSeg as dw, buildSegTimeText as dx, sortEventSegs as dy, getSegMeta as dz, EventRenderRange as e, NowTimer as e0, ScrollResponder as e1, MountArg as e2, StandardEvent as e3, NowIndicatorContainer as e4, DayCellContainer as e5, hasCustomDayCellContent as e6, MinimalEventProps as e7, EventContainer as e8, renderFill as e9, BgEvent as ea, WeekNumberContainerProps as eb, WeekNumberContainer as ec, MoreLinkContainer as ed, computeEarliestSegStart as ee, ViewContainerProps as ef, ViewContainer as eg, DatePointTransform as eh, DateSpanTransform as ei, triggerDateSelect as ej, getDefaultEventEnd as ek, injectStyles as el, EventImpl as em, buildEventApis as en, ElProps as eo, buildElAttrs as ep, InnerContainerFunc as eq, ContentContainer as er, CustomRendering as es, 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, rangesEqual 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, preventDefault as bQ, whenTransitionDone as bR, computeInnerRect as bS, computeEdges as bT, getClippingParents as bU, computeRect as bV, unpromisify as bW, Emitter as bX, DateRange as bY, rangeContainsMarker as bZ, intersectRanges 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, Hit as c$, rangesIntersect as c0, rangeContainsRange as c1, PositionCache as c2, ScrollController as c3, ElementScrollController as c4, WindowScrollController as c5, Theme as c6, ViewContext as c7, ViewContextType as c8, EventSegUiInteractionState as c9, wholeDivideDurations as cA, greatestDurationDenominator as cB, DateEnv as cC, createFormatter as cD, DateFormatter as cE, VerboseFormattingArg as cF, formatIsoTimeString as cG, formatDayString as cH, buildIsoString as cI, formatIsoMonthStr as cJ, NamedTimeZoneImpl as cK, parse as cL, EventSourceDef as cM, EventSourceRefined as cN, EventSourceRefiners as cO, EventPlacement as cP, EventInsertion as cQ, SegHierarchy as cR, SegGroup as cS, groupIntersectingSegs as cT, binarySearch as cU, InteractionSettings as cV, InteractionSettingsStore as cW, Interaction as cX, interactionSettingsToStore as cY, interactionSettingsStore as cZ, PointerDragEvent as c_, DateComponent as ca, CalendarData as cb, ViewProps as cc, DateProfile as cd, DateProfileGenerator as ce, ViewSpec as cf, DateSpan as cg, isDateSpansEqual as ch, DateMarker as ci, addDays as cj, startOfDay as ck, addMs as cl, addWeeks as cm, diffWeeks as cn, diffWholeWeeks as co, diffWholeDays as cp, diffDayAndTime as cq, diffDays as cr, isValidDate as cs, createDuration as ct, asCleanDays as cu, multiplyDuration as cv, addDurations as cw, asRoughMinutes as cx, asRoughSeconds as cy, asRoughMs as cz, EventApi as d, BgEvent as d$, dateSelectionJoinTransformer as d0, eventDragMutationMassager as d1, EventDropTransformers as d2, ElementDragging as d3, config as d4, RecurringType as d5, DragMetaInput as d6, DragMeta as d7, parseDragMeta as d8, ViewPropsTransformer as d9, applyMutationToEventStore as dA, Constraint as dB, isPropsValid as dC, isInteractionValid as dD, isDateSelectionValid as dE, requestJson as dF, BaseComponent as dG, setRef as dH, DelayedRunner as dI, getStickyFooterScrollbar as dJ, getStickyHeaderDates as dK, getIsHeightAuto as dL, getScrollerSyncerClass as dM, ScrollerInterface as dN, ScrollerSyncerInterface as dO, getScrollbarWidths as dP, RefMap as dQ, getIsRtlScrollbarOnLeft as dR, NowTimer as dS, MountArg as dT, StandardEvent as dU, NowIndicatorContainer as dV, DayCellContainer as dW, hasCustomDayCellContent as dX, MinimalEventProps as dY, EventContainer as dZ, renderFill as d_, Action as da, CalendarContext as db, CalendarContentProps as dc, CalendarRoot as dd, DaySeriesModel as de, EventInteractionState as df, sliceEventStore as dg, hasBgRendering as dh, getElEventRange as di, buildEventRangeTimeText as dj, sortEventSegs as dk, getEventRangeMeta as dl, buildEventRangeKey as dm, getEventRangeAnchorAttrs as dn, EventRangeProps as dp, getEventKey as dq, DayTableCell as dr, DayGridRange as ds, DayTableModel as dt, Scroller as du, getNormalizedScrollX as dv, setNormalizedScrollX as dw, SlicedProps as dx, Slicer as dy, EventMutation as dz, EventRenderRange as e, WeekNumberContainerProps as e0, WeekNumberContainer as e1, MoreLinkContainer as e2, ViewContainerProps as e3, ViewContainer as e4, DatePointTransform as e5, DateSpanTransform as e6, triggerDateSelect as e7, getDefaultEventEnd as e8, injectStyles as e9, EventImpl as ea, buildEventApis as eb, ElProps as ec, buildElAttrs as ed, InnerContainerFunc as ee, ContentContainer as ef, renderText as eg, CustomRendering as eh, CoordRange as ei, CoordSpan as ej, SlicedCoordRange as ek, computeEarliestStart as el, computeLatestEnd as em, getCoordRangeEnd as en, StickyFooterScrollbar as eo, 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 };