import { RawOptionsFromRefiners, RefinedOptionsFromRefiners, EventSourceOptions, EventSourceOptionsRefined, BaseOptionsRefined, EventRefiners, BaseOptions } from '@fullcalendar/core/protected-api';
import { NativeDateFormatterOptions, FuncDateFormatterFunc, DateFormatter, DateRange, DateMarker, DateEnv, Duration, DateInput, DateTimeFormatPartWithWeek as DateTimeFormatPartWithWeek$1, DurationInput, DateRangeInput, OpenDateRange, createDuration, CmdDateFormatterFunc, WeekNumberCalculation, LocaleCodeArg } from '@full-ui/headless-calendar';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import { ReactNode, Ref, Component, CSSProperties, ComponentType, FC, RefObject, ReactElement } from 'react';

type FormatterInput = NativeDateFormatterOptions | string | FuncDateFormatterFunc;
declare function createFormatter(input: FormatterInput): DateFormatter;

interface PointerDragEvent {
    origEvent: UIEvent;
    isTouch: boolean;
    subjectEl: EventTarget;
    pageX: number;
    pageY: number;
    deltaX: number;
    deltaY: number;
}

declare function guid(): string;
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 valuesIdentical<T>(a: T, b: T): boolean;
declare function computeViewBorderless(options: CalendarOptions): {
    borderlessX: boolean;
    borderlessTop: boolean;
    borderlessBottom: boolean;
};

interface ViewApi {
    calendar: CalendarApi;
    type: string;
    title: string;
    activeStart: Date;
    activeEnd: Date;
    currentStart: Date;
    currentEnd: Date;
    getOption(name: string): any;
}

interface EventSourceApi {
    id: string;
    url: string;
    format: string;
    remove(): void;
    refetch(): void;
}

interface EventInstance {
    instanceId: string;
    defId: string;
    range: DateRange;
}
type EventInstanceHash = {
    [instanceId: string]: EventInstance;
};

type BusinessHoursInput = boolean | EventInput | EventInput[];
declare function parseBusinessHours(input: BusinessHoursInput, context: CalendarContext): EventStore;

interface Point {
    left: number;
    top: number;
}
interface Rect {
    left: number;
    right: number;
    top: number;
    bottom: number;
}
declare function getRectCenter(rect: Rect): Point;

type MountInfo<DisplayInfo> = DisplayInfo & {
    el: HTMLElement;
};
type DidMountHandler<DisplayInfo> = (mountData: MountInfo<DisplayInfo>) => void;
type WillUnmountHandler<DisplayInfo> = (mountData: MountInfo<DisplayInfo>) => void;
interface ObjCustomContent {
    html?: string;
    domNodes?: any[];
}
type CustomContent = ReactNode | ObjCustomContent;
type ContentGenerator<RenderProps> = CustomContent | ((renderProps: RenderProps) => (CustomContent | true | void | undefined));
type ClassNameInput = string | undefined | null | false | 0;
type ClassNameGenerator<RenderProps> = ClassNameInput | ((renderProps: RenderProps) => ClassNameInput);
declare function refineClassName(input: unknown, optionName: string): ClassNameInput;
declare function refineClassNameGenerator<RenderProps>(input: ClassNameGenerator<RenderProps>, optionName: string): ClassNameGenerator<RenderProps>;

interface EventInteractionState {
    affectedEvents: EventStore;
    mutatedEvents: EventStore;
    isEvent: boolean;
}

interface SplittableProps {
    businessHours: EventStore | null;
    dateSelection: DateSpan | null;
    eventStore: EventStore;
    eventUiBases: EventUiHash;
    eventDrag: EventInteractionState | null;
    eventResize: EventInteractionState | null;
    eventSelection: string;
}
declare abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {
    private getKeysForEventDefs;
    private splitDateSelection;
    private splitEventStore;
    private splitIndividualUi;
    private splitEventDrag;
    private splitEventResize;
    private eventUiBuilders;
    abstract getKeyInfo(props: PropsType): {
        [key: string]: {
            ui?: EventUi;
            businessHours?: EventStore;
        };
    };
    abstract getKeysForDateSpan(dateSpan: DateSpan): string[];
    abstract getKeysForEventDef(eventDef: EventDef): string[];
    splitProps(props: PropsType): {
        [key: string]: SplittableProps;
    };
    private _splitDateSpan;
    private _getKeysForEventDefs;
    private _splitEventStore;
    private _splitIndividualUi;
    private _splitInteraction;
}

interface DateMeta {
    dow: number;
    date: Date;
    isDisabled: boolean;
    isOther: boolean;
    isToday: boolean;
    isPast: boolean;
    isFuture: boolean;
}
declare function getDateMeta(dateMarker: DateMarker, dateEnv: DateEnv, dateProfile?: DateProfile, todayRange?: DateRange, nowDate?: DateMarker): DateMeta;

type EventSourceSuccessResponseHandler = (this: CalendarApiImpl, rawData: any, response: any) => EventInput[] | void;
type EventSourceErrorResponseHandler = (error: Error) => void;
interface EventSource<Meta> {
    _raw: any;
    sourceId: string;
    sourceDefId: number;
    meta: Meta;
    publicId: string;
    isFetching: boolean;
    latestFetchId: string;
    fetchRange: DateRange | null;
    defaultAllDay: boolean | null;
    eventDataTransform: EventInputTransformer;
    ui: EventUi;
    success: EventSourceSuccessResponseHandler | null;
    failure: EventSourceErrorResponseHandler | null;
    extendedProps: Dictionary;
}
type EventSourceHash = {
    [sourceId: string]: EventSource<any>;
};
interface EventSourceFetcherRes {
    rawEvents: EventInput[];
    response?: Response;
}
type EventSourceFetcher<Meta> = (data: {
    eventSource: EventSource<Meta>;
    range: DateRange;
    isRefetch: boolean;
    context: CalendarContext;
}, successCallback: (res: EventSourceFetcherRes) => void, errorCallback: (error: Error) => void) => void;

type EqualityFunc<T> = (a: T, b: T) => boolean;
type EqualityFuncs<P> = {
    [K in keyof P]?: EqualityFunc<P[K]>;
};
declare abstract class PureComponent<Props = Dictionary, State = Dictionary> extends Component<Props, State> {
    static addPropsEquality: typeof addPropsEquality;
    static addStateEquality: typeof addStateEquality;
    static contextType: any;
    context: ViewContext;
    propEquality: EqualityFuncs<Props>;
    stateEquality: EqualityFuncs<State>;
    shouldComponentUpdate(nextProps: Props, nextState: State): boolean;
}
declare abstract class BaseComponent<Props = Dictionary, State = Dictionary> extends PureComponent<Props, State> {
    static contextType: any;
    context: ViewContext;
}
declare function addPropsEquality(this: {
    prototype: {
        propEquality: any;
    };
}, propEquality: any): void;
declare function addStateEquality(this: {
    prototype: {
        stateEquality: any;
    };
}, stateEquality: any): void;
declare function setRef<RefType>(ref: Ref<RefType> | void, current: RefType): void;

type ElRef = Ref<HTMLElement>;
type ElAttrs = {
    ref?: ElRef;
} & Record<string, any>;
interface ElAttrsProps {
    attrs?: ElAttrs;
    className?: string;
    style?: CSSProperties & Record<string, any>;
    elRef?: ElRef;
}
interface ElProps extends ElAttrsProps {
    tag: string;
}
interface ContentGeneratorProps<RenderProps> {
    renderProps: RenderProps;
    generatorName: string | undefined;
    customGenerator?: ContentGenerator<RenderProps>;
    defaultGenerator?: (renderProps: RenderProps) => ReactNode;
}
type ContentInjectorProps<RenderProps> = ElProps & ContentGeneratorProps<RenderProps> & {
    renderId: number;
};
declare class ContentInjector<RenderProps> extends BaseComponent<ContentInjectorProps<RenderProps>> {
    private el;
    private id;
    private queuedDomNodes;
    private currentDomNodes;
    private currentGeneratorMeta;
    render(): react.DetailedReactHTMLElement<react.HTMLAttributes<HTMLElement>, HTMLElement>;
    componentDidMount(): void;
    componentDidUpdate(): void;
    componentWillUnmount(): void;
    private triggerCustomRendering;
    private handleEl;
    private applyQueueudDomNodes;
}

interface ToolbarModel {
    sectionWidgets: {
        start: ToolbarWidget[][];
        center: ToolbarWidget[][];
        end: ToolbarWidget[][];
    };
    viewsWithButtons: string[];
    hasTitle: boolean;
}
interface ToolbarInfo {
    borderlessX: boolean;
    borderlessTop: boolean;
    borderlessBottom: boolean;
}
interface ToolbarSectionInfo {
    name: string;
}
interface ButtonGroupInfo {
    hasSelection: boolean;
}
interface ButtonInfo {
    name: string;
    text: string;
    isPrimary: boolean;
    isSelected: boolean;
    isDisabled: boolean;
    isIconOnly: boolean;
    buttonGroup: ButtonGroupInfo | null;
}
type ButtonDisplay = 'auto' | 'icon' | 'text' | 'icon-text' | 'text-icon';
interface ButtonInput {
    didMount?: DidMountHandler<ButtonInfo>;
    willUnmount?: WillUnmountHandler<ButtonInfo>;
    click?: (ev: MouseEvent) => void;
    hint?: string | ((viewOrCurrentUnitText: string, viewOrCurrentUnit: string) => string);
    class?: ClassNameGenerator<ButtonInfo>;
    className?: ClassNameGenerator<ButtonInfo>;
    display?: ButtonDisplay;
    iconClass?: string | undefined;
    iconContent?: ContentGenerator<{}>;
    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?: ContentGenerator<{}>;
    buttonClick?: (ev: MouseEvent) => void;
    buttonIsPrimary?: boolean;
    buttonClass?: ClassNameGenerator<ButtonInfo>;
    buttonDidMount?: DidMountHandler<ButtonInfo>;
    buttonWillUnmount?: WillUnmountHandler<ButtonInfo>;
}
interface ToolbarInput {
    left?: string;
    center?: string;
    right?: string;
    start?: string;
    end?: string;
}
type ToolbarElementInput = ContentGenerator<{}>;

interface ViewContainerProps extends Partial<ElProps> {
    viewSpec: ViewSpec;
    attrs?: any;
    children?: ReactNode;
}
interface ViewDisplayInfo {
    view: ViewApi;
    borderlessX: boolean;
    borderlessTop: boolean;
    borderlessBottom: boolean;
    options: {
        headerToolbar: ToolbarInput | false | undefined;
        footerToolbar: ToolbarInput | false | undefined;
    };
    isHeightAuto: boolean;
}
declare class ViewContainer extends BaseComponent<ViewContainerProps> {
    private refineRenderProps;
    render(): react_jsx_runtime.JSX.Element;
}

interface ViewProps {
    className?: string;
    dateProfile: DateProfile;
    businessHours: EventStore;
    eventStore: EventStore;
    eventUiBases: EventUiHash;
    dateSelection: DateSpan | null;
    eventSelection: string;
    eventDrag: EventInteractionState | null;
    eventResize: EventInteractionState | null;
    forPrint: boolean;
    labelId: string | undefined;
    labelStr: string | undefined;
}
type ViewContentInfo = ViewProps & ViewDisplayInfo & {
    nextDayThreshold: Duration;
};
declare function sliceEvents(props: ViewContentInfo, allDay?: boolean): EventRenderRange[];

type ViewComponentType = ComponentType<ViewProps>;
type ViewConfigInput = ViewComponentType | ViewOptions;
type ViewConfigInputHash = {
    [viewType: string]: ViewConfigInput;
};

interface ViewSpec {
    type: string;
    component: ViewComponentType;
    duration: Duration;
    durationUnit: string;
    singleUnit: string;
    optionDefaults: ViewOptions;
    optionOverrides: ViewOptions;
}
type ViewSpecHash = {
    [viewType: string]: ViewSpec;
};

interface HandlerFuncTypeHash {
    [eventName: string]: (...args: any[]) => any;
}
declare class Emitter<HandlerFuncs extends HandlerFuncTypeHash> {
    private handlers;
    private options;
    private thisContext;
    setThisContext(thisContext: any): void;
    setOptions(options: Partial<HandlerFuncs>): void;
    on<Prop extends keyof HandlerFuncs>(type: Prop, handler: HandlerFuncs[Prop]): void;
    off<Prop extends keyof HandlerFuncs>(type: Prop, handler?: HandlerFuncs[Prop]): void;
    trigger<Prop extends keyof HandlerFuncs>(type: Prop, ...args: Parameters<HandlerFuncs[Prop]>): void;
    hasHandlers(type: keyof HandlerFuncs): boolean;
}

declare class CalendarNowManager {
    private dateEnv?;
    private resetListeners;
    private nowAnchorDate?;
    private nowAnchorQueried?;
    private nowFn?;
    handleInput(dateEnv: DateEnv, // will change if timezone setup changed
    nowInput: DateInput | (() => DateInput)): void;
    getDateMarker(): DateMarker;
    addResetListener(handler: () => void): void;
    removeResetListener(handler: () => void): void;
}

interface CalendarDataManagerState {
    dynamicOptionOverrides: CalendarOptions;
    currentViewType: string;
    currentDate: DateMarker;
    dateProfile: DateProfile;
    businessHours: EventStore;
    eventSources: EventSourceHash;
    eventUiBases: EventUiHash;
    eventStore: EventStore;
    renderableEventStore: EventStore;
    dateSelection: DateSpan | null;
    eventSelection: string;
    eventDrag: EventInteractionState | null;
    eventResize: EventInteractionState | null;
    selectionConfig: EventUi;
    nowDate: DateMarker;
}
interface CalendarToolbarProps {
    title: string;
    selectedButton: string;
    navUnit: string;
    isTodayEnabled: boolean;
    isPrevEnabled: boolean;
    isNextEnabled: boolean;
}
interface CalendarOptionsData {
    localeDefaults: CalendarOptions;
    calendarOptions: CalendarOptionsRefined;
    toolbarConfig: {
        [toolbarName: string]: ToolbarModel;
    };
    availableRawLocales: any;
    dateEnv: DateEnv;
    pluginHooks: PluginHooks;
    viewSpecs: ViewSpecHash;
}
interface CalendarCurrentViewData {
    viewSpec: ViewSpec;
    options: ViewOptionsRefined;
    viewApi: ViewImpl;
    dateProfileGenerator: DateProfileGenerator;
}
type CalendarDataBase = CalendarOptionsData & CalendarCurrentViewData & CalendarDataManagerState;
interface CalendarData extends CalendarDataBase {
    nowManager: CalendarNowManager;
    viewTitle: string;
    calendarApi: CalendarApiImpl;
    dispatch: (action: Action) => void;
    emitter: Emitter<Required<CalendarListeners>>;
    getCurrentData(): CalendarData;
    toolbarProps: CalendarToolbarProps;
}

declare class ViewImpl implements ViewApi {
    type: string;
    private getCurrentData;
    private dateEnv;
    constructor(type: string, getCurrentData: () => CalendarData, dateEnv: DateEnv);
    get calendar(): CalendarApi;
    get title(): string;
    get activeStart(): Date;
    get activeEnd(): Date;
    get currentStart(): Date;
    get currentEnd(): Date;
    getOption(name: string): any;
}

interface Hit {
    componentId?: string;
    context?: ViewContext;
    dateProfile: DateProfile;
    dateSpan: DateSpan;
    getDayEl: () => HTMLElement;
    rect: Rect;
    layer: number;
    largeUnit?: string;
}

interface EventSegUiInteractionState<S> {
    affectedInstances: EventInstanceHash;
    segs: (S & EventRangeProps)[];
    isEvent: boolean;
}
declare abstract class DateComponent<Props = Dictionary, State = Dictionary> extends BaseComponent<Props, State> {
    uid: string;
    prepareHits(): void;
    queryHit(isRtl: boolean, positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit | null;
    isValidSegDownEl(el: HTMLElement): boolean;
    isValidDateDownEl(el: HTMLElement): boolean;
}

declare abstract class Interaction {
    component: DateComponent<any>;
    isHitComboAllowed: ((hit0: Hit, hit1: Hit) => boolean) | null;
    constructor(settings: InteractionSettings);
    destroy(): void;
}
type InteractionClass = {
    new (settings: InteractionSettings): Interaction;
};
interface InteractionSettingsInput {
    el: HTMLElement;
    useEventCenter?: boolean;
    isHitComboAllowed?: (hit0: Hit, hit1: Hit) => boolean;
    disableHits?: boolean;
}
interface InteractionSettings {
    component: DateComponent<any>;
    el: HTMLElement;
    useEventCenter: boolean;
    isHitComboAllowed: ((hit0: Hit, hit1: Hit) => boolean) | null;
}

interface ViewContext extends CalendarContext {
    options: ViewOptionsRefined;
    dateProfileGenerator: DateProfileGenerator;
    viewSpec: ViewSpec;
    viewApi: ViewImpl;
    baseId: string;
    registerInteractiveComponent: (component: DateComponent<any>, settingsInput: InteractionSettingsInput) => void;
    unregisterInteractiveComponent: (component: DateComponent<any>) => void;
}

declare abstract class ElementDragging {
    emitter: Emitter<any>;
    constructor(el: HTMLElement, selector?: string);
    destroy(): void;
    abstract cancel(): void;
    setMirrorIsVisible(bool: boolean): void;
    setMirrorNeedsRevert(bool: boolean): void;
    setAutoScrollEnabled(bool: boolean): void;
}
type ElementDraggingClass = {
    new (el: HTMLElement, selector?: string): ElementDragging;
};

interface CalendarInnerProps extends CalendarData {
    forPrint: boolean;
    baseId: string;
}
interface CalendarContentProps extends CalendarData {
    toolbarProps: CalendarToolbarProps;
    forPrint: boolean;
}
declare class CalendarInner extends PureComponent<CalendarInnerProps> {
    private buildViewContext;
    private buildViewPropTransformers;
    private interactionsStore;
    private calendarInteractions;
    private get viewTitleId();
    render(): react_jsx_runtime.JSX.Element;
    private renderView;
    private buildAppendContent;
    componentDidMount(): void;
    componentDidUpdate(prevProps: Readonly<CalendarData>): void;
    componentWillUnmount(): void;
    private registerInteractiveComponent;
    private unregisterInteractiveComponent;
}

interface ScrollerInterface {
    x: number;
    y: number;
    scrollTo(options: {
        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 ScrollerSyncerClass {
    new (horizontal?: boolean): ScrollerSyncerInterface;
}
interface ScrollerSyncerInterface extends ScrollerInterface {
    handleChildren(scrollers: ScrollerInterface[]): void;
    destroy(): void;
    addScrollStartListener(handler: (isDevice: boolean) => void): void;
    removeScrollStartListener(handler: (isDevice: boolean) => void): void;
    addScrollListener(handler: (isDevice: boolean, scroll: number) => void): void;
    removeScrollListener(handler: (isDevice: boolean, scroll: number) => void): void;
}

type CssDimValue = string | number;
declare function getIsHeightAuto(options: {
    height?: CssDimValue;
    contentHeight?: CssDimValue;
}): boolean;
declare function getTableHeaderSticky(options: {
    height?: CssDimValue;
    contentHeight?: CssDimValue;
    tableHeaderSticky?: boolean | 'auto';
}): boolean;
declare function getFooterScrollbarSticky(options: {
    height?: CssDimValue;
    contentHeight?: CssDimValue;
    footerScrollbarSticky?: boolean | 'auto';
}): boolean;

type ContentContainerProps<RenderProps> = ElAttrsProps & ContentGeneratorProps<RenderProps> & {
    tag?: string;
    classNameGenerator?: ClassNameGenerator<RenderProps> | undefined;
    didMount?: ((renderProps: RenderProps & {
        el: HTMLElement;
    }) => void) | undefined;
    willUnmount?: ((renderProps: RenderProps & {
        el: HTMLElement;
    }) => void) | undefined;
    children?: InnerContainerFunc<RenderProps>;
};
declare class ContentContainer<RenderProps> extends Component<ContentContainerProps<RenderProps>> {
    static contextType: react.Context<number>;
    didMountMisfire?: boolean;
    context: number;
    el: HTMLElement;
    InnerContent: (props: ElProps) => react.CElement<ContentInjectorProps<unknown>, ContentInjector<unknown>>;
    render(): ReactNode;
    handleEl: (el: HTMLElement | null) => void;
    componentDidMount(): void;
    componentWillUnmount(): void;
}
type InnerContainerComponent = FC<ElProps>;
type InnerContainerFunc<RenderProps> = (InnerContainer: InnerContainerComponent, renderProps: RenderProps, attrs: ElAttrs) => ReactNode;
declare function generateClassName<RenderProps>(classNameGenerator: ClassNameGenerator<RenderProps> | undefined, renderProps: RenderProps): string;

interface NowIndicatorHeaderContainerProps extends Partial<ElProps> {
    date: DateMarker;
    children?: InnerContainerFunc<NowIndicatorHeaderInfo>;
}
interface NowIndicatorHeaderInfo {
    date: Date;
    view: ViewApi;
}
declare const NowIndicatorHeaderContainer: (props: NowIndicatorHeaderContainerProps) => react_jsx_runtime.JSX.Element;

interface NowIndicatorLineContainerProps extends Partial<ElProps> {
    date: DateMarker;
    children?: InnerContainerFunc<NowIndicatorLineInfo>;
}
interface NowIndicatorLineInfo {
    date: Date;
    view: ViewApi;
}
declare const NowIndicatorLineContainer: (props: NowIndicatorLineContainerProps) => react_jsx_runtime.JSX.Element;

interface MoreLinkContainerProps extends Partial<ElAttrsProps> {
    dateProfile: DateProfile;
    todayRange: DateRange;
    allDayDate: DateMarker | null;
    segs: EventRangeProps[];
    hiddenSegs: EventRangeProps[];
    dateSpanProps?: Dictionary;
    alignElRef?: RefObject<HTMLElement>;
    alignParentTop?: string;
    forceTimed?: boolean;
    popoverContent: () => ReactNode;
    isNarrow: boolean;
    isMicro: boolean;
    display: 'row' | 'column';
}
interface MoreLinkInfo$1 {
    num: number;
    numericText: string;
    longText: string;
    text: string;
    isNarrow: boolean;
    view: ViewApi;
}
interface MoreLinkContainerState {
    isPopoverOpen: boolean;
}
declare class MoreLinkContainer extends BaseComponent<MoreLinkContainerProps, MoreLinkContainerState> {
    private linkEl;
    state: {
        isPopoverOpen: boolean;
    };
    render(): react_jsx_runtime.JSX.Element;
    handleLinkEl: (linkEl: HTMLElement | null) => void;
    handleClick: (ev: MouseEvent) => void;
    handlePopoverClose: () => void;
}

interface CalendarDisplayInfo {
    borderlessX: boolean;
    borderlessTop: boolean;
    borderlessBottom: boolean;
}
interface CalendarMediaRootProps {
    emitter: Emitter<Required<CalendarListeners>>;
    children?: (forPrint: boolean) => ReactElement;
}
interface CalendarMediaRootState {
    forPrint: boolean;
}
declare class CalendarMediaRoot extends Component<CalendarMediaRootProps, CalendarMediaRootState> {
    state: CalendarMediaRootState;
    render(): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
    componentDidMount(): void;
    componentWillUnmount(): void;
    private handleBeforePrint;
    private handleAfterPrint;
}
declare function computeRootClassName(options: CalendarOptions, forPrint: boolean): string;

declare class Store<Value> {
    private handlers;
    private currentValue;
    set(value: Value): void;
    subscribe(handler: (value: Value) => void): void;
}

type CustomRenderingHandler<RenderProps> = (customRender: CustomRendering<RenderProps>) => void;
interface CustomRendering<RenderProps> {
    id: string;
    isActive: boolean;
    containerEl: HTMLElement;
    generatorMeta: any;
    renderProps: RenderProps;
}
declare class CustomRenderingStore<RenderProps> extends Store<Map<string, CustomRendering<RenderProps>>> {
    private map;
    handle(customRendering: CustomRendering<RenderProps>): void;
}

interface SlotLaneInfo extends DateMeta {
    time?: Duration;
    isMajor: boolean;
    isMinor: boolean;
    view: ViewApi;
}
interface SlotHeaderInfo extends SlotLaneInfo {
    level: number;
    isTime: boolean;
    text: string;
    isNarrow: boolean;
    hasNavLink: boolean;
    isFirst: boolean;
}
interface AllDayHeaderInfo {
    text: string;
    view: ViewApi;
    isNarrow: boolean;
}
interface DayHeaderInfo extends DateMeta {
    date: Date;
    isNarrow: boolean;
    isMajor: boolean;
    inPopover: boolean;
    hasNavLink: boolean;
    level: number;
    text: string;
    textParts: DateTimeFormatPartWithWeek$1[];
    weekdayText: string;
    dayNumberText: string;
    view: ViewApi;
    [otherProp: string]: any;
}
interface DayHeaderDividerInfo {
    isSticky: boolean;
    multiMonthColumns: number;
    options: {
        allDaySlot: boolean;
    };
}
interface DayCellInfo extends DateMeta {
    date: DateMarker;
    isMajor: boolean;
    isNarrow: boolean;
    inPopover: boolean;
    hasNavLink: boolean;
    view: ViewApi;
    text: string;
    textParts: DateTimeFormatPartWithWeek$1[];
    weekdayText: string;
    dayNumberText: string;
    monthText: string;
    options: {
        businessHours: boolean;
    };
    [extraProp: string]: any;
}

type EventSourceFuncInfo = {
    start: Date;
    end: Date;
    startStr: string;
    endStr: string;
    timeZone: string;
};
type EventSourceFunc = ((info: EventSourceFuncInfo, successCallback: (eventInputs: EventInput[]) => void, failureCallback: (error: Error) => void) => void) | ((info: EventSourceFuncInfo) => Promise<EventInput[]>);

declare const JSON_FEED_EVENT_SOURCE_REFINERS: {
    method: StringConstructor;
    extraParams: Identity<Dictionary | (() => Dictionary)>;
    startParam: StringConstructor;
    endParam: StringConstructor;
    timeZoneParam: StringConstructor;
};

declare const EVENT_SOURCE_REFINERS: {
    id: StringConstructor;
    defaultAllDay: BooleanConstructor;
    url: StringConstructor;
    format: StringConstructor;
    events: Identity<EventInput[] | EventSourceFunc>;
    eventDataTransform: Identity<EventInputTransformer>;
    success: Identity<EventSourceSuccessResponseHandler>;
    failure: Identity<EventSourceErrorResponseHandler>;
};
type BuiltInEventSourceRefiners = typeof EVENT_SOURCE_REFINERS & typeof JSON_FEED_EVENT_SOURCE_REFINERS;
declare module '@fullcalendar/core/protected-api' {
    interface EventSourceOptions extends RawOptionsFromRefiners<BuiltInEventSourceRefiners> {
    }
    interface EventSourceOptionsRefined extends RefinedOptionsFromRefiners<BuiltInEventSourceRefiners> {
    }
}
type EventSourceInputObject = EventUiInput & EventSourceOptions;
type EventSourceInput = EventSourceInputObject | // object in extended form
EventInput[] | EventSourceFunc | // just a function
string;
type EventSourceRefined = EventUiRefined & EventSourceOptionsRefined;

type DateTimeFormatPartWithWeek = Omit<Intl.DateTimeFormatPart, 'type'> & {
    type: Intl.DateTimeFormatPart['type'] | 'week';
};
interface WeekNumberHeaderInfo {
    num?: number;
    date?: Date;
    text: string;
    textParts: DateTimeFormatPartWithWeek[];
    isNarrow: boolean;
    hasNavLink: boolean;
    options: {
        dayMinWidth: number | undefined;
    };
}
interface InlineWeekNumberInfo {
    num: number;
    date: Date;
    text: string;
    textParts: DateTimeFormatPartWithWeek[];
    isNarrow: boolean;
    hasNavLink: boolean;
}

interface EventSegment {
    event: EventApi;
    start: Date;
    end: Date;
    isStart: boolean;
    isEnd: boolean;
}
type MoreLinkAction = MoreLinkSimpleAction | MoreLinkHandler;
type MoreLinkSimpleAction = 'popover' | 'week' | 'day' | 'timeGridWeek' | 'timeGridDay' | string;
interface MoreLinkInfo {
    date: Date;
    allDay: boolean;
    allSegs: EventSegment[];
    hiddenSegs: EventSegment[];
    jsEvent: UIEvent;
    view: ViewApi;
}
type MoreLinkHandler = (info: MoreLinkInfo) => MoreLinkSimpleAction | void;

interface DayLaneInfo extends DateMeta {
    date: DateMarker;
    isNarrow: boolean;
    isStack: boolean;
    isMajor: boolean;
    view: ViewApi;
    [extraProp: string]: any;
}

type TableDisplayInfo = {
    borderlessX: boolean;
    borderlessTop: boolean;
    borderlessBottom: boolean;
    multiMonthColumns: number;
};
type TableHeaderInfo = TableDisplayInfo & {
    isSticky: boolean;
};
type TableBodyInfo = TableDisplayInfo;

interface EventClickInfo {
    el: HTMLElement;
    event: EventImpl;
    jsEvent: MouseEvent;
    view: ViewApi;
}

interface EventHoveringInfo {
    el: HTMLElement;
    event: EventImpl;
    jsEvent: MouseEvent;
    view: ViewApi;
}

interface DateSelectionApi extends DateSpanApi {
    jsEvent: UIEvent;
    view: ViewApi;
}
type DatePointTransform = (dateSpan: DateSpan, context: CalendarContext) => any;
type DateSpanTransform = (dateSpan: DateSpan, context: CalendarContext) => any;
type CalendarInteraction = {
    destroy: () => void;
};
type CalendarInteractionClass = {
    new (context: CalendarContext): CalendarInteraction;
};
type OptionChangeHandler = (propValue: any, context: CalendarContext) => void;
type OptionChangeHandlerMap = {
    [propName: string]: OptionChangeHandler;
};
interface DateSelectInfo extends DateSpanApi {
    jsEvent: MouseEvent | null;
    view: ViewApi;
}
interface DateUnselectInfo {
    jsEvent: MouseEvent;
    view: ViewApi;
}

type DatesSetInfo = RangeApiWithTimeZone & {
    view: ViewApi;
};

interface EventAddInfo {
    event: EventImpl;
    relatedEvents: EventImpl[];
    revert: () => void;
}
interface EventChangeInfo {
    oldEvent: EventImpl;
    event: EventImpl;
    relatedEvents: EventImpl[];
    revert: () => void;
}
interface EventDropInfo extends EventChangeInfo {
    el: HTMLElement;
    delta: Duration;
    jsEvent: MouseEvent;
    view: ViewApi;
}
interface EventRemoveInfo {
    event: EventImpl;
    relatedEvents: EventImpl[];
    revert: () => 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 NoEventsInfo {
    text: string;
    view: ViewApi;
}

interface ListDayInfo extends DateMeta {
    isFirst: boolean;
    isLast: boolean;
    view: ViewApi;
}
interface ListDayHeaderInfo extends DateMeta {
    view: ViewApi;
}
interface ListDayEventsInfo extends DateMeta {
    view: ViewApi;
}
interface ListDayHeaderInnerInfo extends DateMeta {
    text: string;
    textParts: DateTimeFormatPartWithWeek$1[];
    weekdayText: string;
    dayNumberText: string;
    hasNavLink: boolean;
    level: number;
    view: ViewApi;
}

interface SingleMonthInfo {
    multiMonthColumns: number;
    isFirst: boolean;
    isLast: boolean;
}
type SingleMonthHeaderInfo = {
    isSticky: boolean;
    isNarrow: boolean;
    hasNavLink: boolean;
    multiMonthColumns: number;
};

type EventDragStopInfo = EventDragInfo;
type EventDragStartInfo = EventDragInfo;
interface EventDragInfo {
    el: HTMLElement;
    event: EventApi;
    jsEvent: MouseEvent;
    view: ViewApi;
}

type EventResizeStartInfo = EventResizeStartStopData;
type EventResizeStopInfo = EventResizeStartStopData;
interface EventResizeStartStopData {
    el: HTMLElement;
    event: EventApi;
    jsEvent: MouseEvent;
    view: ViewApi;
}
interface EventResizeDoneInfo extends EventChangeInfo {
    el: HTMLElement;
    startDelta: Duration;
    endDelta: Duration;
    jsEvent: MouseEvent;
    view: ViewApi;
}

interface DateClickInfo extends DatePointApi {
    dayEl: HTMLElement;
    jsEvent: MouseEvent;
    view: ViewApi;
}

interface DropInfo extends DatePointApi {
    draggedEl: HTMLElement;
    jsEvent: MouseEvent;
    view: ViewApi;
}
type EventReceiveInfo = EventReceiveLeaveData;
type EventLeaveInfo = EventReceiveLeaveData;
interface EventReceiveLeaveData {
    draggedEl: HTMLElement;
    event: EventApi;
    relatedEvents: EventApi[];
    revert: () => void;
    view: ViewApi;
}

interface EventApi {
    source: EventSourceApi | null;
    start: Date | null;
    end: Date | null;
    startStr: string;
    endStr: string;
    id: string;
    groupId: string;
    allDay: boolean;
    title: string;
    url: string;
    display: string;
    startEditable: boolean;
    durationEditable: boolean;
    constraint: any;
    overlap: boolean;
    allow: any;
    color: string;
    contrastColor: string;
    className: string;
    extendedProps: Dictionary;
    setProp(name: string, val: any): void;
    setExtendedProp(name: string, val: any): void;
    setStart(startInput: DateInput, options?: {
        granularity?: string;
        maintainDuration?: boolean;
    }): void;
    setEnd(endInput: DateInput | null, options?: {
        granularity?: string;
    }): void;
    setDates(startInput: DateInput, endInput: DateInput | null, options?: {
        allDay?: boolean;
        granularity?: string;
    }): void;
    moveStart(deltaInput: DurationInput): void;
    moveEnd(deltaInput: DurationInput): void;
    moveDates(deltaInput: DurationInput): void;
    setAllDay(allDay: boolean, options?: {
        maintainDuration?: boolean;
    }): void;
    formatRange(formatInput: FormatterInput): any;
    remove(): void;
    toPlainObject(settings?: {
        collapseExtendedProps?: boolean;
    }): Dictionary;
    toJSON(): Dictionary;
}

interface CalendarApi {
    view: ViewApi;
    setOption<OptionName extends keyof CalendarOptions>(name: OptionName, val: CalendarOptions[OptionName]): void;
    getOption<OptionName extends keyof CalendarOptions>(name: OptionName): CalendarOptions[OptionName];
    getAvailableLocaleCodes(): string[];
    on<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: Required<CalendarListeners>[ListenerName]): void;
    off<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: Required<CalendarListeners>[ListenerName]): void;
    trigger<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, ...args: Parameters<Required<CalendarListeners>[ListenerName]>): void;
    changeView(viewType: string, dateOrRange?: DateRangeInput | DateInput): void;
    zoomTo(dateMarker: Date, viewType?: string): void;
    prev(): void;
    next(): void;
    prevYear(): void;
    nextYear(): void;
    today(): void;
    gotoDate(zonedDateInput: DateInput): void;
    incrementDate(deltaInput: DurationInput): void;
    getDate(): Date;
    formatDate(d: DateInput, formatter: FormatterInput): string;
    formatRange(d0: DateInput, d1: DateInput, settings: any): string;
    formatIso(d: DateInput, omitTime?: boolean): string;
    select(dateOrObj: DateInput | any, endDate?: DateInput): void;
    unselect(): void;
    addEvent(eventInput: EventInput, sourceInput?: EventSourceApi | string | boolean): EventApi | null;
    getEventById(id: string): EventApi | null;
    getEvents(): EventApi[];
    removeAllEvents(): void;
    getEventSources(): EventSourceApi[];
    getEventSourceById(id: string): EventSourceApi | null;
    addEventSource(sourceInput: EventSourceInput): EventSourceApi;
    removeAllEventSources(): void;
    refetchEvents(): void;
    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;
}

declare class EventSourceImpl implements EventSourceApi {
    private context;
    internalEventSource: EventSource<any>;
    constructor(context: CalendarContext, internalEventSource: EventSource<any>);
    remove(): void;
    refetch(): void;
    get id(): string;
    get url(): string;
    get format(): string;
}

declare class EventImpl implements EventApi {
    _context: CalendarContext;
    _def: EventDef;
    _instance: EventInstance | null;
    constructor(context: CalendarContext, def: EventDef, instance?: EventInstance);
    setProp(name: string, val: any): void;
    setExtendedProp(name: string, val: any): void;
    setStart(startInput: DateInput, options?: {
        granularity?: string;
        maintainDuration?: boolean;
    }): void;
    setEnd(endInput: DateInput | null, options?: {
        granularity?: string;
    }): void;
    setDates(startInput: DateInput, endInput: DateInput | null, options?: {
        allDay?: boolean;
        granularity?: string;
    }): void;
    moveStart(deltaInput: DurationInput): void;
    moveEnd(deltaInput: DurationInput): void;
    moveDates(deltaInput: DurationInput): void;
    setAllDay(allDay: boolean, options?: {
        maintainDuration?: boolean;
    }): void;
    formatRange(formatInput: FormatterInput): string;
    mutate(mutation: EventMutation): void;
    remove(): void;
    get source(): EventSourceImpl | null;
    get start(): Date | null;
    get end(): Date | null;
    get startStr(): string;
    get endStr(): string;
    get id(): string;
    get groupId(): string;
    get allDay(): boolean;
    get title(): string;
    get url(): string;
    get display(): string;
    get startEditable(): boolean;
    get durationEditable(): boolean;
    get constraint(): string | EventStore;
    get overlap(): boolean;
    get allow(): AllowFunc;
    get color(): string;
    get contrastColor(): string;
    get className(): string;
    get extendedProps(): Dictionary;
    toPlainObject(settings?: {
        collapseExtendedProps?: boolean;
    }): Dictionary;
    toJSON(): Dictionary;
}

interface EventRenderRange extends EventTuple {
    ui: EventUi;
    range: DateRange;
    isStart: boolean;
    isEnd: boolean;
}
interface EventRangeProps {
    eventRange: EventRenderRange;
}
declare function getEventKey(seg: EventRangeProps): string;
declare function sortEventSegs<S extends EventRangeProps>(segs: S[], eventOrderSpecs: OrderSpec<EventImpl>[]): S[];
interface MinimalEventProps {
    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;
}
interface EventDisplayInfo {
    event: EventImpl;
    timeText: string;
    color: string;
    contrastColor: string;
    isDraggable: boolean;
    isStartResizable: boolean;
    isEndResizable: boolean;
    isMirror: boolean;
    isStart: boolean;
    isEnd: boolean;
    isFirst: boolean;
    isLast: boolean;
    isPast: boolean;
    isFuture: boolean;
    isToday: boolean;
    isSelected: boolean;
    isDragging: boolean;
    isResizing: boolean;
    isInteractive: boolean;
    view: ViewApi;
    isNarrow: boolean;
    isShort: boolean;
    level: number;
    timeClass: string;
    titleClass: string;
    options: {
        eventOverlap: boolean;
    };
}
declare function getEventRangeMeta(eventRange: EventRenderRange, todayRange: DateRange, nowDate?: DateMarker): {
    isPast: boolean;
    isFuture: boolean;
    isToday: boolean;
};
declare function buildEventRangeKey(eventRange: EventRenderRange): string;

interface OpenDateSpanInput {
    start?: DateInput;
    end?: DateInput;
    allDay?: boolean;
    [otherProp: string]: any;
}
interface DateSpanInput extends OpenDateSpanInput {
    start: DateInput;
    end: DateInput;
}
interface OpenDateSpan {
    range: OpenDateRange;
    allDay: boolean;
    [otherProp: string]: any;
}
interface DateSpan extends OpenDateSpan {
    range: DateRange;
}
interface RangeApi {
    start: Date;
    end: Date;
    startStr: string;
    endStr: string;
}
interface DateSpanApi extends RangeApi {
    allDay: boolean;
}
interface RangeApiWithTimeZone extends RangeApi {
    timeZone: string;
}
interface DatePointApi {
    date: Date;
    dateStr: string;
    allDay: boolean;
}

type ConstraintInput = 'businessHours' | string | EventInput | EventInput[];
type Constraint = 'businessHours' | string | EventStore | false;
type OverlapFunc = ((stillEvent: EventImpl, movingEvent: EventImpl | null) => boolean);
type AllowFunc = (span: DateSpanApi, movingEvent: EventImpl | null) => boolean;
type isPropsValidTester = (props: SplittableProps, context: CalendarContext) => boolean;

declare const EVENT_UI_REFINERS: {
    display: StringConstructor;
    editable: BooleanConstructor;
    startEditable: BooleanConstructor;
    durationEditable: BooleanConstructor;
    constraint: Identity<any>;
    overlap: Identity<boolean>;
    allow: Identity<AllowFunc>;
    class: typeof refineClassName;
    className: typeof refineClassName;
    color: StringConstructor;
    contrastColor: StringConstructor;
};
type BuiltInEventUiRefiners = typeof EVENT_UI_REFINERS;
interface EventUiRefiners extends BuiltInEventUiRefiners {
}
type EventUiInput = RawOptionsFromRefiners<Required<EventUiRefiners>>;
type EventUiRefined = RefinedOptionsFromRefiners<Required<EventUiRefiners>>;
interface EventUi {
    display: string | null;
    startEditable: boolean | null;
    durationEditable: boolean | null;
    constraints: Constraint[];
    overlap: boolean | null;
    allows: AllowFunc[];
    color: string;
    contrastColor: string;
    className: string;
}
type EventUiHash = {
    [defId: string]: EventUi;
};
declare function createEventUi(refined: EventUiRefined, context: CalendarContext): EventUi;
declare function combineEventUis(uis: EventUi[]): EventUi;

interface EventDef {
    defId: string;
    sourceId: string;
    publicId: string;
    groupId: string;
    allDay: boolean;
    hasEnd: boolean;
    recurringDef: {
        typeId: number;
        typeData: any;
        duration: Duration | null;
    } | null;
    title: string;
    url: string;
    ui: EventUi;
    interactive?: boolean;
    extendedProps: Dictionary;
}
type EventDefHash = {
    [defId: string]: EventDef;
};

interface EventStore {
    defs: EventDefHash;
    instances: EventInstanceHash;
}
declare function mergeEventStores(store0: EventStore, store1: EventStore): EventStore;

interface EventMutation {
    datesDelta?: Duration;
    startDelta?: Duration;
    endDelta?: Duration;
    standardProps?: any;
    extendedProps?: any;
}
type eventDefMutationApplier = (eventDef: EventDef, mutation: EventMutation, context: CalendarContext) => void;

type eventDragMutationMassager = (mutation: EventMutation, hit0: Hit, hit1: Hit) => void;
type EventDropTransformers = (mutation: EventMutation, context: CalendarContext) => Dictionary;
type eventIsDraggableTransformer = (val: boolean, eventDef: EventDef, eventUi: EventUi, context: CalendarContext) => boolean;

type dateSelectionJoinTransformer = (hit0: Hit, hit1: Hit) => any;

declare const DRAG_META_REFINERS: {
    startTime: typeof createDuration;
    duration: typeof createDuration;
    create: BooleanConstructor;
    sourceId: StringConstructor;
};
type DragMetaInput = RawOptionsFromRefiners<typeof DRAG_META_REFINERS> & {
    [otherProp: string]: any;
};
interface DragMeta {
    startTime: Duration | null;
    duration: Duration | null;
    create: boolean;
    sourceId: string;
    leftoverProps: Dictionary;
}

type ExternalDefTransform = (dateSpan: DateSpan, dragMeta: DragMeta) => any;

interface EventSourceDef<Meta> {
    ignoreRange?: boolean;
    parseMeta: (refined: EventSourceRefined) => Meta | null;
    fetch: EventSourceFetcher<Meta>;
}

interface ParsedRecurring<RecurringData> {
    typeData: RecurringData;
    allDayGuess: boolean | null;
    duration: Duration | null;
}
interface RecurringType<RecurringData> {
    parse: (refined: EventRefined, dateEnv: DateEnv) => ParsedRecurring<RecurringData> | null;
    expand: (typeData: any, framingRange: DateRange, dateEnv: DateEnv) => DateMarker[];
}

interface PluginInput {
    name: string;
    premiumReleaseDate?: string;
    deps?: PluginInput[];
    reducers?: ReducerFunc[];
    isLoadingFuncs?: ((state: Dictionary) => boolean)[];
    contextInit?: (context: CalendarContext) => void;
    eventRefiners?: GenericRefiners;
    eventDefMemberAdders?: EventDefMemberAdder[];
    eventSourceRefiners?: GenericRefiners;
    isDraggableTransformers?: eventIsDraggableTransformer[];
    eventDragMutationMassagers?: eventDragMutationMassager[];
    eventDefMutationAppliers?: eventDefMutationApplier[];
    dateSelectionTransformers?: dateSelectionJoinTransformer[];
    datePointTransforms?: DatePointTransform[];
    dateSpanTransforms?: DateSpanTransform[];
    views?: ViewConfigInputHash;
    viewPropsTransformers?: ViewPropsTransformerClass[];
    isPropsValid?: isPropsValidTester;
    externalDefTransforms?: ExternalDefTransform[];
    viewContainerAppends?: ViewContainerAppend[];
    eventDropTransformers?: EventDropTransformers[];
    componentInteractions?: InteractionClass[];
    calendarInteractions?: CalendarInteractionClass[];
    eventSourceDefs?: EventSourceDef<any>[];
    cmdFormatter?: CmdDateFormatterFunc;
    recurringTypes?: RecurringType<any>[];
    initialView?: string;
    elementDraggingImpl?: ElementDraggingClass;
    optionChangeHandlers?: OptionChangeHandlerMap;
    scrollerSyncerClass?: ScrollerSyncerClass;
    listenerRefiners?: GenericListenerRefiners;
    optionRefiners?: GenericRefiners;
    optionDefaults?: CalendarOptions;
    propSetHandlers?: {
        [propName: string]: (val: any, context: CalendarData) => void;
    };
}
interface PluginHooks {
    premiumReleaseDate: Date | undefined;
    reducers: ReducerFunc[];
    isLoadingFuncs: ((state: Dictionary) => boolean)[];
    contextInit: ((context: CalendarContext) => void)[];
    eventRefiners: GenericRefiners;
    eventDefMemberAdders: EventDefMemberAdder[];
    eventSourceRefiners: GenericRefiners;
    isDraggableTransformers: eventIsDraggableTransformer[];
    eventDragMutationMassagers: eventDragMutationMassager[];
    eventDefMutationAppliers: eventDefMutationApplier[];
    dateSelectionTransformers: dateSelectionJoinTransformer[];
    datePointTransforms: DatePointTransform[];
    dateSpanTransforms: DateSpanTransform[];
    views: ViewConfigInputHash;
    viewPropsTransformers: ViewPropsTransformerClass[];
    isPropsValid: isPropsValidTester | null;
    externalDefTransforms: ExternalDefTransform[];
    viewContainerAppends: ViewContainerAppend[];
    eventDropTransformers: EventDropTransformers[];
    componentInteractions: InteractionClass[];
    calendarInteractions: CalendarInteractionClass[];
    eventSourceDefs: EventSourceDef<any>[];
    cmdFormatter?: CmdDateFormatterFunc;
    recurringTypes: RecurringType<any>[];
    initialView: string;
    elementDraggingImpl?: ElementDraggingClass;
    optionChangeHandlers: OptionChangeHandlerMap;
    scrollerSyncerClass: ScrollerSyncerClass | null;
    listenerRefiners: GenericListenerRefiners;
    optionRefiners: GenericRefiners;
    optionDefaults: CalendarOptions[];
    propSetHandlers: {
        [propName: string]: (val: any, context: CalendarData) => void;
    };
}
type ViewPropsTransformerClass = new () => ViewPropsTransformer;
interface ViewPropsTransformer {
    transform(viewProps: ViewProps, calendarProps: CalendarContentProps): any;
}
type ViewContainerAppend = (context: CalendarContext) => ReactNode;

interface CalendarContext {
    nowManager: CalendarNowManager;
    dateEnv: DateEnv;
    options: BaseOptionsRefined;
    pluginHooks: PluginHooks;
    emitter: Emitter<Required<CalendarListeners>>;
    dispatch(action: Action): void;
    getCurrentData(): CalendarData;
    calendarApi: CalendarApiImpl;
}

declare const EVENT_REFINERS: {
    extendedProps: Identity<Dictionary>;
    start: Identity<DateInput>;
    end: Identity<DateInput>;
    date: Identity<DateInput>;
    allDay: BooleanConstructor;
    id: StringConstructor;
    groupId: StringConstructor;
    title: StringConstructor;
    url: StringConstructor;
    interactive: BooleanConstructor;
};
type BuiltInEventRefiners = typeof EVENT_REFINERS;
declare module '@fullcalendar/core/protected-api' {
    interface EventRefiners extends BuiltInEventRefiners {
    }
}
type EventInput = EventUiInput & RawOptionsFromRefiners<Required<EventRefiners>> & // Required hack
{
    [extendedProp: string]: any;
};
type EventRefined = EventUiRefined & RefinedOptionsFromRefiners<Required<EventRefiners>>;
interface EventTuple {
    def: EventDef;
    instance: EventInstance | null;
}
type EventInputTransformer = (input: EventInput) => EventInput;
type EventDefMemberAdder = (refined: EventRefined) => Partial<EventDef>;

type Action = {
    type: 'IDLE';
} | // hack
{
    type: 'UPDATE_NOW';
} | {
    type: 'SET_OPTION';
    optionName: string;
    rawOptionValue: any;
} | // TODO: how to link this to CalendarOptions?
{
    type: 'RESET_OPTIONS';
} | {
    type: 'PREV';
} | {
    type: 'NEXT';
} | {
    type: 'CHANGE_DATE';
    dateMarker: DateMarker;
} | {
    type: 'CHANGE_VIEW_TYPE';
    viewType: string;
    dateMarker?: DateMarker;
} | {
    type: 'SELECT_DATES';
    selection: DateSpan;
} | {
    type: 'UNSELECT_DATES';
} | {
    type: 'SELECT_EVENT';
    eventInstanceId: string;
} | {
    type: 'UNSELECT_EVENT';
} | {
    type: 'SET_EVENT_DRAG';
    state: EventInteractionState;
} | {
    type: 'UNSET_EVENT_DRAG';
} | {
    type: 'SET_EVENT_RESIZE';
    state: EventInteractionState;
} | {
    type: 'UNSET_EVENT_RESIZE';
} | {
    type: 'ADD_EVENT_SOURCES';
    sources: EventSource<any>[];
} | {
    type: 'REMOVE_EVENT_SOURCE';
    sourceId: string;
} | {
    type: 'REMOVE_ALL_EVENT_SOURCES';
} | {
    type: 'FETCH_EVENT_SOURCES';
    sourceIds?: string[];
    isRefetch?: boolean;
} | // if no sourceIds, fetch all
{
    type: 'RECEIVE_EVENTS';
    sourceId: string;
    fetchId: string;
    fetchRange: DateRange | null;
    rawEvents: EventInput[];
} | {
    type: 'RECEIVE_EVENT_ERROR';
    sourceId: string;
    fetchId: string;
    fetchRange: DateRange | null;
    error: Error;
} | // need all these?
{
    type: 'ADD_EVENTS';
    eventStore: EventStore;
} | {
    type: 'RESET_EVENTS';
    eventStore: EventStore;
} | {
    type: 'RESET_RAW_EVENTS';
    rawEvents: EventInput[];
    sourceId: string;
} | {
    type: 'MERGE_EVENTS';
    eventStore: EventStore;
} | {
    type: 'REMOVE_EVENTS';
    eventStore: EventStore;
} | {
    type: 'REMOVE_ALL_EVENTS';
};

interface CalendarDataManagerConfig {
    calendarApi: CalendarApiImpl;
    onDataChange?: (data: CalendarData, actionsComplete: Action[]) => void;
}
type ReducerFunc = (currentState: Dictionary | undefined, action: Action | undefined, context: CalendarContext & CalendarDataManagerState) => Dictionary;
declare class CalendarDataManager {
    private computeCurrentViewData;
    private organizeRawLocales;
    private buildLocale;
    private buildPluginHooks;
    private buildDateEnv;
    private parseToolbars;
    private buildViewSpecs;
    private buildDateProfileGenerator;
    private buildViewApi;
    private buildViewUiProps;
    private buildEventUiBySource;
    private buildEventUiBases;
    private parseContextBusinessHours;
    private buildToolbarProps;
    private buildTitle;
    private nowManager;
    private nowTimer;
    private isDrainingActionQueue;
    private actionQueue;
    private optionOverrides;
    private config;
    private state;
    private data;
    emitter: Emitter<Required<CalendarListeners>>;
    currentCalendarOptionsRefiners: any;
    currentCalendarOptionsInput: CalendarOptions;
    private currentCalendarOptionsRefined;
    private currentViewOptionsInput;
    private currentViewOptionsRefined;
    private stableOptionOverrides;
    private stableDynamicOptionOverrides;
    private stableCalendarOptionsData;
    private optionsForRefining;
    private optionsForHandling;
    constructor(config: CalendarDataManagerConfig);
    destroy(): void;
    update(optionOverrides: CalendarOptions): CalendarData;
    resetOptions(optionOverrides: CalendarOptions, changedOptionNames?: string[]): void;
    getCurrentData: () => CalendarData;
    private handleNowChange;
    dispatch: (action: Action) => void;
    private drainActionQueue;
    private reduce;
    private computeOptionsData;
    private processRawCalendarOptions;
    private _computeCurrentViewData;
    private processRawViewOptions;
}

declare class CalendarApiImpl implements CalendarApi {
    currentDataManager?: CalendarDataManager;
    getCurrentData(): CalendarData;
    dispatch(action: Action): void;
    get view(): ViewImpl;
    batchRendering(callback: () => void): void;
    setOption<OptionName extends keyof CalendarOptions>(name: OptionName, val: CalendarOptions[OptionName]): void;
    getOption<OptionName extends keyof CalendarOptions>(name: OptionName): CalendarOptions[OptionName];
    getAvailableLocaleCodes(): string[];
    on<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: Required<CalendarListeners>[ListenerName]): void;
    off<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, handler: Required<CalendarListeners>[ListenerName]): void;
    trigger<ListenerName extends keyof CalendarListeners>(handlerName: ListenerName, ...args: Parameters<Required<CalendarListeners>[ListenerName]>): void;
    changeView(viewType: string, dateOrRange?: DateRangeInput | DateInput): void;
    zoomTo(dateMarker: Date, viewType?: string): void;
    private getUnitViewSpec;
    prev(): void;
    next(): void;
    prevYear(): void;
    nextYear(): void;
    today(): void;
    gotoDate(zonedDateInput: DateInput): void;
    incrementDate(deltaInput: DurationInput): void;
    getDate(): Date;
    formatDate(d: DateInput, formatter: FormatterInput): string;
    formatRange(d0: DateInput, d1: DateInput, settings: any): string;
    formatIso(d: DateInput, omitTime?: boolean): string;
    select(dateOrObj: DateInput | any, endDate?: DateInput): void;
    unselect(pev?: PointerDragEvent): void;
    addEvent(eventInput: EventInput, sourceInput?: EventSourceImpl | string | boolean): EventImpl | null;
    private triggerEventAdd;
    getEventById(id: string): EventImpl | null;
    getEvents(): EventImpl[];
    removeAllEvents(): void;
    getEventSources(): EventSourceImpl[];
    getEventSourceById(id: string): EventSourceImpl | null;
    addEventSource(sourceInput: EventSourceInput): EventSourceImpl;
    removeAllEventSources(): void;
    refetchEvents(): void;
    scrollToTime(timeInput: DurationInput): void;
    getButtonState(): ButtonStateMap;
}

interface DateProfile {
    currentDate: DateMarker;
    isValid: boolean;
    validRange: OpenDateRange;
    renderRange: DateRange;
    activeRange: DateRange | null;
    currentRange: DateRange;
    currentRangeUnit: string;
    isRangeAllDay: boolean;
    dateIncrement: Duration;
    slotMinTime: Duration;
    slotMaxTime: Duration;
}
interface DateProfileGeneratorProps extends DateProfileOptions {
    dateProfileGeneratorClass: DateProfileGeneratorClass;
    duration: Duration;
    durationUnit: string;
    usesMinMaxTime: boolean;
    dateEnv: DateEnv;
    calendarApi: CalendarApiImpl;
}
interface DateProfileOptions {
    slotMinTime: Duration;
    slotMaxTime: Duration;
    showNonCurrentDates?: boolean;
    dayCount?: number;
    dateAlignment?: string;
    dateIncrement?: Duration;
    hiddenDays?: number[];
    weekends?: boolean;
    validRangeInput?: DateRangeInput | ((this: CalendarApiImpl, nowDate: Date) => DateRangeInput);
    visibleRangeInput?: DateRangeInput | ((this: CalendarApiImpl, nowDate: Date) => DateRangeInput);
    fixedWeekCount?: boolean;
}
type DateProfileGeneratorClass = {
    new (props: DateProfileGeneratorProps): DateProfileGenerator;
};
declare class DateProfileGenerator {
    protected props: DateProfileGeneratorProps;
    isHiddenDayHash: boolean[];
    constructor(props: DateProfileGeneratorProps);
    buildPrev(currentDateProfile: DateProfile, currentDate: DateMarker, nowDate: DateMarker, forceToValid?: boolean): DateProfile;
    buildNext(currentDateProfile: DateProfile, currentDate: DateMarker, nowDate: DateMarker, forceToValid?: boolean): DateProfile;
    build(currentDate: DateMarker, nowDate: DateMarker, direction?: any, forceToValid?: boolean): DateProfile;
    buildValidRange(nowDate: DateMarker): OpenDateRange;
    buildCurrentRangeInfo(date: DateMarker, direction: any): {
        duration: any;
        unit: any;
        range: any;
    };
    getFallbackDuration(): Duration;
    adjustActiveRange(range: DateRange): {
        start: Date;
        end: Date;
    };
    buildRangeFromDuration(date: DateMarker, direction: any, duration: Duration, unit: any): any;
    buildRangeFromDayCount(date: DateMarker, direction: any, dayCount: any): {
        start: Date;
        end: Date;
    };
    buildCustomVisibleRange(date: DateMarker): DateRange;
    buildRenderRange(currentRange: DateRange, currentRangeUnit: any, isRangeAllDay: any): DateRange;
    buildDateIncrement(fallback: any): Duration;
    refineRange(rangeInput: DateRangeInput | undefined): DateRange | null;
    initHiddenDays(): void;
    trimHiddenDays(range: DateRange): DateRange | null;
    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;

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;
    buttons: Identity<Partial<{
        today: ButtonInput;
        prev: ButtonInput;
        next: ButtonInput;
        prevYear: ButtonInput;
        nextYear: ButtonInput;
        year: ButtonInput;
        month: ButtonInput;
        week: ButtonInput;
        day: ButtonInput;
        [buttonName: string]: ButtonInput;
    }>>;
    toolbarElements: Identity<{
        [elementName: string]: ToolbarElementInput;
    }>;
    prevText: StringConstructor;
    nextText: StringConstructor;
    prevYearText: StringConstructor;
    nextYearText: StringConstructor;
    todayText: StringConstructor;
    yearText: StringConstructor;
    monthText: StringConstructor;
    weekTextLong: 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<ButtonGroupInfo>>;
    buttonClass: Identity<ClassNameGenerator<ButtonInfo>>;
    defaultAllDayEventDuration: typeof createDuration;
    defaultTimedEventDuration: typeof createDuration;
    nextDayThreshold: typeof createDuration;
    scrollTime: typeof createDuration;
    scrollTimeReset: BooleanConstructor;
    slotMinTime: typeof createDuration;
    slotMaxTime: typeof createDuration;
    popoverFormat: typeof createFormatter;
    slotDuration: typeof createDuration;
    snapDuration: typeof createDuration;
    headerToolbar: Identity<ToolbarInput | false>;
    footerToolbar: Identity<ToolbarInput | false>;
    forceEventDuration: BooleanConstructor;
    dayLaneClass: Identity<ClassNameGenerator<DayLaneInfo>>;
    dayLaneInnerClass: Identity<ClassNameGenerator<DayLaneInfo>>;
    dayLaneDidMount: Identity<DidMountHandler<DayLaneInfo>>;
    dayLaneWillUnmount: Identity<WillUnmountHandler<DayLaneInfo>>;
    initialView: StringConstructor;
    aspectRatio: NumberConstructor;
    weekends: BooleanConstructor;
    weekNumberCalculation: Identity<WeekNumberCalculation>;
    weekNumbers: BooleanConstructor;
    weekNumberHeaderClass: Identity<ClassNameGenerator<WeekNumberHeaderInfo>>;
    weekNumberHeaderInnerClass: Identity<ClassNameGenerator<WeekNumberHeaderInfo>>;
    weekNumberHeaderContent: Identity<ContentGenerator<WeekNumberHeaderInfo>>;
    weekNumberHeaderDidMount: Identity<DidMountHandler<WeekNumberHeaderInfo>>;
    weekNumberHeaderWillUnmount: Identity<WillUnmountHandler<WeekNumberHeaderInfo>>;
    inlineWeekNumberClass: Identity<ClassNameGenerator<InlineWeekNumberInfo>>;
    inlineWeekNumberContent: Identity<ContentGenerator<InlineWeekNumberInfo>>;
    inlineWeekNumberDidMount: Identity<DidMountHandler<InlineWeekNumberInfo>>;
    inlineWeekNumberWillUnmount: Identity<WillUnmountHandler<InlineWeekNumberInfo>>;
    editable: BooleanConstructor;
    controller: Identity<CalendarController>;
    nowIndicator: BooleanConstructor;
    nowIndicatorSnap: Identity<boolean | "auto">;
    nowIndicatorHeaderClass: Identity<ClassNameGenerator<NowIndicatorHeaderInfo>>;
    nowIndicatorHeaderContent: Identity<ContentGenerator<NowIndicatorHeaderInfo>>;
    nowIndicatorHeaderDidMount: Identity<DidMountHandler<NowIndicatorHeaderInfo>>;
    nowIndicatorHeaderWillUnmount: Identity<WillUnmountHandler<NowIndicatorHeaderInfo>>;
    nowIndicatorDotClass: typeof refineClassName;
    nowIndicatorLineClass: Identity<ClassNameGenerator<NowIndicatorLineInfo>>;
    nowIndicatorLineContent: Identity<ContentGenerator<NowIndicatorLineInfo>>;
    nowIndicatorLineDidMount: Identity<DidMountHandler<NowIndicatorLineInfo>>;
    nowIndicatorLineWillUnmount: Identity<WillUnmountHandler<NowIndicatorLineInfo>>;
    showNonCurrentDates: BooleanConstructor;
    lazyFetching: BooleanConstructor;
    startParam: StringConstructor;
    endParam: StringConstructor;
    timeZoneParam: StringConstructor;
    timeZone: StringConstructor;
    locales: Identity<LocaleInput[]>;
    locale: Identity<LocaleSingularArg>;
    dragRevertDuration: NumberConstructor;
    dragScroll: BooleanConstructor;
    allDayMaintainDuration: BooleanConstructor;
    unselectAuto: BooleanConstructor;
    dropAccept: Identity<string | ((this: CalendarApi, draggable: any) => boolean)>;
    eventOrder: typeof parseFieldSpecs;
    eventOrderStrict: BooleanConstructor;
    eventSlicing: BooleanConstructor;
    eventPrintLayout: Identity<"auto" | "stack" | "grid">;
    longPressDelay: NumberConstructor;
    eventDragMinDistance: NumberConstructor;
    expandRows: BooleanConstructor;
    height: Identity<CssDimValue>;
    contentHeight: Identity<CssDimValue>;
    direction: Identity<"ltr" | "rtl">;
    colorScheme: Identity<"light" | "dark" | string | undefined>;
    weekNumberFormat: typeof createFormatter;
    eventResizableFromStart: BooleanConstructor;
    displayEventTime: BooleanConstructor;
    displayEventEnd: BooleanConstructor;
    progressiveEventRendering: BooleanConstructor;
    businessHours: Identity<BusinessHoursInput>;
    initialDate: Identity<DateInput>;
    now: Identity<DateInput | ((this: CalendarApi) => DateInput)>;
    eventDataTransform: Identity<EventInputTransformer>;
    tableHeaderSticky: Identity<boolean | "auto">;
    footerScrollbarSticky: Identity<boolean | "auto">;
    defaultAllDay: BooleanConstructor;
    eventSourceFailure: Identity<(this: CalendarApi, error: any) => void>;
    eventSourceSuccess: Identity<(this: CalendarApi, eventsInput: EventInput[], response?: Response) => EventInput[] | void>;
    eventDisplay: StringConstructor;
    eventStartEditable: BooleanConstructor;
    eventDurationEditable: BooleanConstructor;
    eventOverlap: Identity<boolean | OverlapFunc>;
    eventConstraint: Identity<ConstraintInput>;
    eventAllow: Identity<AllowFunc>;
    eventColor: StringConstructor;
    eventContrastColor: StringConstructor;
    eventDidMount: Identity<DidMountHandler<EventDisplayInfo>>;
    eventWillUnmount: Identity<WillUnmountHandler<EventDisplayInfo>>;
    eventContent: Identity<ContentGenerator<EventDisplayInfo>>;
    eventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    eventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    eventTimeClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    eventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    eventBeforeClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    eventAfterClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    listItemEventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    listItemEventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    listItemEventTimeClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    listItemEventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
        timeText: string;
    }>>;
    listItemEventBeforeClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    listItemEventAfterClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    blockEventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    blockEventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    blockEventTimeClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    blockEventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    blockEventBeforeClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    blockEventAfterClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    rowEventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    rowEventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    rowEventTimeClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    rowEventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    rowEventTitleSticky: BooleanConstructor;
    rowEventBeforeClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    rowEventBeforeContent: Identity<ContentGenerator<EventDisplayInfo>>;
    rowEventAfterClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    rowEventAfterContent: Identity<ContentGenerator<EventDisplayInfo>>;
    columnEventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    columnEventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    columnEventTimeClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    columnEventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    columnEventTitleSticky: BooleanConstructor;
    columnEventBeforeClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    columnEventAfterClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    backgroundEventClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    backgroundEventDidMount: Identity<DidMountHandler<EventDisplayInfo>>;
    backgroundEventWillUnmount: Identity<WillUnmountHandler<EventDisplayInfo>>;
    backgroundEventContent: Identity<ContentGenerator<EventDisplayInfo>>;
    backgroundEventInnerClass: Identity<ClassNameGenerator<EventDisplayInfo>>;
    backgroundEventTitleClass: Identity<ClassNameGenerator<{
        event: EventApi;
        isNarrow: boolean;
        isShort: boolean;
    }>>;
    backgroundEventColor: StringConstructor;
    selectConstraint: Identity<ConstraintInput>;
    selectOverlap: Identity<boolean | OverlapFunc>;
    selectAllow: Identity<AllowFunc>;
    droppable: BooleanConstructor;
    unselectCancel: StringConstructor;
    slotHeaderFormat: Identity<FormatterInput | FormatterInput[]>;
    slotLaneClass: Identity<ClassNameGenerator<SlotLaneInfo>>;
    slotLaneDidMount: Identity<DidMountHandler<SlotLaneInfo>>;
    slotLaneWillUnmount: Identity<WillUnmountHandler<SlotLaneInfo>>;
    slotHeaderClass: Identity<ClassNameGenerator<SlotHeaderInfo>>;
    slotHeaderInnerClass: Identity<ClassNameGenerator<SlotHeaderInfo>>;
    slotHeaderContent: Identity<ContentGenerator<SlotHeaderInfo>>;
    slotHeaderDidMount: Identity<DidMountHandler<SlotHeaderInfo>>;
    slotHeaderWillUnmount: Identity<WillUnmountHandler<SlotHeaderInfo>>;
    slotHeaderAlign: Identity<"start" | "center" | "end" | ((info: {
        level: number;
        isTime: boolean;
    }) => "start" | "center" | "end")>;
    slotHeaderSticky: Identity<boolean | number | string>;
    slotHeaderRowClass: typeof refineClassName;
    slotHeaderDividerClass: Identity<ClassNameGenerator<{
        inTableHeader: boolean;
        options: {
            dayMinWidth: number | undefined;
        };
    }>>;
    dayMaxEvents: Identity<boolean | number>;
    dayMaxEventRows: Identity<boolean | number>;
    dayMinWidth: NumberConstructor;
    slotHeaderInterval: typeof createDuration;
    dayHeaderClass: Identity<ClassNameGenerator<DayHeaderInfo>>;
    dayHeaderInnerClass: Identity<ClassNameGenerator<DayHeaderInfo>>;
    dayHeaderContent: Identity<ContentGenerator<DayHeaderInfo>>;
    dayHeaderDidMount: Identity<DidMountHandler<DayHeaderInfo>>;
    dayHeaderWillUnmount: Identity<WillUnmountHandler<DayHeaderInfo>>;
    dayHeaderAlign: Identity<"start" | "center" | "end" | ((info: {
        level: number;
        inPopover: boolean;
        isNarrow: boolean;
    }) => "start" | "center" | "end")>;
    _dayHeaderSticky: Identity<boolean | number | string>;
    dayHeaderRowClass: typeof refineClassName;
    dayHeaderDividerClass: Identity<ClassNameGenerator<DayHeaderDividerInfo>>;
    dayRowClass: typeof refineClassName;
    dayCellDidMount: Identity<DidMountHandler<DayCellInfo>>;
    dayCellWillUnmount: Identity<WillUnmountHandler<DayCellInfo>>;
    dayCellClass: Identity<ClassNameGenerator<DayCellInfo>>;
    dayCellInnerClass: Identity<ClassNameGenerator<DayCellInfo>>;
    dayCellTopContent: Identity<ContentGenerator<DayCellInfo>>;
    dayCellTopClass: Identity<ClassNameGenerator<DayCellInfo>>;
    dayCellTopInnerClass: Identity<ClassNameGenerator<DayCellInfo>>;
    dayCellBottomClass: Identity<ClassNameGenerator<DayCellInfo>>;
    allDaySlot: BooleanConstructor;
    allDayText: StringConstructor;
    allDayHeaderClass: Identity<ClassNameGenerator<AllDayHeaderInfo>>;
    allDayHeaderInnerClass: Identity<ClassNameGenerator<AllDayHeaderInfo>>;
    allDayHeaderContent: Identity<ContentGenerator<AllDayHeaderInfo>>;
    allDayHeaderDidMount: Identity<DidMountHandler<AllDayHeaderInfo>>;
    allDayHeaderWillUnmount: Identity<WillUnmountHandler<AllDayHeaderInfo>>;
    timedText: StringConstructor;
    slotMinWidth: NumberConstructor;
    slotMinHeight: NumberConstructor;
    navLinks: BooleanConstructor;
    eventTimeFormat: typeof createFormatter;
    rerenderDelay: NumberConstructor;
    moreLinkText: Identity<string | ((this: CalendarApi, num: number) => string)>;
    moreLinkHint: Identity<string | ((this: CalendarApi, num: number) => string)>;
    selectMinDistance: NumberConstructor;
    selectable: BooleanConstructor;
    selectLongPressDelay: NumberConstructor;
    eventLongPressDelay: NumberConstructor;
    selectMirror: BooleanConstructor;
    eventMaxStack: NumberConstructor;
    eventMinHeight: NumberConstructor;
    eventMinWidth: NumberConstructor;
    eventShortHeight: NumberConstructor;
    slotEventOverlap: BooleanConstructor;
    firstDay: NumberConstructor;
    dayCount: NumberConstructor;
    dateAlignment: StringConstructor;
    dateIncrement: typeof createDuration;
    hiddenDays: Identity<number[]>;
    fixedWeekCount: BooleanConstructor;
    validRange: Identity<DateRangeInput | ((this: CalendarApi, nowDate: Date) => DateRangeInput)>;
    visibleRange: Identity<DateRangeInput | ((this: CalendarApi, currentDate: Date) => DateRangeInput)>;
    titleFormat: Identity<FormatterInput>;
    eventInteractive: BooleanConstructor;
    noEventsText: StringConstructor;
    viewHint: Identity<string | ((viewButtonText: string, viewName: string) => string)>;
    viewChangeHint: StringConstructor;
    navLinkHint: Identity<string | ((dateText: string, date: Date) => string)>;
    closeHint: StringConstructor;
    eventsHint: StringConstructor;
    headingLevel: NumberConstructor;
    moreLinkClick: Identity<MoreLinkAction>;
    moreLinkContent: Identity<ContentGenerator<MoreLinkInfo$1>>;
    moreLinkDidMount: Identity<DidMountHandler<MoreLinkInfo$1>>;
    moreLinkWillUnmount: Identity<WillUnmountHandler<MoreLinkInfo$1>>;
    moreLinkClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    moreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    rowMoreLinkClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    rowMoreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    columnMoreLinkClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    columnMoreLinkInnerClass: Identity<ClassNameGenerator<MoreLinkInfo$1>>;
    navLinkClass: typeof refineClassName;
    monthStartFormat: typeof createFormatter;
    dayCellFormat: typeof createFormatter;
    handleCustomRendering: Identity<CustomRenderingHandler<any>>;
    customRenderingMetaMap: Identity<{
        [optionName: string]: any;
    }>;
    popoverClass: typeof refineClassName;
    popoverCloseClass: typeof refineClassName;
    popoverCloseContent: Identity<ContentGenerator<{}>>;
    dayNarrowWidth: NumberConstructor;
    borderless: BooleanConstructor;
    borderlessX: BooleanConstructor;
    borderlessTop: BooleanConstructor;
    borderlessBottom: BooleanConstructor;
    fillerClass: Identity<ClassNameGenerator<{
        inTableHeader: boolean;
    }>>;
    headerToolbarClass: Identity<ClassNameGenerator<ToolbarInfo>>;
    footerToolbarClass: Identity<ClassNameGenerator<ToolbarInfo>>;
    toolbarClass: Identity<ClassNameGenerator<ToolbarInfo>>;
    toolbarSectionClass: Identity<ClassNameGenerator<ToolbarSectionInfo>>;
    toolbarTitleClass: typeof refineClassName;
    tableClass: Identity<ClassNameGenerator<TableDisplayInfo>>;
    tableHeaderClass: Identity<ClassNameGenerator<TableHeaderInfo>>;
    tableBodyClass: Identity<ClassNameGenerator<TableBodyInfo>>;
    nonBusinessHoursClass: typeof refineClassName;
    highlightClass: typeof refineClassName;
    dayHeaders: BooleanConstructor;
    dayHeaderFormat: typeof createFormatter;
    allDayDividerClass: typeof refineClassName;
    listDaysClass: typeof refineClassName;
    listDayClass: Identity<ClassNameGenerator<ListDayInfo>>;
    listDayFormat: typeof createFalsableFormatter;
    listDayAltFormat: typeof createFalsableFormatter;
    listDayHeaderDidMount: Identity<DidMountHandler<ListDayHeaderInfo>>;
    listDayHeaderWillUnmount: Identity<WillUnmountHandler<ListDayHeaderInfo>>;
    listDayHeaderClass: Identity<ClassNameGenerator<ListDayHeaderInfo>>;
    listDayHeaderInnerClass: Identity<ClassNameGenerator<ListDayHeaderInnerInfo>>;
    listDayHeaderContent: Identity<ContentGenerator<ListDayHeaderInnerInfo>>;
    listDayBodyClass: Identity<ClassNameGenerator<ListDayEventsInfo>>;
    noEventsClass: Identity<ClassNameGenerator<NoEventsInfo>>;
    noEventsInnerClass: Identity<ClassNameGenerator<NoEventsInfo>>;
    noEventsContent: Identity<ContentGenerator<NoEventsInfo>>;
    noEventsDidMount: Identity<DidMountHandler<NoEventsInfo>>;
    noEventsWillUnmount: Identity<WillUnmountHandler<NoEventsInfo>>;
    multiMonthMaxColumns: NumberConstructor;
    singleMonthMinWidth: NumberConstructor;
    singleMonthTitleFormat: typeof createFormatter;
    singleMonthDidMount: Identity<DidMountHandler<SingleMonthInfo>>;
    singleMonthWillUnmount: Identity<WillUnmountHandler<SingleMonthInfo>>;
    singleMonthClass: Identity<ClassNameGenerator<SingleMonthInfo>>;
    singleMonthHeaderClass: Identity<ClassNameGenerator<SingleMonthHeaderInfo>>;
    singleMonthHeaderInnerClass: Identity<ClassNameGenerator<SingleMonthHeaderInfo>>;
};
type BaseOptionRefiners = typeof BASE_OPTION_REFINERS;
declare module '@fullcalendar/core/protected-api' {
    interface BaseOptions extends RawOptionsFromRefiners<BaseOptionRefiners> {
    }
    interface BaseOptionsRefined extends RefinedOptionsFromRefiners<BaseOptionRefiners> {
    }
}
declare const CALENDAR_LISTENER_REFINERS: {
    datesSet: Identity<(info: DatesSetInfo) => void>;
    eventsSet: Identity<(events: EventApi[]) => void>;
    eventAdd: Identity<(info: EventAddInfo) => void>;
    eventChange: Identity<(info: EventChangeInfo) => void>;
    eventRemove: Identity<(info: EventRemoveInfo) => void>;
    eventClick: Identity<(info: EventClickInfo) => void>;
    eventMouseEnter: Identity<(info: EventHoveringInfo) => void>;
    eventMouseLeave: Identity<(info: EventHoveringInfo) => void>;
    select: Identity<(info: DateSelectInfo) => void>;
    unselect: Identity<(info: DateUnselectInfo) => void>;
    loading: Identity<(isLoading: boolean) => void>;
    _unmount: Identity<() => void>;
    _beforeprint: Identity<() => void>;
    _afterprint: Identity<() => void>;
    _noDateSelect: Identity<() => void>;
    _noEventDrop: Identity<() => void>;
    _noEventResize: Identity<() => void>;
    _timeScrollRequest: Identity<(time: Duration) => void>;
    dateClick: Identity<(info: DateClickInfo) => void>;
    eventDragStart: Identity<(info: EventDragStartInfo) => void>;
    eventDragStop: Identity<(info: EventDragStopInfo) => void>;
    eventDrop: Identity<(info: EventDropInfo) => void>;
    eventResizeStart: Identity<(info: EventResizeStartInfo) => void>;
    eventResizeStop: Identity<(info: EventResizeStopInfo) => void>;
    eventResize: Identity<(info: EventResizeDoneInfo) => void>;
    drop: Identity<(info: DropInfo) => void>;
    eventReceive: Identity<(info: EventReceiveInfo) => void>;
    eventLeave: Identity<(info: EventLeaveInfo) => void>;
};
type CalendarListenerRefiners = typeof CALENDAR_LISTENER_REFINERS;
interface CalendarListeners extends RawOptionsFromRefiners<CalendarListenerRefiners> {
}
interface CalendarListenersRefined extends RefinedOptionsFromRefiners<CalendarListenerRefiners> {
}
declare const CALENDAR_ONLY_OPTION_REFINERS: {
    class: Identity<ClassNameGenerator<CalendarDisplayInfo>>;
    className: Identity<ClassNameGenerator<CalendarDisplayInfo>>;
    viewClass: Identity<ClassNameGenerator<ViewDisplayInfo>>;
    viewDidMount: Identity<DidMountHandler<ViewDisplayInfo>>;
    viewWillUnmount: Identity<WillUnmountHandler<ViewDisplayInfo>>;
    views: Identity<{
        [viewId: string]: ViewOptions;
    }>;
    plugins: Identity<PluginInput[]>;
    initialEvents: Identity<EventSourceInput>;
    events: Identity<EventSourceInput>;
    eventSources: Identity<EventSourceInput[]>;
};
type CalendarOnlyOptionRefiners = typeof CALENDAR_ONLY_OPTION_REFINERS;
type CalendarOnlyOptions = RawOptionsFromRefiners<CalendarOnlyOptionRefiners>;
type CalendarOnlyOptionsRefined = RefinedOptionsFromRefiners<CalendarOnlyOptionRefiners>;
declare const VIEW_ONLY_OPTION_REFINERS: {
    type: StringConstructor;
    component: Identity<ViewComponentType>;
    class: Identity<ClassNameGenerator<ViewDisplayInfo>>;
    className: Identity<ClassNameGenerator<ViewDisplayInfo>>;
    content: Identity<ContentGenerator<ViewContentInfo>>;
    didMount: Identity<DidMountHandler<ViewDisplayInfo>>;
    willUnmount: Identity<WillUnmountHandler<ViewDisplayInfo>>;
    buttonTextKey: StringConstructor;
    dateProfileGeneratorClass: Identity<DateProfileGeneratorClass>;
    usesMinMaxTime: BooleanConstructor;
    disallowAmbigTitle: BooleanConstructor;
};
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;
};
type GenericRefiners = {
    [propName: string]: (input: any, propName: string) => any;
};
type GenericListenerRefiners = {
    [listenerName: string]: Identity<(this: CalendarApi, ...args: any[]) => void>;
};
type Dictionary = Record<string, any>;
type Identity<T = any> = (raw: T) => T;
declare function identity<T>(raw: T): T;
declare function createFalsableFormatter(input: FormatterInput | false): DateFormatter;

type LocaleSingularArg = LocaleCodeArg | LocaleInput;
interface LocaleInput extends CalendarOptions {
    code: string;
}

export { ButtonInput as $, AllowFunc as A, BusinessHoursInput as B, CalendarController as C, DateSpanInput as D, EventSourceApi as E, DayHeaderDividerInfo as F, DayCellInfo as G, DayLaneInfo as H, InlineWeekNumberInfo as I, ViewDisplayInfo as J, TableBodyInfo as K, LocaleInput as L, MountInfo as M, NowIndicatorHeaderInfo as N, OverlapFunc as O, PluginInput as P, TableHeaderInfo as Q, CalendarDisplayInfo as R, SlotLaneInfo as S, TableDisplayInfo as T, EventClickInfo as U, ViewApi as V, WillUnmountHandler as W, EventHoveringInfo as X, DateSelectInfo as Y, DateUnselectInfo as Z, ToolbarInput as _, CalendarApi as a, DateMeta as a$, ButtonGroupInfo as a0, ButtonInfo as a1, ButtonDisplay as a2, ToolbarElementInput as a3, ToolbarSectionInfo as a4, ToolbarInfo as a5, EventDisplayInfo as a6, ViewContentInfo as a7, DatesSetInfo as a8, EventAddInfo as a9, EventResizeStopInfo as aA, EventResizeDoneInfo as aB, DateClickInfo as aC, DropInfo as aD, EventReceiveInfo as aE, EventLeaveInfo as aF, Dictionary as aG, valuesIdentical as aH, ViewContext as aI, EventRangeProps as aJ, DateProfileGenerator as aK, Emitter as aL, DateComponent as aM, ScrollerInterface as aN, EventSegUiInteractionState as aO, DateProfile as aP, CalendarContext as aQ, DateSpan as aR, EventStore as aS, EventInteractionState as aT, EventUiHash as aU, SplittableProps as aV, BaseComponent as aW, ElRef as aX, ViewOptionsRefined as aY, Splitter as aZ, EventDef as a_, EventChangeInfo as aa, EventDropInfo as ab, EventRemoveInfo as ac, CustomRenderingHandler as ad, CustomRenderingStore as ae, DateSpanApi as af, DatePointApi as ag, DateSelectionApi as ah, ButtonState as ai, NavButtonState as aj, ButtonStateMap as ak, FormatterInput as al, LocaleSingularArg as am, NoEventsInfo as an, ListDayHeaderInfo as ao, ListDayHeaderInnerInfo as ap, ListDayInfo as aq, SingleMonthInfo as ar, SingleMonthHeaderInfo as as, EventSegment as at, MoreLinkAction as au, MoreLinkSimpleAction as av, MoreLinkHandler as aw, EventDragStartInfo as ax, EventDragStopInfo as ay, EventResizeStartInfo as az, EventApi as b, Hit as b0, CalendarListenersRefined as b1, Identity as b2, identity as b3, refineProps as b4, EventDefHash as b5, EventInstanceHash as b6, EventRefined as b7, parseBusinessHours as b8, OrderSpec as b9, MinimalEventProps as bA, EventMutation as bB, Constraint as bC, setRef as bD, getFooterScrollbarSticky as bE, getTableHeaderSticky as bF, getIsHeightAuto as bG, ScrollerSyncerInterface as bH, refineClassName as bI, refineClassNameGenerator as bJ, NowIndicatorHeaderContainer as bK, NowIndicatorLineContainer as bL, MoreLinkContainer as bM, ViewContainer as bN, CalendarApiImpl as bO, EventImpl as bP, CalendarMediaRoot as bQ, computeRootClassName as bR, ContentContainer as bS, generateClassName as bT, CustomRendering as bU, createFormatter as bV, Rect as bW, DragMetaInput as bX, parseFieldSpecs as ba, compareByFieldSpecs as bb, flexibleCompare as bc, guid as bd, computeViewBorderless as be, getRectCenter as bf, mergeEventStores as bg, EventUi as bh, combineEventUis as bi, createEventUi as bj, getDateMeta as bk, CalendarData as bl, CalendarDataManager as bm, ViewProps as bn, computeMajorUnit as bo, isMajorUnit as bp, PointerDragEvent as bq, ElementDragging as br, ViewPropsTransformer as bs, Action as bt, CalendarContentProps as bu, CalendarInner as bv, sortEventSegs as bw, getEventRangeMeta as bx, buildEventRangeKey as by, getEventKey as bz, EventRenderRange as c, CalendarOptions as d, CalendarListeners as e, ViewOptions as f, EventSourceInput as g, EventSourceFunc as h, EventSourceFuncInfo as i, EventInput as j, EventInputTransformer as k, CssDimValue as l, ConstraintInput as m, ViewComponentType as n, ClassNameInput as o, ClassNameGenerator as p, ContentGenerator as q, DidMountHandler as r, sliceEvents as s, NowIndicatorLineInfo as t, WeekNumberHeaderInfo as u, DateTimeFormatPartWithWeek as v, MoreLinkInfo$1 as w, SlotHeaderInfo as x, AllDayHeaderInfo as y, DayHeaderInfo as z };