dimaslanjaka / universal-framework

// Dependencies for this module:

//   ../../../../../@fullcalendar/core

declare module '@fullcalendar/core' {

    export const version = "<%= version %>";

    export { OptionsInput } from '@fullcalendar/core/types/input-types';

    export { EventInput, EventDef, EventDefHash, EventInstance, EventInstanceHash, parseEventDef, createEventInstance, EventTuple } from '@fullcalendar/core/structs/event';

    export { BusinessHoursInput, parseBusinessHours } from '@fullcalendar/core/structs/business-hours';

    export { applyAll, debounce, padStart, isInt, capitaliseFirstLetter, parseFieldSpecs, compareByFieldSpecs, compareByFieldSpec, flexibleCompare, computeVisibleDayRange, refineProps, matchCellWidths, uncompensateScroll, compensateScroll, subtractInnerElHeight, isMultiDayRange, distributeHeight, undistributeHeight, preventSelection, allowSelection, preventContextMenu, allowContextMenu, compareNumbers, enableCursor, disableCursor, diffDates } from '@fullcalendar/core/util/misc';

    export { htmlEscape, cssToStr } from '@fullcalendar/core/util/html';

    export { removeExact, isArraysEqual } from '@fullcalendar/core/util/array';

    export { memoize, memoizeOutput } from '@fullcalendar/core/util/memoize';

    export { memoizeRendering, MemoizedRendering } from '@fullcalendar/core/component/memoized-rendering';

    export { intersectRects, Rect, pointInsideRect, constrainPoint, getRectCenter, diffPoints, Point, translateRect } from '@fullcalendar/core/util/geom';

    export { mapHash, filterHash, isPropsEqual } from '@fullcalendar/core/util/object';

    export { findElements, findChildren, htmlToElement, createElement, insertAfterElement, prependToElement, removeElement, appendToElement, applyStyle, applyStyleProp, elementMatches, elementClosest, forceClassName } from '@fullcalendar/core/util/dom-manip';

    export { EventStore, filterEventStoreDefs, createEmptyEventStore, mergeEventStores, getRelevantEvents, eventTupleToStore } from '@fullcalendar/core/structs/event-store';

    export { EventUiHash, EventUi, processScopedUiProps, combineEventUis } from '@fullcalendar/core/component/event-ui';

    export { default as Splitter, SplittableProps } from '@fullcalendar/core/component/event-splitting';

    export { buildGotoAnchorHtml, getAllDayHtml, getDayClasses } from '@fullcalendar/core/component/date-rendering';

    export { preventDefault, listenBySelector, whenTransitionDone } from '@fullcalendar/core/util/dom-event';

    export { computeInnerRect, computeEdges, computeHeightAndMargins, getClippingParents, computeClippingRect, computeRect } from '@fullcalendar/core/util/dom-geom';

    export { unpromisify } from '@fullcalendar/core/util/promise';

    export { default as EmitterMixin, EmitterInterface } from '@fullcalendar/core/common/EmitterMixin';

    export { DateRange, rangeContainsMarker, intersectRanges, rangesEqual, rangesIntersect, rangeContainsRange } from '@fullcalendar/core/datelib/date-range';

    export { default as Mixin } from '@fullcalendar/core/common/Mixin';

    export { default as PositionCache } from '@fullcalendar/core/common/PositionCache';

    export { default as ScrollComponent, ScrollbarWidths } from '@fullcalendar/core/common/ScrollComponent';

    export { ScrollController, ElementScrollController, WindowScrollController } from '@fullcalendar/core/common/scroll-controller';

    export { default as Theme } from '@fullcalendar/core/theme/Theme';

    export { default as Component, ComponentContext } from '@fullcalendar/core/component/Component';

    export { default as DateComponent, Seg, EventSegUiInteractionState } from '@fullcalendar/core/component/DateComponent';

    export { default as Calendar, DatePointTransform, DateSpanTransform, DateSelectionApi } from '@fullcalendar/core/Calendar';

    export { default as View, ViewProps } from '@fullcalendar/core/View';

    export { default as FgEventRenderer, buildSegCompareObj } from '@fullcalendar/core/component/renderers/FgEventRenderer';

    export { default as FillRenderer } from '@fullcalendar/core/component/renderers/FillRenderer';

    export { default as DateProfileGenerator, DateProfile } from '@fullcalendar/core/DateProfileGenerator';

    export { ViewDef } from '@fullcalendar/core/structs/view-def';

    export { ViewSpec } from '@fullcalendar/core/structs/view-spec';

    export { DateSpan, DateSpanApi, DatePointApi, isDateSpansEqual } from '@fullcalendar/core/structs/date-span';

    export { DateMarker, addDays, startOfDay, addMs, addWeeks, diffWeeks, diffWholeWeeks, diffWholeDays, diffDayAndTime, diffDays, isValidDate } from '@fullcalendar/core/datelib/marker';

    export { Duration, createDuration, isSingleDay, multiplyDuration, addDurations, asRoughMinutes, asRoughSeconds, asRoughMs, wholeDivideDurations, greatestDurationDenominator } from '@fullcalendar/core/datelib/duration';

    export { DateEnv, DateMarkerMeta } from '@fullcalendar/core/datelib/env';

    export { DateFormatter, createFormatter, VerboseFormattingArg, formatIsoTimeString } from '@fullcalendar/core/datelib/formatting';

    export { NamedTimeZoneImpl } from '@fullcalendar/core/datelib/timezone';

    export { parse as parseMarker } from '@fullcalendar/core/datelib/parsing';

    export { EventSourceDef, EventSource, EventSourceHash } from '@fullcalendar/core/structs/event-source';

    export { Interaction, InteractionSettings, interactionSettingsToStore, interactionSettingsStore, InteractionSettingsStore } from '@fullcalendar/core/interactions/interaction';

    export { PointerDragEvent } from '@fullcalendar/core/interactions/pointer';

    export { Hit } from '@fullcalendar/core/interactions/hit';

    export { dateSelectionJoinTransformer } from '@fullcalendar/core/interactions/date-selecting';

    export { eventDragMutationMassager, EventDropTransformers } from '@fullcalendar/core/interactions/event-dragging';

    export { EventResizeJoinTransforms } from '@fullcalendar/core/interactions/event-resizing';

    export { default as ElementDragging } from '@fullcalendar/core/interactions/ElementDragging';

    export { formatDate, formatRange } from '@fullcalendar/core/formatting-api';

    export { globalDefaults, config } from '@fullcalendar/core/options';

    export { RecurringType, ParsedRecurring } from '@fullcalendar/core/structs/recurring-event';

    export { DragMetaInput, DragMeta, parseDragMeta } from '@fullcalendar/core/structs/drag-meta';

    export { createPlugin, PluginDef, PluginDefInput, ViewPropsTransformer, ViewContainerModifier } from '@fullcalendar/core/plugin-system';

    export { reducerFunc, Action, CalendarState } from '@fullcalendar/core/reducers/types';

    export { CalendarComponentProps } from '@fullcalendar/core/CalendarComponent';

    export { default as DayHeader } from '@fullcalendar/core/common/DayHeader';

    export { computeFallbackHeaderFormat, renderDateCell } from '@fullcalendar/core/common/table-utils';

    export { default as DaySeries } from '@fullcalendar/core/common/DaySeries';

    export { EventInteractionState } from '@fullcalendar/core/interactions/event-interaction-state';

    export { EventRenderRange, sliceEventStore, hasBgRendering, getElSeg, computeEventDraggable, computeEventStartResizable, computeEventEndResizable } from '@fullcalendar/core/component/event-rendering';

    export { default as DayTable, DayTableSeg, DayTableCell } from '@fullcalendar/core/common/DayTable';

    export { default as Slicer, SlicedProps } from '@fullcalendar/core/common/slicing-utils';

    export { EventMutation, applyMutationToEventStore } from '@fullcalendar/core/structs/event-mutation';

    export { Constraint, ConstraintInput, AllowFunc, isPropsValid, isInteractionValid } from '@fullcalendar/core/validation';

    export { default as EventApi } from '@fullcalendar/core/api/EventApi';

    export { default as requestJson } from '@fullcalendar/core/util/requestJson';

}

declare module '@fullcalendar/core/types/input-types' {

    import View from '@fullcalendar/core/View';

    import { EventSourceInput, EventInputTransformer } from '@fullcalendar/core/structs/event-source';

    import { Duration, DurationInput } from '@fullcalendar/core/datelib/duration';

    import { DateInput } from '@fullcalendar/core/datelib/env';

    import { FormatterInput } from '@fullcalendar/core/datelib/formatting';

    import { DateRangeInput } from '@fullcalendar/core/datelib/date-range';

    import { BusinessHoursInput } from '@fullcalendar/core/structs/business-hours';

    import EventApi from '@fullcalendar/core/api/EventApi';

    import { AllowFunc, ConstraintInput, OverlapFunc } from '@fullcalendar/core/validation';

    import { PluginDef } from '@fullcalendar/core/plugin-system';

    import { LocaleSingularArg, RawLocale } from '@fullcalendar/core/datelib/locale';

    export interface ToolbarInput {

        left?: string;

        center?: string;

        right?: string;

    }

    export interface CustomButtonInput {

        text: string;

        icon?: string;

        themeIcon?: string;

        bootstrapFontAwesome?: string;

        click(element: HTMLElement): void;

    }

    export interface ButtonIconsInput {

        prev?: string;

        next?: string;

        prevYear?: string;

        nextYear?: string;

    }

    export interface ButtonTextCompoundInput {

        prev?: string;

        next?: string;

        prevYear?: string;

        nextYear?: string;

        today?: string;

        month?: string;

        week?: string;

        day?: string;

        [viewId: string]: string | undefined;

    }

    export interface EventSegment {

        event: EventApi;

        start: Date;

        end: Date;

        isStart: boolean;

        isEnd: boolean;

    }

    export interface CellInfo {

        date: Date;

        dayEl: HTMLElement;

        moreEl: HTMLElement;

        segs: EventSegment[];

        hiddenSegs: EventSegment[];

    }

    export interface DropInfo {

        start: Date;

        end: Date;

    }

    export type EventHandlerName = '_init' | 'selectAllow' | 'eventAllow' | 'eventDataTransform' | 'datesRender' | 'datesDestroy' | 'dayRender' | 'windowResize' | 'dateClick' | 'eventClick' | 'eventMouseEnter' | 'eventMouseLeave' | 'select' | 'unselect' | 'loading' | 'eventRender' | 'eventPositioned' | '_eventsPositioned' | 'eventDestroy' | 'eventDragStart' | 'eventDragStop' | 'eventDrop' | '_destroyed' | 'drop' | 'eventResizeStart' | 'eventResizeStop' | 'eventResize' | 'eventReceive' | 'eventLeave' | 'viewSkeletonRender' | 'viewSkeletonDestroy' | '_noEventDrop' | '_noEventResize' | 'eventLimitClick' | 'resourceRender';

    export type EventHandlerArgs<T extends EventHandlerName> = Parameters<Extract<OptionsInput[T], (...args: any[]) => any>>;

    export type EventHandlerArg<T extends EventHandlerName> = EventHandlerArgs<T>[0];

    export interface OptionsInputBase {

        header?: boolean | ToolbarInput;

        footer?: boolean | ToolbarInput;

        customButtons?: {

            [name: string]: CustomButtonInput;

        };

        buttonIcons?: boolean | ButtonIconsInput;

        themeSystem?: 'standard' | string;

        bootstrapFontAwesome?: boolean | ButtonIconsInput;

        firstDay?: number;

        dir?: 'ltr' | 'rtl' | 'auto';

        weekends?: boolean;

        hiddenDays?: number[];

        fixedWeekCount?: boolean;

        weekNumbers?: boolean;

        weekNumbersWithinDays?: boolean;

        weekNumberCalculation?: 'local' | 'ISO' | ((m: Date) => number);

        businessHours?: BusinessHoursInput;

        showNonCurrentDates?: boolean;

        height?: number | 'auto' | 'parent' | (() => number);

        contentHeight?: number | 'auto' | (() => number);

        aspectRatio?: number;

        handleWindowResize?: boolean;

        windowResizeDelay?: number;

        eventLimit?: boolean | number;

        eventLimitClick?: 'popover' | 'week' | 'day' | 'timeGridWeek' | 'timeGridDay' | string | ((arg: {

            date: Date;

            allDay: boolean;

            dayEl: HTMLElement;

            moreEl: HTMLElement;

            segs: any[];

            hiddenSegs: any[];

            jsEvent: MouseEvent;

            view: View;

        }) => void);

        timeZone?: string | boolean;

        now?: DateInput | (() => DateInput);

        defaultView?: string;

        allDaySlot?: boolean;

        allDayText?: string;

        slotDuration?: DurationInput;

        slotLabelFormat?: FormatterInput;

        slotLabelInterval?: DurationInput;

        snapDuration?: DurationInput;

        scrollTime?: DurationInput;

        minTime?: DurationInput;

        maxTime?: DurationInput;

        slotEventOverlap?: boolean;

        listDayFormat?: FormatterInput | boolean;

        listDayAltFormat?: FormatterInput | boolean;

        noEventsMessage?: string;

        defaultDate?: DateInput;

        nowIndicator?: boolean;

        visibleRange?: ((currentDate: Date) => DateRangeInput) | DateRangeInput;

        validRange?: DateRangeInput;

        dateIncrement?: DurationInput;

        dateAlignment?: string;

        duration?: DurationInput;

        dayCount?: number;

        locales?: RawLocale[];

        locale?: LocaleSingularArg;

        eventTimeFormat?: FormatterInput;

        columnHeader?: boolean;

        columnHeaderFormat?: FormatterInput;

        columnHeaderText?: string | ((date: DateInput) => string);

        columnHeaderHtml?: string | ((date: DateInput) => string);

        titleFormat?: FormatterInput;

        weekLabel?: string;

        displayEventTime?: boolean;

        displayEventEnd?: boolean;

        eventLimitText?: string | ((eventCnt: number) => string);

        dayPopoverFormat?: FormatterInput;

        navLinks?: boolean;

        navLinkDayClick?: string | ((date: Date, jsEvent: Event) => void);

        navLinkWeekClick?: string | ((weekStart: any, jsEvent: Event) => void);

        selectable?: boolean;

        selectMirror?: boolean;

        unselectAuto?: boolean;

        unselectCancel?: string;

        defaultAllDayEventDuration?: DurationInput;

        defaultTimedEventDuration?: DurationInput;

        cmdFormatter?: string;

        defaultRangeSeparator?: string;

        selectConstraint?: ConstraintInput;

        selectOverlap?: boolean | OverlapFunc;

        selectAllow?: AllowFunc;

        editable?: boolean;

        eventStartEditable?: boolean;

        eventDurationEditable?: boolean;

        eventConstraint?: ConstraintInput;

        eventOverlap?: boolean | OverlapFunc;

        eventAllow?: AllowFunc;

        eventClassName?: string[] | string;

        eventClassNames?: string[] | string;

        eventBackgroundColor?: string;

        eventBorderColor?: string;

        eventTextColor?: string;

        eventColor?: string;

        events?: EventSourceInput;

        eventSources?: EventSourceInput[];

        allDayDefault?: boolean;

        startParam?: string;

        endParam?: string;

        lazyFetching?: boolean;

        nextDayThreshold?: DurationInput;

        eventOrder?: string | Array<((a: EventApi, b: EventApi) => number) | (string | ((a: EventApi, b: EventApi) => number))>;

        rerenderDelay?: number | null;

        dragRevertDuration?: number;

        dragScroll?: boolean;

        longPressDelay?: number;

        eventLongPressDelay?: number;

        droppable?: boolean;

        dropAccept?: string | ((draggable: any) => boolean);

        eventDataTransform?: EventInputTransformer;

        allDayMaintainDuration?: boolean;

        eventResizableFromStart?: boolean;

        timeGridEventMinHeight?: number;

        allDayHtml?: string;

        eventDragMinDistance?: number;

        eventSourceFailure?: any;

        eventSourceSuccess?: any;

        forceEventDuration?: boolean;

        progressiveEventRendering?: boolean;

        selectLongPressDelay?: number;

        selectMinDistance?: number;

        timeZoneParam?: string;

        titleRangeSeparator?: string;

        datesRender?(arg: {

            view: View;

            el: HTMLElement;

        }): void;

        datesDestroy?(arg: {

            view: View;

            el: HTMLElement;

        }): void;

        dayRender?(arg: {

            view: View;

            date: Date;

            allDay?: boolean;

            el: HTMLElement;

        }): void;

        windowResize?(view: View): void;

        dateClick?(arg: {

            date: Date;

            dateStr: string;

            allDay: boolean;

            resource?: any;

            dayEl: HTMLElement;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventClick?(arg: {

            el: HTMLElement;

            event: EventApi;

            jsEvent: MouseEvent;

            view: View;

        }): boolean | void;

        eventMouseEnter?(arg: {

            el: HTMLElement;

            event: EventApi;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventMouseLeave?(arg: {

            el: HTMLElement;

            event: EventApi;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        select?(arg: {

            start: Date;

            end: Date;

            startStr: string;

            endStr: string;

            allDay: boolean;

            resource?: any;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        unselect?(arg: {

            view: View;

            jsEvent: Event;

        }): void;

        loading?(isLoading: boolean): void;

        eventRender?(arg: {

            isMirror: boolean;

            isStart: boolean;

            isEnd: boolean;

            event: EventApi;

            el: HTMLElement;

            view: View;

        }): void;

        eventPositioned?(arg: {

            isMirror: boolean;

            isStart: boolean;

            isEnd: boolean;

            event: EventApi;

            el: HTMLElement;

            view: View;

        }): void;

        _eventsPositioned?(arg: {

            view: View;

        }): void;

        eventDestroy?(arg: {

            isMirror: boolean;

            event: EventApi;

            el: HTMLElement;

            view: View;

        }): void;

        eventDragStart?(arg: {

            event: EventApi;

            el: HTMLElement;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventDragStop?(arg: {

            event: EventApi;

            el: HTMLElement;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventDrop?(arg: {

            el: HTMLElement;

            event: EventApi;

            oldEvent: EventApi;

            delta: Duration;

            revert: () => void;

            jsEvent: Event;

            view: View;

        }): void;

        eventResizeStart?(arg: {

            el: HTMLElement;

            event: EventApi;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventResizeStop?(arg: {

            el: HTMLElement;

            event: EventApi;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventResize?(arg: {

            el: HTMLElement;

            startDelta: Duration;

            endDelta: Duration;

            prevEvent: EventApi;

            event: EventApi;

            revert: () => void;

            jsEvent: Event;

            view: View;

        }): void;

        drop?(arg: {

            date: Date;

            dateStr: string;

            allDay: boolean;

            draggedEl: HTMLElement;

            jsEvent: MouseEvent;

            view: View;

        }): void;

        eventReceive?(arg: {

            event: EventApi;

            draggedEl: HTMLElement;

            view: View;

        }): void;

        eventLeave?(arg: {

            draggedEl: HTMLElement;

            event: EventApi;

            view: View;

        }): void;

        viewSkeletonRender?(arg: {

            el: HTMLElement;

            view: View;

        }): void;

        viewSkeletonDestroy?(arg: {

            el: HTMLElement;

            view: View;

        }): void;

        _destroyed?(): void;

        _init?(): void;

        _noEventDrop?(): void;

        _noEventResize?(): void;

        resourceRender?(arg: {

            resource: any;

            el: HTMLElement;

            view: View;

        }): void;

    }

    export interface ViewOptionsInput extends OptionsInputBase {

        type?: string;

        buttonText?: string;

    }

    export interface OptionsInput extends OptionsInputBase {

        buttonText?: ButtonTextCompoundInput;

        views?: {

            [viewId: string]: ViewOptionsInput;

        };

        plugins?: (PluginDef | string)[];

    }

}

declare module '@fullcalendar/core/structs/event' {

    import { DateInput } from '@fullcalendar/core/datelib/env';

    import Calendar from '@fullcalendar/core/Calendar';

    import { DateRange } from '@fullcalendar/core/datelib/date-range';

    import { Duration } from '@fullcalendar/core/datelib/duration';

    import { UnscopedEventUiInput, EventUi } from '@fullcalendar/core/component/event-ui';

    export type EventRenderingChoice = '' | 'background' | 'inverse-background' | 'none';

    export interface EventNonDateInput extends UnscopedEventUiInput {

        id?: string | number;

        groupId?: string | number;

        title?: string;

        url?: string;

        rendering?: EventRenderingChoice;

        extendedProps?: object;

        [extendedProp: string]: any;

    }

    export interface EventDateInput {

        start?: DateInput;

        end?: DateInput;

        date?: DateInput;

        allDay?: boolean;

    }

    export type EventInput = EventNonDateInput & EventDateInput;

    export 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;

        rendering: EventRenderingChoice;

        ui: EventUi;

        extendedProps: any;

    }

    export interface EventInstance {

        instanceId: string;

        defId: string;

        range: DateRange;

        forcedStartTzo: number | null;

        forcedEndTzo: number | null;

    }

    export interface EventTuple {

        def: EventDef;

        instance: EventInstance | null;

    }

    export type EventInstanceHash = {

        [instanceId: string]: EventInstance;

    };

    export type EventDefHash = {

        [defId: string]: EventDef;

    };

    export const NON_DATE_PROPS: {

        id: StringConstructor;

        groupId: StringConstructor;

        title: StringConstructor;

        url: StringConstructor;

        rendering: StringConstructor;

        extendedProps: any;

    };

    export const DATE_PROPS: {

        start: any;

        date: any;

        end: any;

        allDay: any;

    };

    export function parseEvent(raw: EventInput, sourceId: string, calendar: Calendar, allowOpenRange?: boolean): EventTuple | null;

    export function parseEventDef(raw: EventNonDateInput, sourceId: string, allDay: boolean, hasEnd: boolean, calendar: Calendar): EventDef;

    export type eventDefParserFunc = (def: EventDef, props: any, leftovers: any) => void;

    export function createEventInstance(defId: string, range: DateRange, forcedStartTzo?: number, forcedEndTzo?: number): EventInstance;

}

declare module '@fullcalendar/core/structs/business-hours' {

    import Calendar from '@fullcalendar/core/Calendar';

    import { EventInput } from '@fullcalendar/core/structs/event';

    import { EventStore } from '@fullcalendar/core/structs/event-store';

    export type BusinessHoursInput = boolean | EventInput | EventInput[];

    export function parseBusinessHours(input: BusinessHoursInput, calendar: Calendar): EventStore;

}

declare module '@fullcalendar/core/util/misc' {

    import { DateMarker } from '@fullcalendar/core/datelib/marker';

    import { Duration } from '@fullcalendar/core/datelib/duration';

    import { DateEnv } from '@fullcalendar/core/datelib/env';

    import { DateRange, OpenDateRange } from '@fullcalendar/core/datelib/date-range';

    export function compensateScroll(rowEl: HTMLElement, scrollbarWidths: any): void;

    export function uncompensateScroll(rowEl: HTMLElement): void;

    export function disableCursor(): void;

    export function enableCursor(): void;

    export function distributeHeight(els: HTMLElement[], availableHeight: any, shouldRedistribute: any): void;

    export function undistributeHeight(els: HTMLElement[]): void;

    export function matchCellWidths(els: HTMLElement[]): number;

    export function subtractInnerElHeight(outerEl: HTMLElement, innerEl: HTMLElement): number;

    export function preventSelection(el: HTMLElement): void;

    export function allowSelection(el: HTMLElement): void;

    export function preventContextMenu(el: HTMLElement): void;

    export function allowContextMenu(el: HTMLElement): void;

    export function parseFieldSpecs(input: any): any[];

    export function compareByFieldSpecs(obj0: any, obj1: any, fieldSpecs: any): any;

    export function compareByFieldSpec(obj0: any, obj1: any, fieldSpec: any): any;

    export function flexibleCompare(a: any, b: any): number;

    export function capitaliseFirstLetter(str: any): any;

    export function padStart(val: any, len: any): string;

    export function compareNumbers(a: any, b: any): number;

    export function isInt(n: any): boolean;

    export function applyAll(functions: any, thisObj: any, args: any): any;

    export function firstDefined(...args: any[]): any;

    export function debounce(func: any, wait: any): () => any;

    export type GenericHash = {

        [key: string]: any;

    };

    export function refineProps(rawProps: GenericHash, processors: GenericHash, defaults?: GenericHash, leftoverProps?: GenericHash): GenericHash;

    export function computeAlignedDayRange(timedRange: DateRange): DateRange;

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

    export function isMultiDayRange(range: DateRange): boolean;

    export function diffDates(date0: DateMarker, date1: DateMarker, dateEnv: DateEnv, largeUnit?: string): Duration;

}

declare module '@fullcalendar/core/util/html' {

    export function htmlEscape(s: any): string;

    export function cssToStr(cssProps: any): string;

    export function attrsToStr(attrs: any): string;

    export type ClassNameInput = string | string[];

    export function parseClassName(raw: ClassNameInput): string[];

}

declare module '@fullcalendar/core/util/array' {

    export function removeMatching(array: any, testFunc: any): number;

    export function removeExact(array: any, exactVal: any): number;

    export function isArraysEqual(a0: any, a1: any): boolean;

}

declare module '@fullcalendar/core/util/memoize' {

    export function memoize<T>(workerFunc: T): T;

    export function memoizeOutput<T>(workerFunc: T, equalityFunc: (output0: any, output1: any) => boolean): T;

}

declare module '@fullcalendar/core/component/memoized-rendering' {

    export interface MemoizedRendering<ArgsType extends any[]> {

        (...args: ArgsType): void;

        unrender: () => void;

        dependents: MemoizedRendering<any>[];

    }

    export function memoizeRendering<ArgsType extends any[]>(renderFunc: (...args: ArgsType) => void, unrenderFunc?: (...args: ArgsType) => void, dependencies?: MemoizedRendering<any>[]): MemoizedRendering<ArgsType>;

}

declare module '@fullcalendar/core/util/geom' {

    export interface Point {

        left: number;

        top: number;

    }

    export interface Rect {

        left: number;

        right: number;

        top: number;

        bottom: number;

    }

    export function pointInsideRect(point: Point, rect: Rect): boolean;

    export function intersectRects(rect1: Rect, rect2: Rect): Rect | false;

    export function translateRect(rect: Rect, deltaX: number, deltaY: number): Rect;

    export function constrainPoint(point: Point, rect: Rect): Point;

    export function getRectCenter(rect: Rect): Point;

    export function diffPoints(point1: Point, point2: Point): Point;

}

declare module '@fullcalendar/core/util/object' {

    export function mergeProps(propObjs: any, complexProps?: any): any;

    export function filterHash(hash: any, func: any): {};

    export function mapHash<InputItem, OutputItem>(hash: {

        [key: string]: InputItem;

    }, func: (input: InputItem, key: string) => OutputItem): {

        [key: string]: OutputItem;

    };

    export function arrayToHash(a: any): {

        [key: string]: true;

    };

    export function hashValuesToArray(obj: any): any[];

    export function isPropsEqual(obj0: any, obj1: any): boolean;

}

declare module '@fullcalendar/core/util/dom-manip' {

    export function createElement(tagName: string, attrs: object | null, content?: ElementContent): HTMLElement;

    export function htmlToElement(html: string): HTMLElement;

    export function htmlToElements(html: string): HTMLElement[];

    export type ElementContent = string | Node | Node[] | NodeList;

    export function appendToElement(el: HTMLElement, content: ElementContent): void;

    export function prependToElement(parent: HTMLElement, content: ElementContent): void;

    export function insertAfterElement(refEl: HTMLElement, content: ElementContent): void;

    export function removeElement(el: HTMLElement): void;

    export function elementClosest(el: HTMLElement, selector: string): HTMLElement;

    export function elementMatches(el: HTMLElement, selector: string): HTMLElement;

    export function findElements(container: HTMLElement[] | HTMLElement | NodeListOf<HTMLElement>, selector: string): HTMLElement[];

    export function findChildren(parent: HTMLElement[] | HTMLElement, selector?: string): HTMLElement[];

    export function forceClassName(el: HTMLElement, className: string, bool: any): void;

    export function applyStyle(el: HTMLElement, props: object): void;

    export function applyStyleProp(el: HTMLElement, name: string, val: any): void;

}

declare module '@fullcalendar/core/structs/event-store' {

    import { EventInput, EventDef, EventDefHash, EventInstanceHash, EventTuple } from '@fullcalendar/core/structs/event';

    import { EventSource } from '@fullcalendar/core/structs/event-source';

    import Calendar from '@fullcalendar/core/Calendar';

    import { DateRange } from '@fullcalendar/core/datelib/date-range';

    export interface EventStore {

        defs: EventDefHash;

        instances: EventInstanceHash;

    }

    export function parseEvents(rawEvents: EventInput[], sourceId: string, calendar: Calendar, allowOpenRange?: boolean): EventStore;

    export function eventTupleToStore(tuple: EventTuple, eventStore?: EventStore): EventStore;

    export function expandRecurring(eventStore: EventStore, framingRange: DateRange, calendar: Calendar): EventStore;

    export function getRelevantEvents(eventStore: EventStore, instanceId: string): EventStore;

    export function transformRawEvents(rawEvents: any, eventSource: EventSource, calendar: Calendar): any;

    export function createEmptyEventStore(): EventStore;

    export function mergeEventStores(store0: EventStore, store1: EventStore): EventStore;

    export function filterEventStoreDefs(eventStore: EventStore, filterFunc: (eventDef: EventDef) => boolean): EventStore;

}

declare module '@fullcalendar/core/component/event-ui' {

    import { Constraint, AllowFunc, ConstraintInput } from '@fullcalendar/core/validation';

    import { parseClassName } from '@fullcalendar/core/util/html';

    import Calendar from '@fullcalendar/core/Calendar';

    export interface UnscopedEventUiInput {

        editable?: boolean;

        startEditable?: boolean;

        durationEditable?: boolean;

        constraint?: ConstraintInput;

        overlap?: boolean;

        allow?: AllowFunc;

        className?: string[] | string;

        classNames?: string[] | string;

        backgroundColor?: string;

        borderColor?: string;

        textColor?: string;

        color?: string;

    }

    export interface EventUi {

        startEditable: boolean | null;

        durationEditable: boolean | null;

        constraints: Constraint[];

        overlap: boolean | null;

        allows: AllowFunc[];

        backgroundColor: string;

        borderColor: string;

        textColor: string;

        classNames: string[];

    }

    export type EventUiHash = {

        [defId: string]: EventUi;

    };

    export const UNSCOPED_EVENT_UI_PROPS: {

        editable: BooleanConstructor;

        startEditable: BooleanConstructor;

        durationEditable: BooleanConstructor;

        constraint: any;

        overlap: any;

        allow: any;

        className: typeof parseClassName;

        classNames: typeof parseClassName;

        color: StringConstructor;

        backgroundColor: StringConstructor;

        borderColor: StringConstructor;

        textColor: StringConstructor;

    };

    export function processUnscopedUiProps(rawProps: UnscopedEventUiInput, calendar: Calendar, leftovers?: any): EventUi;

    export function processScopedUiProps(prefix: string, rawScoped: any, calendar: Calendar, leftovers?: any): EventUi;

    export function combineEventUis(uis: EventUi[]): EventUi;

}

declare module '@fullcalendar/core/component/event-splitting' {

    import { EventStore } from '@fullcalendar/core/structs/event-store';

    import { EventDef } from '@fullcalendar/core/structs/event';

    import { EventInteractionState } from '@fullcalendar/core/interactions/event-interaction-state';

    import { EventUiHash, EventUi } from '@fullcalendar/core/component/event-ui';

    import { DateSpan } from '@fullcalendar/core/structs/date-span';

    export interface SplittableProps {

        businessHours: EventStore | null;

        dateSelection: DateSpan | null;

        eventStore: EventStore;

        eventUiBases: EventUiHash;

        eventSelection: string;

        eventDrag: EventInteractionState | null;

        eventResize: EventInteractionState | null;

    }

    export { Splitter as default, Splitter };

    abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {

        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;

        };

    }

}

declare module '@fullcalendar/core/component/date-rendering' {

    import { DateMarker } from '@fullcalendar/core/datelib/marker';

    import { ComponentContext } from '@fullcalendar/core/component/Component';

    import { DateProfile } from '@fullcalendar/core/DateProfileGenerator';

    import { DateEnv } from '@fullcalendar/core/datelib/env';

    export function buildGotoAnchorHtml(allOptions: any, dateEnv: DateEnv, gotoOptions: any, attrs: any, innerHtml?: any): string;

    export function getAllDayHtml(allOptions: any): any;

    export function getDayClasses(date: DateMarker, dateProfile: DateProfile, context: ComponentContext, noThemeHighlight?: any): any[];

}

declare module '@fullcalendar/core/util/dom-event' {

    export function preventDefault(ev: any): void;

    export function listenBySelector(container: HTMLElement, eventType: string, selector: string, handler: (ev: Event, matchedTarget: HTMLElement) => void): () => void;

    export function listenToHoverBySelector(container: HTMLElement, selector: string, onMouseEnter: (ev: Event, matchedTarget: HTMLElement) => void, onMouseLeave: (ev: Event, matchedTarget: HTMLElement) => void): () => void;

    export function whenTransitionDone(el: HTMLElement, callback: (ev: Event) => void): void;

}

declare module '@fullcalendar/core/util/dom-geom' {

    import { Rect } from '@fullcalendar/core/util/geom';

    export interface EdgeInfo {

        borderLeft: number;

        borderRight: number;

        borderTop: number;

        borderBottom: number;

        scrollbarLeft: number;

        scrollbarRight: number;

        scrollbarBottom: number;

        paddingLeft?: number;

        paddingRight?: number;

        paddingTop?: number;

        paddingBottom?: number;

    }

    export function computeEdges(el: any, getPadding?: boolean): EdgeInfo;

    export function computeInnerRect(el: any, goWithinPadding?: boolean): {

        left: number;

        right: number;

        top: number;

        bottom: number;

    };

    export function computeRect(el: any): Rect;

    export function computeHeightAndMargins(el: HTMLElement): number;

    export function computeVMargins(el: HTMLElement): number;

    export function getClippingParents(el: HTMLElement): HTMLElement[];

    export function computeClippingRect(el: HTMLElement): Rect;

}

declare module '@fullcalendar/core/util/promise' {

    export function unpromisify(func: any, success: any, failure?: any): void;

}

declare module '@fullcalendar/core/common/EmitterMixin' {

    import Mixin from '@fullcalendar/core/common/Mixin';

    export interface EmitterInterface {

        on(types: any, handler: any): any;

        one(types: any, handler: any): any;

        off(types: any, handler: any): any;

        trigger(type: any, ...args: any[]): any;

        triggerWith(type: any, context: any, args: any): any;

        hasHandlers(type: any): any;

    }

    export { EmitterMixin as default, EmitterMixin };

    class EmitterMixin extends Mixin implements EmitterInterface {

        _handlers: any;

        _oneHandlers: any;

        on(type: any, handler: any): this;

        one(type: any, handler: any): this;

        off(type: any, handler?: any): this;

        trigger(type: any, ...args: any[]): this;

        triggerWith(type: any, context: any, args: any): this;

        hasHandlers(type: any): any;

    }

}

declare module '@fullcalendar/core/datelib/date-range' {

    import { DateMarker } from '@fullcalendar/core/datelib/marker';

    import { DateEnv, DateInput } from '@fullcalendar/core/datelib/env';

    export interface DateRangeInput {

        start?: DateInput;

        end?: DateInput;

    }

    export interface OpenDateRange {

        start: DateMarker | null;

        end: DateMarker | null;

    }

    export interface DateRange {

        start: DateMarker;

        end: DateMarker;

    }

    export function parseRange(input: DateRangeInput, dateEnv: DateEnv): OpenDateRange;

    export function invertRanges(ranges: DateRange[], constraintRange: DateRange): DateRange[];

    export function intersectRanges(range0: OpenDateRange, range1: OpenDateRange): OpenDateRange;

    export function rangesEqual(range0: OpenDateRange, range1: OpenDateRange): boolean;

    export function rangesIntersect(range0: OpenDateRange, range1: OpenDateRange): boolean;

    export function rangeContainsRange(outerRange: OpenDateRange, innerRange: OpenDateRange): boolean;

    export function rangeContainsMarker(range: OpenDateRange, date: DateMarker | number): boolean;

    export function constrainMarkerToRange(date: DateMarker, range: DateRange): DateMarker;

}

declare module '@fullcalendar/core/common/Mixin' {

    export { Mixin as default, Mixin };

    class Mixin {

        static mixInto(destClass: any): void;

        static mixIntoObj(destObj: any): void;

        static mixOver(destClass: any): void;

    }

}

declare module '@fullcalendar/core/common/PositionCache' {

    export { PositionCache as default, PositionCache };

    class PositionCache {

        originClientRect: ClientRect;

        els: HTMLElement[];

        originEl: HTMLElement;

        isHorizontal: boolean;

        isVertical: boolean;

        lefts: any;

        rights: any;

        tops: any;

        bottoms: any;

        constructor(originEl: HTMLElement, els: HTMLElement[], isHorizontal: boolean, isVertical: boolean);

        build(): void;

        buildElHorizontals(originClientLeft: number): void;

        buildElVerticals(originClientTop: number): void;

        leftToIndex(leftPosition: number): any;

        topToIndex(topPosition: number): any;

        getWidth(leftIndex: number): number;

        getHeight(topIndex: number): number;

    }

}

declare module '@fullcalendar/core/common/ScrollComponent' {

    import { ElementScrollController } from '@fullcalendar/core/common/scroll-controller';

    export interface ScrollbarWidths {

        left: number;

        right: number;

        bottom: number;

    }

    export { ScrollComponent as default, ScrollComponent };

    class ScrollComponent extends ElementScrollController {

        overflowX: string;

        overflowY: string;

        constructor(overflowX: string, overflowY: string);

        clear(): void;

        destroy(): void;

        applyOverflow(): void;

        lockOverflow(scrollbarWidths: ScrollbarWidths): void;

        setHeight(height: number | string): void;

        getScrollbarWidths(): ScrollbarWidths;

    }

}

declare module '@fullcalendar/core/common/scroll-controller' {

    export abstract class ScrollController {

        abstract getScrollTop(): number;

        abstract getScrollLeft(): number;

        abstract setScrollTop(top: number): void;

        abstract setScrollLeft(left: number): void;

        abstract getClientWidth(): number;

        abstract getClientHeight(): number;

        abstract getScrollWidth(): number;

        abstract getScrollHeight(): number;

        getMaxScrollTop(): number;

        getMaxScrollLeft(): number;

        canScrollVertically(): boolean;

        canScrollHorizontally(): boolean;

        canScrollUp(): boolean;

        canScrollDown(): boolean;

        canScrollLeft(): boolean;

        canScrollRight(): boolean;

    }

    export class ElementScrollController extends ScrollController {

        el: HTMLElement;

        constructor(el: HTMLElement);

        getScrollTop(): number;

        getScrollLeft(): number;

        setScrollTop(top: number): void;

        setScrollLeft(left: number): void;

        getScrollWidth(): number;

        getScrollHeight(): number;

        getClientHeight(): number;

        getClientWidth(): number;

    }

    export class WindowScrollController extends ScrollController {

        getScrollTop(): number;

        getScrollLeft(): number;

        setScrollTop(n: number): void;

        setScrollLeft(n: number): void;

        getScrollWidth(): number;

        getScrollHeight(): number;

        getClientHeight(): number;

        getClientWidth(): number;

    }

}

declare module '@fullcalendar/core/theme/Theme' {

    export { Theme as default, Theme };

    class Theme {

        calendarOptions: any;

        classes: any;

        iconClasses: any;

        baseIconClass: string;

        iconOverrideOption: any;

        iconOverrideCustomButtonOption: any;

        iconOverridePrefix: string;

        constructor(calendarOptions: any);

        processIconOverride(): void;

        setIconOverride(iconOverrideHash: any): void;

        applyIconOverridePrefix(className: any): any;

        getClass(key: any): any;

        getIconClass(buttonName: any): string;

        getCustomButtonIconClass(customButtonProps: any): string;

    }

    export type ThemeClass = {

        new (calendarOptions: any): Theme;

    };

}

declare module '@fullcalendar/core/component/Component' {

    import Calendar from '@fullcalendar/core/Calendar';

    import View from '@fullcalendar/core/View';

    import Theme from '@fullcalendar/core/theme/Theme';

    import { DateEnv } from '@fullcalendar/core/datelib/env';

    import { Duration } from '@fullcalendar/core/datelib/duration';

    export class ComponentContext {

        calendar: Calendar;

        theme: Theme;

        dateEnv: DateEnv;

        options: any;

        view?: View;

        isRtl: boolean;

        eventOrderSpecs: any;

        nextDayThreshold: Duration;

        constructor(calendar: Calendar, theme: Theme, dateEnv: DateEnv, options: any, view?: View);

        extend(options?: any, view?: View): ComponentContext;

    }

    export type EqualityFuncHash = {

        [propName: string]: (obj0: any, obj1: any) => boolean;

    };

    export { Component as default, Component };

    class Component<PropsType> {

        equalityFuncs: EqualityFuncHash;

        uid: string;

        props: PropsType | null;

        context: ComponentContext;

        constructor();

        static addEqualityFuncs(newFuncs: EqualityFuncHash): void;

        receiveProps(props: PropsType, context: ComponentContext): void;

        protected render(props: PropsType, context: ComponentContext): void;

        firstContext(context: ComponentContext): void;

        beforeUpdate(): void;

        afterUpdate(): void;

        destroy(): void;

    }

}

declare module '@fullcalendar/core/component/DateComponent' {

    import Component from '@fullcalendar/core/component/Component';

    import { EventRenderRange } from '@fullcalendar/core/component/event-rendering';

    import { DateSpan } from '@fullcalendar/core/structs/date-span';

    import { EventInstanceHash } from '@fullcalendar/core/structs/event';

    import { Hit } from '@fullcalendar/core/interactions/hit';

    import FgEventRenderer from '@fullcalendar/core/component/renderers/FgEventRenderer';

    import FillRenderer from '@fullcalendar/core/component/renderers/FillRenderer';

    import { EventInteractionState } from '@fullcalendar/core/interactions/event-interaction-state';

    export type DateComponentHash = {

        [uid: string]: DateComponent<any>;

    };

    export interface Seg {

        component?: DateComponent<any>;

        isStart: boolean;

        isEnd: boolean;

        eventRange?: EventRenderRange;

        el?: HTMLElement;

        [otherProp: string]: any;

    }

    export interface EventSegUiInteractionState {

        affectedInstances: EventInstanceHash;

        segs: Seg[];

        isEvent: boolean;

        sourceSeg: any;

    }

    export { DateComponent as default, DateComponent };

    class DateComponent<PropsType> extends Component<PropsType> {

        fgSegSelector: string;

        bgSegSelector: string;

        largeUnit: any;

        eventRenderer: FgEventRenderer;

        mirrorRenderer: FgEventRenderer;