import { aI as valuesIdentical, aH as Dictionary, aD as ViewOptions, a as CalendarOptions, p as ContentGenerator, aJ as ViewContext, aK as DateComponent, aL as ScrollerInterface, aM as EventRangeProps, aN as EventSegUiInteractionState, aO as DateProfile, aP as CalendarContext, aQ as SplittableProps, aR as BaseComponent, aS as ViewOptionsRefined, aT as Splitter, aU as DateSpan, aV as EventDef, m as ClassNameGenerator, J as DidMountHandler, aF as WillUnmountHandler, H as DayHeaderInfo, aW as DateProfileGenerator, n as ClassNameInput, aX as Emitter, aY as EventStore, aZ as EventInteractionState, a_ as EventUiHash, a$ as ElRef, Z as EventRenderRange, q as CssDimValue, b0 as DateMeta, b1 as Hit } from './chunks/623d1736.js';
export { b2 as Action, aR as BaseComponent, C as CalendarApiImpl, b3 as CalendarContentProps, aP as CalendarContext, b4 as CalendarData, b5 as CalendarDataManager, b6 as CalendarInner, l as CalendarListeners, b7 as CalendarListenersRefined, b8 as CalendarMediaRoot, b9 as Constraint, ba as ContentContainer, p as ContentGenerator, bb as CustomRendering, s as CustomRenderingStore, aK as DateComponent, b0 as DateMeta, aO as DateProfile, aW as DateProfileGenerator, aU as DateSpan, aH as Dictionary, J as DidMountHandler, bc as ElementDragging, aX as Emitter, aV as EventDef, bd as EventDefHash, be as EventImpl, bf as EventInstanceHash, aZ as EventInteractionState, bg as EventMutation, aM as EventRangeProps, bh as EventRefined, aN as EventSegUiInteractionState, aY as EventStore, bi as EventUi, a_ as EventUiHash, b1 as Hit, bj as Identity, bk as MinimalEventProps, bl as MoreLinkContainer, ah as MountInfo, bm as NowIndicatorHeaderContainer, bn as NowIndicatorLineContainer, bo as OrderSpec, bp as PointerDragEvent, bq as ScrollerSyncerInterface, aQ as SplittableProps, aT as Splitter, br as ViewContainer, aJ as ViewContext, aS as ViewOptionsRefined, bs as ViewProps, bt as ViewPropsTransformer, aF as WillUnmountHandler, bu as buildEventRangeKey, bv as combineEventUis, bw as compareByFieldSpecs, bx as computeMajorUnit, by as computeRootClassName, bz as computeViewBorderless, bA as createEventUi, bB as createFormatter, bC as flexibleCompare, bD as generateClassName, bE as getDateMeta, bF as getEventKey, bG as getEventRangeMeta, bH as getFooterScrollbarSticky, bI as getIsHeightAuto, bJ as getRectCenter, bK as getTableHeaderSticky, bL as guid, bM as identity, bN as isMajorUnit, bO as mergeEventStores, bP as parseBusinessHours, bQ as parseFieldSpecs, bR as refineClassName, bS as refineClassNameGenerator, bT as refineProps, bU as setRef, bV as sortEventSegs } from './chunks/623d1736.js';
import { OpenDateRange, Duration, DateMarker, DateEnv, DateRange, DateFormatter } from '@full-ui/headless-calendar';
export { DateEnv, DateFormatter, DateMarker, DateRange, addDays, addMs, asCleanDays, asRoughMinutes, asRoughMs, asRoughSeconds, createDuration, diffDayAndTime, diffWholeDays, diffWholeWeeks, formatDayString, greatestDurationDenominator, intersectRanges, isInt, isValidDate, multiplyDuration, padStart, parseMarker, rangeContainsMarker, rangesEqual, rangesIntersect, startOfDay, wholeDivideDurations } from '@full-ui/headless-calendar';
import * as preact from 'preact';
import { Component, ReactNode, Ref } from 'preact/compat';
export { r as requestJson } from './chunks/2a89260c.js';

declare function warn(...args: any[]): void;

declare function computeVisibleDayRange(timedRange: OpenDateRange, nextDayThreshold?: Duration): OpenDateRange;

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;

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 isPropsEqualShallow(props0: any, props1: any): boolean;

type FuncishClassNameInput = ((info: 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, optionName: string): FuncishClassNameInput;
declare function mergeContentInjectors(contentGenerator0: ContentGenerator<any>, // fallback
contentGenerator1: ContentGenerator<any>): ContentGenerator<any>;
declare function mergeLifecycleCallbacks(fn0: (...args: any[]) => any, // called first
fn1: (...args: any[]) => any): (...args: any[]) => any;

declare function computeElIsRtl(el: HTMLElement): boolean;
declare function applyStyleProp(el: HTMLElement, name: string, val: any): void;

type SizeCallback = (width: number, height: number) => void;
type DisconnectSize = () => void;
declare function afterSize(callback: () => void): void;
declare function watchSize(el: HTMLElement, callback: SizeCallback, watchWidth?: boolean, watchHeight?: boolean): DisconnectSize;
declare function watchWidth(el: HTMLElement, callback: (width: number) => void): DisconnectSize;
declare function watchHeight(el: HTMLElement, callback: (height: number) => void): DisconnectSize;

declare function debounce(fn: () => void, ms: number): [
    request: () => void,
    cancel: () => void
];

declare function buildNavLinkAttrs(context: ViewContext, dateMarker: DateMarker, viewType?: string, dateStr?: string, isTabbable?: boolean): {
    tabIndex: number;
    onKeyDown(ev: KeyboardEvent): void;
    onClick: (ev: UIEvent) => void;
    role: any;
    'aria-label': any;
    className: string;
} | {
    onClick: (ev: UIEvent) => void;
    role: any;
    'aria-label': any;
    className: string;
};

interface EdgeInfo {
    borderLeft: number;
    borderRight: number;
    borderTop: number;
    borderBottom: number;
    scrollbarLeft: number;
    scrollbarRight: number;
    scrollbarBottom: number;
    paddingLeft?: number;
    paddingRight?: number;
    paddingTop?: number;
    paddingBottom?: number;
}
declare function computeEdges(el: HTMLElement, getPadding?: boolean): EdgeInfo;
declare function computeInnerRect(el: any, goWithinPadding?: boolean, doFromWindowViewport?: boolean): {
    left: any;
    right: number;
    top: any;
    bottom: number;
};

declare function unpromisify<Res>(func: (successCallback: (res: Res) => void, failureCallback: (error: Error) => void) => Promise<Res> | void, normalizedSuccessCallback: (res: Res) => void, normalizedFailureCallback: (error: Error) => void): void;

interface CoordSpan {
    start: number;
    size: number;
}
interface CoordRange {
    start: number;
    end: number;
}
interface SlicedCoordRange extends CoordRange {
    isStart: boolean;
    isEnd: boolean;
}

type EventSeg<R extends SlicedCoordRange> = R & EventRangeProps & {
    isSlice?: boolean;
};
type EventPlacement<R extends SlicedCoordRange> = EventSeg<R> & {
    thickness: number;
    depth: number;
    isSlice: boolean;
    isZombie: boolean;
};
interface EventInsertion<R extends SlicedCoordRange> {
    levelIndex: number;
    levelCoord: number;
    lateralIndex: number;
    touchingPlacement: EventPlacement<R> | undefined;
    depth: number;
}
declare class SegHierarchy<R extends SlicedCoordRange> {
    private getSegThickness;
    strictOrder: boolean;
    private maxCoord;
    private maxDepth;
    private hiddenConsumes;
    private allowSlicing;
    placementsByLevel: EventPlacement<R>[][];
    levelCoords: number[];
    hiddenSegs: EventSeg<R>[];
    constructor(segs: EventSeg<R>[], getSegThickness: (seg: EventSeg<R>) => number | undefined, strictOrder: boolean, // HACK
    maxCoord: number | undefined, maxDepth: number | undefined, hiddenConsumes?: boolean, // hidden segs also hide the touchingPlacement?
    allowSlicing?: boolean);
    private insertSeg;
    private isInsertionValid;
    private splitSeg;
    private insertSegAt;
    findInsertion(seg: CoordRange, segThickness: number): EventInsertion<R>;
    traverseSegs(handler: (seg: EventPlacement<R>, levelCoord: number) => void): void;
}
interface SegInternalGroup<R extends SlicedCoordRange> extends CoordRange {
    segs: EventSeg<R>[];
}
interface SegGroup<R extends SlicedCoordRange> extends SegInternalGroup<R> {
    key: string;
}
declare function groupIntersectingSegs<R extends SlicedCoordRange>(segs: EventSeg<R>[]): SegGroup<R>[];

declare const config: any;

declare class DaySeriesModel {
    cnt: number;
    dates: DateMarker[];
    indices: number[];
    constructor(range: DateRange, dateProfileGenerator: DateProfileGenerator);
    sliceRange(range: DateRange): SlicedCoordRange | null;
    private getDateDayIndex;
}

interface DayGridRange extends SlicedCoordRange {
    row: number;
}
interface DayTableCell {
    key: string;
    date: DateMarker;
    isMajor: boolean;
    renderProps?: Dictionary;
    attrs?: Dictionary;
    className?: string;
    dateSpanProps?: Dictionary;
}
declare class DayTableModel {
    private dateEnv;
    private majorUnit;
    rowCount: number;
    colCount: number;
    cellRows: DayTableCell[][];
    headerDates: DateMarker[];
    private daySeries;
    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<{
        scrollStart: (isDevice: boolean) => void;
        scroll: (isDevice: boolean) => void;
        scrollEnd: (isDevice: 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 getIsDevice;
    private handleScroll;
    private handleScrollWait;
    private handleWheel;
    private handleWheelWait;
    private handleMouseDown;
    private handleMouseUp;
    private handleTouchStart;
    private handleTouchEnd;
}

interface ScrollerProps {
    vertical?: boolean;
    horizontal?: boolean;
    hideScrollbars?: boolean;
    children?: ReactNode;
    clientWidthRef?: Ref<number>;
    clientHeightRef?: Ref<number>;
    bottomScrollbarWidthRef?: Ref<number>;
    className?: string;
    style?: Dictionary;
}
declare class Scroller extends DateComponent<ScrollerProps> implements ScrollerInterface {
    private el?;
    private _isUnmounting;
    listener: ScrollListener;
    private disconnectHRuler?;
    private disconnectVRuler?;
    private clientWidth?;
    private clientHeight?;
    private bottomScrollbarWidth?;
    render(): preact.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;
    scrollTo({ x, y }: {
        x?: number;
        y?: number;
    }): void;
    addScrollStartListener(handler: () => void): void;
    removeScrollStartListener(handler: () => void): void;
    addScrollEndListener(handler: (isDevice: boolean) => void): void;
    removeScrollEndListener(handler: (isDevice: boolean) => void): void;
}

interface SliceableProps {
    dateSelection: DateSpan;
    businessHours: EventStore;
    eventStore: EventStore;
    eventDrag: EventInteractionState | null;
    eventResize: EventInteractionState | null;
    eventSelection: string;
    eventUiBases: EventUiHash;
}
interface SlicedProps<R> {
    fgEventSegs: (R & EventRangeProps)[];
    bgEventSegs: (R & EventRangeProps)[];
    businessHourSegs: (R & EventRangeProps)[];
    dateSelectionSegs: (R & EventRangeProps)[];
    eventDrag: EventSegUiInteractionState<R> | null;
    eventResize: EventSegUiInteractionState<R> | null;
    eventSelection: string;
}
declare abstract class Slicer<R, ExtraArgs extends any[] = []> {
    private sliceBusinessHours;
    private sliceDateSelection;
    private sliceEventStore;
    private sliceEventDrag;
    private sliceEventResize;
    abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): R[];
    protected forceDayIfListItem: boolean;
    sliceProps(props: SliceableProps, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): SlicedProps<R>;
    sliceNowDate(// does not memoize
    date: DateMarker, dateProfile: DateProfile, nextDayThreshold: Duration | null, context: CalendarContext, ...extraArgs: ExtraArgs): R[];
    private _sliceBusinessHours;
    private _sliceEventStore;
    private _sliceInteraction;
    private _sliceDateSpan;
    private sliceEventRanges;
    private sliceEventRange;
}

declare function isPropsValid(state: SplittableProps, context: CalendarContext, dateSpanMeta?: {}, filterConfig?: any): boolean;

declare class DelayedRunner {
    private drainedOption?;
    private isRunning;
    private isDirty;
    private pauseDepths;
    private timeoutId;
    constructor(drainedOption?: () => void);
    request(delay?: number): void;
    pause(scope?: string): void;
    resume(scope?: string, force?: boolean): void;
    isPaused(): number;
    tryDrain(): void;
    clear(): void;
    private clearTimeout;
    protected drained(): void;
}

interface RulerProps {
    widthRef: Ref<number>;
}
declare class Ruler extends BaseComponent<RulerProps> {
    private elRef;
    private _isUnmounting;
    private disconnectWidth?;
    render(): preact.JSX.Element;
    componentDidMount(): void;
    componentWillUnmount(): void;
}

declare class RefMap<K, V> {
    masterCallback?: (val: V, key: K) => void;
    private ignoreDeletes;
    rev: string;
    current: Map<K, V>;
    private callbacks;
    constructor(masterCallback?: (val: V, key: K) => void, ignoreDeletes?: boolean);
    createRef(key: K): (val: V | null) => void;
    handleValue: (val: V, key: K) => void;
}

interface NowTimerProps {
    unit: string;
    unitValue?: number;
    children?: (now: DateMarker, todayRange: DateRange) => ReactNode;
}
declare class NowTimer extends Component<NowTimerProps> {
    static contextType: any;
    context: ViewContext;
    private runner;
    constructor(props: NowTimerProps, context: ViewContext);
    render(): ReactNode;
    componentWillUnmount(): void;
    private handleChange;
}

interface StandardEventProps {
    elRef?: ElRef;
    attrs?: any;
    className?: string;
    display: 'list-item' | 'row' | 'column';
    eventRange: EventRenderRange;
    slicedStart?: DateMarker;
    slicedEnd?: DateMarker;
    isStart: boolean;
    isEnd: boolean;
    isFirst?: boolean;
    isLast?: boolean;
    isDragging: boolean;
    isResizing: boolean;
    isMirror: boolean;
    isSelected: boolean;
    isPast: boolean;
    isFuture: boolean;
    isToday: boolean;
    disableDragging?: boolean;
    disableResizing?: boolean;
    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(): preact.JSX.Element;
    handleEl: (el: HTMLElement | null) => void;
    componentDidUpdate(prevProps: StandardEventProps): void;
}

interface NowIndicatorDotProps {
    className?: string;
    style?: any;
}
declare const NowIndicatorDot: (props: NowIndicatorDotProps) => preact.JSX.Element;

interface BgEventProps {
    eventRange: EventRenderRange;
    isStart: boolean;
    isEnd: boolean;
    isPast: boolean;
    isFuture: boolean;
    isToday: boolean;
    isNarrow?: boolean;
    isShort?: boolean;
    isVertical: boolean;
}
declare class BgEvent extends BaseComponent<BgEventProps> {
    private buildPublicEvent;
    private el;
    render(): preact.JSX.Element;
    handleEl: (el: HTMLElement | null) => void;
    componentDidUpdate(prevProps: BgEventProps): void;
}
declare function renderFill(fillType: string, options: ViewOptionsRefined): preact.JSX.Element;

declare const RenderId: preact.Context<number>;

interface FooterScrollbarProps {
    isSticky?: boolean;
    canvasWidth: CssDimValue;
    scrollerRef?: Ref<Scroller>;
    scrollbarWidthRef?: Ref<number>;
}
declare class FooterScrollbar extends BaseComponent<FooterScrollbarProps> {
    rootElRef: preact.RefObject<HTMLDivElement>;
    private _isUnmounting;
    disconnectHeight?: () => void;
    render(): preact.JSX.Element;
    componentDidMount(): void;
    componentWillUnmount(): void;
}

interface TimeGridRange {
    col: number;
    startDate: DateMarker;
    endDate: DateMarker;
    isStart: boolean;
    isEnd: boolean;
    showDot?: boolean;
}
declare function organizeSegsByCol<S extends TimeGridRange>(segs: S[] | null, colCount: number): S[][];
declare function splitInteractionByCol(ui: EventSegUiInteractionState<TimeGridRange> | null, colCount: number): EventSegUiInteractionState<TimeGridRange>[];

declare class DayTimeColsSlicer extends Slicer<TimeGridRange, [DateRange[]]> {
    sliceRange(range: DateRange, dayRanges: DateRange[]): TimeGridRange[];
}

declare class AllDaySplitter extends Splitter {
    getKeyInfo(): {
        allDay: {};
        timed: {};
    };
    getKeysForDateSpan(dateSpan: DateSpan): string[];
    getKeysForEventDef(eventDef: EventDef): string[];
}

interface CellRenderConfig<BaseRenderProps, RenderProps = BaseRenderProps> {
    generatorName: string;
    customGenerator: ContentGenerator<RenderProps>;
    innerClassNameGenerator: ClassNameGenerator<RenderProps>;
    classNameGenerator: ClassNameGenerator<RenderProps>;
    didMount: DidMountHandler<RenderProps & {
        el: HTMLElement;
    }>;
    willUnmount: WillUnmountHandler<RenderProps & {
        el: HTMLElement;
    }>;
    align: 'start' | 'center' | 'end' | ((info: {
        level: number;
        inPopover: boolean;
        isNarrow: boolean;
    }) => 'start' | 'center' | 'end');
    sticky: boolean | number | string;
    dayHeaderFormat?: DateFormatter;
    datesRepDistinctDays?: boolean;
}
interface CellDataConfig<RenderProps> {
    key: string;
    dateMarker: DateMarker;
    renderProps: RenderProps;
    className?: string;
    attrs?: any;
    innerAttrs?: any;
    colSpan?: number;
    hasNavLink?: boolean;
}
interface RowConfig<BaseRenderProps, RenderProps = BaseRenderProps> {
    isDateRow: boolean;
    renderConfig: CellRenderConfig<BaseRenderProps, RenderProps>;
    dataConfigs: CellDataConfig<BaseRenderProps>[];
}
interface BaseDayHeaderData extends DateMeta {
    isMajor: DayHeaderInfo['isMajor'];
    isSticky: DayHeaderInfo['isSticky'];
    inPopover: DayHeaderInfo['inPopover'];
    hasNavLink: DayHeaderInfo['hasNavLink'];
    view: DayHeaderInfo['view'];
    [otherProp: string]: any;
}
declare function buildDateRowConfig(dateMarkers: DateMarker[], datesRepDistinctDays: boolean, dateProfile: DateProfile, todayRange: DateRange, dayHeaderFormat: DateFormatter, // TODO: rename to dateHeaderFormat?
context: ViewContext, colSpan?: number, isMajorMod?: number): RowConfig<BaseDayHeaderData, DayHeaderInfo>;
declare function buildDateRenderConfig(dayHeaderFormat: DateFormatter, datesRepDistinctDays: boolean, context: ViewContext): CellRenderConfig<BaseDayHeaderData, DayHeaderInfo>;
declare function buildDateDataConfigs(dateMarkers: DateMarker[], datesRepDistinctDays: boolean, dateProfile: DateProfile, todayRange: DateRange, dayHeaderFormat: DateFormatter, // TODO: rename to dateHeaderFormat?
context: ViewContext, colSpan?: number, keyPrefix?: string, extraRenderProps?: Dictionary, // TODO
extraAttrs?: Dictionary, // TODO
className?: string, isMajorMod?: number): CellDataConfig<BaseDayHeaderData>[];

interface TimeGridLayoutProps {
    labelId: string | undefined;
    labelStr: string | undefined;
    dateProfile: DateProfile;
    nowDate: DateMarker;
    todayRange: DateRange;
    cells: DayTableCell[];
    forPrint: boolean;
    isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
    className: string;
    headerTiers: RowConfig<any, {
        text: string;
        isDisabled: boolean;
    }>[];
    fgEventSegs: (SlicedCoordRange & EventRangeProps)[];
    bgEventSegs: (SlicedCoordRange & EventRangeProps)[];
    businessHourSegs: (SlicedCoordRange & EventRangeProps)[];
    dateSelectionSegs: (SlicedCoordRange & EventRangeProps)[];
    eventDrag: EventSegUiInteractionState<SlicedCoordRange> | null;
    eventResize: EventSegUiInteractionState<SlicedCoordRange> | null;
    fgEventSegsByCol: (TimeGridRange & EventRangeProps)[][];
    bgEventSegsByCol: (TimeGridRange & EventRangeProps)[][];
    businessHourSegsByCol: (TimeGridRange & EventRangeProps)[][];
    nowIndicatorSegsByCol: TimeGridRange[][];
    dateSelectionSegsByCol: (TimeGridRange & EventRangeProps)[][];
    eventDragByCol: EventSegUiInteractionState<TimeGridRange>[];
    eventResizeByCol: EventSegUiInteractionState<TimeGridRange>[];
    eventSelection: string;
}
declare class TimeGridLayout extends BaseComponent<TimeGridLayoutProps> {
    private buildSlatMetas;
    private dayScrollerRef;
    private timeScrollerRef;
    private slatHeight?;
    private _isUnmounting;
    private currentSlatCnt?;
    private scrollState;
    render(): preact.JSX.Element;
    componentDidMount(): void;
    componentDidUpdate(prevProps: TimeGridLayoutProps): void;
    componentWillUnmount(): void;
    private handleSlatHeight;
    private resetScroll;
    private handleTimeScrollRequest;
    private handleTimeScrollEnd;
    private applyTimeScroll;
}

declare function buildTimeColsModel(dateProfile: DateProfile, dateProfileGenerator: DateProfileGenerator, dateEnv: DateEnv): DayTableModel;
declare function buildDayRanges(dayTableModel: DayTableModel, dateProfile: DateProfile, dateEnv: DateEnv): DateRange[];

declare class DayTableSlicer extends Slicer<DayGridRange, [DayTableModel]> {
    forceDayIfListItem: boolean;
    sliceRange(dateRange: DateRange, dayTableModel: DayTableModel): DayGridRange[];
}

declare function buildDayTableModel(dateProfile: DateProfile, dateProfileGenerator: DateProfileGenerator, dateEnv: DateEnv): DayTableModel;
declare function createDayHeaderFormatter(explicitFormat: DateFormatter, datesRepDistinctDays: boolean, dateCnt: number): DateFormatter;

interface DayGridLayoutProps {
    labelId: string | undefined;
    labelStr: string | undefined;
    dateProfile: DateProfile;
    todayRange: DateRange;
    cellRows: DayTableCell[][];
    forPrint: boolean;
    isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
    className: string;
    headerTiers: RowConfig<any, {
        text: string;
        isDisabled: boolean;
    }>[];
    fgEventSegs: (DayGridRange & EventRangeProps)[];
    bgEventSegs: (DayGridRange & EventRangeProps)[];
    businessHourSegs: (DayGridRange & EventRangeProps)[];
    dateSelectionSegs: (DayGridRange & EventRangeProps)[];
    eventDrag: EventSegUiInteractionState<DayGridRange> | null;
    eventResize: EventSegUiInteractionState<DayGridRange> | null;
    eventSelection: string;
}
declare class DayGridLayout extends BaseComponent<DayGridLayoutProps> {
    private scrollerRef;
    private rowHeightRefMap;
    private _isUnmounting;
    private scrollDate;
    render(): preact.JSX.Element;
    componentDidMount(): void;
    componentDidUpdate(prevProps: DayGridLayoutProps): void;
    componentWillUnmount(): void;
    resetScroll(): void;
    updateScrollY: () => void;
    handleScrollEnd: (isDevice: boolean) => void;
}

declare const strictModeFactor = 1;

declare const vdomExtraRenders = 2;

export { AllDaySplitter, BgEvent, CellDataConfig, CellRenderConfig, CoordRange, CoordSpan, DayGridLayout, DayGridRange, DayTableCell, DayTableModel, DayTableSlicer, DayTimeColsSlicer, DelayedRunner, FooterScrollbar, NowIndicatorDot, NowTimer, RefMap, RenderId, RowConfig, Ruler, Scroller, SegGroup, SegHierarchy, SlicedCoordRange, SlicedProps, Slicer, StandardEvent, TimeGridLayout, TimeGridRange, afterSize, applyStyleProp, buildDateDataConfigs, buildDateRenderConfig, buildDateRowConfig, buildDayRanges, buildDayTableModel, buildNavLinkAttrs, buildTimeColsModel, computeEdges, computeElIsRtl, computeInnerRect, computeVisibleDayRange, config, createDayHeaderFormatter, debounce, filterHash, groupIntersectingSegs, isArraysEqual, isPropsEqualShallow, isPropsValid, joinFuncishClassNames, mapHash, memoize, memoizeObjArg, mergeCalendarOptions, mergeContentInjectors, mergeLifecycleCallbacks, mergeViewOptionsMap, organizeSegsByCol, removeExact, renderFill, splitInteractionByCol, strictModeFactor, unpromisify, vdomExtraRenders, warn, watchHeight, watchSize, watchWidth };