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

package/{internal-common.d.ts → esm/internal-common.d.ts}

@@ -1,173 +1,9 @@
 import * as preact from 'preact';
+import * as _full_ui_headless_calendar from '@full-ui/headless-calendar';
+import { DateRange, LocaleCodeArg, FuncFormatterFunc, DateFormatter, Duration, DateInput, DurationInput, DateMarker, OpenDateRange, DateRangeInput, DateEnv, createDuration, CmdFormatterFunc, NamedTimeZoneImplClass, WeekNumberCalculation } from '@full-ui/headless-calendar';
 import { ComponentChildren, ComponentType, Context, Ref, Component, JSX, ComponentChild, FunctionalComponent, createElement, RefObject } from './preact.js';
 import { ViewApi as ViewApi$1 } from './index.js';
 
-type DurationInput = DurationObjectInput | string | number;
-interface DurationObjectInput {
-    years?: number;
-    year?: number;
-    months?: number;
-    month?: number;
-    weeks?: number;
-    week?: number;
-    days?: number;
-    day?: number;
-    hours?: number;
-    hour?: number;
-    minutes?: number;
-    minute?: number;
-    seconds?: number;
-    second?: number;
-    milliseconds?: number;
-    millisecond?: number;
-    ms?: number;
-}
-interface Duration {
-    years: number;
-    months: number;
-    days: number;
-    milliseconds: number;
-    specifiedWeeks?: boolean;
-}
-declare function createDuration(input: DurationInput, unit?: string): Duration | null;
-declare function asCleanDays(dur: Duration): number;
-declare function addDurations(d0: Duration, d1: Duration): {
-    years: number;
-    months: number;
-    days: number;
-    milliseconds: number;
-};
-declare function multiplyDuration(d: Duration, n: number): {
-    years: number;
-    months: number;
-    days: number;
-    milliseconds: number;
-};
-declare function asRoughMinutes(dur: Duration): number;
-declare function asRoughSeconds(dur: Duration): number;
-declare function asRoughMs(dur: Duration): number;
-declare function wholeDivideDurations(numerator: Duration, denominator: Duration): number;
-declare function greatestDurationDenominator(dur: Duration): {
-    unit: string;
-    value: number;
-};
-
-type DateMarker = Date;
-declare function addWeeks(m: DateMarker, n: number): Date;
-declare function addDays(m: DateMarker, n: number): Date;
-declare function addMs(m: DateMarker, n: number): Date;
-declare function diffWeeks(m0: any, m1: any): number;
-declare function diffDays(m0: any, m1: any): number;
-declare function diffDayAndTime(m0: DateMarker, m1: DateMarker): Duration;
-declare function diffWholeWeeks(m0: DateMarker, m1: DateMarker): number;
-declare function diffWholeDays(m0: DateMarker, m1: DateMarker): number;
-declare function startOfDay(m: DateMarker): DateMarker;
-declare function isValidDate(m: DateMarker): boolean;
-
-interface CalendarSystem {
-    getMarkerYear(d: DateMarker): number;
-    getMarkerMonth(d: DateMarker): number;
-    getMarkerDay(d: DateMarker): number;
-    arrayToMarker(arr: number[]): DateMarker;
-    markerToArray(d: DateMarker): number[];
-}
-
-type LocaleCodeArg = string | string[];
-type LocaleSingularArg = LocaleCodeArg | LocaleInput;
-interface Locale {
-    codeArg: LocaleCodeArg;
-    codes: string[];
-    week: {
-        dow: number;
-        doy: number;
-    };
-    simpleNumberFormat: Intl.NumberFormat;
-    options: CalendarOptionsRefined;
-}
-interface LocaleInput extends CalendarOptions {
-    code: string;
-}
-type LocaleInputMap = {
-    [code: string]: LocaleInput;
-};
-interface RawLocaleInfo {
-    map: LocaleInputMap;
-    defaultCode: string;
-}
-
-interface ZonedMarker {
-    marker: DateMarker;
-    timeZoneOffset: number;
-}
-interface ExpandedZonedMarker extends ZonedMarker {
-    array: number[];
-    year: number;
-    month: number;
-    day: number;
-    hour: number;
-    minute: number;
-    second: number;
-    millisecond: number;
-}
-
-interface VerboseFormattingArg {
-    date: ExpandedZonedMarker;
-    start: ExpandedZonedMarker;
-    end?: ExpandedZonedMarker;
-    timeZone: string;
-    localeCodes: string[];
-    defaultSeparator: string;
-}
-type CmdFormatterFunc = (cmd: string, arg: VerboseFormattingArg) => string;
-interface DateFormattingContext {
-    timeZone: string;
-    locale: Locale;
-    calendarSystem: CalendarSystem;
-    computeWeekNumber: (d: DateMarker) => number;
-    weekText: string;
-    weekTextLong: string;
-    cmdFormatter?: CmdFormatterFunc;
-    defaultSeparator: string;
-}
-interface DateFormatter {
-    format(date: ZonedMarker, context: DateFormattingContext): string;
-    formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext, betterDefaultSeparator?: string): string;
-}
-
-interface NativeFormatterOptions extends Intl.DateTimeFormatOptions {
-    week?: 'long' | 'short' | 'narrow' | 'numeric';
-    meridiem?: 'lowercase' | 'short' | 'narrow' | boolean;
-    omitZeroMinute?: boolean;
-    omitCommas?: boolean;
-    separator?: string;
-}
-
-type FuncFormatterFunc = (arg: VerboseFormattingArg) => string;
-
-type FormatterInput = NativeFormatterOptions | string | FuncFormatterFunc;
-declare function createFormatter(input: FormatterInput): DateFormatter;
-
-declare function guid(): string;
-declare function disableCursor(): void;
-declare function enableCursor(): void;
-declare function preventSelection(el: HTMLElement): void;
-declare function allowSelection(el: HTMLElement): void;
-declare function preventContextMenu(el: HTMLElement): void;
-declare function allowContextMenu(el: HTMLElement): void;
-interface OrderSpec<Subject> {
-    field?: string;
-    order?: number;
-    func?: FieldSpecInputFunc<Subject>;
-}
-type FieldSpecInput<Subject> = string | string[] | FieldSpecInputFunc<Subject> | FieldSpecInputFunc<Subject>[];
-type FieldSpecInputFunc<Subject> = (a: Subject, b: Subject) => number;
-declare function parseFieldSpecs<Subject>(input: FieldSpecInput<Subject>): OrderSpec<Subject>[];
-declare function compareByFieldSpecs<Subject>(obj0: Subject, obj1: Subject, fieldSpecs: OrderSpec<Subject>[]): number;
-declare function flexibleCompare(a: any, b: any): number;
-declare function padStart(val: any, len: any): string;
-declare function compareNumbers(a: any, b: any): number;
-declare function isInt(n: any): boolean;
-
 interface ViewApi {
     calendar: CalendarApi;
     type: string;
@@ -187,109 +23,6 @@ interface EventSourceApi {
     refetch(): void;
 }
 
-declare abstract class NamedTimeZoneImpl {
-    timeZoneName: string;
-    constructor(timeZoneName: string);
-    abstract offsetForArray(a: number[]): number;
-    abstract timestampToArray(ms: number): number[];
-}
-type NamedTimeZoneImplClass = {
-    new (timeZoneName: string): NamedTimeZoneImpl;
-};
-
-type WeekNumberCalculation = 'local' | 'ISO' | ((m: Date) => number);
-interface DateEnvSettings {
-    timeZone: string;
-    namedTimeZoneImpl?: NamedTimeZoneImplClass;
-    calendarSystem: string;
-    locale: Locale;
-    weekNumberCalculation?: WeekNumberCalculation;
-    firstDay?: number;
-    weekText?: string;
-    weekTextLong?: string;
-    cmdFormatter?: CmdFormatterFunc;
-    defaultSeparator?: string;
-}
-type DateInput = Date | string | number | number[];
-interface DateMarkerMeta {
-    marker: DateMarker;
-    isTimeUnspecified: boolean;
-    forcedTzo: number | null;
-}
-declare class DateEnv {
-    timeZone: string;
-    namedTimeZoneImpl: NamedTimeZoneImpl;
-    canComputeOffset: boolean;
-    calendarSystem: CalendarSystem;
-    locale: Locale;
-    weekDow: number;
-    weekDoy: number;
-    weekNumberFunc: any;
-    weekText: string;
-    weekTextLong: string;
-    cmdFormatter?: CmdFormatterFunc;
-    defaultSeparator: string;
-    constructor(settings: DateEnvSettings);
-    createMarker(input: DateInput): DateMarker;
-    createNowMarker(): DateMarker;
-    createMarkerMeta(input: DateInput): DateMarkerMeta;
-    parse(s: string): {
-        marker: Date;
-        isTimeUnspecified: boolean;
-        forcedTzo: any;
-    };
-    getYear(marker: DateMarker): number;
-    getMonth(marker: DateMarker): number;
-    getDay(marker: DateMarker): number;
-    add(marker: DateMarker, dur: Duration): DateMarker;
-    subtract(marker: DateMarker, dur: Duration): DateMarker;
-    addYears(marker: DateMarker, n: number): Date;
-    addMonths(marker: DateMarker, n: number): Date;
-    diffWholeYears(m0: DateMarker, m1: DateMarker): number;
-    diffWholeMonths(m0: DateMarker, m1: DateMarker): number;
-    greatestWholeUnit(m0: DateMarker, m1: DateMarker): {
-        unit: string;
-        value: number;
-    };
-    countDurationsBetween(m0: DateMarker, m1: DateMarker, d: Duration): number;
-    startOf(m: DateMarker, unit: string): Date;
-    startOfYear(m: DateMarker): DateMarker;
-    startOfMonth(m: DateMarker): DateMarker;
-    startOfWeek(m: DateMarker): DateMarker;
-    computeWeekNumber(marker: DateMarker): number;
-    format(marker: DateMarker, formatter: DateFormatter, dateOptions?: {
-        forcedTzo?: number;
-    }): string;
-    formatRange(start: DateMarker, end: DateMarker, formatter: DateFormatter, dateOptions?: {
-        forcedStartTzo?: number;
-        forcedEndTzo?: number;
-        isEndExclusive?: boolean;
-        defaultSeparator?: string;
-    }): string;
-    formatIso(marker: DateMarker, extraOptions?: any): string;
-    timestampToMarker(ms: number): Date;
-    offsetForMarker(m: DateMarker): number;
-    toDate(m: DateMarker, forcedTzo?: number): Date;
-}
-
-interface DateRangeInput {
-    start?: DateInput;
-    end?: DateInput;
-}
-interface OpenDateRange {
-    start: DateMarker | null;
-    end: DateMarker | null;
-}
-interface DateRange {
-    start: DateMarker;
-    end: DateMarker;
-}
-declare function intersectRanges(range0: OpenDateRange, range1: OpenDateRange): OpenDateRange;
-declare function rangesEqual(range0: OpenDateRange, range1: OpenDateRange): boolean;
-declare function rangesIntersect(range0: OpenDateRange, range1: OpenDateRange): boolean;
-declare function rangeContainsRange(outerRange: OpenDateRange, innerRange: OpenDateRange): boolean;
-declare function rangeContainsMarker(range: OpenDateRange, date: DateMarker | number): boolean;
-
 interface EventInstance {
     instanceId: string;
     defId: string;
@@ -302,6 +35,31 @@ type EventInstanceHash = {
 };
 declare function createEventInstance(defId: string, range: DateRange, forcedStartTzo?: number, forcedEndTzo?: number): EventInstance;
 
+type LocaleSingularArg = LocaleCodeArg | LocaleInput;
+interface LocaleInput extends CalendarOptions {
+    code: string;
+}
+type LocaleInputMap = {
+    [code: string]: LocaleInput;
+};
+interface RawLocaleInfo {
+    map: LocaleInputMap;
+    defaultCode: string;
+}
+
+interface NativeFormatterOptions extends Intl.DateTimeFormatOptions {
+    week?: 'long' | 'short' | 'narrow' | 'numeric';
+    meridiem?: 'lowercase' | 'short' | 'narrow' | boolean;
+    omitZeroMinute?: boolean;
+    omitCommas?: boolean;
+    forceCommas?: boolean;
+    separator?: string;
+    weekdayJustify?: 'start' | 'end';
+}
+
+type FormatterInput = NativeFormatterOptions | string | FuncFormatterFunc;
+declare function createFormatter(input: FormatterInput): DateFormatter;
+
 interface PointerDragEvent {
     origEvent: UIEvent;
     isTouch: boolean;
@@ -376,14 +134,12 @@ declare class EventImpl implements EventApi {
     get constraint(): string | EventStore;
     get overlap(): boolean;
     get allow(): AllowFunc;
-    get backgroundColor(): string;
-    get borderColor(): string;
-    get textColor(): string;
-    get classNames(): string[];
+    get color(): string;
+    get contrastColor(): string;
+    get className(): string;
     get extendedProps(): Dictionary;
     toPlainObject(settings?: {
         collapseExtendedProps?: boolean;
-        collapseColor?: boolean;
     }): Dictionary;
     toJSON(): Dictionary;
 }
@@ -460,6 +216,8 @@ declare class DateProfileGenerator {
     isHiddenDay(day: any): boolean;
     skipHiddenDays(date: DateMarker, inc?: number, isExclusive?: boolean): Date;
 }
+declare function computeMajorUnit(dateProfile: DateProfile, dateEnv: DateEnv): string | undefined;
+declare function isMajorUnit(dateMarker: DateMarker, majorUnit: string, dateEnv: DateEnv): boolean;
 
 interface EventInteractionState {
     affectedEvents: EventStore;
@@ -468,6 +226,7 @@ interface EventInteractionState {
 }
 
 interface ViewProps {
+    className?: string;
     dateProfile: DateProfile;
     businessHours: EventStore;
     eventStore: EventStore;
@@ -477,44 +236,44 @@ interface ViewProps {
     eventDrag: EventInteractionState | null;
     eventResize: EventInteractionState | null;
     forPrint: boolean;
+    labelId: string | undefined;
+    labelStr: string | undefined;
+    borderlessX: boolean;
+    borderlessTop: boolean;
+    borderlessBottom: boolean;
+    noEdgeEffects: boolean;
 }
 declare function sliceEvents(props: ViewProps & {
     dateProfile: DateProfile;
     nextDayThreshold: Duration;
 }, 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;
-
-type MountArg<ContentArg> = ContentArg & {
+type MountData<DisplayData> = DisplayData & {
     el: HTMLElement;
 };
-type DidMountHandler<TheMountArg extends {
+type DidMountHandler<TheMountData extends {
     el: HTMLElement;
-}> = (mountArg: TheMountArg) => void;
-type WillUnmountHandler<TheMountArg extends {
+}> = (mountData: TheMountData) => void;
+type WillUnmountHandler<TheMountData extends {
     el: HTMLElement;
-}> = (mountArg: TheMountArg) => void;
+}> = (mountData: TheMountData) => void;
 interface ObjCustomContent {
     html: string;
     domNodes: any[];
 }
 type CustomContent = ComponentChildren | ObjCustomContent;
 type CustomContentGenerator<RenderProps> = CustomContent | ((renderProps: RenderProps, createElement: any) => (CustomContent | true));
-type ClassNamesGenerator<RenderProps> = ClassNamesInput | ((renderProps: RenderProps) => ClassNamesInput);
+type ClassNameGenerator<RenderProps> = string | undefined | ((renderProps: RenderProps) => string | undefined);
 
 type ViewComponentType = ComponentType<ViewProps>;
 type ViewConfigInput = ViewComponentType | ViewOptions;
 type ViewConfigInputHash = {
     [viewType: string]: ViewConfigInput;
 };
-interface SpecificViewContentArg extends ViewProps {
+interface SpecificViewData extends ViewProps {
     nextDayThreshold: Duration;
 }
-type SpecificViewMountArg = MountArg<SpecificViewContentArg>;
+type SpecificViewMountData = MountData<SpecificViewData>;
 
 interface ViewSpec {
     type: string;
@@ -524,10 +283,6 @@ interface ViewSpec {
     singleUnit: string;
     optionDefaults: ViewOptions;
     optionOverrides: ViewOptions;
-    buttonTextOverride: string;
-    buttonTextDefault: string;
-    buttonTitleOverride: string | ((...args: any[]) => string);
-    buttonTitleDefault: string | ((...args: any[]) => string);
 }
 type ViewSpecHash = {
     [viewType: string]: ViewSpec;
@@ -562,24 +317,72 @@ declare class ViewImpl implements ViewApi {
     getOption(name: string): any;
 }
 
-declare class Theme {
-    classes: any;
-    iconClasses: any;
-    rtlIconClasses: any;
-    baseIconClass: string;
-    iconOverrideOption: any;
-    iconOverrideCustomButtonOption: any;
-    iconOverridePrefix: string;
-    constructor(calendarOptions: CalendarOptionsRefined);
-    setIconOverride(iconOverrideHash: any): void;
-    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 ToolbarData {
+    borderlessX: boolean;
+}
+interface ToolbarSectionData {
+    name: string;
+}
+interface ButtonGroupData {
+    isSelectGroup: boolean;
+}
+interface ButtonData {
+    name: string;
+    text: string;
+    isPrimary: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    isIconOnly: boolean;
+    inGroup: boolean;
+    inSelectGroup: boolean;
+}
+type ButtonMountData = MountData<ButtonData>;
+type ButtonDisplay = 'auto' | 'icon' | 'text' | 'icon-text' | 'text-icon';
+interface ButtonInput {
+    didMount?: DidMountHandler<ButtonMountData>;
+    willUnmount?: DidMountHandler<ButtonMountData>;
+    click?: (ev: MouseEvent) => void;
+    hint?: string | ((viewOrCurrentUnitText: string, viewOrCurrentUnit: string) => string);
+    class?: ClassNameGenerator<ButtonData>;
+    className?: ClassNameGenerator<ButtonData>;
+    display?: ButtonDisplay;
+    iconClass?: string | undefined;
+    iconContent?: CustomContentGenerator<{}>;
+    text?: string;
+    isPrimary?: boolean;
+}
+interface ToolbarWidget {
+    name: string;
+    isView?: boolean;
+    customElement?: ToolbarElementInput;
+    buttonText?: string;
+    buttonHint?: string | ((currentUnit: string) => string);
+    buttonDisplay?: ButtonDisplay;
+    buttonIconClass?: string | undefined;
+    buttonIconContent?: CustomContentGenerator<{}>;
+    buttonClick?: (ev: MouseEvent) => void;
+    buttonIsPrimary?: boolean;
+    buttonClass?: ClassNameGenerator<ButtonData>;
+    buttonDidMount?: DidMountHandler<ButtonMountData>;
+    buttonWillUnmount?: WillUnmountHandler<ButtonMountData>;
+}
+interface ToolbarInput {
+    left?: string;
+    center?: string;
+    right?: string;
+    start?: string;
+    end?: string;
+}
+type ToolbarElementInput = CustomContentGenerator<{}>;
 
 interface CalendarDataManagerState {
     dynamicOptionOverrides: CalendarOptions;
@@ -600,10 +403,11 @@ interface CalendarDataManagerState {
 interface CalendarOptionsData {
     localeDefaults: CalendarOptions;
     calendarOptions: CalendarOptionsRefined;
-    toolbarConfig: any;
+    toolbarConfig: {
+        [toolbarName: string]: ToolbarModel;
+    };
     availableRawLocales: any;
     dateEnv: DateEnv;
-    theme: Theme;
     pluginHooks: PluginHooks;
     viewSpecs: ViewSpecHash;
 }
@@ -689,7 +493,7 @@ interface EventSourceFetcherRes {
     rawEvents: EventInput[];
     response?: Response;
 }
-type EventSourceFetcher<Meta> = (arg: {
+type EventSourceFetcher<Meta> = (data: {
     eventSource: EventSource<Meta>;
     range: DateRange;
     isRefetch: boolean;
@@ -795,7 +599,6 @@ declare class CalendarDataManager {
     private buildLocale;
     private buildPluginHooks;
     private buildDateEnv;
-    private buildTheme;
     private parseToolbars;
     private buildViewSpecs;
     private buildDateProfileGenerator;
@@ -805,7 +608,7 @@ declare class CalendarDataManager {
     private buildEventUiBases;
     private parseContextBusinessHours;
     private buildTitle;
-    emitter: Emitter<Required<RefinedOptionsFromRefiners<Required<CalendarListenerRefiners>>>>;
+    emitter: Emitter<CalendarListeners>;
     private actionRunner;
     private props;
     private state;
@@ -832,14 +635,12 @@ declare class CalendarDataManager {
         refinedOptions: CalendarOptionsRefined;
         pluginHooks: PluginHooks;
         availableLocaleData: RawLocaleInfo;
-        localeDefaults: CalendarOptionsRefined;
-        extra: {};
+        localeDefaults: any;
     };
     _computeCurrentViewData(viewType: string, optionsData: CalendarOptionsData, optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions): CalendarCurrentViewData;
     processRawViewOptions(viewSpec: ViewSpec, pluginHooks: PluginHooks, localeDefaults: CalendarOptions, optionOverrides: CalendarOptions, dynamicOptionOverrides: CalendarOptions): {
         rawOptions: ViewOptions;
         refinedOptions: ViewOptionsRefined;
-        extra: {};
     };
 }
 
@@ -859,14 +660,14 @@ type OptionChangeHandler = (propValue: any, context: CalendarContext) => void;
 type OptionChangeHandlerMap = {
     [propName: string]: OptionChangeHandler;
 };
-interface DateSelectArg extends DateSpanApi {
+interface DateSelectData extends DateSpanApi {
     jsEvent: MouseEvent | null;
     view: ViewApi;
 }
 declare function triggerDateSelect(selection: DateSpan, pev: PointerDragEvent | null, context: CalendarContext & {
     viewApi?: ViewImpl;
 }): void;
-interface DateUnselectArg {
+interface DateUnselectData {
     jsEvent: MouseEvent;
     view: ViewApi;
 }
@@ -875,8 +676,6 @@ declare function getDefaultEventEnd(allDay: boolean, marker: DateMarker, context
 declare const ViewContextType: Context<any>;
 interface ViewContext extends CalendarContext {
     options: ViewOptionsRefined;
-    theme: Theme;
-    isRtl: boolean;
     dateProfileGenerator: DateProfileGenerator;
     viewSpec: ViewSpec;
     viewApi: ViewImpl;
@@ -884,23 +683,10 @@ interface ViewContext extends CalendarContext {
     unregisterInteractiveComponent: (component: DateComponent<any>) => void;
 }
 
-declare function filterHash(hash: any, func: any): {};
-declare function mapHash<InputItem, OutputItem>(hash: {
-    [key: string]: InputItem;
-}, func: (input: InputItem, key: string) => OutputItem): {
-    [key: string]: OutputItem;
-};
-declare function isPropsEqual(obj0: any, obj1: any): boolean;
 type EqualityFunc<T> = (a: T, b: T) => boolean;
-type EqualityThing<T> = EqualityFunc<T> | true;
-type EqualityFuncs<ObjType> = {
-    [K in keyof ObjType]?: EqualityThing<ObjType[K]>;
+type EqualityFuncs<P> = {
+    [K in keyof P]?: EqualityFunc<P[K]>;
 };
-declare function compareObjs(oldProps: any, newProps: any, equalityFuncs?: EqualityFuncs<any>): boolean;
-declare function collectFromHash<Item>(hash: {
-    [key: string]: Item;
-}, startIndex?: number, endIndex?: number, step?: number): Item[];
-
 declare abstract class PureComponent<Props = Dictionary, State = Dictionary> extends Component<Props, State> {
     static addPropsEquality: typeof addPropsEquality;
     static addStateEquality: typeof addStateEquality;
@@ -949,7 +735,7 @@ interface Hit {
     context?: ViewContext;
     dateProfile: DateProfile;
     dateSpan: DateSpan;
-    dayEl: HTMLElement;
+    getDayEl: () => HTMLElement;
     rect: Rect;
     layer: number;
     largeUnit?: string;
@@ -963,7 +749,7 @@ interface EventSegUiInteractionState<S> {
 declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
     uid: string;
     prepareHits(): void;
-    queryHit(positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit | null;
+    queryHit(isRtl: boolean, positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit | null;
     isValidSegDownEl(el: HTMLElement): boolean;
     isValidDateDownEl(el: HTMLElement): boolean;
 }
@@ -998,8 +784,17 @@ declare function interactionSettingsToStore(settings: InteractionSettings): {
 declare const interactionSettingsStore: InteractionSettingsStore;
 
 interface CalendarContentProps extends CalendarData {
+    toolbarProps: CalendarToolbarProps;
     forPrint: boolean;
 }
+interface CalendarToolbarProps {
+    title: string;
+    selectedButton: string;
+    navUnit: string;
+    isTodayEnabled: boolean;
+    isPrevEnabled: boolean;
+    isNextEnabled: boolean;
+}
 
 type eventDragMutationMassager = (mutation: EventMutation, hit0: Hit, hit1: Hit) => void;
 type EventDropTransformers = (mutation: EventMutation, context: CalendarContext) => Dictionary;
@@ -1027,14 +822,14 @@ declare function parseDragMeta(raw: DragMetaInput): DragMeta;
 
 type ExternalDefTransform = (dateSpan: DateSpan, dragMeta: DragMeta) => any;
 
-type EventSourceFuncArg = {
+type EventSourceFuncData = {
     start: Date;
     end: Date;
     startStr: string;
     endStr: string;
     timeZone: string;
 };
-type EventSourceFunc = ((arg: EventSourceFuncArg, successCallback: (eventInputs: EventInput[]) => void, failureCallback: (error: Error) => void) => void) | ((arg: EventSourceFuncArg) => Promise<EventInput[]>);
+type EventSourceFunc = ((data: EventSourceFuncData, successCallback: (eventInputs: EventInput[]) => void, failureCallback: (error: Error) => void) => void) | ((data: EventSourceFuncData) => Promise<EventInput[]>);
 
 declare const JSON_FEED_EVENT_SOURCE_REFINERS: {
     method: StringConstructor;
@@ -1055,13 +850,15 @@ declare const EVENT_SOURCE_REFINERS: {
     failure: Identity<EventSourceErrorResponseHandler>;
 };
 type BuiltInEventSourceRefiners = typeof EVENT_SOURCE_REFINERS & typeof JSON_FEED_EVENT_SOURCE_REFINERS;
-interface EventSourceRefiners extends BuiltInEventSourceRefiners {
+interface EventSourceOptions extends RawOptionsFromRefiners<BuiltInEventSourceRefiners> {
+}
+interface EventSourceOptionsRefined extends RefinedOptionsFromRefiners<BuiltInEventSourceRefiners> {
 }
-type EventSourceInputObject = EventUiInput & RawOptionsFromRefiners<Required<EventSourceRefiners>>;
+type EventSourceInputObject = EventUiInput & EventSourceOptions;
 type EventSourceInput = EventSourceInputObject | // object in extended form
 EventInput[] | EventSourceFunc | // just a function
 string;
-type EventSourceRefined = EventUiRefined & RefinedOptionsFromRefiners<Required<EventSourceRefiners>>;
+type EventSourceRefined = EventUiRefined & EventSourceOptionsRefined;
 
 interface EventSourceDef<Meta> {
     ignoreRange?: boolean;
@@ -1083,7 +880,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;
@@ -1099,8 +896,8 @@ 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: (isUser: boolean) => void): void;
+    removeScrollEndListener(handler: (isUser: boolean) => void): void;
 }
 
 interface ScrollerSyncerClass {
@@ -1135,9 +932,6 @@ interface PluginDefInput {
     eventDropTransformers?: EventDropTransformers[];
     componentInteractions?: InteractionClass[];
     calendarInteractions?: CalendarInteractionClass[];
-    themeClasses?: {
-        [themeSystemName: string]: ThemeClass;
-    };
     eventSourceDefs?: EventSourceDef<any>[];
     cmdFormatter?: CmdFormatterFunc;
     recurringTypes?: RecurringType<any>[];
@@ -1148,6 +942,7 @@ interface PluginDefInput {
     scrollerSyncerClass?: ScrollerSyncerClass;
     listenerRefiners?: GenericListenerRefiners;
     optionRefiners?: GenericRefiners;
+    optionDefaults?: CalendarOptions;
     propSetHandlers?: {
         [propName: string]: (val: any, context: CalendarData) => void;
     };
@@ -1174,9 +969,6 @@ interface PluginHooks {
     eventDropTransformers: EventDropTransformers[];
     componentInteractions: InteractionClass[];
     calendarInteractions: CalendarInteractionClass[];
-    themeClasses: {
-        [themeSystemName: string]: ThemeClass;
-    };
     eventSourceDefs: EventSourceDef<any>[];
     cmdFormatter?: CmdFormatterFunc;
     recurringTypes: RecurringType<any>[];
@@ -1187,6 +979,7 @@ interface PluginHooks {
     scrollerSyncerClass: ScrollerSyncerClass | null;
     listenerRefiners: GenericListenerRefiners;
     optionRefiners: GenericRefiners;
+    optionDefaults: CalendarOptions[];
     propSetHandlers: {
         [propName: string]: (val: any, context: CalendarData) => void;
     };
@@ -1306,12 +1099,10 @@ declare const EVENT_UI_REFINERS: {
     constraint: Identity<any>;
     overlap: Identity<boolean>;
     allow: Identity<AllowFunc>;
-    className: typeof parseClassNames;
-    classNames: typeof parseClassNames;
+    class: Identity<string>;
+    className: Identity<string>;
     color: StringConstructor;
-    backgroundColor: StringConstructor;
-    borderColor: StringConstructor;
-    textColor: StringConstructor;
+    contrastColor: StringConstructor;
 };
 type BuiltInEventUiRefiners = typeof EVENT_UI_REFINERS;
 interface EventUiRefiners extends BuiltInEventUiRefiners {
@@ -1325,10 +1116,9 @@ interface EventUi {
     constraints: Constraint[];
     overlap: boolean | null;
     allows: AllowFunc[];
-    backgroundColor: string;
-    borderColor: string;
-    textColor: string;
-    classNames: string[];
+    color: string;
+    contrastColor: string;
+    className: string;
 }
 type EventUiHash = {
     [defId: string]: EventUi;
@@ -1358,6 +1148,26 @@ type EventDefHash = {
     [defId: string]: EventDef;
 };
 
+declare function guid(): string;
+declare function disableCursor(): void;
+declare function enableCursor(): void;
+declare function preventSelection(el: HTMLElement): void;
+declare function allowSelection(el: HTMLElement): void;
+declare function preventContextMenu(el: HTMLElement): void;
+declare function allowContextMenu(el: HTMLElement): void;
+interface OrderSpec<Subject> {
+    field?: string;
+    order?: number;
+    func?: FieldSpecInputFunc<Subject>;
+}
+type FieldSpecInput<Subject> = string | string[] | FieldSpecInputFunc<Subject> | FieldSpecInputFunc<Subject>[];
+type FieldSpecInputFunc<Subject> = (a: Subject, b: Subject) => number;
+declare function parseFieldSpecs<Subject>(input: FieldSpecInput<Subject>): OrderSpec<Subject>[];
+declare function compareByFieldSpecs<Subject>(obj0: Subject, obj1: Subject, fieldSpecs: OrderSpec<Subject>[]): number;
+declare function flexibleCompare(a: any, b: any): number;
+declare function compareNumbers(a: any, b: any): number;
+declare function valuesIdentical<T>(a: T, b: T): boolean;
+
 interface EventRenderRange extends EventTuple {
     ui: EventUi;
     range: DateRange;
@@ -1375,12 +1185,25 @@ declare function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHa
 declare function hasBgRendering(def: EventDef): boolean;
 declare function getElEventRange(el: HTMLElement): EventRenderRange | null;
 declare function sortEventSegs<S extends EventRangeProps>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
-interface EventContentArg {
+interface MinimalEventProps {
+    eventRange: EventRenderRange;
+    slicedStart?: DateMarker;
+    slicedEnd?: DateMarker;
+    isStart: boolean;
+    isEnd: boolean;
+    isDragging: boolean;
+    isResizing: boolean;
+    isMirror: boolean;
+    isSelected: boolean;
+    isPast: boolean;
+    isFuture: boolean;
+    isToday: boolean;
+}
+interface EventDisplayData {
     event: EventImpl;
     timeText: string;
-    backgroundColor: string;
-    borderColor: string;
-    textColor: string;
+    color: string;
+    contrastColor: string;
     isDraggable: boolean;
     isStartResizable: boolean;
     isEndResizable: boolean;
@@ -1393,9 +1216,18 @@ interface EventContentArg {
     isSelected: boolean;
     isDragging: boolean;
     isResizing: boolean;
+    isInteractive: boolean;
     view: ViewApi;
+    isNarrow: boolean;
+    isShort: boolean;
+    level: number;
+    timeClass: string;
+    titleClass: string;
+    options: {
+        eventOverlap: boolean;
+    };
 }
-type EventMountArg = MountArg<EventContentArg>;
+type EventMountData = MountData<EventDisplayData>;
 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
@@ -1406,12 +1238,11 @@ declare function getEventRangeMeta(eventRange: EventRenderRange, todayRange: Dat
     isToday: boolean;
 };
 declare function buildEventRangeKey(eventRange: EventRenderRange): string;
-declare function getEventRangeAnchorAttrs(eventRange: EventRenderRange, context: ViewContext): {
-    tabIndex: number;
-    onKeyDown(ev: KeyboardEvent): void;
-} | {
-    href: string;
-};
+declare function getEventTagAndAttrs(eventRange: EventRenderRange, context: ViewContext): [
+    tag: string,
+    attrs: any,
+    isInteractive: boolean
+];
 
 interface OpenDateSpanInput {
     start?: DateInput;
@@ -1453,16 +1284,16 @@ declare function isDateSpansEqual(span0: DateSpan, span1: DateSpan): boolean;
 type CssDimValue = string | number;
 declare function getIsHeightAuto(options: {
     height?: CssDimValue;
-    viewHeight?: CssDimValue;
+    contentHeight?: CssDimValue;
 }): boolean;
 declare function getStickyHeaderDates(options: {
     height?: CssDimValue;
-    viewHeight?: CssDimValue;
+    contentHeight?: CssDimValue;
     stickyHeaderDates?: boolean | 'auto';
 }): boolean;
 declare function getStickyFooterScrollbar(options: {
     height?: CssDimValue;
-    viewHeight?: CssDimValue;
+    contentHeight?: CssDimValue;
     stickyFooterScrollbar?: boolean | 'auto';
 }): boolean;
 declare function getScrollerSyncerClass(pluginHooks: {
@@ -1495,11 +1326,11 @@ declare function buildElAttrs(props: ElAttrsProps, className?: string, elRef?: E
 
 type ContentContainerProps<RenderProps> = ElAttrsProps & ContentGeneratorProps<RenderProps> & {
     tag?: string;
-    classNameGenerator: ClassNamesGenerator<RenderProps> | undefined;
-    didMount: ((renderProps: RenderProps & {
+    classNameGenerator?: ClassNameGenerator<RenderProps> | undefined;
+    didMount?: ((renderProps: RenderProps & {
         el: HTMLElement;
     }) => void) | undefined;
-    willUnmount: ((renderProps: RenderProps & {
+    willUnmount?: ((renderProps: RenderProps & {
         el: HTMLElement;
     }) => void) | undefined;
     children?: InnerContainerFunc<RenderProps>;
@@ -1511,43 +1342,65 @@ declare class ContentContainer<RenderProps> extends Component<ContentContainerPr
     el: HTMLElement;
     InnerContent: any;
     render(): ComponentChildren;
-    handleEl: (el: HTMLElement) => void;
+    handleEl: (el: HTMLElement | null) => void;
     componentDidMount(): void;
     componentWillUnmount(): void;
 }
 type InnerContainerComponent = FunctionalComponent<ElProps>;
 type InnerContainerFunc<RenderProps> = (InnerContainer: InnerContainerComponent, renderProps: RenderProps, attrs: ElAttrs) => ComponentChildren;
+declare function generateClassName<RenderProps>(classNameGenerator: ClassNameGenerator<RenderProps> | undefined, renderProps: RenderProps): string;
 declare function renderText(renderProps: {
     text: string;
 }): ComponentChild;
 
-interface NowIndicatorContainerProps extends Partial<ElProps> {
-    isAxis: boolean;
+interface NowIndicatorHeaderContainerProps extends Partial<ElProps> {
     date: DateMarker;
-    children?: InnerContainerFunc<NowIndicatorContentArg>;
+    children?: InnerContainerFunc<NowIndicatorHeaderData>;
 }
-interface NowIndicatorContentArg {
-    isAxis: boolean;
+interface NowIndicatorHeaderData {
     date: Date;
     view: ViewApi;
 }
-type NowIndicatorMountArg = MountArg<NowIndicatorContentArg>;
-declare const NowIndicatorContainer: (props: NowIndicatorContainerProps) => createElement.JSX.Element;
+type NowIndicatorHeaderMountData = MountData<NowIndicatorHeaderData>;
+declare const NowIndicatorHeaderContainer: (props: NowIndicatorHeaderContainerProps) => createElement.JSX.Element;
 
-interface WeekNumberContainerProps extends ElProps {
+interface NowIndicatorLineContainerProps extends Partial<ElProps> {
     date: DateMarker;
-    defaultFormat: DateFormatter;
-    children?: InnerContainerFunc<WeekNumberContentArg>;
+    children?: InnerContainerFunc<NowIndicatorLineData>;
 }
-interface WeekNumberContentArg {
-    num: number;
+interface NowIndicatorLineData {
+    date: Date;
+    view: ViewApi;
+}
+type NowIndicatorLineMountData = MountData<NowIndicatorLineData>;
+declare const NowIndicatorLineContainer: (props: NowIndicatorLineContainerProps) => createElement.JSX.Element;
+
+type DateTimeFormatPartWithWeek = Omit<Intl.DateTimeFormatPart, 'type'> & {
+    type: Intl.DateTimeFormatPart['type'] | 'week';
+};
+interface WeekNumberHeaderData {
+    num?: number;
+    date?: Date;
     text: string;
+    textParts: DateTimeFormatPartWithWeek[];
+    isNarrow: boolean;
+    hasNavLink: boolean;
+    options: {
+        dayMinWidth: number | undefined;
+    };
+}
+type WeekNumberHeaderMountData = MountData<WeekNumberHeaderData>;
+interface InlineWeekNumberData {
+    num: number;
     date: Date;
+    text: string;
+    textParts: DateTimeFormatPartWithWeek[];
+    isNarrow: boolean;
+    hasNavLink: boolean;
 }
-type WeekNumberMountArg = MountArg<WeekNumberContentArg>;
-declare const WeekNumberContainer: (props: WeekNumberContainerProps) => createElement.JSX.Element;
+type InlineWeekNumberMountData = MountData<InlineWeekNumberData>;
 
-interface MoreLinkContainerProps extends Partial<ElProps> {
+interface MoreLinkContainerProps extends Partial<ElAttrsProps> {
     dateProfile: DateProfile;
     todayRange: DateRange;
     allDayDate: DateMarker | null;
@@ -1558,32 +1411,31 @@ interface MoreLinkContainerProps extends Partial<ElProps> {
     alignParentTop?: string;
     forceTimed?: boolean;
     popoverContent: () => ComponentChild;
-    defaultGenerator?: (renderProps: MoreLinkContentArg) => ComponentChild;
-    children?: InnerContainerFunc<MoreLinkContentArg>;
+    isNarrow: boolean;
+    isMicro: boolean;
+    display: 'row' | 'column';
 }
-interface MoreLinkContentArg {
+interface MoreLinkData$1 {
     num: number;
+    numericText: string;
+    longText: string;
     text: string;
-    shortText: string;
+    isNarrow: boolean;
     view: ViewApi;
 }
-type MoreLinkMountArg = MountArg<MoreLinkContentArg>;
+type MoreLinkMountData = MountData<MoreLinkData$1>;
 interface MoreLinkContainerState {
     isPopoverOpen: boolean;
     popoverId: string;
 }
 declare class MoreLinkContainer extends BaseComponent<MoreLinkContainerProps, MoreLinkContainerState> {
     private linkEl;
-    private parentEl;
     state: {
         isPopoverOpen: boolean;
         popoverId: string;
     };
     render(): createElement.JSX.Element;
-    componentDidMount(): void;
-    componentDidUpdate(): void;
     handleLinkEl: (linkEl: HTMLElement | null) => void;
-    updateParentEl(): void;
     handleClick: (ev: MouseEvent) => void;
     handlePopoverClose: () => void;
 }
@@ -1597,7 +1449,7 @@ interface EventSegment {
 }
 type MoreLinkAction = MoreLinkSimpleAction | MoreLinkHandler;
 type MoreLinkSimpleAction = 'popover' | 'week' | 'day' | 'timeGridWeek' | 'timeGridDay' | string;
-interface MoreLinkArg {
+interface MoreLinkData {
     date: Date;
     allDay: boolean;
     allSegs: EventSegment[];
@@ -1605,175 +1457,137 @@ interface MoreLinkArg {
     jsEvent: UIEvent;
     view: ViewApi;
 }
-type MoreLinkHandler = (arg: MoreLinkArg) => MoreLinkSimpleAction | void;
+type MoreLinkHandler = (data: MoreLinkData) => MoreLinkSimpleAction | void;
 
 interface DateMeta {
     dow: number;
+    date: Date;
     isDisabled: boolean;
     isOther: boolean;
     isToday: boolean;
     isPast: boolean;
     isFuture: boolean;
 }
-declare function getDateMeta(date: DateMarker, todayRange?: DateRange, nowDate?: DateMarker, dateProfile?: DateProfile): DateMeta;
-declare function getDayClassName(meta: DateMeta): string;
-declare function getSlotClassName(meta: DateMeta): string;
+declare function getDateMeta(dateMarker: DateMarker, dateEnv: DateEnv, dateProfile?: DateProfile, todayRange?: DateRange, nowDate?: DateMarker): DateMeta;
 
-interface SlotLaneContentArg extends Partial<DateMeta> {
+interface SlotLaneData extends DateMeta {
     time?: Duration;
-    date?: Date;
+    isMajor: boolean;
+    isMinor: boolean;
     view: ViewApi;
 }
-type SlotLaneMountArg = MountArg<SlotLaneContentArg>;
-interface SlotLabelContentArg {
+type SlotLaneMountData = MountData<SlotLaneData>;
+interface SlotHeaderData extends SlotLaneData {
     level: number;
-    time: Duration;
-    date: Date;
-    view: ViewApi;
+    isTime: boolean;
     text: string;
+    isNarrow: boolean;
+    hasNavLink: boolean;
+    isFirst: boolean;
 }
-type SlotLabelMountArg = MountArg<SlotLabelContentArg>;
-interface AllDayContentArg {
+type SlotHeaderMountData = MountData<SlotHeaderData>;
+interface AllDayHeaderData {
     text: string;
     view: ViewApi;
+    isNarrow: boolean;
 }
-type AllDayMountArg = MountArg<AllDayContentArg>;
-interface DayHeaderContentArg extends DateMeta {
+type AllDayHeaderMountData = MountData<AllDayHeaderData>;
+interface DayHeaderData extends DateMeta {
     date: Date;
+    isNarrow: boolean;
+    isMajor: boolean;
+    inPopover: boolean;
+    hasNavLink: boolean;
+    level: number;
     text: string;
+    textParts: Intl.DateTimeFormatPart[];
+    weekdayText: string;
+    dayNumberText: string;
     view: ViewApi;
     [otherProp: string]: any;
 }
-type DayHeaderMountArg = MountArg<DayHeaderContentArg>;
-
-interface DayCellContentArg extends DateMeta {
+type DayHeaderMountData = MountData<DayHeaderData>;
+interface DayCellData extends DateMeta {
     date: DateMarker;
+    isMajor: boolean;
+    isNarrow: boolean;
+    inPopover: boolean;
+    hasNavLink: boolean;
     view: ViewApi;
+    text: string;
+    textParts: Intl.DateTimeFormatPart[];
     dayNumberText: string;
+    monthText: string;
+    options: {
+        businessHours: boolean;
+    };
     [extraProp: string]: any;
 }
-type DayCellMountArg = MountArg<DayCellContentArg>;
-interface DayCellContainerProps extends Partial<ElProps> {
-    date: DateMarker;
-    dateProfile: DateProfile;
-    todayRange: DateRange;
-    isMonthStart?: boolean;
-    showDayNumber?: boolean;
-    renderProps?: Dictionary;
-    defaultGenerator?: (renderProps: DayCellContentArg) => ComponentChild;
-    children?: InnerContainerFunc<DayCellContentArg>;
-}
-declare class DayCellContainer extends BaseComponent<DayCellContainerProps> {
-    refineRenderProps: (arg: DayCellRenderPropsInput) => DayCellContentArg;
-    render(): createElement.JSX.Element;
-}
-declare function hasCustomDayCellContent(options: ViewOptions): boolean;
-interface DayCellRenderPropsInput {
+type DayCellMountData = MountData<DayCellData>;
+
+interface DayLaneData extends DateMeta {
     date: DateMarker;
-    dateProfile: DateProfile;
-    todayRange: DateRange;
-    dateEnv: DateEnv;
-    viewApi: ViewApi;
-    monthStartFormat: DateFormatter;
-    isMonthStart: boolean;
-    showDayNumber?: boolean;
-    renderProps?: Dictionary;
+    isNarrow: boolean;
+    isStack: boolean;
+    isMajor: boolean;
+    view: ViewApi;
+    [extraProp: string]: any;
 }
+type DayLaneMountData = MountData<DayLaneData>;
 
 interface ViewContainerProps extends Partial<ElProps> {
     viewSpec: ViewSpec;
+    attrs?: any;
     children: ComponentChildren;
+    borderlessX: boolean;
+    borderlessTop: boolean;
+    borderlessBottom: boolean;
+    noEdgeEffects: boolean;
 }
-interface ViewContentArg {
+interface ViewDisplayData {
     view: ViewApi;
 }
-type ViewMountArg = MountArg<ViewContentArg>;
+type ViewMountData = MountData<ViewDisplayData>;
 declare class ViewContainer extends BaseComponent<ViewContainerProps> {
     render(): createElement.JSX.Element;
 }
 
-interface EventClickArg {
+interface EventClickData {
     el: HTMLElement;
     event: EventImpl;
     jsEvent: MouseEvent;
     view: ViewApi;
 }
 
-interface EventHoveringArg {
+interface EventHoveringData {
     el: HTMLElement;
     event: EventImpl;
     jsEvent: MouseEvent;
     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 & {
+type DatesSetData = RangeApiWithTimeZone & {
     view: ViewApi;
 };
 
-interface EventAddArg {
+interface EventAddData {
     event: EventImpl;
     relatedEvents: EventImpl[];
     revert: () => void;
 }
-interface EventChangeArg {
+interface EventChangeData {
     oldEvent: EventImpl;
     event: EventImpl;
     relatedEvents: EventImpl[];
     revert: () => void;
 }
-interface EventDropArg extends EventChangeArg {
+interface EventDropData extends EventChangeData {
     el: HTMLElement;
     delta: Duration;
     jsEvent: MouseEvent;
     view: ViewApi$1;
 }
-interface EventRemoveArg {
+interface EventRemoveData {
     event: EventImpl;
     relatedEvents: EventImpl[];
     revert: () => void;
@@ -1801,6 +1615,22 @@ declare class CustomRenderingStore<RenderProps> extends Store<Map<string, Custom
     handle(customRendering: CustomRendering<RenderProps>): void;
 }
 
+interface ButtonState {
+    text: string;
+    hint: string;
+}
+interface NavButtonState extends ButtonState {
+    isDisabled: boolean;
+}
+interface ButtonStateMap {
+    today: NavButtonState;
+    prev: NavButtonState;
+    next: NavButtonState;
+    prevYear: NavButtonState;
+    nextYear: NavButtonState;
+    [availableView: string]: ButtonState;
+}
+
 interface EventApi {
     source: EventSourceApi | null;
     start: Date | null;
@@ -1818,10 +1648,9 @@ interface EventApi {
     constraint: any;
     overlap: boolean;
     allow: any;
-    backgroundColor: string;
-    borderColor: string;
-    textColor: string;
-    classNames: string[];
+    color: string;
+    contrastColor: string;
+    className: string;
     extendedProps: Dictionary;
     setProp(name: string, val: any): void;
     setExtendedProp(name: string, val: any): void;
@@ -1846,7 +1675,6 @@ interface EventApi {
     remove(): void;
     toPlainObject(settings?: {
         collapseExtendedProps?: boolean;
-        collapseColor?: boolean;
     }): Dictionary;
     toJSON(): Dictionary;
 }
@@ -1887,15 +1715,64 @@ interface CalendarApi {
     scrollToTime(timeInput: DurationInput): void;
 }
 
+declare class CalendarController {
+    private handleDateChange;
+    private calendarApi?;
+    constructor(handleDateChange: () => void);
+    today(): void;
+    prev(): void;
+    next(): void;
+    prevYear(): void;
+    nextYear(): void;
+    gotoDate(zonedDateInput: DateInput): void;
+    incrementDate(duration: DurationInput): void;
+    changeView(viewType: string): void;
+    get view(): ViewApi | undefined;
+    getDate(): Date | undefined;
+    getButtonState(): ButtonStateMap;
+    _setApi(calendarApi: CalendarApi | undefined): void;
+}
+
+type TableHeaderData = {
+    isSticky: boolean;
+};
+
 declare const BASE_OPTION_REFINERS: {
     navLinkDayClick: Identity<string | ((this: CalendarApi, date: Date, jsEvent: UIEvent) => void)>;
     navLinkWeekClick: Identity<string | ((this: CalendarApi, weekStart: Date, jsEvent: UIEvent) => void)>;
     duration: typeof createDuration;
-    bootstrapFontAwesome: Identity<false | ButtonIconsInput>;
-    buttonIcons: Identity<false | ButtonIconsInput>;
-    customButtons: Identity<{
-        [name: string]: CustomButtonInput;
+    buttons: Identity<{
+        [buttonName: string]: ButtonInput;
+        today?: ButtonInput;
+        prev?: ButtonInput;
+        next?: ButtonInput;
+        prevYear?: ButtonInput;
+        nextYear?: ButtonInput;
+        year?: ButtonInput;
+        month?: ButtonInput;
+        week?: ButtonInput;
+        day?: ButtonInput;
     }>;
+    toolbarElements: Identity<{
+        [elementName: string]: ToolbarElementInput;
+    }>;
+    prevText: StringConstructor;
+    nextText: StringConstructor;
+    prevYearText: StringConstructor;
+    nextYearText: StringConstructor;
+    todayText: StringConstructor;
+    yearText: StringConstructor;
+    monthText: StringConstructor;
+    weekText: StringConstructor;
+    weekTextShort: StringConstructor;
+    dayText: StringConstructor;
+    listText: Identity<string | false>;
+    todayHint: Identity<string | ((currentUnitText: string, currentUnit: string) => string)>;
+    prevHint: Identity<string | ((currentUnitText: string, currentUnit: string) => string)>;
+    nextHint: Identity<string | ((currentUnitText: string, currentUnit: string) => string)>;
+    buttonDisplay: Identity<ButtonDisplay>;
+    buttonGroupClass: Identity<ClassNameGenerator<ButtonGroupData>>;
+    buttonClass: Identity<ClassNameGenerator<ButtonData>>;
     defaultAllDayEventDuration: typeof createDuration;
     defaultTimedEventDuration: typeof createDuration;
     nextDayThreshold: typeof createDuration;
@@ -1911,34 +1788,39 @@ declare const BASE_OPTION_REFINERS: {
     defaultRangeSeparator: StringConstructor;
     titleRangeSeparator: StringConstructor;
     forceEventDuration: BooleanConstructor;
-    dayHeaders: BooleanConstructor;
-    dayHeaderFormat: typeof createFormatter;
-    dayHeaderClassNames: Identity<ClassNamesGenerator<DayHeaderContentArg>>;
-    dayHeaderContent: Identity<CustomContentGenerator<DayHeaderContentArg>>;
-    dayHeaderDidMount: Identity<DidMountHandler<DayHeaderMountArg>>;
-    dayHeaderWillUnmount: Identity<WillUnmountHandler<DayHeaderMountArg>>;
-    dayCellClassNames: Identity<ClassNamesGenerator<DayCellContentArg>>;
-    dayCellContent: Identity<CustomContentGenerator<DayCellContentArg>>;
-    dayCellDidMount: Identity<DidMountHandler<DayCellMountArg>>;
-    dayCellWillUnmount: Identity<WillUnmountHandler<DayCellMountArg>>;
+    dayLaneClass: Identity<ClassNameGenerator<DayLaneData>>;
+    dayLaneInnerClass: Identity<ClassNameGenerator<DayLaneData>>;
+    dayLaneDidMount: Identity<DidMountHandler<DayLaneMountData>>;
+    dayLaneWillUnmount: Identity<WillUnmountHandler<DayLaneMountData>>;
     initialView: StringConstructor;
     aspectRatio: NumberConstructor;
     weekends: BooleanConstructor;
     weekNumberCalculation: Identity<WeekNumberCalculation>;
     weekNumbers: BooleanConstructor;
-    weekNumberClassNames: Identity<ClassNamesGenerator<WeekNumberContentArg>>;
-    weekNumberContent: Identity<CustomContentGenerator<WeekNumberContentArg>>;
-    weekNumberDidMount: Identity<DidMountHandler<WeekNumberMountArg>>;
-    weekNumberWillUnmount: Identity<WillUnmountHandler<WeekNumberMountArg>>;
+    weekNumberHeaderClass: Identity<ClassNameGenerator<WeekNumberHeaderData>>;
+    weekNumberHeaderInnerClass: Identity<ClassNameGenerator<WeekNumberHeaderData>>;
+    weekNumberHeaderContent: Identity<CustomContentGenerator<WeekNumberHeaderData>>;
+    weekNumberHeaderDidMount: Identity<DidMountHandler<WeekNumberHeaderMountData>>;
+    weekNumberHeaderWillUnmount: Identity<WillUnmountHandler<WeekNumberHeaderMountData>>;
+    inlineWeekNumberClass: Identity<ClassNameGenerator<InlineWeekNumberData>>;
+    inlineWeekNumberContent: Identity<CustomContentGenerator<InlineWeekNumberData>>;
+    inlineWeekNumberDidMount: Identity<DidMountHandler<InlineWeekNumberMountData>>;
+    inlineWeekNumberWillUnmount: Identity<WillUnmountHandler<InlineWeekNumberMountData>>;
     editable: BooleanConstructor;
-    viewClassNames: Identity<ClassNamesGenerator<ViewContentArg>>;
-    viewDidMount: Identity<DidMountHandler<ViewMountArg>>;
-    viewWillUnmount: Identity<WillUnmountHandler<ViewMountArg>>;
+    controller: Identity<CalendarController>;
+    viewClass: Identity<ClassNameGenerator<ViewDisplayData>>;
+    viewDidMount: Identity<DidMountHandler<ViewMountData>>;
+    viewWillUnmount: Identity<WillUnmountHandler<ViewMountData>>;
     nowIndicator: BooleanConstructor;
-    nowIndicatorClassNames: Identity<ClassNamesGenerator<NowIndicatorContentArg>>;
-    nowIndicatorContent: Identity<CustomContentGenerator<NowIndicatorContentArg>>;
-    nowIndicatorDidMount: Identity<DidMountHandler<NowIndicatorMountArg>>;
-    nowIndicatorWillUnmount: Identity<WillUnmountHandler<NowIndicatorMountArg>>;
+    nowIndicatorHeaderClass: Identity<ClassNameGenerator<NowIndicatorHeaderData>>;
+    nowIndicatorHeaderContent: Identity<CustomContentGenerator<NowIndicatorHeaderData>>;
+    nowIndicatorHeaderDidMount: Identity<DidMountHandler<NowIndicatorHeaderMountData>>;
+    nowIndicatorHeaderWillUnmount: Identity<WillUnmountHandler<NowIndicatorHeaderMountData>>;
+    nowIndicatorDotClass: Identity<string>;
+    nowIndicatorLineClass: Identity<ClassNameGenerator<NowIndicatorLineData>>;
+    nowIndicatorLineContent: Identity<CustomContentGenerator<NowIndicatorLineData>>;
+    nowIndicatorLineDidMount: Identity<DidMountHandler<NowIndicatorLineMountData>>;
+    nowIndicatorLineWillUnmount: Identity<WillUnmountHandler<NowIndicatorLineMountData>>;
     showNonCurrentDates: BooleanConstructor;
     lazyFetching: BooleanConstructor;
     startParam: StringConstructor;
@@ -1947,7 +1829,6 @@ declare const BASE_OPTION_REFINERS: {
     timeZone: StringConstructor;
     locales: Identity<LocaleInput[]>;
     locale: Identity<LocaleSingularArg>;
-    themeSystem: Identity<string>;
     dragRevertDuration: NumberConstructor;
     dragScroll: BooleanConstructor;
     allDayMaintainDuration: BooleanConstructor;
@@ -1966,8 +1847,6 @@ declare const BASE_OPTION_REFINERS: {
     eventResizableFromStart: BooleanConstructor;
     displayEventTime: BooleanConstructor;
     displayEventEnd: BooleanConstructor;
-    weekText: StringConstructor;
-    weekTextLong: StringConstructor;
     progressiveEventRendering: BooleanConstructor;
     businessHours: Identity<BusinessHoursInput>;
     initialDate: Identity<DateInput>;
@@ -1975,7 +1854,6 @@ declare const BASE_OPTION_REFINERS: {
     eventDataTransform: Identity<EventInputTransformer>;
     stickyHeaderDates: Identity<boolean | "auto">;
     stickyFooterScrollbar: Identity<boolean | "auto">;
-    viewHeight: Identity<CssDimValue>;
     defaultAllDay: BooleanConstructor;
     eventSourceFailure: Identity<(this: CalendarApi, error: any) => void>;
     eventSourceSuccess: Identity<(this: CalendarApi, eventsInput: EventInput[], response?: Response) => EventInput[] | void>;
@@ -1985,37 +1863,159 @@ declare const BASE_OPTION_REFINERS: {
     eventOverlap: Identity<boolean | OverlapFunc>;
     eventConstraint: Identity<ConstraintInput>;
     eventAllow: Identity<AllowFunc>;
-    eventBackgroundColor: StringConstructor;
-    eventBorderColor: StringConstructor;
-    eventTextColor: StringConstructor;
     eventColor: StringConstructor;
-    eventClassNames: Identity<ClassNamesGenerator<EventContentArg>>;
-    eventContent: Identity<CustomContentGenerator<EventContentArg>>;
-    eventDidMount: Identity<DidMountHandler<EventMountArg>>;
-    eventWillUnmount: Identity<WillUnmountHandler<EventMountArg>>;
+    eventContrastColor: StringConstructor;
+    eventDidMount: Identity<DidMountHandler<EventMountData>>;
+    eventWillUnmount: Identity<WillUnmountHandler<EventMountData>>;
+    eventContent: Identity<CustomContentGenerator<EventDisplayData>>;
+    backgroundEventColor: StringConstructor;
+    eventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    eventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    eventTimeClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    eventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    eventBeforeClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    eventAfterClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    listItemEventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    listItemEventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    listItemEventTimeClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    listItemEventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+        timeText: string;
+    }>>;
+    listItemEventBeforeClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    listItemEventAfterClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    blockEventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    blockEventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    blockEventTimeClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    blockEventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    blockEventBeforeClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    blockEventAfterClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    rowEventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    rowEventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    rowEventTimeClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    rowEventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    rowEventTitleSticky: BooleanConstructor;
+    rowEventBeforeClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    rowEventBeforeContent: Identity<CustomContentGenerator<EventDisplayData>>;
+    rowEventAfterClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    rowEventAfterContent: Identity<CustomContentGenerator<EventDisplayData>>;
+    columnEventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    columnEventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    columnEventTimeClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    columnEventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
+    columnEventTitleSticky: BooleanConstructor;
+    columnEventBeforeClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    columnEventAfterClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    backgroundEventClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    backgroundEventInnerClass: Identity<ClassNameGenerator<EventDisplayData>>;
+    backgroundEventTitleClass: Identity<ClassNameGenerator<{
+        event: EventApi;
+        isNarrow: boolean;
+        isShort: boolean;
+    }>>;
     selectConstraint: Identity<ConstraintInput>;
     selectOverlap: Identity<boolean | OverlapFunc>;
     selectAllow: Identity<AllowFunc>;
     droppable: BooleanConstructor;
     unselectCancel: StringConstructor;
-    slotLabelFormat: Identity<FormatterInput | FormatterInput[]>;
-    slotLaneClassNames: Identity<ClassNamesGenerator<SlotLaneContentArg>>;
-    slotLaneContent: Identity<CustomContentGenerator<SlotLaneContentArg>>;
-    slotLaneDidMount: Identity<DidMountHandler<SlotLaneMountArg>>;
-    slotLaneWillUnmount: Identity<WillUnmountHandler<SlotLaneMountArg>>;
-    slotLabelClassNames: Identity<ClassNamesGenerator<SlotLabelContentArg>>;
-    slotLabelContent: Identity<CustomContentGenerator<SlotLabelContentArg>>;
-    slotLabelDidMount: Identity<DidMountHandler<SlotLabelMountArg>>;
-    slotLabelWillUnmount: Identity<WillUnmountHandler<SlotLabelMountArg>>;
+    slotHeaderFormat: Identity<FormatterInput | FormatterInput[]>;
+    slotLaneClass: Identity<ClassNameGenerator<SlotLaneData>>;
+    slotLaneDidMount: Identity<DidMountHandler<SlotLaneMountData>>;
+    slotLaneWillUnmount: Identity<WillUnmountHandler<SlotLaneMountData>>;
+    slotHeaderClass: Identity<ClassNameGenerator<SlotHeaderData>>;
+    slotHeaderInnerClass: Identity<ClassNameGenerator<SlotHeaderData>>;
+    slotHeaderContent: Identity<CustomContentGenerator<SlotHeaderData>>;
+    slotHeaderDidMount: Identity<DidMountHandler<SlotHeaderMountData>>;
+    slotHeaderWillUnmount: Identity<WillUnmountHandler<SlotHeaderMountData>>;
+    slotHeaderAlign: Identity<"start" | "end" | "center" | ((data: {
+        level: number;
+        isTime: boolean;
+    }) => 'start' | 'center' | 'end')>;
+    slotHeaderSticky: Identity<string | number | boolean>;
+    slotHeaderRowClass: Identity<string>;
+    slotHeaderDividerClass: Identity<ClassNameGenerator<{
+        isHeader: boolean;
+        options: {
+            dayMinWidth: number | undefined;
+        };
+    }>>;
     dayMaxEvents: Identity<number | boolean>;
     dayMaxEventRows: Identity<number | boolean>;
     dayMinWidth: NumberConstructor;
-    slotLabelInterval: typeof createDuration;
+    slotHeaderInterval: typeof createDuration;
+    dayHeaderClass: Identity<ClassNameGenerator<DayHeaderData>>;
+    dayHeaderInnerClass: Identity<ClassNameGenerator<DayHeaderData>>;
+    dayHeaderContent: Identity<CustomContentGenerator<DayHeaderData>>;
+    dayHeaderDidMount: Identity<DidMountHandler<DayHeaderMountData>>;
+    dayHeaderWillUnmount: Identity<WillUnmountHandler<DayHeaderMountData>>;
+    dayHeaderAlign: Identity<"start" | "end" | "center" | ((data: {
+        level: number;
+        inPopover: boolean;
+        isNarrow: boolean;
+    }) => 'start' | 'center' | 'end')>;
+    dayHeaderSticky: Identity<string | number | boolean>;
+    dayHeaderRowClass: Identity<string>;
+    dayHeaderDividerClass: Identity<ClassNameGenerator<{
+        isSticky: boolean;
+        options: {
+            allDaySlot: boolean;
+        };
+    }>>;
+    dayRowClass: Identity<string>;
+    dayCellDidMount: Identity<DidMountHandler<DayCellMountData>>;
+    dayCellWillUnmount: Identity<WillUnmountHandler<DayCellMountData>>;
+    dayCellClass: Identity<ClassNameGenerator<DayCellData>>;
+    dayCellInnerClass: Identity<ClassNameGenerator<DayCellData>>;
+    dayCellTopContent: Identity<CustomContentGenerator<DayCellData>>;
+    dayCellTopClass: Identity<ClassNameGenerator<DayCellData>>;
+    dayCellTopInnerClass: Identity<ClassNameGenerator<DayCellData>>;
+    dayCellBottomClass: Identity<ClassNameGenerator<DayCellData>>;
+    allDaySlot: BooleanConstructor;
     allDayText: StringConstructor;
-    allDayClassNames: Identity<ClassNamesGenerator<AllDayContentArg>>;
-    allDayContent: Identity<CustomContentGenerator<AllDayContentArg>>;
-    allDayDidMount: Identity<DidMountHandler<AllDayMountArg>>;
-    allDayWillUnmount: Identity<WillUnmountHandler<AllDayMountArg>>;
+    allDayHeaderClass: Identity<ClassNameGenerator<AllDayHeaderData>>;
+    allDayHeaderInnerClass: Identity<ClassNameGenerator<AllDayHeaderData>>;
+    allDayHeaderContent: Identity<CustomContentGenerator<AllDayHeaderData>>;
+    allDayHeaderDidMount: Identity<DidMountHandler<AllDayHeaderMountData>>;
+    allDayHeaderWillUnmount: Identity<WillUnmountHandler<AllDayHeaderMountData>>;
+    timedText: StringConstructor;
     slotMinWidth: NumberConstructor;
     navLinks: BooleanConstructor;
     eventTimeFormat: typeof createFormatter;
@@ -2044,29 +2044,61 @@ declare const BASE_OPTION_REFINERS: {
     titleFormat: Identity<FormatterInput>;
     eventInteractive: BooleanConstructor;
     noEventsText: StringConstructor;
-    viewHint: Identity<string | ((...args: any[]) => string)>;
-    navLinkHint: Identity<string | ((...args: any[]) => string)>;
+    viewHint: Identity<string | ((viewButtonText: string, viewName: string) => string)>;
+    viewChangeHint: StringConstructor;
+    navLinkHint: Identity<string | ((dateText: string, date: Date) => string)>;
     closeHint: StringConstructor;
-    timeHint: StringConstructor;
-    eventHint: StringConstructor;
+    eventsHint: StringConstructor;
+    headingLevel: NumberConstructor;
     moreLinkClick: Identity<MoreLinkAction>;
-    moreLinkClassNames: Identity<ClassNamesGenerator<MoreLinkContentArg>>;
-    moreLinkContent: Identity<CustomContentGenerator<MoreLinkContentArg>>;
-    moreLinkDidMount: Identity<DidMountHandler<MoreLinkMountArg>>;
-    moreLinkWillUnmount: Identity<WillUnmountHandler<MoreLinkMountArg>>;
+    moreLinkContent: Identity<CustomContentGenerator<MoreLinkData$1>>;
+    moreLinkDidMount: Identity<DidMountHandler<MoreLinkMountData>>;
+    moreLinkWillUnmount: Identity<WillUnmountHandler<MoreLinkMountData>>;
+    moreLinkClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    moreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    rowMoreLinkClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    rowMoreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    columnMoreLinkClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    columnMoreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkData$1>>;
+    navLinkClass: Identity<string>;
     monthStartFormat: typeof createFormatter;
+    dayCellFormat: typeof createFormatter;
     handleCustomRendering: Identity<CustomRenderingHandler<any>>;
     customRenderingMetaMap: Identity<{
         [optionName: string]: any;
     }>;
     customRenderingReplaces: BooleanConstructor;
+    class: Identity<string>;
+    className: Identity<string>;
+    popoverClass: Identity<string>;
+    popoverCloseClass: Identity<string>;
+    popoverCloseContent: Identity<CustomContentGenerator<{}>>;
+    dayNarrowWidth: NumberConstructor;
+    borderless: BooleanConstructor;
+    borderlessX: BooleanConstructor;
+    borderlessTop: BooleanConstructor;
+    borderlessBottom: BooleanConstructor;
+    fillerClass: Identity<ClassNameGenerator<{
+        isHeader: boolean;
+    }>>;
+    headerToolbarClass: Identity<ClassNameGenerator<ToolbarData>>;
+    footerToolbarClass: Identity<ClassNameGenerator<ToolbarData>>;
+    toolbarClass: Identity<ClassNameGenerator<ToolbarData>>;
+    toolbarSectionClass: Identity<ClassNameGenerator<ToolbarSectionData>>;
+    toolbarTitleClass: Identity<string>;
+    tableClass: Identity<string>;
+    tableHeaderClass: Identity<ClassNameGenerator<TableHeaderData>>;
+    tableBodyClass: Identity<string>;
+    nonBusinessClass: Identity<string>;
+    highlightClass: Identity<string>;
 };
-type BuiltInBaseOptionRefiners = typeof BASE_OPTION_REFINERS;
-interface BaseOptionRefiners extends BuiltInBaseOptionRefiners {
+type BaseOptionRefiners = typeof BASE_OPTION_REFINERS;
+interface BaseOptions extends RawOptionsFromRefiners<BaseOptionRefiners> {
+}
+interface BaseOptionsRefined extends RefinedOptionsFromRefiners<BaseOptionRefiners> {
 }
-type BaseOptions = RawOptionsFromRefiners<// as RawOptions
-Required<BaseOptionRefiners>>;
 declare const BASE_OPTION_DEFAULTS: {
+    buttonDisplay: string;
     eventDisplay: string;
     defaultRangeSeparator: string;
     titleRangeSeparator: string;
@@ -2076,14 +2108,8 @@ declare const BASE_OPTION_DEFAULTS: {
     };
     forceEventDuration: boolean;
     nextDayThreshold: string;
-    dayHeaders: boolean;
     initialView: string;
     aspectRatio: number;
-    headerToolbar: {
-        start: string;
-        center: string;
-        end: string;
-    };
     weekends: boolean;
     weekNumbers: boolean;
     weekNumberCalculation: WeekNumberCalculation;
@@ -2101,7 +2127,6 @@ declare const BASE_OPTION_DEFAULTS: {
     timeZone: string;
     locales: any[];
     locale: string;
-    themeSystem: string;
     dragRevertDuration: number;
     dragScroll: boolean;
     allDayMaintainDuration: boolean;
@@ -2125,20 +2150,31 @@ declare const BASE_OPTION_DEFAULTS: {
         month: string;
         day: string;
     };
+    dayCellFormat: {
+        day: string;
+    };
+    headingLevel: number;
+    outerBorder: boolean;
+    dayNarrowWidth: number;
+    eventOverlap: boolean;
+    slotHeaderAlign: string;
+    slotHeaderSticky: boolean;
+    dayHeaderAlign: string;
+    dayHeaderSticky: boolean;
+    rowEventTitleSticky: boolean;
+    columnEventTitleSticky: boolean;
 };
-type BaseOptionsRefined = DefaultedRefinedOptions<RefinedOptionsFromRefiners<Required<BaseOptionRefiners>>, // Required is a hack for "Index signature is missing"
-keyof typeof BASE_OPTION_DEFAULTS>;
 declare const CALENDAR_LISTENER_REFINERS: {
-    datesSet: Identity<(arg: DatesSetArg) => void>;
+    datesSet: Identity<(data: DatesSetData) => void>;
     eventsSet: Identity<(events: EventApi[]) => void>;
-    eventAdd: Identity<(arg: EventAddArg) => void>;
-    eventChange: Identity<(arg: EventChangeArg) => void>;
-    eventRemove: Identity<(arg: EventRemoveArg) => void>;
-    eventClick: Identity<(arg: EventClickArg) => void>;
-    eventMouseEnter: Identity<(arg: EventHoveringArg) => void>;
-    eventMouseLeave: Identity<(arg: EventHoveringArg) => void>;
-    select: Identity<(arg: DateSelectArg) => void>;
-    unselect: Identity<(arg: DateUnselectArg) => void>;
+    eventAdd: Identity<(data: EventAddData) => void>;
+    eventChange: Identity<(data: EventChangeData) => void>;
+    eventRemove: Identity<(data: EventRemoveData) => void>;
+    eventClick: Identity<(data: EventClickData) => void>;
+    eventMouseEnter: Identity<(data: EventHoveringData) => void>;
+    eventMouseLeave: Identity<(data: EventHoveringData) => void>;
+    select: Identity<(data: DateSelectData) => void>;
+    unselect: Identity<(data: DateUnselectData) => void>;
     loading: Identity<(isLoading: boolean) => void>;
     _unmount: Identity<() => void>;
     _beforeprint: Identity<() => void>;
@@ -2147,14 +2183,12 @@ declare const CALENDAR_LISTENER_REFINERS: {
     _noEventResize: Identity<() => void>;
     _timeScrollRequest: Identity<(time: Duration) => void>;
 };
-type BuiltInCalendarListenerRefiners = typeof CALENDAR_LISTENER_REFINERS;
-interface CalendarListenerRefiners extends BuiltInCalendarListenerRefiners {
-}
-type CalendarListenersLoose = RefinedOptionsFromRefiners<Required<CalendarListenerRefiners>>;
-type CalendarListeners = Required<CalendarListenersLoose>;
-declare const CALENDAR_OPTION_REFINERS: {
-    buttonText: Identity<ButtonTextCompoundInput>;
-    buttonHints: Identity<ButtonHintCompoundInput>;
+type CalendarListenerRefiners = typeof CALENDAR_LISTENER_REFINERS;
+interface CalendarListeners extends RawOptionsFromRefiners<CalendarListenerRefiners> {
+}
+interface CalendarListenersRefined extends RefinedOptionsFromRefiners<CalendarListenerRefiners> {
+}
+declare const CALENDAR_ONLY_OPTION_REFINERS: {
     views: Identity<{
         [viewId: string]: ViewOptions;
     }>;
@@ -2163,19 +2197,19 @@ declare const CALENDAR_OPTION_REFINERS: {
     events: Identity<EventSourceInput>;
     eventSources: Identity<EventSourceInput[]>;
 };
-type BuiltInCalendarOptionRefiners = typeof CALENDAR_OPTION_REFINERS;
-interface CalendarOptionRefiners extends BuiltInCalendarOptionRefiners {
-}
-type CalendarOptions = BaseOptions & CalendarListenersLoose & RawOptionsFromRefiners<Required<CalendarOptionRefiners>>;
-type CalendarOptionsRefined = BaseOptionsRefined & CalendarListenersLoose & RefinedOptionsFromRefiners<Required<CalendarOptionRefiners>>;
-declare const VIEW_OPTION_REFINERS: {
+type CalendarOnlyOptionRefiners = typeof CALENDAR_ONLY_OPTION_REFINERS;
+type CalendarOnlyOptions = RawOptionsFromRefiners<CalendarOnlyOptionRefiners>;
+type CalendarOnlyOptionsRefined = RefinedOptionsFromRefiners<CalendarOnlyOptionRefiners>;
+declare const VIEW_ONLY_OPTION_REFINERS: {
     [name: string]: any;
 };
-type BuiltInViewOptionRefiners = typeof VIEW_OPTION_REFINERS;
-interface ViewOptionRefiners extends BuiltInViewOptionRefiners {
-}
-type ViewOptions = BaseOptions & CalendarListenersLoose & RawOptionsFromRefiners<Required<ViewOptionRefiners>>;
-type ViewOptionsRefined = BaseOptionsRefined & CalendarListenersLoose & RefinedOptionsFromRefiners<Required<ViewOptionRefiners>>;
+type ViewOnlyRefiners = typeof VIEW_ONLY_OPTION_REFINERS;
+type ViewOnlyOptions = RawOptionsFromRefiners<ViewOnlyRefiners>;
+type ViewOnlyOptionsRefined = RefinedOptionsFromRefiners<ViewOnlyRefiners>;
+type ViewOptions = BaseOptions & CalendarListeners & ViewOnlyOptions;
+type ViewOptionsRefined = BaseOptionsRefined & CalendarListenersRefined & ViewOnlyOptionsRefined;
+type CalendarOptions = BaseOptions & CalendarListeners & CalendarOnlyOptions;
+type CalendarOptionsRefined = BaseOptionsRefined & CalendarListenersRefined & CalendarOnlyOptionsRefined;
 declare function refineProps<Refiners extends GenericRefiners, Raw extends RawOptionsFromRefiners<Refiners>>(input: Raw, refiners: Refiners): {
     refined: RefinedOptionsFromRefiners<Refiners>;
     extra: Dictionary;
@@ -2192,29 +2226,64 @@ type RawOptionsFromRefiners<Refiners extends GenericRefiners> = {
 type RefinedOptionsFromRefiners<Refiners extends GenericRefiners> = {
     [Prop in keyof Refiners]?: Refiners[Prop] extends ((input: any) => infer RefinedType) ? RefinedType : never;
 };
-type DefaultedRefinedOptions<RefinedOptions extends Dictionary, DefaultKey extends keyof RefinedOptions> = Required<Pick<RefinedOptions, DefaultKey>> & Partial<Omit<RefinedOptions, DefaultKey>>;
 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]>;
+
+type ClassValue = string | undefined | null | false | number;
+declare function joinArrayishClassNames(...args: (ClassValue | ClassValue[])[]): string;
+declare function joinClassNames(...args: ClassValue[]): string;
+declare function fracToCssDim(frac: number): string;
+
 declare function computeVisibleDayRange(timedRange: OpenDateRange, nextDayThreshold?: Duration): OpenDateRange;
 declare function diffDates(date0: DateMarker, date1: DateMarker, dateEnv: DateEnv, largeUnit?: string): Duration;
 
-declare function removeExact(array: any, exactVal: any): number;
-declare function isArraysEqual(a0: any, a1: any, equalityFunc?: (v0: any, v1: any) => boolean): boolean;
+declare const FULL_DATE_FORMAT: _full_ui_headless_calendar.DateFormatter;
+declare const WEEKDAY_ONLY_FORMAT: _full_ui_headless_calendar.DateFormatter;
+declare function findWeekdayText(parts: Intl.DateTimeFormatPart[]): string;
+declare function findDayNumberText(parts: Intl.DateTimeFormatPart[]): string;
+declare function findMonthText(parts: Intl.DateTimeFormatPart[]): string;
+
+declare function removeExact(array: any[], exactItem: any): number;
+declare function isArraysEqual(array0: any[], array1: any[], itemsEqual?: typeof valuesIdentical): boolean;
 
 declare function memoize<Args extends any[], Res>(workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): (...args: Args) => Res;
 declare function memoizeObjArg<Arg extends Dictionary, Res>(workerFunc: (arg: Arg) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): (arg: Arg) => Res;
-type MemoiseArrayFunc<Args extends any[], Res> = (argSets: Args[]) => Res[];
-declare function memoizeArraylike<Args extends any[], Res>(// used at all?
-workerFunc: (...args: Args) => Res, resEquality?: (res0: Res, res1: Res) => boolean, teardownFunc?: (res: Res) => void): MemoiseArrayFunc<Args, Res>;
-type MemoizeHashFunc<Args extends any[], Res> = (argHash: {
-    [key: string]: Args;
-}) => {
-    [key: string]: Res;
+
+declare function filterHash(hash: any, func: any): {};
+declare function mapHash<InputItem, OutputItem>(hash: {
+    [key: string]: InputItem;
+}, func: (input: InputItem, key: string) => OutputItem): {
+    [key: string]: OutputItem;
 };
-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 isPropsEqualShallow(props0: any, props1: any): boolean;
+declare function isPropsEqualWithMap(props0: any, props1: any, equalityFuncMap: {
+    [key: string | symbol]: (val0: any, val1: any) => boolean;
+}): boolean;
 
+type ClassNameInput = string | undefined;
+type FuncishClassNameInput = ((data: any) => ClassNameInput) | ClassNameInput;
+declare function mergeViewOptionsMap(...hashes: {
+    [view: string]: ViewOptions;
+}[]): {
+    [view: string]: ViewOptions;
+};
+declare function mergeCalendarOptions(...optionSets: CalendarOptions[]): any;
+declare function joinFuncishClassNames(input0: FuncishClassNameInput, // added to string first
+input1: FuncishClassNameInput): FuncishClassNameInput;
+declare function mergeContentInjectors(contentGenerator0: CustomContentGenerator<any>, // fallback
+contentGenerator1: CustomContentGenerator<any>): CustomContentGenerator<any>;
+declare function mergeLifecycleCallbacks(fn0: (...args: any[]) => any, // called first
+fn1: (...args: any[]) => any): (...args: any[]) => any;
+
+declare function getAppendableRoot(el: HTMLElement): Node;
+declare function computeElIsRtl(el: HTMLElement): boolean;
 declare function applyStyle(el: HTMLElement, props: Dictionary): void;
 declare function getEventTargetViaRoot(ev: Event): EventTarget;
 declare function getUniqueDomId(): string;
@@ -2223,26 +2292,25 @@ declare function isDimsEqual(v0: number | undefined, v1: number): boolean;
 
 type SizeCallback = (width: number, height: number) => void;
 type DisconnectSize = () => void;
-type WatchSize = (el: HTMLElement, callback: SizeCallback, client?: boolean, watchWidth?: boolean, watchHeight?: boolean) => DisconnectSize;
+type WatchSize = (el: HTMLElement, callback: SizeCallback, 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;
-    'data-navlink': string;
-    'aria-label'?: undefined;
+    role: any;
+    'aria-label': any;
+    className: string;
 } | {
     onClick: (ev: UIEvent) => void;
-    title: any;
-    'data-navlink': string;
-    'aria-label'?: undefined;
-} | {
-    'aria-label': string;
+    role: any;
+    'aria-label': any;
+    className: string;
 };
 
 declare function preventDefault(ev: any): void;
@@ -2331,17 +2399,6 @@ declare class WindowScrollController extends ScrollController {
     getClientWidth(): number;
 }
 
-declare function buildIsoString(marker: DateMarker, timeZoneOffset?: number, stripZeroTime?: boolean): string;
-declare function formatDayString(marker: DateMarker): string;
-declare function formatIsoMonthStr(marker: DateMarker): string;
-declare function formatIsoTimeString(marker: DateMarker): string;
-
-declare function parse(str: any): {
-    marker: Date;
-    isTimeUnspecified: boolean;
-    timeZoneOffset: any;
-};
-
 interface CoordSpan {
     start: number;
     size: number;
@@ -2407,9 +2464,8 @@ declare const config: any;
 
 interface CalendarRootProps {
     options: CalendarOptions;
-    theme: Theme;
     emitter: Emitter<CalendarListeners>;
-    children: (classNames: string[], height: CssDimValue | undefined, forPrint: boolean) => ComponentChildren;
+    children: (isRtl: boolean, className: string, height: CssDimValue | undefined, forPrint: boolean) => ComponentChildren;
 }
 interface CalendarRootState {
     forPrint: boolean;
@@ -2438,41 +2494,56 @@ interface DayGridRange extends SlicedCoordRange {
 interface DayTableCell {
     key: string;
     date: DateMarker;
+    isMajor: boolean;
     renderProps?: Dictionary;
     attrs?: Dictionary;
     className?: string;
     dateSpanProps?: Dictionary;
 }
 declare class DayTableModel {
-    rowCnt: number;
-    colCnt: number;
+    private dateEnv;
+    private majorUnit;
+    rowCount: number;
+    colCount: number;
     cellRows: DayTableCell[][];
     headerDates: DateMarker[];
     private daySeries;
-    constructor(daySeries: DaySeriesModel, breakOnWeeks: boolean);
+    constructor(daySeries: DaySeriesModel, breakOnWeeks: boolean, dateEnv: DateEnv, majorUnit?: string);
     buildCells(): any[];
     private buildCell;
+    protected cellIsMajor(dateMarker: DateMarker): boolean;
     private buildHeaderDates;
     sliceRange(range: DateRange): DayGridRange[];
 }
 
 declare class ScrollListener {
     el: HTMLElement;
-    emitter: Emitter<any>;
-    private isScrolling;
-    private isTouching;
-    private isRecentlyWheeled;
-    private isRecentlyScrolled;
+    emitter: Emitter<{
+        scrollStart: (isUser: boolean) => void;
+        scroll: (isUser: boolean) => void;
+        scrollEnd: (isUser: boolean) => void;
+    }>;
     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;
 }
@@ -2482,23 +2553,24 @@ interface ScrollerProps {
     horizontal?: boolean;
     hideScrollbars?: boolean;
     children: ComponentChildren;
-    className?: string;
-    style?: Dictionary;
     clientWidthRef?: Ref<number>;
     clientHeightRef?: Ref<number>;
-    endScrollbarWidthRef?: Ref<number>;
     bottomScrollbarWidthRef?: Ref<number>;
+    className?: string;
+    style?: Dictionary;
 }
 declare class Scroller extends DateComponent<ScrollerProps> implements ScrollerInterface {
     private el?;
     listener: ScrollListener;
-    private disconnectSize?;
-    private currentClientWidth;
-    private currentClientHeight;
-    private currentEndScrollbarWidth;
-    private currentBottomScrollbarWidth;
+    private disconnectHRuler?;
+    private disconnectVRuler?;
+    private clientWidth?;
+    private clientHeight?;
+    private bottomScrollbarWidth?;
     render(): createElement.JSX.Element;
     handleEl: (el: HTMLDivElement | null) => void;
+    handleHRuler: (el: HTMLDivElement | null) => void;
+    handleVRuler: (el: HTMLDivElement | null) => void;
     endScroll(): void;
     get x(): number;
     get y(): number;
@@ -2506,11 +2578,11 @@ declare class Scroller extends DateComponent<ScrollerProps> implements ScrollerI
         x?: number;
         y?: number;
     }): void;
-    addScrollEndListener(handler: (x: number, y: number) => void): void;
-    removeScrollEndListener(handler: (x: number, y: number) => void): void;
+    addScrollEndListener(handler: (isUser: boolean) => void): void;
+    removeScrollEndListener(handler: (isUser: boolean) => void): void;
 }
-declare function getNormalizedScrollX(el: HTMLElement, isRtl: boolean): number;
-declare function setNormalizedScrollX(el: HTMLElement, isRtl: boolean, x: number): void;
+declare function getNormalizedScrollX(el: HTMLElement): number;
+declare function setNormalizedScrollX(el: HTMLElement, x: number): void;
 
 interface SliceableProps {
     dateSelection: DateSpan;
@@ -2553,12 +2625,6 @@ 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;
@@ -2576,11 +2642,16 @@ declare class DelayedRunner {
     protected drained(): void;
 }
 
-interface ScrollbarWidths {
-    x: number;
-    y: number;
+interface RulerProps {
+    widthRef: Ref<number>;
+}
+declare class Ruler extends BaseComponent<RulerProps> {
+    private elRef;
+    private disconnectWidth?;
+    render(): createElement.JSX.Element;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
 }
-declare function getScrollbarWidths(): ScrollbarWidths;
 
 declare class RefMap<K, V> {
     masterCallback?: (val: V, key: K) => void;
@@ -2592,8 +2663,6 @@ declare class RefMap<K, V> {
     handleValue: (val: V, key: K) => void;
 }
 
-declare function getIsRtlScrollbarOnLeft(): boolean;
-
 interface NowTimerProps {
     unit: string;
     children: (now: DateMarker, todayRange: DateRange) => ComponentChildren;
@@ -2620,7 +2689,9 @@ declare class NowTimer extends Component<NowTimerProps, NowTimerState> {
 
 interface StandardEventProps {
     elRef?: ElRef;
+    attrs?: any;
     className?: string;
+    display: 'list-item' | 'row' | 'column';
     eventRange: EventRenderRange;
     slicedStart?: DateMarker;
     slicedEnd?: DateMarker;
@@ -2628,7 +2699,7 @@ interface StandardEventProps {
     isEnd: boolean;
     isDragging: boolean;
     isResizing: boolean;
-    isDateSelecting: boolean;
+    isMirror: boolean;
     isSelected: boolean;
     isPast: boolean;
     isFuture: boolean;
@@ -2638,38 +2709,26 @@ interface StandardEventProps {
     defaultTimeFormat: DateFormatter;
     defaultDisplayEventTime?: boolean;
     defaultDisplayEventEnd?: boolean;
+    isNarrow?: boolean;
+    isShort?: boolean;
+    level?: number;
+    forcedTimeText?: string;
+    disableLiquid?: boolean;
+    disableZindexes?: boolean;
 }
 declare class StandardEvent extends BaseComponent<StandardEventProps> {
+    private buildPublicEvent;
+    private el;
     render(): createElement.JSX.Element;
+    handleEl: (el: HTMLElement | null) => void;
+    componentDidUpdate(prevProps: StandardEventProps): void;
 }
 
-interface MinimalEventProps {
-    eventRange: EventRenderRange;
-    slicedStart?: DateMarker;
-    slicedEnd?: DateMarker;
-    isStart: boolean;
-    isEnd: boolean;
-    isDragging: boolean;
-    isResizing: boolean;
-    isDateSelecting: boolean;
-    isSelected: boolean;
-    isPast: boolean;
-    isFuture: boolean;
-    isToday: boolean;
-}
-type EventContainerProps = ElProps & MinimalEventProps & {
-    defaultGenerator: (renderProps: EventContentArg) => ComponentChild;
-    disableDragging?: boolean;
-    disableResizing?: boolean;
-    timeText: string;
-    children?: InnerContainerFunc<EventContentArg>;
-};
-declare class EventContainer extends BaseComponent<EventContainerProps> {
-    el: HTMLElement;
-    render(): createElement.JSX.Element;
-    handleEl: (el: HTMLElement | null) => void;
-    componentDidUpdate(prevProps: EventContainerProps): void;
+interface NowIndicatorDotProps {
+    className?: string;
+    style?: any;
 }
+declare const NowIndicatorDot: (props: NowIndicatorDotProps) => createElement.JSX.Element;
 
 interface BgEventProps {
     eventRange: EventRenderRange;
@@ -2678,20 +2737,26 @@ interface BgEventProps {
     isPast: boolean;
     isFuture: boolean;
     isToday: boolean;
+    isNarrow?: boolean;
+    isShort?: boolean;
+    isVertical: boolean;
 }
 declare class BgEvent extends BaseComponent<BgEventProps> {
+    private buildPublicEvent;
+    private el;
     render(): createElement.JSX.Element;
+    handleEl: (el: HTMLElement | null) => void;
+    componentDidUpdate(prevProps: BgEventProps): void;
 }
-declare function renderFill(fillType: string): createElement.JSX.Element;
-
-declare function injectStyles(styleText: string): void;
+declare function renderFill(fillType: string, options: ViewOptionsRefined): createElement.JSX.Element;
 
-interface StickyFooterScrollbarProps {
+interface FooterScrollbarProps {
+    isSticky?: boolean;
     canvasWidth: CssDimValue;
     scrollerRef?: Ref<Scroller>;
     scrollbarWidthRef?: Ref<number>;
 }
-declare class StickyFooterScrollbar extends BaseComponent<StickyFooterScrollbarProps> {
+declare class FooterScrollbar extends BaseComponent<FooterScrollbarProps> {
     rootElRef: preact.RefObject<HTMLDivElement>;
     disconnectHeight?: () => void;
     render(): createElement.JSX.Element;
@@ -2699,4 +2764,4 @@ declare class StickyFooterScrollbar extends BaseComponent<StickyFooterScrollbarP
     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 };
+export { DayHeaderData as $, AllowFunc as A, ButtonStateMap as B, CalendarImpl as C, DateSpanInput as D, EventSourceApi as E, NowIndicatorLineMountData as F, InlineWeekNumberMountData as G, WeekNumberHeaderData as H, InlineWeekNumberData as I, JsonRequestError as J, WeekNumberHeaderMountData as K, LocaleInput as L, DateTimeFormatPartWithWeek as M, NativeFormatterOptions as N, OverlapFunc as O, PluginDefInput as P, MoreLinkData$1 as Q, MoreLinkMountData as R, SpecificViewData as S, SlotLaneData as T, SlotLaneMountData as U, ViewApi as V, WillUnmountHandler as W, SlotHeaderData as X, SlotHeaderMountData as Y, AllDayHeaderData as Z, AllDayHeaderMountData as _, CalendarOptions as a, parseFieldSpecs as a$, DayHeaderMountData as a0, DayCellData as a1, DayCellMountData as a2, DayLaneData as a3, DayLaneMountData as a4, ViewDisplayData as a5, ViewMountData as a6, EventClickData as a7, EventHoveringData as a8, DateSelectData as a9, EventSegment as aA, MoreLinkAction as aB, MoreLinkSimpleAction as aC, MoreLinkHandler as aD, BaseOptions as aE, BaseOptionsRefined as aF, BASE_OPTION_DEFAULTS as aG, CalendarListenersRefined as aH, ViewOptionsRefined as aI, RawOptionsFromRefiners as aJ, RefinedOptionsFromRefiners as aK, Identity as aL, Dictionary as aM, identity as aN, refineProps as aO, EventDef as aP, EventDefHash as aQ, EventInstance as aR, EventInstanceHash as aS, createEventInstance as aT, EventRefined as aU, EventTuple as aV, EventRefiners as aW, parseEventDef as aX, refineEventDef as aY, parseBusinessHours as aZ, OrderSpec as a_, DateUnselectData as aa, ToolbarInput as ab, ButtonInput as ac, ButtonGroupData as ad, ButtonData as ae, ButtonMountData as af, ButtonDisplay as ag, ToolbarElementInput as ah, ToolbarSectionData as ai, ToolbarData as aj, EventDisplayData as ak, EventMountData as al, DatesSetData as am, EventAddData as an, EventChangeData as ao, EventDropData as ap, EventRemoveData as aq, CustomRenderingHandler as ar, CustomRenderingStore as as, DateSpanApi as at, DatePointApi as au, DateSelectionApi as av, ButtonState as aw, NavButtonState as ax, FormatterInput as ay, LocaleSingularArg as az, PluginDef as b, buildNavLinkAttrs as b$, compareByFieldSpecs as b0, flexibleCompare as b1, preventSelection as b2, allowSelection as b3, preventContextMenu as b4, allowContextMenu as b5, compareNumbers as b6, enableCursor as b7, disableCursor as b8, guid as b9, mergeCalendarOptions as bA, mergeViewOptionsMap as bB, getAppendableRoot as bC, computeElIsRtl as bD, applyStyle as bE, getEventTargetViaRoot as bF, getUniqueDomId as bG, joinArrayishClassNames as bH, fracToCssDim as bI, EventStore as bJ, createEmptyEventStore as bK, mergeEventStores as bL, getRelevantEvents as bM, eventTupleToStore as bN, EventUiHash as bO, EventUi as bP, combineEventUis as bQ, createEventUi as bR, SplittableProps as bS, Splitter as bT, getDateMeta as bU, DateMeta as bV, isDimsEqual as bW, watchSize as bX, watchWidth as bY, watchHeight as bZ, afterSize as b_, computeVisibleDayRange as ba, diffDates as bb, WEEKDAY_ONLY_FORMAT as bc, FULL_DATE_FORMAT as bd, findWeekdayText as be, findDayNumberText as bf, findMonthText as bg, removeExact as bh, isArraysEqual as bi, memoize as bj, memoizeObjArg as bk, Rect as bl, Point as bm, intersectRects as bn, pointInsideRect as bo, constrainPoint as bp, getRectCenter as bq, diffPoints as br, translateRect as bs, mapHash as bt, filterHash as bu, isPropsEqualShallow as bv, isPropsEqualWithMap as bw, joinFuncishClassNames as bx, mergeContentInjectors as by, mergeLifecycleCallbacks as bz, CalendarApi as c, sortEventSegs as c$, buildDateStr as c0, preventDefault as c1, whenTransitionDone as c2, computeInnerRect as c3, computeEdges as c4, getClippingParents as c5, computeRect as c6, unpromisify as c7, Emitter as c8, PositionCache as c9, InteractionSettings as cA, InteractionSettingsStore as cB, Interaction as cC, interactionSettingsToStore as cD, interactionSettingsStore as cE, PointerDragEvent as cF, Hit as cG, dateSelectionJoinTransformer as cH, eventDragMutationMassager as cI, EventDropTransformers as cJ, ElementDragging as cK, config as cL, RecurringType as cM, DragMetaInput as cN, DragMeta as cO, parseDragMeta as cP, ViewPropsTransformer as cQ, Action as cR, CalendarContext as cS, CalendarContentProps as cT, CalendarRoot as cU, DaySeriesModel as cV, EventInteractionState as cW, sliceEventStore as cX, hasBgRendering as cY, getElEventRange as cZ, buildEventRangeTimeText as c_, ScrollController as ca, ElementScrollController as cb, WindowScrollController as cc, ViewContext as cd, ViewContextType as ce, EventSegUiInteractionState as cf, DateComponent as cg, CalendarData as ch, ViewProps as ci, DateProfile as cj, DateProfileGenerator as ck, computeMajorUnit as cl, isMajorUnit as cm, ViewSpec as cn, DateSpan as co, isDateSpansEqual as cp, EventSourceDef as cq, EventSourceRefined as cr, EventSourceOptions as cs, EventSourceOptionsRefined as ct, EventPlacement as cu, EventInsertion as cv, SegHierarchy as cw, SegGroup as cx, groupIntersectingSegs as cy, binarySearch as cz, CalendarController as d, computeLatestEnd as d$, getEventRangeMeta as d0, buildEventRangeKey as d1, getEventTagAndAttrs as d2, EventRangeProps as d3, getEventKey as d4, MinimalEventProps as d5, DayTableCell as d6, DayGridRange as d7, DayTableModel as d8, Scroller as d9, StandardEvent as dA, StandardEventProps as dB, NowIndicatorHeaderContainer as dC, NowIndicatorLineContainer as dD, NowIndicatorDot as dE, renderFill as dF, BgEvent as dG, MoreLinkContainer as dH, ViewContainerProps as dI, ViewContainer as dJ, DatePointTransform as dK, DateSpanTransform as dL, triggerDateSelect as dM, getDefaultEventEnd as dN, EventImpl as dO, buildEventApis as dP, ElProps as dQ, buildElAttrs as dR, InnerContainerFunc as dS, ContentContainer as dT, renderText as dU, generateClassName as dV, CustomRendering as dW, CoordRange as dX, CoordSpan as dY, SlicedCoordRange as dZ, computeEarliestStart as d_, getNormalizedScrollX as da, setNormalizedScrollX as db, SlicedProps as dc, Slicer as dd, EventMutation as de, applyMutationToEventStore as df, Constraint as dg, isPropsValid as dh, isInteractionValid as di, isDateSelectionValid as dj, requestJson as dk, BaseComponent as dl, setRef as dm, DelayedRunner as dn, getStickyFooterScrollbar as dp, getStickyHeaderDates as dq, getIsHeightAuto as dr, getScrollerSyncerClass as ds, ScrollerInterface as dt, ScrollerSyncerInterface as du, Ruler as dv, RulerProps as dw, RefMap as dx, NowTimer as dy, MountData as dz, EventApi as e, getCoordRangeEnd as e0, FooterScrollbar as e1, createFormatter as e2, EventRenderRange as f, CalendarListeners as g, ViewOptions as h, EventSourceInput as i, joinClassNames as j, EventSourceFunc as k, EventSourceFuncData as l, EventInput as m, EventInputTransformer as n, CssDimValue as o, BusinessHoursInput as p, ConstraintInput as q, ViewComponentType as r, sliceEvents as s, SpecificViewMountData as t, ClassNameGenerator as u, CustomContentGenerator as v, DidMountHandler as w, NowIndicatorHeaderData as x, NowIndicatorHeaderMountData as y, NowIndicatorLineData as z };