@fullcalendar/core

  • Version 6.1.13
  • Published
  • 1.86 MB
  • 1 dependency
  • MIT license

Install

npm i @fullcalendar/core
yarn add @fullcalendar/core
pnpm add @fullcalendar/core

Overview

FullCalendar core package for rendering a calendar

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable globalLocales

const globalLocales: LocaleInput[];

    variable globalPlugins

    const globalPlugins: PluginDef[];

      variable version

      const version: string;

        Functions

        function createPlugin

        createPlugin: (input: PluginDefInput) => PluginDef;

          function formatDate

          formatDate: (dateInput: DateInput, options?: FormatDateOptions) => string;

            function formatRange

            formatRange: (
            startInput: DateInput,
            endInput: DateInput,
            options: FormatRangeOptions
            ) => string;

              function sliceEvents

              sliceEvents: (
              props: ViewProps & { dateProfile: DateProfile; nextDayThreshold: Duration },
              allDay?: boolean
              ) => EventRenderRange[];

                Classes

                class Calendar

                class Calendar extends CalendarImpl {}

                  constructor

                  constructor(el: HTMLElement, optionOverrides?: CalendarOptions);

                    property el

                    el: HTMLElement;

                      method batchRendering

                      batchRendering: (func: any) => void;

                        method destroy

                        destroy: () => void;

                          method pauseRendering

                          pauseRendering: () => void;

                            method render

                            render: () => void;

                              method resetOptions

                              resetOptions: (optionOverrides: any, changedOptionNames?: string[]) => void;

                                method resumeRendering

                                resumeRendering: () => void;

                                  method updateSize

                                  updateSize: () => void;

                                    class CustomRenderingStore

                                    class CustomRenderingStore<RenderProps> extends Store<
                                    Map<string, CustomRendering<RenderProps>>
                                    > {}

                                      method handle

                                      handle: (customRendering: CustomRendering<RenderProps>) => void;

                                        class JsonRequestError

                                        class JsonRequestError extends Error {}

                                          constructor

                                          constructor(message: string, response: Response);

                                            property response

                                            response: Response;

                                              Interfaces

                                              interface AllDayContentArg

                                              interface AllDayContentArg {}

                                                property text

                                                text: string;

                                                  property view

                                                  view: ViewApi;

                                                    interface ButtonHintCompoundInput

                                                    interface ButtonHintCompoundInput {}

                                                      property day

                                                      day?: string | ((...args: any[]) => string);

                                                        property month

                                                        month?: string | ((...args: any[]) => string);

                                                          property next

                                                          next?: string | ((...args: any[]) => string);

                                                            property nextYear

                                                            nextYear?: string | ((...args: any[]) => string);

                                                              property prev

                                                              prev?: string | ((...args: any[]) => string);

                                                                property prevYear

                                                                prevYear?: string | ((...args: any[]) => string);

                                                                  property today

                                                                  today?: string | ((...args: any[]) => string);

                                                                    property week

                                                                    week?: string | ((...args: any[]) => string);

                                                                      index signature

                                                                      [viewOrCustomButton: string]: string | ((...args: any[]) => string) | undefined;

                                                                        interface ButtonIconsInput

                                                                        interface ButtonIconsInput {}

                                                                          property next

                                                                          next?: string;

                                                                            property nextYear

                                                                            nextYear?: string;

                                                                              property prev

                                                                              prev?: string;

                                                                                property prevYear

                                                                                prevYear?: string;

                                                                                  property today

                                                                                  today?: string;

                                                                                    index signature

                                                                                    [viewOrCustomButton: string]: string | undefined;

                                                                                      interface ButtonTextCompoundInput

                                                                                      interface ButtonTextCompoundInput {}

                                                                                        property day

                                                                                        day?: string;

                                                                                          property month

                                                                                          month?: string;

                                                                                            property next

                                                                                            next?: string;

                                                                                              property nextYear

                                                                                              nextYear?: string;

                                                                                                property prev

                                                                                                prev?: string;

                                                                                                  property prevYear

                                                                                                  prevYear?: string;

                                                                                                    property today

                                                                                                    today?: string;

                                                                                                      property week

                                                                                                      week?: string;

                                                                                                        index signature

                                                                                                        [viewOrCustomButton: string]: string | undefined;

                                                                                                          interface CalendarApi

                                                                                                          interface CalendarApi {}

                                                                                                            property view

                                                                                                            view: ViewApi;

                                                                                                              method addEvent

                                                                                                              addEvent: (
                                                                                                              eventInput: EventInput,
                                                                                                              sourceInput?: EventSourceApi | string | boolean
                                                                                                              ) => EventApi | null;

                                                                                                                method addEventSource

                                                                                                                addEventSource: (sourceInput: EventSourceInput) => EventSourceApi;

                                                                                                                  method changeView

                                                                                                                  changeView: (viewType: string, dateOrRange?: DateRangeInput | DateInput) => void;

                                                                                                                    method formatDate

                                                                                                                    formatDate: (d: DateInput, formatter: FormatterInput) => string;

                                                                                                                      method formatIso

                                                                                                                      formatIso: (d: DateInput, omitTime?: boolean) => string;

                                                                                                                        method formatRange

                                                                                                                        formatRange: (d0: DateInput, d1: DateInput, settings: any) => string;

                                                                                                                          method getAvailableLocaleCodes

                                                                                                                          getAvailableLocaleCodes: () => string[];

                                                                                                                            method getDate

                                                                                                                            getDate: () => Date;

                                                                                                                              method getEventById

                                                                                                                              getEventById: (id: string) => EventApi | null;

                                                                                                                                method getEvents

                                                                                                                                getEvents: () => EventApi[];

                                                                                                                                  method getEventSourceById

                                                                                                                                  getEventSourceById: (id: string) => EventSourceApi | null;

                                                                                                                                    method getEventSources

                                                                                                                                    getEventSources: () => EventSourceApi[];

                                                                                                                                      method getOption

                                                                                                                                      getOption: <
                                                                                                                                      OptionName extends
                                                                                                                                      | 'navLinkDayClick'
                                                                                                                                      | 'navLinkWeekClick'
                                                                                                                                      | 'duration'
                                                                                                                                      | 'bootstrapFontAwesome'
                                                                                                                                      | 'buttonIcons'
                                                                                                                                      | 'customButtons'
                                                                                                                                      | 'defaultAllDayEventDuration'
                                                                                                                                      | 'defaultTimedEventDuration'
                                                                                                                                      | 'nextDayThreshold'
                                                                                                                                      | 'scrollTime'
                                                                                                                                      | 'scrollTimeReset'
                                                                                                                                      | 'slotMinTime'
                                                                                                                                      | 'slotMaxTime'
                                                                                                                                      | 'dayPopoverFormat'
                                                                                                                                      | 'slotDuration'
                                                                                                                                      | 'snapDuration'
                                                                                                                                      | 'headerToolbar'
                                                                                                                                      | 'footerToolbar'
                                                                                                                                      | 'defaultRangeSeparator'
                                                                                                                                      | 'titleRangeSeparator'
                                                                                                                                      | 'forceEventDuration'
                                                                                                                                      | 'dayHeaders'
                                                                                                                                      | 'dayHeaderFormat'
                                                                                                                                      | 'dayHeaderClassNames'
                                                                                                                                      | 'dayHeaderContent'
                                                                                                                                      | 'dayHeaderDidMount'
                                                                                                                                      | 'dayHeaderWillUnmount'
                                                                                                                                      | 'dayCellClassNames'
                                                                                                                                      | 'dayCellContent'
                                                                                                                                      | 'dayCellDidMount'
                                                                                                                                      | 'dayCellWillUnmount'
                                                                                                                                      | 'initialView'
                                                                                                                                      | 'aspectRatio'
                                                                                                                                      | 'weekends'
                                                                                                                                      | 'weekNumberCalculation'
                                                                                                                                      | 'weekNumbers'
                                                                                                                                      | 'weekNumberClassNames'
                                                                                                                                      | 'weekNumberContent'
                                                                                                                                      | 'weekNumberDidMount'
                                                                                                                                      | 'weekNumberWillUnmount'
                                                                                                                                      | 'editable'
                                                                                                                                      | 'viewClassNames'
                                                                                                                                      | 'viewDidMount'
                                                                                                                                      | 'viewWillUnmount'
                                                                                                                                      | 'nowIndicator'
                                                                                                                                      | 'nowIndicatorClassNames'
                                                                                                                                      | 'nowIndicatorContent'
                                                                                                                                      | 'nowIndicatorDidMount'
                                                                                                                                      | 'nowIndicatorWillUnmount'
                                                                                                                                      | 'showNonCurrentDates'
                                                                                                                                      | 'lazyFetching'
                                                                                                                                      | 'startParam'
                                                                                                                                      | 'endParam'
                                                                                                                                      | 'timeZoneParam'
                                                                                                                                      | 'timeZone'
                                                                                                                                      | 'locales'
                                                                                                                                      | 'locale'
                                                                                                                                      | 'themeSystem'
                                                                                                                                      | 'dragRevertDuration'
                                                                                                                                      | 'dragScroll'
                                                                                                                                      | 'allDayMaintainDuration'
                                                                                                                                      | 'unselectAuto'
                                                                                                                                      | 'dropAccept'
                                                                                                                                      | 'eventOrder'
                                                                                                                                      | 'eventOrderStrict'
                                                                                                                                      | 'handleWindowResize'
                                                                                                                                      | 'windowResizeDelay'
                                                                                                                                      | 'longPressDelay'
                                                                                                                                      | 'eventDragMinDistance'
                                                                                                                                      | 'expandRows'
                                                                                                                                      | 'height'
                                                                                                                                      | 'contentHeight'
                                                                                                                                      | 'direction'
                                                                                                                                      | 'weekNumberFormat'
                                                                                                                                      | 'eventResizableFromStart'
                                                                                                                                      | 'displayEventTime'
                                                                                                                                      | 'displayEventEnd'
                                                                                                                                      | 'weekText'
                                                                                                                                      | 'weekTextLong'
                                                                                                                                      | 'progressiveEventRendering'
                                                                                                                                      | 'businessHours'
                                                                                                                                      | 'initialDate'
                                                                                                                                      | 'now'
                                                                                                                                      | 'eventDataTransform'
                                                                                                                                      | 'stickyHeaderDates'
                                                                                                                                      | 'stickyFooterScrollbar'
                                                                                                                                      | 'viewHeight'
                                                                                                                                      | 'defaultAllDay'
                                                                                                                                      | 'eventSourceFailure'
                                                                                                                                      | 'eventSourceSuccess'
                                                                                                                                      | 'eventDisplay'
                                                                                                                                      | 'eventStartEditable'
                                                                                                                                      | 'eventDurationEditable'
                                                                                                                                      | 'eventOverlap'
                                                                                                                                      | 'eventConstraint'
                                                                                                                                      | 'eventAllow'
                                                                                                                                      | 'eventBackgroundColor'
                                                                                                                                      | 'eventBorderColor'
                                                                                                                                      | 'eventTextColor'
                                                                                                                                      | 'eventColor'
                                                                                                                                      | 'eventClassNames'
                                                                                                                                      | 'eventContent'
                                                                                                                                      | 'eventDidMount'
                                                                                                                                      | 'eventWillUnmount'
                                                                                                                                      | 'selectConstraint'
                                                                                                                                      | 'selectOverlap'
                                                                                                                                      | 'selectAllow'
                                                                                                                                      | 'droppable'
                                                                                                                                      | 'unselectCancel'
                                                                                                                                      | 'slotLabelFormat'
                                                                                                                                      | 'slotLaneClassNames'
                                                                                                                                      | 'slotLaneContent'
                                                                                                                                      | 'slotLaneDidMount'
                                                                                                                                      | 'slotLaneWillUnmount'
                                                                                                                                      | 'slotLabelClassNames'
                                                                                                                                      | 'slotLabelContent'
                                                                                                                                      | 'slotLabelDidMount'
                                                                                                                                      | 'slotLabelWillUnmount'
                                                                                                                                      | 'dayMaxEvents'
                                                                                                                                      | 'dayMaxEventRows'
                                                                                                                                      | 'dayMinWidth'
                                                                                                                                      | 'slotLabelInterval'
                                                                                                                                      | 'allDayText'
                                                                                                                                      | 'allDayClassNames'
                                                                                                                                      | 'allDayContent'
                                                                                                                                      | 'allDayDidMount'
                                                                                                                                      | 'allDayWillUnmount'
                                                                                                                                      | 'slotMinWidth'
                                                                                                                                      | 'navLinks'
                                                                                                                                      | 'eventTimeFormat'
                                                                                                                                      | 'rerenderDelay'
                                                                                                                                      | 'moreLinkText'
                                                                                                                                      | 'moreLinkHint'
                                                                                                                                      | 'selectMinDistance'
                                                                                                                                      | 'selectable'
                                                                                                                                      | 'selectLongPressDelay'
                                                                                                                                      | 'eventLongPressDelay'
                                                                                                                                      | 'selectMirror'
                                                                                                                                      | 'eventMaxStack'
                                                                                                                                      | 'eventMinHeight'
                                                                                                                                      | 'eventMinWidth'
                                                                                                                                      | 'eventShortHeight'
                                                                                                                                      | 'slotEventOverlap'
                                                                                                                                      | 'plugins'
                                                                                                                                      | 'firstDay'
                                                                                                                                      | 'dayCount'
                                                                                                                                      | 'dateAlignment'
                                                                                                                                      | 'dateIncrement'
                                                                                                                                      | 'hiddenDays'
                                                                                                                                      | 'fixedWeekCount'
                                                                                                                                      | 'validRange'
                                                                                                                                      | 'visibleRange'
                                                                                                                                      | 'titleFormat'
                                                                                                                                      | 'eventInteractive'
                                                                                                                                      | 'noEventsText'
                                                                                                                                      | 'viewHint'
                                                                                                                                      | 'navLinkHint'
                                                                                                                                      | 'closeHint'
                                                                                                                                      | 'timeHint'
                                                                                                                                      | 'eventHint'
                                                                                                                                      | 'moreLinkClick'
                                                                                                                                      | 'moreLinkClassNames'
                                                                                                                                      | 'moreLinkContent'
                                                                                                                                      | 'moreLinkDidMount'
                                                                                                                                      | 'moreLinkWillUnmount'
                                                                                                                                      | 'monthStartFormat'
                                                                                                                                      | 'handleCustomRendering'
                                                                                                                                      | 'customRenderingMetaMap'
                                                                                                                                      | 'customRenderingReplaces'
                                                                                                                                      | 'datesSet'
                                                                                                                                      | 'eventsSet'
                                                                                                                                      | 'eventAdd'
                                                                                                                                      | 'eventChange'
                                                                                                                                      | 'eventRemove'
                                                                                                                                      | 'windowResize'
                                                                                                                                      | 'eventClick'
                                                                                                                                      | 'eventMouseEnter'
                                                                                                                                      | 'eventMouseLeave'
                                                                                                                                      | 'select'
                                                                                                                                      | 'unselect'
                                                                                                                                      | 'loading'
                                                                                                                                      | '_unmount'
                                                                                                                                      | '_beforeprint'
                                                                                                                                      | '_afterprint'
                                                                                                                                      | '_noEventDrop'
                                                                                                                                      | '_noEventResize'
                                                                                                                                      | '_resize'
                                                                                                                                      | '_scrollRequest'
                                                                                                                                      | 'buttonText'
                                                                                                                                      | 'buttonHints'
                                                                                                                                      | 'views'
                                                                                                                                      | 'initialEvents'
                                                                                                                                      | 'events'
                                                                                                                                      | 'eventSources'
                                                                                                                                      >(
                                                                                                                                      name: OptionName
                                                                                                                                      ) => CalendarOptions[OptionName];

                                                                                                                                        method gotoDate

                                                                                                                                        gotoDate: (zonedDateInput: DateInput) => void;

                                                                                                                                          method incrementDate

                                                                                                                                          incrementDate: (deltaInput: DurationInput) => void;

                                                                                                                                            method next

                                                                                                                                            next: () => void;

                                                                                                                                              method nextYear

                                                                                                                                              nextYear: () => void;

                                                                                                                                                method off

                                                                                                                                                off: <ListenerName extends keyof CalendarListenerRefiners>(
                                                                                                                                                handlerName: ListenerName,
                                                                                                                                                handler: CalendarListeners[ListenerName]
                                                                                                                                                ) => void;

                                                                                                                                                  method on

                                                                                                                                                  on: <ListenerName extends keyof CalendarListenerRefiners>(
                                                                                                                                                  handlerName: ListenerName,
                                                                                                                                                  handler: CalendarListeners[ListenerName]
                                                                                                                                                  ) => void;

                                                                                                                                                    method prev

                                                                                                                                                    prev: () => void;

                                                                                                                                                      method prevYear

                                                                                                                                                      prevYear: () => void;

                                                                                                                                                        method refetchEvents

                                                                                                                                                        refetchEvents: () => void;

                                                                                                                                                          method removeAllEvents

                                                                                                                                                          removeAllEvents: () => void;

                                                                                                                                                            method removeAllEventSources

                                                                                                                                                            removeAllEventSources: () => void;

                                                                                                                                                              method scrollToTime

                                                                                                                                                              scrollToTime: (timeInput: DurationInput) => void;

                                                                                                                                                                method select

                                                                                                                                                                select: (dateOrObj: DateInput | any, endDate?: DateInput) => void;

                                                                                                                                                                  method setOption

                                                                                                                                                                  setOption: <
                                                                                                                                                                  OptionName extends
                                                                                                                                                                  | 'navLinkDayClick'
                                                                                                                                                                  | 'navLinkWeekClick'
                                                                                                                                                                  | 'duration'
                                                                                                                                                                  | 'bootstrapFontAwesome'
                                                                                                                                                                  | 'buttonIcons'
                                                                                                                                                                  | 'customButtons'
                                                                                                                                                                  | 'defaultAllDayEventDuration'
                                                                                                                                                                  | 'defaultTimedEventDuration'
                                                                                                                                                                  | 'nextDayThreshold'
                                                                                                                                                                  | 'scrollTime'
                                                                                                                                                                  | 'scrollTimeReset'
                                                                                                                                                                  | 'slotMinTime'
                                                                                                                                                                  | 'slotMaxTime'
                                                                                                                                                                  | 'dayPopoverFormat'
                                                                                                                                                                  | 'slotDuration'
                                                                                                                                                                  | 'snapDuration'
                                                                                                                                                                  | 'headerToolbar'
                                                                                                                                                                  | 'footerToolbar'
                                                                                                                                                                  | 'defaultRangeSeparator'
                                                                                                                                                                  | 'titleRangeSeparator'
                                                                                                                                                                  | 'forceEventDuration'
                                                                                                                                                                  | 'dayHeaders'
                                                                                                                                                                  | 'dayHeaderFormat'
                                                                                                                                                                  | 'dayHeaderClassNames'
                                                                                                                                                                  | 'dayHeaderContent'
                                                                                                                                                                  | 'dayHeaderDidMount'
                                                                                                                                                                  | 'dayHeaderWillUnmount'
                                                                                                                                                                  | 'dayCellClassNames'
                                                                                                                                                                  | 'dayCellContent'
                                                                                                                                                                  | 'dayCellDidMount'
                                                                                                                                                                  | 'dayCellWillUnmount'
                                                                                                                                                                  | 'initialView'
                                                                                                                                                                  | 'aspectRatio'
                                                                                                                                                                  | 'weekends'
                                                                                                                                                                  | 'weekNumberCalculation'
                                                                                                                                                                  | 'weekNumbers'
                                                                                                                                                                  | 'weekNumberClassNames'
                                                                                                                                                                  | 'weekNumberContent'
                                                                                                                                                                  | 'weekNumberDidMount'
                                                                                                                                                                  | 'weekNumberWillUnmount'
                                                                                                                                                                  | 'editable'
                                                                                                                                                                  | 'viewClassNames'
                                                                                                                                                                  | 'viewDidMount'
                                                                                                                                                                  | 'viewWillUnmount'
                                                                                                                                                                  | 'nowIndicator'
                                                                                                                                                                  | 'nowIndicatorClassNames'
                                                                                                                                                                  | 'nowIndicatorContent'
                                                                                                                                                                  | 'nowIndicatorDidMount'
                                                                                                                                                                  | 'nowIndicatorWillUnmount'
                                                                                                                                                                  | 'showNonCurrentDates'
                                                                                                                                                                  | 'lazyFetching'
                                                                                                                                                                  | 'startParam'
                                                                                                                                                                  | 'endParam'
                                                                                                                                                                  | 'timeZoneParam'
                                                                                                                                                                  | 'timeZone'
                                                                                                                                                                  | 'locales'
                                                                                                                                                                  | 'locale'
                                                                                                                                                                  | 'themeSystem'
                                                                                                                                                                  | 'dragRevertDuration'
                                                                                                                                                                  | 'dragScroll'
                                                                                                                                                                  | 'allDayMaintainDuration'
                                                                                                                                                                  | 'unselectAuto'
                                                                                                                                                                  | 'dropAccept'
                                                                                                                                                                  | 'eventOrder'
                                                                                                                                                                  | 'eventOrderStrict'
                                                                                                                                                                  | 'handleWindowResize'
                                                                                                                                                                  | 'windowResizeDelay'
                                                                                                                                                                  | 'longPressDelay'
                                                                                                                                                                  | 'eventDragMinDistance'
                                                                                                                                                                  | 'expandRows'
                                                                                                                                                                  | 'height'
                                                                                                                                                                  | 'contentHeight'
                                                                                                                                                                  | 'direction'
                                                                                                                                                                  | 'weekNumberFormat'
                                                                                                                                                                  | 'eventResizableFromStart'
                                                                                                                                                                  | 'displayEventTime'
                                                                                                                                                                  | 'displayEventEnd'
                                                                                                                                                                  | 'weekText'
                                                                                                                                                                  | 'weekTextLong'
                                                                                                                                                                  | 'progressiveEventRendering'
                                                                                                                                                                  | 'businessHours'
                                                                                                                                                                  | 'initialDate'
                                                                                                                                                                  | 'now'
                                                                                                                                                                  | 'eventDataTransform'
                                                                                                                                                                  | 'stickyHeaderDates'
                                                                                                                                                                  | 'stickyFooterScrollbar'
                                                                                                                                                                  | 'viewHeight'
                                                                                                                                                                  | 'defaultAllDay'
                                                                                                                                                                  | 'eventSourceFailure'
                                                                                                                                                                  | 'eventSourceSuccess'
                                                                                                                                                                  | 'eventDisplay'
                                                                                                                                                                  | 'eventStartEditable'
                                                                                                                                                                  | 'eventDurationEditable'
                                                                                                                                                                  | 'eventOverlap'
                                                                                                                                                                  | 'eventConstraint'
                                                                                                                                                                  | 'eventAllow'
                                                                                                                                                                  | 'eventBackgroundColor'
                                                                                                                                                                  | 'eventBorderColor'
                                                                                                                                                                  | 'eventTextColor'
                                                                                                                                                                  | 'eventColor'
                                                                                                                                                                  | 'eventClassNames'
                                                                                                                                                                  | 'eventContent'
                                                                                                                                                                  | 'eventDidMount'
                                                                                                                                                                  | 'eventWillUnmount'
                                                                                                                                                                  | 'selectConstraint'
                                                                                                                                                                  | 'selectOverlap'
                                                                                                                                                                  | 'selectAllow'
                                                                                                                                                                  | 'droppable'
                                                                                                                                                                  | 'unselectCancel'
                                                                                                                                                                  | 'slotLabelFormat'
                                                                                                                                                                  | 'slotLaneClassNames'
                                                                                                                                                                  | 'slotLaneContent'
                                                                                                                                                                  | 'slotLaneDidMount'
                                                                                                                                                                  | 'slotLaneWillUnmount'
                                                                                                                                                                  | 'slotLabelClassNames'
                                                                                                                                                                  | 'slotLabelContent'
                                                                                                                                                                  | 'slotLabelDidMount'
                                                                                                                                                                  | 'slotLabelWillUnmount'
                                                                                                                                                                  | 'dayMaxEvents'
                                                                                                                                                                  | 'dayMaxEventRows'
                                                                                                                                                                  | 'dayMinWidth'
                                                                                                                                                                  | 'slotLabelInterval'
                                                                                                                                                                  | 'allDayText'
                                                                                                                                                                  | 'allDayClassNames'
                                                                                                                                                                  | 'allDayContent'
                                                                                                                                                                  | 'allDayDidMount'
                                                                                                                                                                  | 'allDayWillUnmount'
                                                                                                                                                                  | 'slotMinWidth'
                                                                                                                                                                  | 'navLinks'
                                                                                                                                                                  | 'eventTimeFormat'
                                                                                                                                                                  | 'rerenderDelay'
                                                                                                                                                                  | 'moreLinkText'
                                                                                                                                                                  | 'moreLinkHint'
                                                                                                                                                                  | 'selectMinDistance'
                                                                                                                                                                  | 'selectable'
                                                                                                                                                                  | 'selectLongPressDelay'
                                                                                                                                                                  | 'eventLongPressDelay'
                                                                                                                                                                  | 'selectMirror'
                                                                                                                                                                  | 'eventMaxStack'
                                                                                                                                                                  | 'eventMinHeight'
                                                                                                                                                                  | 'eventMinWidth'
                                                                                                                                                                  | 'eventShortHeight'
                                                                                                                                                                  | 'slotEventOverlap'
                                                                                                                                                                  | 'plugins'
                                                                                                                                                                  | 'firstDay'
                                                                                                                                                                  | 'dayCount'
                                                                                                                                                                  | 'dateAlignment'
                                                                                                                                                                  | 'dateIncrement'
                                                                                                                                                                  | 'hiddenDays'
                                                                                                                                                                  | 'fixedWeekCount'
                                                                                                                                                                  | 'validRange'
                                                                                                                                                                  | 'visibleRange'
                                                                                                                                                                  | 'titleFormat'
                                                                                                                                                                  | 'eventInteractive'
                                                                                                                                                                  | 'noEventsText'
                                                                                                                                                                  | 'viewHint'
                                                                                                                                                                  | 'navLinkHint'
                                                                                                                                                                  | 'closeHint'
                                                                                                                                                                  | 'timeHint'
                                                                                                                                                                  | 'eventHint'
                                                                                                                                                                  | 'moreLinkClick'
                                                                                                                                                                  | 'moreLinkClassNames'
                                                                                                                                                                  | 'moreLinkContent'
                                                                                                                                                                  | 'moreLinkDidMount'
                                                                                                                                                                  | 'moreLinkWillUnmount'
                                                                                                                                                                  | 'monthStartFormat'
                                                                                                                                                                  | 'handleCustomRendering'
                                                                                                                                                                  | 'customRenderingMetaMap'
                                                                                                                                                                  | 'customRenderingReplaces'
                                                                                                                                                                  | 'datesSet'
                                                                                                                                                                  | 'eventsSet'
                                                                                                                                                                  | 'eventAdd'
                                                                                                                                                                  | 'eventChange'
                                                                                                                                                                  | 'eventRemove'
                                                                                                                                                                  | 'windowResize'
                                                                                                                                                                  | 'eventClick'
                                                                                                                                                                  | 'eventMouseEnter'
                                                                                                                                                                  | 'eventMouseLeave'
                                                                                                                                                                  | 'select'
                                                                                                                                                                  | 'unselect'
                                                                                                                                                                  | 'loading'
                                                                                                                                                                  | '_unmount'
                                                                                                                                                                  | '_beforeprint'
                                                                                                                                                                  | '_afterprint'
                                                                                                                                                                  | '_noEventDrop'
                                                                                                                                                                  | '_noEventResize'
                                                                                                                                                                  | '_resize'
                                                                                                                                                                  | '_scrollRequest'
                                                                                                                                                                  | 'buttonText'
                                                                                                                                                                  | 'buttonHints'
                                                                                                                                                                  | 'views'
                                                                                                                                                                  | 'initialEvents'
                                                                                                                                                                  | 'events'
                                                                                                                                                                  | 'eventSources'
                                                                                                                                                                  >(
                                                                                                                                                                  name: OptionName,
                                                                                                                                                                  val: CalendarOptions[OptionName]
                                                                                                                                                                  ) => void;

                                                                                                                                                                    method today

                                                                                                                                                                    today: () => void;

                                                                                                                                                                      method trigger

                                                                                                                                                                      trigger: <ListenerName extends keyof CalendarListenerRefiners>(
                                                                                                                                                                      handlerName: ListenerName,
                                                                                                                                                                      ...args: Parameters<CalendarListeners[ListenerName]>
                                                                                                                                                                      ) => void;

                                                                                                                                                                        method unselect

                                                                                                                                                                        unselect: () => void;

                                                                                                                                                                          method updateSize

                                                                                                                                                                          updateSize: () => void;

                                                                                                                                                                            method zoomTo

                                                                                                                                                                            zoomTo: (dateMarker: Date, viewType?: string) => void;

                                                                                                                                                                              interface CustomButtonInput

                                                                                                                                                                              interface CustomButtonInput {}

                                                                                                                                                                                property bootstrapFontAwesome

                                                                                                                                                                                bootstrapFontAwesome?: string;

                                                                                                                                                                                  property hint

                                                                                                                                                                                  hint?: string;

                                                                                                                                                                                    property icon

                                                                                                                                                                                    icon?: string;

                                                                                                                                                                                      property text

                                                                                                                                                                                      text?: string;

                                                                                                                                                                                        property themeIcon

                                                                                                                                                                                        themeIcon?: string;

                                                                                                                                                                                          method click

                                                                                                                                                                                          click: (ev: MouseEvent, element: HTMLElement) => void;

                                                                                                                                                                                            interface DatePointApi

                                                                                                                                                                                            interface DatePointApi {}

                                                                                                                                                                                              property allDay

                                                                                                                                                                                              allDay: boolean;

                                                                                                                                                                                                property date

                                                                                                                                                                                                date: Date;

                                                                                                                                                                                                  property dateStr

                                                                                                                                                                                                  dateStr: string;

                                                                                                                                                                                                    interface DateRangeInput

                                                                                                                                                                                                    interface DateRangeInput {}

                                                                                                                                                                                                      property end

                                                                                                                                                                                                      end?: DateInput;

                                                                                                                                                                                                        property start

                                                                                                                                                                                                        start?: DateInput;

                                                                                                                                                                                                          interface DateSelectArg

                                                                                                                                                                                                          interface DateSelectArg extends DateSpanApi {}

                                                                                                                                                                                                            property jsEvent

                                                                                                                                                                                                            jsEvent: MouseEvent | null;

                                                                                                                                                                                                              property view

                                                                                                                                                                                                              view: ViewApi;

                                                                                                                                                                                                                interface DateSelectionApi

                                                                                                                                                                                                                interface DateSelectionApi extends DateSpanApi {}

                                                                                                                                                                                                                  property jsEvent

                                                                                                                                                                                                                  jsEvent: UIEvent;

                                                                                                                                                                                                                    property view

                                                                                                                                                                                                                    view: ViewApi;

                                                                                                                                                                                                                      interface DateSpanApi

                                                                                                                                                                                                                      interface DateSpanApi extends RangeApi {}

                                                                                                                                                                                                                        property allDay

                                                                                                                                                                                                                        allDay: boolean;

                                                                                                                                                                                                                          interface DateSpanInput

                                                                                                                                                                                                                          interface DateSpanInput extends OpenDateSpanInput {}

                                                                                                                                                                                                                            property end

                                                                                                                                                                                                                            end: DateInput;

                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                              start: DateInput;

                                                                                                                                                                                                                                interface DateUnselectArg

                                                                                                                                                                                                                                interface DateUnselectArg {}

                                                                                                                                                                                                                                  property jsEvent

                                                                                                                                                                                                                                  jsEvent: MouseEvent;

                                                                                                                                                                                                                                    property view

                                                                                                                                                                                                                                    view: ViewApi;

                                                                                                                                                                                                                                      interface DayCellContentArg

                                                                                                                                                                                                                                      interface DayCellContentArg extends DateMeta {}

                                                                                                                                                                                                                                        property date

                                                                                                                                                                                                                                        date: DateMarker;

                                                                                                                                                                                                                                          property dayNumberText

                                                                                                                                                                                                                                          dayNumberText: string;

                                                                                                                                                                                                                                            property view

                                                                                                                                                                                                                                            view: ViewApi;

                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                              [extraProp: string]: any;

                                                                                                                                                                                                                                                interface DayHeaderContentArg

                                                                                                                                                                                                                                                interface DayHeaderContentArg extends DateMeta {}

                                                                                                                                                                                                                                                  property date

                                                                                                                                                                                                                                                  date: Date;

                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                    text: string;

                                                                                                                                                                                                                                                      property view

                                                                                                                                                                                                                                                      view: ViewApi;

                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                        [otherProp: string]: any;

                                                                                                                                                                                                                                                          interface Duration

                                                                                                                                                                                                                                                          interface Duration {}

                                                                                                                                                                                                                                                            property days

                                                                                                                                                                                                                                                            days: number;

                                                                                                                                                                                                                                                              property milliseconds

                                                                                                                                                                                                                                                              milliseconds: number;

                                                                                                                                                                                                                                                                property months

                                                                                                                                                                                                                                                                months: number;

                                                                                                                                                                                                                                                                  property specifiedWeeks

                                                                                                                                                                                                                                                                  specifiedWeeks?: boolean;

                                                                                                                                                                                                                                                                    property years

                                                                                                                                                                                                                                                                    years: number;

                                                                                                                                                                                                                                                                      interface EventAddArg

                                                                                                                                                                                                                                                                      interface EventAddArg {}

                                                                                                                                                                                                                                                                        property event

                                                                                                                                                                                                                                                                        event: EventImpl;

                                                                                                                                                                                                                                                                          property relatedEvents

                                                                                                                                                                                                                                                                          relatedEvents: EventImpl[];

                                                                                                                                                                                                                                                                            property revert

                                                                                                                                                                                                                                                                            revert: () => void;

                                                                                                                                                                                                                                                                              interface EventApi

                                                                                                                                                                                                                                                                              interface EventApi {}

                                                                                                                                                                                                                                                                                property allDay

                                                                                                                                                                                                                                                                                allDay: boolean;

                                                                                                                                                                                                                                                                                  property allow

                                                                                                                                                                                                                                                                                  allow: any;

                                                                                                                                                                                                                                                                                    property backgroundColor

                                                                                                                                                                                                                                                                                    backgroundColor: string;

                                                                                                                                                                                                                                                                                      property borderColor

                                                                                                                                                                                                                                                                                      borderColor: string;

                                                                                                                                                                                                                                                                                        property classNames

                                                                                                                                                                                                                                                                                        classNames: string[];

                                                                                                                                                                                                                                                                                          property constraint

                                                                                                                                                                                                                                                                                          constraint: any;

                                                                                                                                                                                                                                                                                            property display

                                                                                                                                                                                                                                                                                            display: string;

                                                                                                                                                                                                                                                                                              property durationEditable

                                                                                                                                                                                                                                                                                              durationEditable: boolean;

                                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                                end: Date | null;

                                                                                                                                                                                                                                                                                                  property endStr

                                                                                                                                                                                                                                                                                                  endStr: string;

                                                                                                                                                                                                                                                                                                    property extendedProps

                                                                                                                                                                                                                                                                                                    extendedProps: Dictionary;

                                                                                                                                                                                                                                                                                                      property groupId

                                                                                                                                                                                                                                                                                                      groupId: string;

                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                          property overlap

                                                                                                                                                                                                                                                                                                          overlap: boolean;

                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                            source: EventSourceApi | null;

                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                              start: Date | null;

                                                                                                                                                                                                                                                                                                                property startEditable

                                                                                                                                                                                                                                                                                                                startEditable: boolean;

                                                                                                                                                                                                                                                                                                                  property startStr

                                                                                                                                                                                                                                                                                                                  startStr: string;

                                                                                                                                                                                                                                                                                                                    property textColor

                                                                                                                                                                                                                                                                                                                    textColor: string;

                                                                                                                                                                                                                                                                                                                      property title

                                                                                                                                                                                                                                                                                                                      title: string;

                                                                                                                                                                                                                                                                                                                        property url

                                                                                                                                                                                                                                                                                                                        url: string;

                                                                                                                                                                                                                                                                                                                          method formatRange

                                                                                                                                                                                                                                                                                                                          formatRange: (formatInput: FormatterInput) => any;

                                                                                                                                                                                                                                                                                                                            method moveDates

                                                                                                                                                                                                                                                                                                                            moveDates: (deltaInput: DurationInput) => void;

                                                                                                                                                                                                                                                                                                                              method moveEnd

                                                                                                                                                                                                                                                                                                                              moveEnd: (deltaInput: DurationInput) => void;

                                                                                                                                                                                                                                                                                                                                method moveStart

                                                                                                                                                                                                                                                                                                                                moveStart: (deltaInput: DurationInput) => void;

                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                  remove: () => void;

                                                                                                                                                                                                                                                                                                                                    method setAllDay

                                                                                                                                                                                                                                                                                                                                    setAllDay: (allDay: boolean, options?: { maintainDuration?: boolean }) => void;

                                                                                                                                                                                                                                                                                                                                      method setDates

                                                                                                                                                                                                                                                                                                                                      setDates: (
                                                                                                                                                                                                                                                                                                                                      startInput: DateInput,
                                                                                                                                                                                                                                                                                                                                      endInput: DateInput | null,
                                                                                                                                                                                                                                                                                                                                      options?: { allDay?: boolean; granularity?: string }
                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                        method setEnd

                                                                                                                                                                                                                                                                                                                                        setEnd: (endInput: DateInput | null, options?: { granularity?: string }) => void;

                                                                                                                                                                                                                                                                                                                                          method setExtendedProp

                                                                                                                                                                                                                                                                                                                                          setExtendedProp: (name: string, val: any) => void;

                                                                                                                                                                                                                                                                                                                                            method setProp

                                                                                                                                                                                                                                                                                                                                            setProp: (name: string, val: any) => void;

                                                                                                                                                                                                                                                                                                                                              method setStart

                                                                                                                                                                                                                                                                                                                                              setStart: (
                                                                                                                                                                                                                                                                                                                                              startInput: DateInput,
                                                                                                                                                                                                                                                                                                                                              options?: { granularity?: string; maintainDuration?: boolean }
                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                method toJSON

                                                                                                                                                                                                                                                                                                                                                toJSON: () => Dictionary;

                                                                                                                                                                                                                                                                                                                                                  method toPlainObject

                                                                                                                                                                                                                                                                                                                                                  toPlainObject: (settings?: {
                                                                                                                                                                                                                                                                                                                                                  collapseExtendedProps?: boolean;
                                                                                                                                                                                                                                                                                                                                                  collapseColor?: boolean;
                                                                                                                                                                                                                                                                                                                                                  }) => Dictionary;

                                                                                                                                                                                                                                                                                                                                                    interface EventChangeArg

                                                                                                                                                                                                                                                                                                                                                    interface EventChangeArg {}

                                                                                                                                                                                                                                                                                                                                                      property event

                                                                                                                                                                                                                                                                                                                                                      event: EventImpl;

                                                                                                                                                                                                                                                                                                                                                        property oldEvent

                                                                                                                                                                                                                                                                                                                                                        oldEvent: EventImpl;

                                                                                                                                                                                                                                                                                                                                                          property relatedEvents

                                                                                                                                                                                                                                                                                                                                                          relatedEvents: EventImpl[];

                                                                                                                                                                                                                                                                                                                                                            property revert

                                                                                                                                                                                                                                                                                                                                                            revert: () => void;

                                                                                                                                                                                                                                                                                                                                                              interface EventClickArg

                                                                                                                                                                                                                                                                                                                                                              interface EventClickArg {}

                                                                                                                                                                                                                                                                                                                                                                property el

                                                                                                                                                                                                                                                                                                                                                                el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                  property event

                                                                                                                                                                                                                                                                                                                                                                  event: EventImpl;

                                                                                                                                                                                                                                                                                                                                                                    property jsEvent

                                                                                                                                                                                                                                                                                                                                                                    jsEvent: MouseEvent;

                                                                                                                                                                                                                                                                                                                                                                      property view

                                                                                                                                                                                                                                                                                                                                                                      view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                        interface EventContentArg

                                                                                                                                                                                                                                                                                                                                                                        interface EventContentArg {}

                                                                                                                                                                                                                                                                                                                                                                          property backgroundColor

                                                                                                                                                                                                                                                                                                                                                                          backgroundColor: string;

                                                                                                                                                                                                                                                                                                                                                                            property borderColor

                                                                                                                                                                                                                                                                                                                                                                            borderColor: string;

                                                                                                                                                                                                                                                                                                                                                                              property event

                                                                                                                                                                                                                                                                                                                                                                              event: EventImpl;

                                                                                                                                                                                                                                                                                                                                                                                property isDraggable

                                                                                                                                                                                                                                                                                                                                                                                isDraggable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  property isDragging

                                                                                                                                                                                                                                                                                                                                                                                  isDragging: boolean;

                                                                                                                                                                                                                                                                                                                                                                                    property isEnd

                                                                                                                                                                                                                                                                                                                                                                                    isEnd: boolean;

                                                                                                                                                                                                                                                                                                                                                                                      property isEndResizable

                                                                                                                                                                                                                                                                                                                                                                                      isEndResizable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                        property isFuture

                                                                                                                                                                                                                                                                                                                                                                                        isFuture: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          property isMirror

                                                                                                                                                                                                                                                                                                                                                                                          isMirror: boolean;

                                                                                                                                                                                                                                                                                                                                                                                            property isPast

                                                                                                                                                                                                                                                                                                                                                                                            isPast: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property isResizing

                                                                                                                                                                                                                                                                                                                                                                                              isResizing: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                property isSelected

                                                                                                                                                                                                                                                                                                                                                                                                isSelected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  property isStart

                                                                                                                                                                                                                                                                                                                                                                                                  isStart: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    property isStartResizable

                                                                                                                                                                                                                                                                                                                                                                                                    isStartResizable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      property isToday

                                                                                                                                                                                                                                                                                                                                                                                                      isToday: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                        property textColor

                                                                                                                                                                                                                                                                                                                                                                                                        textColor: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property timeText

                                                                                                                                                                                                                                                                                                                                                                                                          timeText: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property view

                                                                                                                                                                                                                                                                                                                                                                                                            view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                              interface EventDropArg

                                                                                                                                                                                                                                                                                                                                                                                                              interface EventDropArg extends EventChangeArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                property delta

                                                                                                                                                                                                                                                                                                                                                                                                                delta: Duration;

                                                                                                                                                                                                                                                                                                                                                                                                                  property el

                                                                                                                                                                                                                                                                                                                                                                                                                  el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                    property jsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                    jsEvent: MouseEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                      property view

                                                                                                                                                                                                                                                                                                                                                                                                                      view: ViewApi$1;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface EventHoveringArg

                                                                                                                                                                                                                                                                                                                                                                                                                        interface EventHoveringArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                          el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                            property event

                                                                                                                                                                                                                                                                                                                                                                                                                            event: EventImpl;

                                                                                                                                                                                                                                                                                                                                                                                                                              property jsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                              jsEvent: MouseEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                                property view

                                                                                                                                                                                                                                                                                                                                                                                                                                view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EventRemoveArg

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EventRemoveArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property event

                                                                                                                                                                                                                                                                                                                                                                                                                                    event: EventImpl;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property relatedEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedEvents: EventImpl[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property revert

                                                                                                                                                                                                                                                                                                                                                                                                                                        revert: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EventRenderRange

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EventRenderRange extends EventTuple {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property isEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnd: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property isStart

                                                                                                                                                                                                                                                                                                                                                                                                                                              isStart: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                range: DateRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ui

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ui: EventUi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EventSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EventSegment {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                      end: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property event

                                                                                                                                                                                                                                                                                                                                                                                                                                                        event: EventApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnd: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                            isStart: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EventSourceApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EventSourceApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  format: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method refetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        refetch: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FormatDateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FormatDateOptions extends NativeFormatterOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              locale?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormatRangeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormatRangeOptions extends FormatDateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isEndExclusive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEndExclusive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property separator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    separator?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LocaleInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LocaleInput extends CalendarOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MoreLinkArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MoreLinkArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property allDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            allDay: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property allSegs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allSegs: EventSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                date: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hiddenSegs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hiddenSegs: EventSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property jsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jsEvent: UIEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MoreLinkContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MoreLinkContentArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property num

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          num: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property shortText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            shortText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NowIndicatorContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NowIndicatorContentArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    date: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAxis: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PluginDef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PluginDef extends PluginHooks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deps: PluginDef[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PluginDefInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PluginDefInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property calendarInteractions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendarInteractions?: CalendarInteractionClass[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cmdFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cmdFormatter?: CmdFormatterFunc;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property componentInteractions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentInteractions?: InteractionClass[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property contextInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contextInit?: (context: CalendarContext) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property datePointTransforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            datePointTransforms?: DatePointTransform[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dateSelectionTransformers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dateSelectionTransformers?: dateSelectionJoinTransformer[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dateSpanTransforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dateSpanTransforms?: DateSpanTransform[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deps?: PluginDef[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property elementDraggingImpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elementDraggingImpl?: ElementDraggingClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property eventDefMemberAdders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventDefMemberAdders?: EventDefMemberAdder[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property eventDefMutationAppliers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        eventDefMutationAppliers?: eventDefMutationApplier[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property eventDragMutationMassagers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          eventDragMutationMassagers?: eventDragMutationMassager[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property eventDropTransformers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eventDropTransformers?: EventDropTransformers[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property eventRefiners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eventRefiners?: GenericRefiners;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property eventSourceDefs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                eventSourceDefs?: EventSourceDef<any>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property eventSourceRefiners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  eventSourceRefiners?: GenericRefiners;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property externalDefTransforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    externalDefTransforms?: ExternalDefTransform[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property initialView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initialView?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isDraggableTransformers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDraggableTransformers?: eventIsDraggableTransformer[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isLoadingFuncs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isLoadingFuncs?: ((state: Dictionary) => boolean)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isPropsValid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isPropsValid?: isPropsValidTester;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property listenerRefiners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              listenerRefiners?: GenericListenerRefiners;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property namedTimeZonedImpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namedTimeZonedImpl?: NamedTimeZoneImplClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optionChangeHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optionChangeHandlers?: OptionChangeHandlerMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property optionRefiners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      optionRefiners?: GenericRefiners;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property premiumReleaseDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        premiumReleaseDate?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property propSetHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          propSetHandlers?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [propName: string]: (val: any, context: CalendarData) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property recurringTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            recurringTypes?: RecurringType<any>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property reducers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reducers?: ReducerFunc[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scrollGridImpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollGridImpl?: ScrollGridImpl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property themeClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  themeClasses?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [themeSystemName: string]: ThemeClass;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property viewContainerAppends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    viewContainerAppends?: ViewContainerAppend[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property viewPropsTransformers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      viewPropsTransformers?: ViewPropsTransformerClass[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property views

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        views?: ViewConfigInputHash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SlotLabelContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SlotLabelContentArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            date: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              level: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  time: Duration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SlotLaneContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SlotLaneContentArg extends Partial<DateMeta> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        date?: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          time?: Duration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpecificViewContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpecificViewContentArg extends ViewProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property nextDayThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextDayThreshold: Duration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ToolbarInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ToolbarInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property center

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    center?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property left

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        left?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          right?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ViewApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ViewApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property activeEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activeEnd: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property activeStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activeStart: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property calendar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendar: CalendarApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property currentEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      currentEnd: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property currentStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        currentStart: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          title: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getOption: (name: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ViewContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ViewContentArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  view: ViewApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WeekNumberContentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WeekNumberContentArg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      date: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property num

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        num: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AllDayMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AllDayMountArg = MountArg<AllDayContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AllowFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AllowFunc = (span: DateSpanApi, movingEvent: EventImpl | null) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BusinessHoursInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BusinessHoursInput = boolean | EventInput | EventInput[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CalendarListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CalendarListeners = Required<CalendarListenersLoose>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CalendarOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CalendarOptions = BaseOptions &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CalendarListenersLoose &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RawOptionsFromRefiners<Required<CalendarOptionRefiners>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClassNamesGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClassNamesGenerator<RenderProps> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ClassNamesInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((renderProps: RenderProps) => ClassNamesInput);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ConstraintInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ConstraintInput = 'businessHours' | string | EventInput | EventInput[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CssDimValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CssDimValue = string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CustomContentGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CustomContentGenerator<RenderProps> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | CustomContent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((renderProps: RenderProps, createElement: any) => CustomContent | true);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CustomRenderingHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CustomRenderingHandler<RenderProps> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              customRender: CustomRendering<RenderProps>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DateInput = Date | string | number | number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DatesSetArg

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DayCellMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DayCellMountArg = MountArg<DayCellContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DayHeaderMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DayHeaderMountArg = MountArg<DayHeaderContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DidMountHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DidMountHandler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TheMountArg extends {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        el: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = (mountArg: TheMountArg) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DurationInput = DurationObjectInput | string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EventInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EventInput = EventUiInput &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RawOptionsFromRefiners<Required<EventRefiners>> & { // Required hack
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [extendedProp: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EventInputTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EventInputTransformer = (input: EventInput) => EventInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EventMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EventMountArg = MountArg<EventContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EventSourceFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EventSourceFunc =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg: EventSourceFuncArg,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  successCallback: (eventInputs: EventInput[]) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  failureCallback: (error: Error) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((arg: EventSourceFuncArg) => Promise<EventInput[]>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EventSourceFuncArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EventSourceFuncArg = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    start: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    end: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startStr: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endStr: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZone: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EventSourceInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EventSourceInput =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | EventSourceInputObject // object in extended form
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | EventInput[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | EventSourceFunc // just a function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FormatterInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FormatterInput = NativeFormatterOptions | string | FuncFormatterFunc;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocaleSingularArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocaleSingularArg = LocaleCodeArg | LocaleInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MoreLinkAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MoreLinkAction = MoreLinkSimpleAction | MoreLinkHandler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MoreLinkHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MoreLinkHandler = (arg: MoreLinkArg) => MoreLinkSimpleAction | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoreLinkMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoreLinkMountArg = MountArg<MoreLinkContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoreLinkSimpleAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoreLinkSimpleAction =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'popover'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'week'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'day'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'timeGridWeek'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'timeGridDay'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NowIndicatorMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NowIndicatorMountArg = MountArg<NowIndicatorContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OverlapFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OverlapFunc = (stillEvent: EventImpl, movingEvent: EventImpl | null) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SlotLabelMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SlotLabelMountArg = MountArg<SlotLabelContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SlotLaneMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SlotLaneMountArg = MountArg<SlotLaneContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpecificViewMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SpecificViewMountArg = MountArg<SpecificViewContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ViewComponentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ViewComponentType = ComponentType<ViewProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ViewMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ViewMountArg = MountArg<ViewContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type WeekNumberCalculation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type WeekNumberCalculation = 'local' | 'ISO' | ((m: Date) => number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WeekNumberMountArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WeekNumberMountArg = MountArg<WeekNumberContentArg>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WillUnmountHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WillUnmountHandler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TheMountArg extends {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      el: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = (mountArg: TheMountArg) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@fullcalendar/core.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@fullcalendar/core)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@fullcalendar/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>