| Server IP : 49.231.201.246 / Your IP : 216.73.216.41 Web Server : Apache/2.4.18 (Ubuntu) System : Linux 246 4.4.0-210-generic #242-Ubuntu SMP Fri Apr 16 09:57:56 UTC 2021 x86_64 User : root ( 0) PHP Version : 7.0.33-0ubuntu0.16.04.16 Disable Function : exec,passthru,shell_exec,system,proc_open,popen,pcntl_exec MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /proc/11585/task/11585/root/var/www/html/ppaobm/vendor/bower-asset/fullcalendar/dist/core/ |
Upload File : |
declare module "@fullcalendar/core/util/dom-manip" {
export function createElement(tagName: string, attrs: object | null, content?: ElementContent): HTMLElement;
export function htmlToElement(html: string): HTMLElement;
export function htmlToElements(html: string): HTMLElement[];
export type ElementContent = string | Node | Node[] | NodeList;
export function appendToElement(el: HTMLElement, content: ElementContent): void;
export function prependToElement(parent: HTMLElement, content: ElementContent): void;
export function insertAfterElement(refEl: HTMLElement, content: ElementContent): void;
export function removeElement(el: HTMLElement): void;
export function elementClosest(el: HTMLElement, selector: string): HTMLElement;
export function elementMatches(el: HTMLElement, selector: string): HTMLElement;
export function findElements(container: HTMLElement[] | HTMLElement | NodeListOf<HTMLElement>, selector: string): HTMLElement[];
export function findChildren(parent: HTMLElement[] | HTMLElement, selector?: string): HTMLElement[];
export function forceClassName(el: HTMLElement, className: string, bool: any): void;
export function applyStyle(el: HTMLElement, props: object): void;
export function applyStyleProp(el: HTMLElement, name: string, val: any): void;
}
declare module "@fullcalendar/core/util/geom" {
export interface Point {
left: number;
top: number;
}
export interface Rect {
left: number;
right: number;
top: number;
bottom: number;
}
export function pointInsideRect(point: Point, rect: Rect): boolean;
export function intersectRects(rect1: Rect, rect2: Rect): Rect | false;
export function translateRect(rect: Rect, deltaX: number, deltaY: number): Rect;
export function constrainPoint(point: Point, rect: Rect): Point;
export function getRectCenter(rect: Rect): Point;
export function diffPoints(point1: Point, point2: Point): Point;
}
declare module "@fullcalendar/core/util/scrollbars" {
export function getIsRtlScrollbarOnLeft(): boolean;
export function sanitizeScrollbarWidth(width: number): number;
}
declare module "@fullcalendar/core/util/dom-geom" {
import { Rect } from "@fullcalendar/core/util/geom";
export interface EdgeInfo {
borderLeft: number;
borderRight: number;
borderTop: number;
borderBottom: number;
scrollbarLeft: number;
scrollbarRight: number;
scrollbarBottom: number;
paddingLeft?: number;
paddingRight?: number;
paddingTop?: number;
paddingBottom?: number;
}
export function computeEdges(el: any, getPadding?: boolean): EdgeInfo;
export function computeInnerRect(el: any, goWithinPadding?: boolean): {
left: number;
right: number;
top: number;
bottom: number;
};
export function computeRect(el: any): Rect;
export function computeHeightAndMargins(el: HTMLElement): number;
export function getClippingParents(el: HTMLElement): HTMLElement[];
export function computeClippingRect(el: HTMLElement): Rect;
}
declare module "@fullcalendar/core/util/dom-event" {
export function preventDefault(ev: any): void;
export function listenBySelector(container: HTMLElement, eventType: string, selector: string, handler: (ev: Event, matchedTarget: HTMLElement) => void): () => void;
export function listenToHoverBySelector(container: HTMLElement, selector: string, onMouseEnter: (ev: Event, matchedTarget: HTMLElement) => void, onMouseLeave: (ev: Event, matchedTarget: HTMLElement) => void): () => void;
export function whenTransitionDone(el: HTMLElement, callback: (ev: Event) => void): void;
}
declare module "@fullcalendar/core/datelib/duration" {
export type DurationInput = DurationObjectInput | string | number;
export interface DurationObjectInput {
years?: number;
year?: number;
months?: number;
month?: number;
weeks?: number;
week?: number;
days?: number;
day?: number;
hours?: number;
hour?: number;
minutes?: number;
minute?: number;
seconds?: number;
second?: number;
milliseconds?: number;
millisecond?: number;
ms?: number;
}
export interface Duration {
years: number;
months: number;
days: number;
milliseconds: number;
}
export function createDuration(input: DurationInput, unit?: string): Duration | null;
export function getWeeksFromInput(obj: DurationObjectInput): number;
export function durationsEqual(d0: Duration, d1: Duration): boolean;
export function isSingleDay(dur: Duration): boolean;
export function addDurations(d0: Duration, d1: Duration): {
years: number;
months: number;
days: number;
milliseconds: number;
};
export function subtractDurations(d1: Duration, d0: Duration): Duration;
export function multiplyDuration(d: Duration, n: number): {
years: number;
months: number;
days: number;
milliseconds: number;
};
export function asRoughYears(dur: Duration): number;
export function asRoughMonths(dur: Duration): number;
export function asRoughDays(dur: Duration): number;
export function asRoughHours(dur: Duration): number;
export function asRoughMinutes(dur: Duration): number;
export function asRoughSeconds(dur: Duration): number;
export function asRoughMs(dur: Duration): number;
export function wholeDivideDurations(numerator: Duration, denominator: Duration): number;
export function greatestDurationDenominator(dur: Duration, dontReturnWeeks?: boolean): {
unit: string;
value: number;
};
}
declare module "@fullcalendar/core/datelib/marker" {
import { Duration } from "@fullcalendar/core/datelib/duration";
export type DateMarker = Date;
export const DAY_IDS: string[];
export function addWeeks(m: DateMarker, n: number): Date;
export function addDays(m: DateMarker, n: number): Date;
export function addMs(m: DateMarker, n: number): Date;
export function diffWeeks(m0: any, m1: any): number;
export function diffDays(m0: any, m1: any): number;
export function diffHours(m0: any, m1: any): number;
export function diffMinutes(m0: any, m1: any): number;
export function diffSeconds(m0: any, m1: any): number;
export function diffDayAndTime(m0: DateMarker, m1: DateMarker): Duration;
export function diffWholeWeeks(m0: DateMarker, m1: DateMarker): number;
export function diffWholeDays(m0: DateMarker, m1: DateMarker): number;
export function startOfDay(m: DateMarker): DateMarker;
export function startOfHour(m: DateMarker): Date;
export function startOfMinute(m: DateMarker): Date;
export function startOfSecond(m: DateMarker): Date;
export function weekOfYear(marker: any, dow: any, doy: any): number;
export function dateToLocalArray(date: any): any[];
export function arrayToLocalDate(a: any): Date;
export function dateToUtcArray(date: any): any[];
export function arrayToUtcDate(a: any): Date;
export function isValidDate(m: DateMarker): boolean;
export function timeAsMs(m: DateMarker): number;
}
declare module "@fullcalendar/core/datelib/calendar-system" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
export interface CalendarSystem {
getMarkerYear(d: DateMarker): number;
getMarkerMonth(d: DateMarker): number;
getMarkerDay(d: DateMarker): number;
arrayToMarker(arr: number[]): DateMarker;
markerToArray(d: DateMarker): number[];
}
export function registerCalendarSystem(name: any, theClass: any): void;
export function createCalendarSystem(name: any): any;
}
declare module "@fullcalendar/core/util/object" {
export function mergeProps(propObjs: any, complexProps?: any): any;
export function filterHash(hash: any, func: any): {};
export function mapHash<InputItem, OutputItem>(hash: {
[key: string]: InputItem;
}, func: (input: InputItem, key: string) => OutputItem): {
[key: string]: OutputItem;
};
export function arrayToHash(a: any): {
[key: string]: true;
};
export function hashValuesToArray(obj: any): any[];
}
declare module "@fullcalendar/core/datelib/locale" {
export type LocaleCodeArg = string | string[];
export type LocaleSingularArg = LocaleCodeArg | RawLocale;
export interface Locale {
codeArg: LocaleCodeArg;
codes: string[];
week: {
dow: number;
doy: number;
};
simpleNumberFormat: Intl.NumberFormat;
options: any;
}
export interface RawLocale {
code: string;
[otherProp: string]: any;
}
export type RawLocaleMap = {
[code: string]: RawLocale;
};
export interface RawLocaleInfo {
map: RawLocaleMap;
defaultCode: string;
}
export function parseRawLocales(explicitRawLocales: RawLocale[]): RawLocaleInfo;
export function buildLocale(inputSingular: LocaleSingularArg, available: RawLocaleMap): Locale;
}
declare module "@fullcalendar/core/datelib/timezone" {
export abstract class NamedTimeZoneImpl {
timeZoneName: string;
constructor(timeZoneName: string);
abstract offsetForArray(a: number[]): number;
abstract timestampToArray(ms: number): number[];
}
export type NamedTimeZoneImplClass = {
new (timeZoneName: string): NamedTimeZoneImpl;
};
}
declare module "@fullcalendar/core/util/array" {
export function removeMatching(array: any, testFunc: any): number;
export function removeExact(array: any, exactVal: any): number;
export function isArraysEqual(a0: any, a1: any): boolean;
}
declare module "@fullcalendar/core/util/memoize" {
export function memoize<T>(workerFunc: T): T;
export function memoizeOutput<T>(workerFunc: T, equalityFunc: (output0: any, output1: any) => boolean): T;
}
declare module "@fullcalendar/core/datelib/formatting-native" {
import { DateFormatter, DateFormattingContext, ZonedMarker } from "@fullcalendar/core/datelib/formatting";
export class NativeFormatter implements DateFormatter {
standardDateProps: any;
extendedSettings: any;
severity: number;
private buildFormattingFunc;
constructor(formatSettings: any);
format(date: ZonedMarker, context: DateFormattingContext): string;
formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext): string;
getLargestUnit(): "week" | "day" | "month" | "year";
}
}
declare module "@fullcalendar/core/datelib/formatting-cmd" {
import { DateFormatter, DateFormattingContext, ZonedMarker, VerboseFormattingArg } from "@fullcalendar/core/datelib/formatting";
export type CmdFormatterFunc = (cmd: string, arg: VerboseFormattingArg) => string;
export class CmdFormatter implements DateFormatter {
cmdStr: string;
separator: string;
constructor(cmdStr: string, separator?: string);
format(date: ZonedMarker, context: DateFormattingContext): string;
formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext): string;
}
}
declare module "@fullcalendar/core/datelib/formatting-func" {
import { DateFormatter, DateFormattingContext, ZonedMarker, VerboseFormattingArg } from "@fullcalendar/core/datelib/formatting";
export type FuncFormatterFunc = (arg: VerboseFormattingArg) => string;
export class FuncFormatter implements DateFormatter {
func: FuncFormatterFunc;
constructor(func: FuncFormatterFunc);
format(date: ZonedMarker, context: DateFormattingContext): string;
formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext): string;
}
}
declare module "@fullcalendar/core/datelib/formatting" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { CalendarSystem } from "@fullcalendar/core/datelib/calendar-system";
import { Locale } from "@fullcalendar/core/datelib/locale";
import { CmdFormatterFunc } from "@fullcalendar/core/datelib/formatting-cmd";
import { FuncFormatterFunc } from "@fullcalendar/core/datelib/formatting-func";
export interface ZonedMarker {
marker: DateMarker;
timeZoneOffset: number;
}
export interface ExpandedZonedMarker extends ZonedMarker {
array: number[];
year: number;
month: number;
day: number;
hour: number;
minute: number;
second: number;
millisecond: number;
}
export interface VerboseFormattingArg {
date: ExpandedZonedMarker;
start: ExpandedZonedMarker;
end?: ExpandedZonedMarker;
timeZone: string;
localeCodes: string[];
separator: string;
}
export interface DateFormattingContext {
timeZone: string;
locale: Locale;
calendarSystem: CalendarSystem;
computeWeekNumber: (d: DateMarker) => number;
weekLabel: string;
cmdFormatter?: CmdFormatterFunc;
}
export interface DateFormatter {
format(date: ZonedMarker, context: DateFormattingContext): any;
formatRange(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext): any;
}
export type FormatterInput = object | string | FuncFormatterFunc;
export function createFormatter(input: FormatterInput, defaultSeparator?: string): DateFormatter;
export function buildIsoString(marker: DateMarker, timeZoneOffset?: number, stripZeroTime?: boolean): string;
export function formatIsoTimeString(marker: DateMarker): string;
export function formatTimeZoneOffset(minutes: number, doIso?: boolean): string;
export function createVerboseFormattingArg(start: ZonedMarker, end: ZonedMarker, context: DateFormattingContext, separator?: string): VerboseFormattingArg;
}
declare module "@fullcalendar/core/datelib/parsing" {
export function parse(str: any): {
marker: Date;
isTimeUnspecified: boolean;
timeZoneOffset: any;
};
}
declare module "@fullcalendar/core/datelib/env" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { CalendarSystem } from "@fullcalendar/core/datelib/calendar-system";
import { Locale } from "@fullcalendar/core/datelib/locale";
import { NamedTimeZoneImpl, NamedTimeZoneImplClass } from "@fullcalendar/core/datelib/timezone";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { DateFormatter } from "@fullcalendar/core/datelib/formatting";
import { CmdFormatterFunc } from "@fullcalendar/core/datelib/formatting-cmd";
export interface DateEnvSettings {
timeZone: string;
namedTimeZoneImpl?: NamedTimeZoneImplClass;
calendarSystem: string;
locale: Locale;
weekNumberCalculation?: any;
firstDay?: any;
weekLabel?: string;
cmdFormatter?: CmdFormatterFunc;
}
export type DateInput = Date | string | number | number[];
export interface DateMarkerMeta {
marker: DateMarker;
isTimeUnspecified: boolean;
forcedTzo: number | null;
}
export class DateEnv {
timeZone: string;
namedTimeZoneImpl: NamedTimeZoneImpl;
canComputeOffset: boolean;
calendarSystem: CalendarSystem;
locale: Locale;
weekDow: number;
weekDoy: number;
weekNumberFunc: any;
weekLabel: string;
cmdFormatter?: CmdFormatterFunc;
constructor(settings: DateEnvSettings);
createMarker(input: DateInput): DateMarker;
createNowMarker(): DateMarker;
createMarkerMeta(input: DateInput): DateMarkerMeta;
parse(s: string): {
marker: Date;
isTimeUnspecified: boolean;
forcedTzo: any;
};
getYear(marker: DateMarker): number;
getMonth(marker: DateMarker): number;
add(marker: DateMarker, dur: Duration): DateMarker;
subtract(marker: DateMarker, dur: Duration): DateMarker;
addYears(marker: DateMarker, n: number): Date;
addMonths(marker: DateMarker, n: number): Date;
diffWholeYears(m0: DateMarker, m1: DateMarker): number;
diffWholeMonths(m0: DateMarker, m1: DateMarker): number;
greatestWholeUnit(m0: DateMarker, m1: DateMarker): {
unit: string;
value: number;
};
countDurationsBetween(m0: DateMarker, m1: DateMarker, d: Duration): number;
startOf(m: DateMarker, unit: string): Date;
startOfYear(m: DateMarker): DateMarker;
startOfMonth(m: DateMarker): DateMarker;
startOfWeek(m: DateMarker): DateMarker;
computeWeekNumber(marker: DateMarker): number;
format(marker: DateMarker, formatter: DateFormatter, dateOptions?: {
forcedTzo?: number;
}): any;
formatRange(start: DateMarker, end: DateMarker, formatter: DateFormatter, dateOptions?: {
forcedStartTzo?: number;
forcedEndTzo?: number;
isEndExclusive?: boolean;
}): any;
formatIso(marker: DateMarker, extraOptions?: any): string;
timestampToMarker(ms: number): Date;
offsetForMarker(m: DateMarker): number;
toDate(m: DateMarker, forcedTzo?: number): Date;
}
}
declare module "@fullcalendar/core/datelib/date-range" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { DateEnv, DateInput } from "@fullcalendar/core/datelib/env";
export interface DateRangeInput {
start?: DateInput;
end?: DateInput;
}
export interface OpenDateRange {
start: DateMarker | null;
end: DateMarker | null;
}
export interface DateRange {
start: DateMarker;
end: DateMarker;
}
export function parseRange(input: DateRangeInput, dateEnv: DateEnv): OpenDateRange;
export function invertRanges(ranges: DateRange[], constraintRange: DateRange): DateRange[];
export function intersectRanges(range0: OpenDateRange, range1: OpenDateRange): OpenDateRange;
export function rangesEqual(range0: OpenDateRange, range1: OpenDateRange): boolean;
export function rangesIntersect(range0: OpenDateRange, range1: OpenDateRange): boolean;
export function rangeContainsRange(outerRange: OpenDateRange, innerRange: OpenDateRange): boolean;
export function rangeContainsMarker(range: OpenDateRange, date: DateMarker | number): boolean;
export function constrainMarkerToRange(date: DateMarker, range: DateRange): DateMarker;
}
declare module "@fullcalendar/core/util/misc" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { DateEnv } from "@fullcalendar/core/datelib/env";
import { DateRange, OpenDateRange } from "@fullcalendar/core/datelib/date-range";
export function compensateScroll(rowEl: HTMLElement, scrollbarWidths: any): void;
export function uncompensateScroll(rowEl: HTMLElement): void;
export function disableCursor(): void;
export function enableCursor(): void;
export function distributeHeight(els: HTMLElement[], availableHeight: any, shouldRedistribute: any): void;
export function undistributeHeight(els: HTMLElement[]): void;
export function matchCellWidths(els: HTMLElement[]): number;
export function subtractInnerElHeight(outerEl: HTMLElement, innerEl: HTMLElement): number;
export function preventSelection(el: HTMLElement): void;
export function allowSelection(el: HTMLElement): void;
export function preventContextMenu(el: HTMLElement): void;
export function allowContextMenu(el: HTMLElement): void;
export function parseFieldSpecs(input: any): any[];
export function compareByFieldSpecs(obj0: any, obj1: any, fieldSpecs: any): any;
export function compareByFieldSpec(obj0: any, obj1: any, fieldSpec: any): any;
export function flexibleCompare(a: any, b: any): number;
export function capitaliseFirstLetter(str: any): any;
export function padStart(val: any, len: any): string;
export function compareNumbers(a: any, b: any): number;
export function isInt(n: any): boolean;
export function applyAll(functions: any, thisObj: any, args: any): any;
export function firstDefined(...args: any[]): any;
export function debounce(func: any, wait: any): () => any;
export type GenericHash = {
[key: string]: any;
};
export function refineProps(rawProps: GenericHash, processors: GenericHash, defaults?: GenericHash, leftoverProps?: GenericHash): GenericHash;
export function freezeRaw(raw: any): any;
export function computeAlignedDayRange(timedRange: DateRange): DateRange;
export function computeVisibleDayRange(timedRange: OpenDateRange, nextDayThreshold?: Duration): OpenDateRange;
export function isMultiDayRange(range: DateRange): boolean;
export function diffDates(date0: DateMarker, date1: DateMarker, dateEnv: DateEnv, largeUnit?: string): Duration;
}
declare module "@fullcalendar/core/common/Mixin" {
export { Mixin as default, Mixin };
class Mixin {
static mixInto(destClass: any): void;
static mixIntoObj(destObj: any): void;
static mixOver(destClass: any): void;
}
}
declare module "@fullcalendar/core/common/EmitterMixin" {
import Mixin from "@fullcalendar/core/common/Mixin";
export interface EmitterInterface {
on(types: any, handler: any): any;
one(types: any, handler: any): any;
off(types: any, handler: any): any;
trigger(type: any, ...args: any[]): any;
triggerWith(type: any, context: any, args: any): any;
hasHandlers(type: any): any;
}
export { EmitterMixin as default, EmitterMixin };
class EmitterMixin extends Mixin implements EmitterInterface {
_handlers: any;
_oneHandlers: any;
on(type: any, handler: any): this;
one(type: any, handler: any): this;
off(type: any, handler?: any): this;
trigger(type: any, ...args: any[]): this;
triggerWith(type: any, context: any, args: any): this;
hasHandlers(type: any): any;
}
}
declare module "@fullcalendar/core/structs/recurring-event" {
import { EventInput, EventDef } from "@fullcalendar/core/structs/event";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { DateEnv } from "@fullcalendar/core/datelib/env";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
export interface ParsedRecurring {
typeData: any;
allDayGuess: boolean | null;
duration: Duration | null;
}
export interface RecurringType {
parse: (rawEvent: EventInput, leftoverProps: any, dateEnv: DateEnv) => ParsedRecurring | null;
expand: (typeData: any, framingRange: DateRange, dateEnv: DateEnv) => DateMarker[];
}
export function parseRecurring(eventInput: EventInput, allDayDefault: boolean | null, dateEnv: DateEnv, recurringTypes: RecurringType[], leftovers: any): {
allDay: any;
duration: Duration;
typeData: any;
typeId: number;
};
export function expandRecurringRanges(eventDef: EventDef, framingRange: DateRange, dateEnv: DateEnv, recurringTypes: RecurringType[]): DateMarker[];
}
declare module "@fullcalendar/core/util/promise" {
export function unpromisify(func: any, success: any, failure?: any): void;
}
declare module "@fullcalendar/core/event-sources/func-event-source" {
import { EventSourceError } from "@fullcalendar/core/structs/event-source";
import { EventInput } from "@fullcalendar/core/structs/event";
export type EventSourceFunc = (arg: {
start: Date;
end: Date;
timeZone: string;
}, successCallback: (events: EventInput[]) => void, failureCallback: (error: EventSourceError) => void) => (void | PromiseLike<EventInput[]>);
const _default: import("@fullcalendar/core/plugin-system").PluginDef;
export default _default;
}
declare module "@fullcalendar/core/structs/event-source" {
import { EventInput } from "@fullcalendar/core/structs/event";
import Calendar from "@fullcalendar/core/Calendar";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { EventSourceFunc } from "@fullcalendar/core/event-sources/func-event-source";
import { EventUi } from "@fullcalendar/core/component/event-ui";
import { ConstraintInput, AllowFunc } from "@fullcalendar/core/validation";
export type EventSourceError = {
message: string;
response?: any;
[otherProp: string]: any;
};
export type EventInputTransformer = (eventInput: EventInput) => EventInput | null;
export type EventSourceSuccessResponseHandler = (rawData: any, response: any) => EventInput[] | void;
export type EventSourceErrorResponseHandler = (error: EventSourceError) => void;
export interface ExtendedEventSourceInput {
id?: string | number;
allDayDefault?: boolean;
eventDataTransform?: EventInputTransformer;
events?: EventInput[] | EventSourceFunc;
url?: string;
method?: string;
extraParams?: object | (() => object);
startParam?: string;
endParam?: string;
timeZoneParam?: string;
success?: EventSourceSuccessResponseHandler;
failure?: EventSourceErrorResponseHandler;
editable?: boolean;
startEditable?: boolean;
durationEditable?: boolean;
constraint?: ConstraintInput;
overlap?: boolean;
allow?: AllowFunc;
className?: string[] | string;
classNames?: string[] | string;
backgroundColor?: string;
borderColor?: string;
textColor?: string;
color?: string;
[otherProp: string]: any;
}
export type EventSourceInput = ExtendedEventSourceInput | // object in extended form
EventSourceFunc | // just a function
string;
export interface EventSource {
_raw: any;
sourceId: string;
sourceDefId: number;
meta: any;
publicId: string;
isFetching: boolean;
latestFetchId: string;
fetchRange: DateRange | null;
allDayDefault: boolean | null;
eventDataTransform: EventInputTransformer;
ui: EventUi;
success: EventSourceSuccessResponseHandler | null;
failure: EventSourceErrorResponseHandler | null;
extendedProps: any;
}
export type EventSourceHash = {
[sourceId: string]: EventSource;
};
export type EventSourceFetcher = (arg: {
eventSource: EventSource;
calendar: Calendar;
range: DateRange;
}, success: (res: {
rawEvents: EventInput[];
xhr?: XMLHttpRequest;
}) => void, failure: (error: EventSourceError) => void) => (void | PromiseLike<EventInput[]>);
export interface EventSourceDef {
ignoreRange?: boolean;
parseMeta: (raw: EventSourceInput) => object | null;
fetch: EventSourceFetcher;
}
export function doesSourceNeedRange(eventSource: EventSource, calendar: Calendar): boolean;
export function parseEventSource(raw: EventSourceInput, calendar: Calendar): EventSource | null;
}
declare module "@fullcalendar/core/structs/event-store" {
import { EventInput, EventDef, EventDefHash, EventInstanceHash, EventTuple } from "@fullcalendar/core/structs/event";
import { EventSource } from "@fullcalendar/core/structs/event-source";
import Calendar from "@fullcalendar/core/Calendar";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
export interface EventStore {
defs: EventDefHash;
instances: EventInstanceHash;
}
export function parseEvents(rawEvents: EventInput[], sourceId: string, calendar: Calendar, allowOpenRange?: boolean): EventStore;
export function eventTupleToStore(tuple: EventTuple, eventStore?: EventStore): EventStore;
export function expandRecurring(eventStore: EventStore, framingRange: DateRange, calendar: Calendar): EventStore;
export function getRelevantEvents(eventStore: EventStore, instanceId: string): EventStore;
export function transformRawEvents(rawEvents: any, eventSource: EventSource, calendar: Calendar): any;
export function createEmptyEventStore(): EventStore;
export function mergeEventStores(store0: EventStore, store1: EventStore): EventStore;
export function filterEventStoreDefs(eventStore: EventStore, filterFunc: (eventDef: EventDef) => boolean): EventStore;
}
declare module "@fullcalendar/core/interactions/hit" {
import DateComponent from "@fullcalendar/core/component/DateComponent";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { Rect } from "@fullcalendar/core/util/geom";
export interface Hit {
component: DateComponent<any>;
dateSpan: DateSpan;
dayEl: HTMLElement;
rect: Rect;
layer: number;
}
}
declare module "@fullcalendar/core/structs/event-mutation" {
import { Duration } from "@fullcalendar/core/datelib/duration";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventDef } from "@fullcalendar/core/structs/event";
import Calendar from "@fullcalendar/core/Calendar";
import { EventUiHash } from "@fullcalendar/core/component/event-ui";
export interface EventMutation {
startDelta?: Duration;
endDelta?: Duration;
standardProps?: any;
extendedProps?: any;
}
export function applyMutationToEventStore(eventStore: EventStore, eventConfigBase: EventUiHash, mutation: EventMutation, calendar: Calendar): EventStore;
export type eventDefMutationApplier = (eventDef: EventDef, mutation: EventMutation, calendar: Calendar) => void;
}
declare module "@fullcalendar/core/api/EventSourceApi" {
import Calendar from "@fullcalendar/core/Calendar";
import { EventSource } from "@fullcalendar/core/structs/event-source";
export { EventSourceApi as default, EventSourceApi };
class EventSourceApi {
calendar: Calendar;
internalEventSource: EventSource;
constructor(calendar: Calendar, internalEventSource: EventSource);
remove(): void;
refetch(): void;
readonly id: string;
readonly url: string;
}
}
declare module "@fullcalendar/core/api/EventApi" {
import Calendar from "@fullcalendar/core/Calendar";
import { EventDef, EventInstance } from "@fullcalendar/core/structs/event";
import { EventMutation } from "@fullcalendar/core/structs/event-mutation";
import { DateInput } from "@fullcalendar/core/datelib/env";
import { DurationInput } from "@fullcalendar/core/datelib/duration";
import { FormatterInput } from "@fullcalendar/core/datelib/formatting";
import EventSourceApi from "@fullcalendar/core/api/EventSourceApi";
export { EventApi as default, EventApi };
class EventApi {
_calendar: Calendar;
_def: EventDef;
_instance: EventInstance | null;
constructor(calendar: Calendar, def: EventDef, instance?: EventInstance);
setProp(name: string, val: string): void;
setExtendedProp(name: string, val: string): void;
setStart(startInput: DateInput, options?: {
granularity?: string;
maintainDuration?: boolean;
}): void;
setEnd(endInput: DateInput | null, options?: {
granularity?: string;
}): void;
setDates(startInput: DateInput, endInput: DateInput | null, options?: {
allDay?: boolean;
granularity?: string;
}): void;
moveStart(deltaInput: DurationInput): void;
moveEnd(deltaInput: DurationInput): void;
moveDates(deltaInput: DurationInput): void;
setAllDay(allDay: boolean, options?: {
maintainDuration?: boolean;
}): void;
formatRange(formatInput: FormatterInput): any;
mutate(mutation: EventMutation): void;
remove(): void;
readonly source: EventSourceApi | null;
readonly start: Date | null;
readonly end: Date | null;
readonly id: string;
readonly groupId: string;
readonly allDay: boolean;
readonly title: string;
readonly url: string;
readonly rendering: string;
readonly startEditable: boolean;
readonly durationEditable: boolean;
readonly constraint: any;
readonly overlap: any;
readonly allow: any;
readonly backgroundColor: string;
readonly borderColor: string;
readonly textColor: string;
readonly classNames: string[];
readonly extendedProps: any;
}
}
declare module "@fullcalendar/core/component/renderers/FgEventRenderer" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { DateFormatter } from "@fullcalendar/core/datelib/formatting";
import { EventUi } from "@fullcalendar/core/component/event-ui";
import { EventRenderRange } from "@fullcalendar/core/component/event-rendering";
import { Seg } from "@fullcalendar/core/component/DateComponent";
import { ComponentContext } from "@fullcalendar/core/component/Component";
export { FgEventRenderer as default, FgEventRenderer };
abstract class FgEventRenderer {
context: ComponentContext;
eventTimeFormat: DateFormatter;
displayEventTime: boolean;
displayEventEnd: boolean;
segs: Seg[];
isSizeDirty: boolean;
constructor(context: ComponentContext);
renderSegs(segs: Seg[], mirrorInfo?: any): void;
unrender(_segs: Seg[], mirrorInfo?: any): void;
abstract renderSegHtml(seg: Seg, mirrorInfo: any): string;
abstract attachSegs(segs: Seg[], mirrorInfo: any): any;
abstract detachSegs(segs: Seg[]): any;
rangeUpdated(): void;
renderSegEls(segs: Seg[], mirrorInfo: any): Seg[];
getSegClasses(seg: Seg, isDraggable: any, isResizable: any, mirrorInfo: any): string[];
getTimeText(eventRange: EventRenderRange, formatter?: any, displayEnd?: any): any;
_getTimeText(start: DateMarker, end: DateMarker, allDay: any, formatter?: any, displayEnd?: any, forcedStartTzo?: number, forcedEndTzo?: number): any;
computeEventTimeFormat(): any;
computeDisplayEventTime(): boolean;
computeDisplayEventEnd(): boolean;
getSkinCss(ui: EventUi): {
'background-color': string;
'border-color': string;
color: string;
};
sortEventSegs(segs: any): Seg[];
computeSizes(force: boolean): void;
assignSizes(force: boolean): void;
computeSegSizes(segs: Seg[]): void;
assignSegSizes(segs: Seg[]): void;
hideByHash(hash: any): void;
showByHash(hash: any): void;
selectByInstanceId(instanceId: string): void;
unselectByInstanceId(instanceId: string): void;
}
export function buildSegCompareObj(seg: Seg): any;
}
declare module "@fullcalendar/core/util/html" {
export function htmlEscape(s: any): string;
export function cssToStr(cssProps: any): string;
export function attrsToStr(attrs: any): string;
export type ClassNameInput = string | string[];
export function parseClassName(raw: ClassNameInput): string[];
}
declare module "@fullcalendar/core/component/renderers/FillRenderer" {
import { Seg } from "@fullcalendar/core/component/DateComponent";
import { ComponentContext } from "@fullcalendar/core/component/Component";
export { FillRenderer as default, FillRenderer };
abstract class FillRenderer {
context: ComponentContext;
fillSegTag: string;
containerElsByType: any;
segsByType: any;
dirtySizeFlags: any;
constructor(context: ComponentContext);
getSegsByType(type: string): any;
renderSegs(type: any, segs: Seg[]): void;
unrender(type: any): void;
renderSegEls(type: any, segs: Seg[]): Seg[];
renderSegHtml(type: any, seg: Seg): string;
abstract attachSegs(type: any, segs: Seg[]): HTMLElement[] | void;
detachSegs(type: any, segs: Seg[]): void;
computeSizes(force: boolean): void;
assignSizes(force: boolean): void;
computeSegSizes(segs: Seg[]): void;
assignSegSizes(segs: Seg[]): void;
}
}
declare module "@fullcalendar/core/interactions/event-interaction-state" {
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { Seg } from "@fullcalendar/core/component/DateComponent";
export interface EventInteractionState {
affectedEvents: EventStore;
mutatedEvents: EventStore;
isEvent: boolean;
origSeg: Seg | null;
}
}
declare module "@fullcalendar/core/component/DateComponent" {
import Component, { ComponentContext } from "@fullcalendar/core/component/Component";
import { EventRenderRange } from "@fullcalendar/core/component/event-rendering";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { EventInstanceHash } from "@fullcalendar/core/structs/event";
import { Hit } from "@fullcalendar/core/interactions/hit";
import FgEventRenderer from "@fullcalendar/core/component/renderers/FgEventRenderer";
import FillRenderer from "@fullcalendar/core/component/renderers/FillRenderer";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
export type DateComponentHash = {
[uid: string]: DateComponent<any>;
};
export interface Seg {
component?: DateComponent<any>;
isStart: boolean;
isEnd: boolean;
eventRange?: EventRenderRange;
el?: HTMLElement;
[otherProp: string]: any;
}
export interface EventSegUiInteractionState {
affectedInstances: EventInstanceHash;
segs: Seg[];
isEvent: boolean;
sourceSeg: any;
}
export { DateComponent as default, DateComponent };
class DateComponent<PropsType> extends Component<PropsType> {
fgSegSelector: string;
bgSegSelector: string;
largeUnit: any;
eventRenderer: FgEventRenderer;
mirrorRenderer: FgEventRenderer;
fillRenderer: FillRenderer;
el: HTMLElement;
constructor(context: ComponentContext, el: HTMLElement, isView?: boolean);
destroy(): void;
buildPositionCaches(): void;
queryHit(positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit | null;
isInteractionValid(interaction: EventInteractionState): boolean;
isDateSelectionValid(selection: DateSpan): boolean;
publiclyTrigger(name: any, args: any): any;
publiclyTriggerAfterSizing(name: any, args: any): void;
hasPublicHandlers(name: any): boolean;
triggerRenderedSegs(segs: Seg[], isMirrors: boolean): void;
triggerWillRemoveSegs(segs: Seg[], isMirrors: boolean): void;
isValidSegDownEl(el: HTMLElement): boolean;
isValidDateDownEl(el: HTMLElement): boolean;
isPopover(): boolean;
isInPopover(el: HTMLElement): boolean;
}
}
declare module "@fullcalendar/core/component/event-rendering" {
import { EventDef, EventTuple, EventDefHash } from "@fullcalendar/core/structs/event";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { Seg } from "@fullcalendar/core/component/DateComponent";
import View from "@fullcalendar/core/View";
import { EventUi, EventUiHash } from "@fullcalendar/core/component/event-ui";
export interface EventRenderRange extends EventTuple {
ui: EventUi;
range: DateRange;
isStart: boolean;
isEnd: boolean;
}
export function sliceEventStore(eventStore: EventStore, eventUiBases: EventUiHash, framingRange: DateRange, nextDayThreshold?: Duration): {
bg: EventRenderRange[];
fg: EventRenderRange[];
};
export function hasBgRendering(def: EventDef): boolean;
export function filterSegsViaEls(view: View, segs: Seg[], isMirror: any): Seg[];
export function getElSeg(el: HTMLElement): Seg | null;
export function compileEventUis(eventDefs: EventDefHash, eventUiBases: EventUiHash): {
[key: string]: EventUi;
};
export function compileEventUi(eventDef: EventDef, eventUiBases: EventUiHash): EventUi;
}
declare module "@fullcalendar/core/structs/date-span" {
import { DateRange, OpenDateRange } from "@fullcalendar/core/datelib/date-range";
import { DateInput, DateEnv } from "@fullcalendar/core/datelib/env";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { EventRenderRange } from "@fullcalendar/core/component/event-rendering";
import { EventUiHash } from "@fullcalendar/core/component/event-ui";
import Calendar from "@fullcalendar/core/Calendar";
export interface OpenDateSpanInput {
start?: DateInput;
end?: DateInput;
allDay?: boolean;
[otherProp: string]: any;
}
export interface DateSpanInput extends OpenDateSpanInput {
start: DateInput;
end: DateInput;
}
export interface OpenDateSpan {
range: OpenDateRange;
allDay: boolean;
[otherProp: string]: any;
}
export interface DateSpan extends OpenDateSpan {
range: DateRange;
}
export interface DateSpanApi {
start: Date;
end: Date;
startStr: string;
endStr: string;
allDay: boolean;
}
export interface DatePointApi {
date: Date;
dateStr: string;
allDay: boolean;
}
export function parseDateSpan(raw: DateSpanInput, dateEnv: DateEnv, defaultDuration?: Duration): DateSpan | null;
export function parseOpenDateSpan(raw: OpenDateSpanInput, dateEnv: DateEnv): OpenDateSpan | null;
export function isDateSpansEqual(span0: DateSpan, span1: DateSpan): boolean;
export function buildDateSpanApi(span: DateSpan, dateEnv: DateEnv): DateSpanApi;
export function buildDatePointApi(span: DateSpan, dateEnv: DateEnv): DatePointApi;
export function fabricateEventRange(dateSpan: DateSpan, eventUiBases: EventUiHash, calendar: Calendar): EventRenderRange;
}
declare module "@fullcalendar/core/reducers/eventStore" {
import Calendar from "@fullcalendar/core/Calendar";
import { EventInstanceHash } from "@fullcalendar/core/structs/event";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { Action } from "@fullcalendar/core/reducers/types";
import { EventSourceHash } from "@fullcalendar/core/structs/event-source";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
export default function (eventStore: EventStore, action: Action, eventSources: EventSourceHash, dateProfile: DateProfile, calendar: Calendar): EventStore;
export function excludeInstances(eventStore: EventStore, removals: EventInstanceHash): EventStore;
}
declare module "@fullcalendar/core/component/event-splitting" {
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventDef } from "@fullcalendar/core/structs/event";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
import { EventUiHash, EventUi } from "@fullcalendar/core/component/event-ui";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
export interface SplittableProps {
businessHours: EventStore | null;
dateSelection: DateSpan | null;
eventStore: EventStore;
eventUiBases: EventUiHash;
eventSelection: string;
eventDrag: EventInteractionState | null;
eventResize: EventInteractionState | null;
}
export { Splitter as default, Splitter };
abstract class Splitter<PropsType extends SplittableProps = SplittableProps> {
private getKeysForEventDefs;
private splitDateSelection;
private splitEventStore;
private splitIndividualUi;
private splitEventDrag;
private splitEventResize;
private eventUiBuilders;
abstract getKeyInfo(props: PropsType): {
[key: string]: {
ui?: EventUi;
businessHours?: EventStore;
};
};
abstract getKeysForDateSpan(dateSpan: DateSpan): string[];
abstract getKeysForEventDef(eventDef: EventDef): string[];
splitProps(props: PropsType): {
[key: string]: SplittableProps;
};
private _splitDateSpan;
private _getKeysForEventDefs;
private _splitEventStore;
private _splitIndividualUi;
private _splitInteraction;
}
}
declare module "@fullcalendar/core/validation" {
import { EventStore } from "@fullcalendar/core/structs/event-store";
import Calendar from "@fullcalendar/core/Calendar";
import { DateSpan, DateSpanApi } from "@fullcalendar/core/structs/date-span";
import EventApi from "@fullcalendar/core/api/EventApi";
import { EventInput } from "@fullcalendar/core/structs/event";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
import { SplittableProps } from "@fullcalendar/core/component/event-splitting";
export type ConstraintInput = 'businessHours' | string | EventInput | EventInput[];
export type Constraint = 'businessHours' | string | EventStore | false;
export type OverlapFunc = ((stillEvent: EventApi, movingEvent: EventApi | null) => boolean);
export type AllowFunc = (span: DateSpanApi, movingEvent: EventApi | null) => boolean;
export type isPropsValidTester = (props: SplittableProps, calendar: Calendar) => boolean;
export function isInteractionValid(interaction: EventInteractionState, calendar: Calendar): boolean;
export function isDateSelectionValid(dateSelection: DateSpan, calendar: Calendar): boolean;
export function isPropsValid(state: SplittableProps, calendar: Calendar, dateSpanMeta?: {}, filterConfig?: any): boolean;
export function normalizeConstraint(input: ConstraintInput, calendar: Calendar): Constraint | null;
}
declare module "@fullcalendar/core/component/event-ui" {
import { Constraint, AllowFunc, ConstraintInput } from "@fullcalendar/core/validation";
import { parseClassName } from "@fullcalendar/core/util/html";
import Calendar from "@fullcalendar/core/Calendar";
export interface UnscopedEventUiInput {
editable?: boolean;
startEditable?: boolean;
durationEditable?: boolean;
constraint?: ConstraintInput;
overlap?: boolean;
allow?: AllowFunc;
className?: string[] | string;
classNames?: string[] | string;
backgroundColor?: string;
borderColor?: string;
textColor?: string;
color?: string;
}
export interface EventUi {
startEditable: boolean | null;
durationEditable: boolean | null;
constraints: Constraint[];
overlap: boolean | null;
allows: AllowFunc[];
backgroundColor: string;
borderColor: string;
textColor: string;
classNames: string[];
}
export type EventUiHash = {
[defId: string]: EventUi;
};
export const UNSCOPED_EVENT_UI_PROPS: {
editable: BooleanConstructor;
startEditable: BooleanConstructor;
durationEditable: BooleanConstructor;
constraint: any;
overlap: any;
allow: any;
className: typeof parseClassName;
classNames: typeof parseClassName;
color: StringConstructor;
backgroundColor: StringConstructor;
borderColor: StringConstructor;
textColor: StringConstructor;
};
export function processUnscopedUiProps(rawProps: UnscopedEventUiInput, calendar: Calendar, leftovers?: any): EventUi;
export function processScopedUiProps(prefix: string, rawScoped: any, calendar: Calendar, leftovers?: any): EventUi;
export function combineEventUis(uis: EventUi[]): EventUi;
}
declare module "@fullcalendar/core/structs/event" {
import { DateInput } from "@fullcalendar/core/datelib/env";
import Calendar from "@fullcalendar/core/Calendar";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { UnscopedEventUiInput, EventUi } from "@fullcalendar/core/component/event-ui";
export type EventRenderingChoice = '' | 'background' | 'inverse-background' | 'none';
export interface EventNonDateInput extends UnscopedEventUiInput {
id?: string | number;
groupId?: string | number;
title?: string;
url?: string;
rendering?: EventRenderingChoice;
extendedProps?: object;
[extendedProp: string]: any;
}
export interface EventDateInput {
start?: DateInput;
end?: DateInput;
date?: DateInput;
allDay?: boolean;
}
export type EventInput = EventNonDateInput & EventDateInput;
export interface EventDef {
defId: string;
sourceId: string;
publicId: string;
groupId: string;
allDay: boolean;
hasEnd: boolean;
recurringDef: {
typeId: number;
typeData: any;
duration: Duration | null;
} | null;
title: string;
url: string;
rendering: EventRenderingChoice;
ui: EventUi;
extendedProps: any;
}
export interface EventInstance {
instanceId: string;
defId: string;
range: DateRange;
forcedStartTzo: number | null;
forcedEndTzo: number | null;
}
export interface EventTuple {
def: EventDef;
instance: EventInstance | null;
}
export type EventInstanceHash = {
[instanceId: string]: EventInstance;
};
export type EventDefHash = {
[defId: string]: EventDef;
};
export const NON_DATE_PROPS: {
id: StringConstructor;
groupId: StringConstructor;
title: StringConstructor;
url: StringConstructor;
rendering: StringConstructor;
extendedProps: any;
};
export const DATE_PROPS: {
start: any;
date: any;
end: any;
allDay: any;
};
export function parseEvent(raw: EventInput, sourceId: string, calendar: Calendar, allowOpenRange?: boolean): EventTuple | null;
export function parseEventDef(raw: EventNonDateInput, sourceId: string, allDay: boolean, hasEnd: boolean, calendar: Calendar): EventDef;
export type eventDefParserFunc = (def: EventDef, props: any, leftovers: any) => void;
export function createEventInstance(defId: string, range: DateRange, forcedStartTzo?: number, forcedEndTzo?: number): EventInstance;
}
declare module "@fullcalendar/core/reducers/types" {
import { EventInput, EventInstanceHash } from "@fullcalendar/core/structs/event";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventMutation } from "@fullcalendar/core/structs/event-mutation";
import { EventSource, EventSourceHash, EventSourceError } from "@fullcalendar/core/structs/event-source";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { DateEnv } from "@fullcalendar/core/datelib/env";
import Calendar from "@fullcalendar/core/Calendar";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
export interface CalendarState {
eventSources: EventSourceHash;
eventSourceLoadingLevel: number;
loadingLevel: number;
viewType: string;
currentDate: DateMarker;
dateProfile: DateProfile | null;
eventStore: EventStore;
dateSelection: DateSpan | null;
eventSelection: string;
eventDrag: EventInteractionState | null;
eventResize: EventInteractionState | null;
}
export type reducerFunc = (state: CalendarState, action: Action, calendar: Calendar) => CalendarState;
export type Action = {
type: 'INIT';
} | // wont it create another rerender?
{
type: 'PREV';
} | {
type: 'NEXT';
} | {
type: 'SET_DATE';
dateMarker: DateMarker;
} | {
type: 'SET_VIEW_TYPE';
viewType: string;
dateMarker?: DateMarker;
} | {
type: 'SELECT_DATES';
selection: DateSpan;
} | {
type: 'UNSELECT_DATES';
} | {
type: 'SELECT_EVENT';
eventInstanceId: string;
} | {
type: 'UNSELECT_EVENT';
} | {
type: 'SET_EVENT_DRAG';
state: EventInteractionState;
} | {
type: 'UNSET_EVENT_DRAG';
} | {
type: 'SET_EVENT_RESIZE';
state: EventInteractionState;
} | {
type: 'UNSET_EVENT_RESIZE';
} | {
type: 'ADD_EVENT_SOURCES';
sources: EventSource[];
} | {
type: 'REMOVE_EVENT_SOURCE';
sourceId: string;
} | {
type: 'REMOVE_ALL_EVENT_SOURCES';
} | {
type: 'FETCH_EVENT_SOURCES';
sourceIds?: string[];
} | // if no sourceIds, fetch all
{
type: 'CHANGE_TIMEZONE';
oldDateEnv: DateEnv;
} | {
type: 'RECEIVE_EVENTS';
sourceId: string;
fetchId: string;
fetchRange: DateRange | null;
rawEvents: EventInput[];
} | {
type: 'RECEIVE_EVENT_ERROR';
sourceId: string;
fetchId: string;
fetchRange: DateRange | null;
error: EventSourceError;
} | // need all these?
{
type: 'ADD_EVENTS';
eventStore: EventStore;
} | {
type: 'MERGE_EVENTS';
eventStore: EventStore;
} | {
type: 'MUTATE_EVENTS';
instanceId: string;
mutation: EventMutation;
fromApi?: boolean;
} | {
type: 'REMOVE_EVENT_DEF';
defId: string;
} | {
type: 'REMOVE_EVENT_INSTANCES';
instances: EventInstanceHash;
} | {
type: 'REMOVE_ALL_EVENTS';
} | {
type: 'RESET_EVENTS';
};
}
declare module "@fullcalendar/core/component/memoized-rendering" {
export interface MemoizedRendering<ArgsType extends any[]> {
(...args: ArgsType): void;
unrender: () => void;
dependents: MemoizedRendering<any>[];
}
export function memoizeRendering<ArgsType extends any[]>(renderFunc: (...args: ArgsType) => void, unrenderFunc?: (...args: ArgsType) => void, dependencies?: MemoizedRendering<any>[]): MemoizedRendering<ArgsType>;
}
declare module "@fullcalendar/core/Toolbar" {
import Component, { ComponentContext } from "@fullcalendar/core/component/Component";
export interface ToolbarRenderProps {
layout: any;
title: string;
activeButton: string;
isTodayEnabled: boolean;
isPrevEnabled: boolean;
isNextEnabled: boolean;
}
export { Toolbar as default, Toolbar };
class Toolbar extends Component<ToolbarRenderProps> {
el: HTMLElement;
viewsWithButtons: any;
private _renderLayout;
private _updateTitle;
private _updateActiveButton;
private _updateToday;
private _updatePrev;
private _updateNext;
constructor(context: ComponentContext, extraClassName: any);
destroy(): void;
render(props: ToolbarRenderProps): void;
renderLayout(layout: any): void;
unrenderLayout(): void;
renderSection(position: any, buttonStr: any): HTMLElement;
updateToday(isTodayEnabled: any): void;
updatePrev(isPrevEnabled: any): void;
updateNext(isNextEnabled: any): void;
updateTitle(text: any): void;
updateActiveButton(buttonName?: any): void;
toggleButtonEnabled(buttonName: any, bool: any): void;
}
}
declare module "@fullcalendar/core/structs/business-hours" {
import Calendar from "@fullcalendar/core/Calendar";
import { EventInput } from "@fullcalendar/core/structs/event";
import { EventStore } from "@fullcalendar/core/structs/event-store";
export type BusinessHoursInput = boolean | EventInput | EventInput[];
export function parseBusinessHours(input: BusinessHoursInput, calendar: Calendar): EventStore;
}
declare module "@fullcalendar/core/CalendarComponent" {
import Component, { ComponentContext } from "@fullcalendar/core/component/Component";
import { ViewSpec } from "@fullcalendar/core/structs/view-spec";
import View from "@fullcalendar/core/View";
import Toolbar from "@fullcalendar/core/Toolbar";
import DateProfileGenerator, { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventUiHash } from "@fullcalendar/core/component/event-ui";
import { BusinessHoursInput } from "@fullcalendar/core/structs/business-hours";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { CalendarState } from "@fullcalendar/core/reducers/types";
export interface CalendarComponentProps extends CalendarState {
viewSpec: ViewSpec;
dateProfileGenerator: DateProfileGenerator;
eventUiBases: EventUiHash;
}
export { CalendarComponent as default, CalendarComponent };
class CalendarComponent extends Component<CalendarComponentProps> {
view: View;
header: Toolbar;
footer: Toolbar;
computeTitle: (dateProfile: any, viewOptions: any) => string;
parseBusinessHours: (input: BusinessHoursInput) => EventStore;
el: HTMLElement;
contentEl: HTMLElement;
isHeightAuto: boolean;
viewHeight: number;
private _renderToolbars;
private buildViewPropTransformers;
constructor(context: ComponentContext, el: HTMLElement);
destroy(): void;
toggleElClassNames(bool: boolean): void;
render(props: CalendarComponentProps): void;
renderToolbars(viewSpec: ViewSpec, dateProfile: DateProfile, currentDate: DateMarker, dateProfileGenerator: DateProfileGenerator, title: string): void;
renderView(props: CalendarComponentProps, title: string): void;
updateSize(isResize?: boolean): void;
computeHeightVars(): void;
queryToolbarsHeight(): number;
freezeHeight(): void;
thawHeight(): void;
}
}
declare module "@fullcalendar/core/interactions/event-dragging" {
import Calendar from "@fullcalendar/core/Calendar";
import { EventMutation } from "@fullcalendar/core/structs/event-mutation";
import { Hit } from "@fullcalendar/core/interactions/hit";
export type eventDragMutationMassager = (mutation: EventMutation, hit0: Hit, hit1: Hit) => void;
export type EventDropTransformers = (mutation: EventMutation, calendar: Calendar) => void;
}
declare module "@fullcalendar/core/interactions/date-selecting" {
import { Hit } from "@fullcalendar/core/interactions/hit";
export type dateSelectionJoinTransformer = (hit0: Hit, hit1: Hit) => any;
}
declare module "@fullcalendar/core/interactions/event-resizing" {
import { Hit } from "@fullcalendar/core/interactions/hit";
export type EventResizeJoinTransforms = (hit0: Hit, hit1: Hit) => false | object;
}
declare module "@fullcalendar/core/structs/drag-meta" {
import { Duration, DurationInput } from "@fullcalendar/core/datelib/duration";
import { EventNonDateInput } from "@fullcalendar/core/structs/event";
export interface DragMetaInput extends EventNonDateInput {
startTime?: DurationInput;
duration?: DurationInput;
create?: boolean;
sourceId?: string;
}
export interface DragMeta {
startTime: Duration | null;
duration: Duration | null;
create: boolean;
sourceId: string;
leftoverProps: object;
}
export function parseDragMeta(raw: DragMetaInput): DragMeta;
}
declare module "@fullcalendar/core/interactions/external-element-dragging" {
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { DragMeta } from "@fullcalendar/core/structs/drag-meta";
export type ExternalDefTransform = (dateSpan: DateSpan, dragMeta: DragMeta) => any;
}
declare module "@fullcalendar/core/interactions/interaction" {
import DateComponent from "@fullcalendar/core/component/DateComponent";
export abstract class Interaction {
component: DateComponent<any>;
constructor(settings: InteractionSettings);
destroy(): void;
}
export type InteractionClass = {
new (settings: InteractionSettings): Interaction;
};
export interface InteractionSettingsInput {
el: HTMLElement;
useEventCenter?: boolean;
}
export interface InteractionSettings {
component: DateComponent<any>;
el: HTMLElement;
useEventCenter: boolean;
}
export type InteractionSettingsStore = {
[componenUid: string]: InteractionSettings;
};
export function parseInteractionSettings(component: DateComponent<any>, input: InteractionSettingsInput): InteractionSettings;
export function interactionSettingsToStore(settings: InteractionSettings): {
[x: string]: InteractionSettings;
};
export let interactionSettingsStore: InteractionSettingsStore;
}
declare module "@fullcalendar/core/theme/Theme" {
export { Theme as default, Theme };
class Theme {
calendarOptions: any;
classes: any;
iconClasses: any;
baseIconClass: string;
iconOverrideOption: any;
iconOverrideCustomButtonOption: any;
iconOverridePrefix: string;
constructor(calendarOptions: any);
processIconOverride(): void;
setIconOverride(iconOverrideHash: any): void;
applyIconOverridePrefix(className: any): any;
getClass(key: any): any;
getIconClass(buttonName: any): string;
getCustomButtonIconClass(customButtonProps: any): string;
}
export type ThemeClass = {
new (calendarOptions: any): Theme;
};
}
declare module "@fullcalendar/core/interactions/ElementDragging" {
import EmitterMixin from "@fullcalendar/core/common/EmitterMixin";
export { ElementDragging as default, ElementDragging };
abstract class ElementDragging {
emitter: EmitterMixin;
constructor(el: HTMLElement);
destroy(): void;
abstract setIgnoreMove(bool: boolean): void;
setMirrorIsVisible(bool: boolean): void;
setMirrorNeedsRevert(bool: boolean): void;
setAutoScrollEnabled(bool: boolean): void;
}
export type ElementDraggingClass = {
new (el: HTMLElement): ElementDragging;
};
}
declare module "@fullcalendar/core/plugin-system" {
import { reducerFunc } from "@fullcalendar/core/reducers/types";
import { eventDefParserFunc } from "@fullcalendar/core/structs/event";
import { eventDefMutationApplier } from "@fullcalendar/core/structs/event-mutation";
import Calendar, { DatePointTransform, DateSpanTransform, CalendarInteractionClass, OptionChangeHandlerMap } from "@fullcalendar/core/Calendar";
import { ViewConfigInputHash } from "@fullcalendar/core/structs/view-config";
import { ViewSpec } from "@fullcalendar/core/structs/view-spec";
import View, { ViewProps } from "@fullcalendar/core/View";
import { CalendarComponentProps } from "@fullcalendar/core/CalendarComponent";
import { isPropsValidTester } from "@fullcalendar/core/validation";
import { eventDragMutationMassager, EventDropTransformers } from "@fullcalendar/core/interactions/event-dragging";
import { dateSelectionJoinTransformer } from "@fullcalendar/core/interactions/date-selecting";
import { EventResizeJoinTransforms } from "@fullcalendar/core/interactions/event-resizing";
import { ExternalDefTransform } from "@fullcalendar/core/interactions/external-element-dragging";
import { InteractionClass } from "@fullcalendar/core/interactions/interaction";
import { ThemeClass } from "@fullcalendar/core/theme/Theme";
import { EventSourceDef } from "@fullcalendar/core/structs/event-source";
import { CmdFormatterFunc } from "@fullcalendar/core/datelib/formatting-cmd";
import { RecurringType } from "@fullcalendar/core/structs/recurring-event";
import { NamedTimeZoneImplClass } from "@fullcalendar/core/datelib/timezone";
import { ElementDraggingClass } from "@fullcalendar/core/interactions/ElementDragging";
export interface PluginDefInput {
deps?: PluginDef[];
reducers?: reducerFunc[];
eventDefParsers?: eventDefParserFunc[];
eventDragMutationMassagers?: eventDragMutationMassager[];
eventDefMutationAppliers?: eventDefMutationApplier[];
dateSelectionTransformers?: dateSelectionJoinTransformer[];
datePointTransforms?: DatePointTransform[];
dateSpanTransforms?: DateSpanTransform[];
views?: ViewConfigInputHash;
viewPropsTransformers?: ViewPropsTransformerClass[];
isPropsValid?: isPropsValidTester;
externalDefTransforms?: ExternalDefTransform[];
eventResizeJoinTransforms?: EventResizeJoinTransforms[];
viewContainerModifiers?: ViewContainerModifier[];
eventDropTransformers?: EventDropTransformers[];
componentInteractions?: InteractionClass[];
calendarInteractions?: CalendarInteractionClass[];
themeClasses?: {
[themeSystemName: string]: ThemeClass;
};
eventSourceDefs?: EventSourceDef[];
cmdFormatter?: CmdFormatterFunc;
recurringTypes?: RecurringType[];
namedTimeZonedImpl?: NamedTimeZoneImplClass;
defaultView?: string;
elementDraggingImpl?: ElementDraggingClass;
optionChangeHandlers?: OptionChangeHandlerMap;
}
export interface PluginHooks {
reducers: reducerFunc[];
eventDefParsers: eventDefParserFunc[];
eventDragMutationMassagers: eventDragMutationMassager[];
eventDefMutationAppliers: eventDefMutationApplier[];
dateSelectionTransformers: dateSelectionJoinTransformer[];
datePointTransforms: DatePointTransform[];
dateSpanTransforms: DateSpanTransform[];
views: ViewConfigInputHash;
viewPropsTransformers: ViewPropsTransformerClass[];
isPropsValid: isPropsValidTester | null;
externalDefTransforms: ExternalDefTransform[];
eventResizeJoinTransforms: EventResizeJoinTransforms[];
viewContainerModifiers: ViewContainerModifier[];
eventDropTransformers: EventDropTransformers[];
componentInteractions: InteractionClass[];
calendarInteractions: CalendarInteractionClass[];
themeClasses: {
[themeSystemName: string]: ThemeClass;
};
eventSourceDefs: EventSourceDef[];
cmdFormatter?: CmdFormatterFunc;
recurringTypes: RecurringType[];
namedTimeZonedImpl?: NamedTimeZoneImplClass;
defaultView: string;
elementDraggingImpl?: ElementDraggingClass;
optionChangeHandlers: OptionChangeHandlerMap;
}
export interface PluginDef extends PluginHooks {
id: string;
deps: PluginDef[];
}
export type ViewPropsTransformerClass = new () => ViewPropsTransformer;
export interface ViewPropsTransformer {
transform(viewProps: ViewProps, viewSpec: ViewSpec, calendarProps: CalendarComponentProps, view: View): any;
}
export type ViewContainerModifier = (contentEl: HTMLElement, calendar: Calendar) => void;
export function createPlugin(input: PluginDefInput): PluginDef;
export class PluginSystem {
hooks: PluginHooks;
addedHash: {
[pluginId: string]: true;
};
constructor();
add(plugin: PluginDef): void;
}
}
declare module "@fullcalendar/core/event-sources/array-event-source" {
const _default_1: import("@fullcalendar/core/plugin-system").PluginDef;
export default _default_1;
}
declare module "@fullcalendar/core/util/requestJson" {
export default function requestJson(method: string, url: string, params: object, successCallback: any, failureCallback: any): void;
}
declare module "@fullcalendar/core/event-sources/json-feed-event-source" {
const _default_2: import("@fullcalendar/core/plugin-system").PluginDef;
export default _default_2;
}
declare module "@fullcalendar/core/structs/recurring-event-simple" {
const _default_3: import("@fullcalendar/core/plugin-system").PluginDef;
export default _default_3;
}
declare module "@fullcalendar/core/util/object-similarity" {
export function isValuesSimilar(val0: any, val1: any, depth?: number): boolean;
export function isArraysSimilar(a0: any, a1: any, depth?: number): boolean;
export function isObjectsSimilar(obj0: any, obj1: any, depth?: number): boolean;
export function computeChangedProps(obj0: any, obj1: any, depth?: number): {};
export function anyKeysRemoved(obj0: any, obj1: any): boolean;
}
declare module "@fullcalendar/core/option-change-handlers" {
const _default_4: import("@fullcalendar/core/plugin-system").PluginDef;
export default _default_4;
}
declare module "@fullcalendar/core/options" {
import { PluginDef } from "@fullcalendar/core/plugin-system";
export const config: any;
export const globalDefaults: {
defaultRangeSeparator: string;
titleRangeSeparator: string;
defaultTimedEventDuration: string;
defaultAllDayEventDuration: {
day: number;
};
forceEventDuration: boolean;
nextDayThreshold: string;
columnHeader: boolean;
defaultView: string;
aspectRatio: number;
header: {
left: string;
center: string;
right: string;
};
weekends: boolean;
weekNumbers: boolean;
weekNumberCalculation: string;
editable: boolean;
scrollTime: string;
minTime: string;
maxTime: string;
showNonCurrentDates: boolean;
lazyFetching: boolean;
startParam: string;
endParam: string;
timeZoneParam: string;
timeZone: string;
locales: any[];
locale: string;
timeGridEventMinHeight: number;
themeSystem: string;
dragRevertDuration: number;
dragScroll: boolean;
allDayMaintainDuration: boolean;
unselectAuto: boolean;
dropAccept: string;
eventOrder: string;
eventLimit: boolean;
eventLimitClick: string;
dayPopoverFormat: {
month: string;
day: string;
year: string;
};
handleWindowResize: boolean;
windowResizeDelay: number;
longPressDelay: number;
eventDragMinDistance: number;
};
export const rtlDefaults: {
header: {
left: string;
center: string;
right: string;
};
buttonIcons: {
prev: string;
next: string;
prevYear: string;
nextYear: string;
};
};
export function mergeOptions(optionObjs: any): any;
export function refinePluginDefs(pluginInputs: any[]): PluginDef[];
}
declare module "@fullcalendar/core/OptionsManager" {
export { OptionsManager as default, OptionsManager };
class OptionsManager {
dirDefaults: any;
localeDefaults: any;
overrides: any;
dynamicOverrides: any;
computed: any;
constructor(overrides: any);
add(props: any): void;
addDynamic(props: any): void;
reset(props: any): void;
compute(): void;
}
}
declare module "@fullcalendar/core/reducers/eventSources" {
import { EventSourceHash } from "@fullcalendar/core/structs/event-source";
import Calendar from "@fullcalendar/core/Calendar";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import { Action } from "@fullcalendar/core/reducers/types";
export default function (eventSources: EventSourceHash, action: Action, dateProfile: DateProfile | null, calendar: Calendar): EventSourceHash;
}
declare module "@fullcalendar/core/reducers/main" {
import Calendar from "@fullcalendar/core/Calendar";
import { CalendarState, Action } from "@fullcalendar/core/reducers/types";
export default function (state: CalendarState, action: Action, calendar: Calendar): CalendarState;
}
declare module "@fullcalendar/core/interactions/pointer" {
export interface PointerDragEvent {
origEvent: UIEvent;
isTouch: boolean;
subjectEl: EventTarget;
pageX: number;
pageY: number;
deltaX: number;
deltaY: number;
}
}
declare module "@fullcalendar/core/interactions/EventClicking" {
import { Interaction, InteractionSettings } from "@fullcalendar/core/interactions/interaction";
export { EventClicking as default, EventClicking };
class EventClicking extends Interaction {
constructor(settings: InteractionSettings);
handleSegClick: (ev: Event, segEl: HTMLElement) => void;
}
}
declare module "@fullcalendar/core/interactions/EventHovering" {
import { Interaction, InteractionSettings } from "@fullcalendar/core/interactions/interaction";
export { EventHovering as default, EventHovering };
class EventHovering extends Interaction {
removeHoverListeners: () => void;
currentSegEl: HTMLElement;
constructor(settings: InteractionSettings);
destroy(): void;
handleEventElRemove: (el: HTMLElement) => void;
handleSegEnter: (ev: Event, segEl: HTMLElement) => void;
handleSegLeave: (ev: Event, segEl: HTMLElement) => void;
triggerEvent(publicEvName: string, ev: Event | null, segEl: HTMLElement): void;
}
}
declare module "@fullcalendar/core/theme/StandardTheme" {
import Theme from "@fullcalendar/core/theme/Theme";
export { StandardTheme as default, StandardTheme };
class StandardTheme extends Theme {
}
}
declare module "@fullcalendar/core/Calendar" {
import { EmitterInterface } from "@fullcalendar/core/common/EmitterMixin";
import OptionsManager from "@fullcalendar/core/OptionsManager";
import View from "@fullcalendar/core/View";
import Theme from "@fullcalendar/core/theme/Theme";
import { OptionsInput } from "@fullcalendar/core/types/input-types";
import { RawLocaleMap } from "@fullcalendar/core/datelib/locale";
import { DateEnv, DateInput } from "@fullcalendar/core/datelib/env";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { Duration, DurationInput } from "@fullcalendar/core/datelib/duration";
import { DateSpan, DateSpanApi, DatePointApi } from "@fullcalendar/core/structs/date-span";
import { DateRangeInput } from "@fullcalendar/core/datelib/date-range";
import DateProfileGenerator from "@fullcalendar/core/DateProfileGenerator";
import { EventSourceInput } from "@fullcalendar/core/structs/event-source";
import { EventInput } from "@fullcalendar/core/structs/event";
import { CalendarState, Action } from "@fullcalendar/core/reducers/types";
import EventSourceApi from "@fullcalendar/core/api/EventSourceApi";
import EventApi from "@fullcalendar/core/api/EventApi";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventUiHash, EventUi } from "@fullcalendar/core/component/event-ui";
import { ViewSpecHash, ViewSpec } from "@fullcalendar/core/structs/view-spec";
import { PluginSystem } from "@fullcalendar/core/plugin-system";
import CalendarComponent from "@fullcalendar/core/CalendarComponent";
import DateComponent from "@fullcalendar/core/component/DateComponent";
import { PointerDragEvent } from "@fullcalendar/core/interactions/pointer";
import { InteractionSettingsInput, Interaction } from "@fullcalendar/core/interactions/interaction";
export interface DateClickApi extends DatePointApi {
dayEl: HTMLElement;
jsEvent: UIEvent;
view: View;
}
export interface DateSelectionApi extends DateSpanApi {
jsEvent: UIEvent;
view: View;
}
export type DatePointTransform = (dateSpan: DateSpan, calendar: Calendar) => any;
export type DateSpanTransform = (dateSpan: DateSpan, calendar: Calendar) => any;
export type CalendarInteraction = {
destroy(): any;
};
export type CalendarInteractionClass = {
new (calendar: Calendar): CalendarInteraction;
};
export type OptionChangeHandler = (propValue: any, calendar: Calendar) => void;
export type OptionChangeHandlerMap = {
[propName: string]: OptionChangeHandler;
};
export { Calendar as default, Calendar };
class Calendar {
static on: EmitterInterface['on'];
static off: EmitterInterface['off'];
static trigger: EmitterInterface['trigger'];
on: EmitterInterface['on'];
one: EmitterInterface['one'];
off: EmitterInterface['off'];
trigger: EmitterInterface['trigger'];
triggerWith: EmitterInterface['triggerWith'];
hasHandlers: EmitterInterface['hasHandlers'];
private parseRawLocales;
private buildLocale;
private buildDateEnv;
private buildTheme;
private buildEventUiSingleBase;
private buildSelectionConfig;
private buildEventUiBySource;
private buildEventUiBases;
eventUiBases: EventUiHash;
selectionConfig: EventUi;
optionsManager: OptionsManager;
viewSpecs: ViewSpecHash;
dateProfileGenerators: {
[viewName: string]: DateProfileGenerator;
};
theme: Theme;
dateEnv: DateEnv;
availableRawLocales: RawLocaleMap;
pluginSystem: PluginSystem;
defaultAllDayEventDuration: Duration;
defaultTimedEventDuration: Duration;
calendarInteractions: CalendarInteraction[];
interactionsStore: {
[componentUid: string]: Interaction[];
};
removeNavLinkListener: any;
windowResizeProxy: any;
isHandlingWindowResize: boolean;
state: CalendarState;
actionQueue: any[];
isReducing: boolean;
needsRerender: boolean;
needsFullRerender: boolean;
isRendering: boolean;
renderingPauseDepth: number;
renderableEventStore: EventStore;
buildDelayedRerender: typeof buildDelayedRerender;
delayedRerender: any;
afterSizingTriggers: any;
isViewUpdated: boolean;
isDatesUpdated: boolean;
isEventsUpdated: boolean;
el: HTMLElement;
component: CalendarComponent;
constructor(el: HTMLElement, overrides?: OptionsInput);
addPluginInputs(pluginInputs: any): void;
readonly view: View;
render(): void;
destroy(): void;
bindHandlers(): void;
unbindHandlers(): void;
hydrate(): void;
buildInitialState(): CalendarState;
dispatch(action: Action): void;
reduce(state: CalendarState, action: Action, calendar: Calendar): CalendarState;
requestRerender(needsFull?: boolean): void;
tryRerender(): void;
batchRendering(func: any): void;
executeRender(): void;
renderComponent(needsFull: any): void;
resetOptions(options: any): void;
setOptions(options: any): void;
processOptions(options: any, mode?: 'dynamic' | 'reset'): void;
setOption(name: string, val: any): void;
getOption(name: string): any;
opt(name: string): any;
viewOpt(name: string): any;
viewOpts(): any;
handleOptions(options: any): void;
getAvailableLocaleCodes(): string[];
_buildSelectionConfig(rawOpts: any): EventUi;
_buildEventUiSingleBase(rawOpts: any): EventUi;
hasPublicHandlers(name: string): boolean;
publiclyTrigger(name: string, args?: any): any;
publiclyTriggerAfterSizing(name: any, args: any): void;
releaseAfterSizingTriggers(): void;
isValidViewType(viewType: string): boolean;
changeView(viewType: string, dateOrRange?: DateRangeInput | DateInput): void;
zoomTo(dateMarker: DateMarker, viewType?: string): void;
getUnitViewSpec(unit: string): ViewSpec | null;
getInitialDate(): Date;
prev(): void;
next(): void;
prevYear(): void;
nextYear(): void;
today(): void;
gotoDate(zonedDateInput: any): void;
incrementDate(deltaInput: any): void;
getDate(): Date;
formatDate(d: DateInput, formatter: any): string;
formatRange(d0: DateInput, d1: DateInput, settings: any): any;
formatIso(d: DateInput, omitTime?: boolean): string;
windowResize(ev: Event): void;
updateSize(): void;
registerInteractiveComponent(component: DateComponent<any>, settingsInput: InteractionSettingsInput): void;
unregisterInteractiveComponent(component: DateComponent<any>): void;
select(dateOrObj: DateInput | any, endDate?: DateInput): void;
unselect(pev?: PointerDragEvent): void;
triggerDateSelect(selection: DateSpan, pev?: PointerDragEvent): void;
triggerDateUnselect(pev?: PointerDragEvent): void;
triggerDateClick(dateSpan: DateSpan, dayEl: HTMLElement, view: View, ev: UIEvent): void;
buildDatePointApi(dateSpan: DateSpan): DatePointApi;
buildDateSpanApi(dateSpan: DateSpan): DateSpanApi;
getNow(): DateMarker;
getDefaultEventEnd(allDay: boolean, marker: DateMarker): DateMarker;
addEvent(eventInput: EventInput, sourceInput?: EventSourceApi | string | number): EventApi | null;
getEventById(id: string): EventApi | null;
getEvents(): EventApi[];
removeAllEvents(): void;
rerenderEvents(): void;
getEventSources(): EventSourceApi[];
getEventSourceById(id: string | number): EventSourceApi | null;
addEventSource(sourceInput: EventSourceInput): EventSourceApi;
removeAllEventSources(): void;
refetchEvents(): void;
scrollToTime(timeInput: DurationInput): void;
}
function buildDelayedRerender(this: Calendar, wait: any): any;
}
declare module "@fullcalendar/core/component/Component" {
import Calendar from "@fullcalendar/core/Calendar";
import View from "@fullcalendar/core/View";
import Theme from "@fullcalendar/core/theme/Theme";
import { DateEnv } from "@fullcalendar/core/datelib/env";
export interface ComponentContext {
options: any;
dateEnv: DateEnv;
theme: Theme;
calendar: Calendar;
view: View;
}
export type EqualityFuncHash = {
[propName: string]: (obj0: any, obj1: any) => boolean;
};
export { Component as default, Component };
class Component<PropsType> {
equalityFuncs: EqualityFuncHash;
uid: string;
props: PropsType | null;
context: ComponentContext;
dateEnv: DateEnv;
theme: Theme;
view: View;
calendar: Calendar;
isRtl: boolean;
constructor(context: ComponentContext, isView?: boolean);
static addEqualityFuncs(newFuncs: EqualityFuncHash): void;
opt(name: any): any;
receiveProps(props: PropsType): void;
protected render(props: PropsType): void;
destroy(): void;
}
}
declare module "@fullcalendar/core/structs/view-config" {
import View from "@fullcalendar/core/View";
import { ViewSpec } from "@fullcalendar/core/structs/view-spec";
import { ComponentContext } from "@fullcalendar/core/component/Component";
import DateProfileGenerator from "@fullcalendar/core/DateProfileGenerator";
export type ViewClass = new (context: ComponentContext, viewSpec: ViewSpec, dateProfileGenerator: DateProfileGenerator, parentEl: HTMLElement) => View;
export interface ViewConfigObjectInput {
type?: string;
class?: ViewClass;
[optionName: string]: any;
}
export type ViewConfigInput = ViewClass | ViewConfigObjectInput;
export type ViewConfigInputHash = {
[viewType: string]: ViewConfigInput;
};
export interface ViewConfig {
superType: string;
class: ViewClass | null;
options: any;
}
export type ViewConfigHash = {
[viewType: string]: ViewConfig;
};
export function parseViewConfigs(inputs: ViewConfigInputHash): ViewConfigHash;
}
declare module "@fullcalendar/core/structs/view-def" {
import { ViewClass, ViewConfigHash } from "@fullcalendar/core/structs/view-config";
export interface ViewDef {
type: string;
class: ViewClass;
overrides: any;
defaults: any;
}
export type ViewDefHash = {
[viewType: string]: ViewDef;
};
export function compileViewDefs(defaultConfigs: ViewConfigHash, overrideConfigs: ViewConfigHash): ViewDefHash;
}
declare module "@fullcalendar/core/structs/view-spec" {
import { Duration } from "@fullcalendar/core/datelib/duration";
import OptionsManager from "@fullcalendar/core/OptionsManager";
import { ViewConfigInputHash, ViewClass } from "@fullcalendar/core/structs/view-config";
export interface ViewSpec {
type: string;
class: ViewClass;
duration: Duration;
durationUnit: string;
singleUnit: string;
options: any;
buttonTextOverride: string;
buttonTextDefault: string;
}
export type ViewSpecHash = {
[viewType: string]: ViewSpec;
};
export function buildViewSpecs(defaultInputs: ViewConfigInputHash, optionsManager: OptionsManager): ViewSpecHash;
}
declare module "@fullcalendar/core/DateProfileGenerator" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { DateRange, OpenDateRange } from "@fullcalendar/core/datelib/date-range";
import { ViewSpec } from "@fullcalendar/core/structs/view-spec";
import { DateEnv } from "@fullcalendar/core/datelib/env";
import Calendar from "@fullcalendar/core/Calendar";
export interface DateProfile {
currentRange: DateRange;
currentRangeUnit: string;
isRangeAllDay: boolean;
validRange: OpenDateRange;
activeRange: DateRange;
renderRange: DateRange;
minTime: Duration;
maxTime: Duration;
isValid: boolean;
dateIncrement: Duration;
}
export { DateProfileGenerator as default, DateProfileGenerator };
class DateProfileGenerator {
viewSpec: ViewSpec;
options: any;
dateEnv: DateEnv;
calendar: Calendar;
isHiddenDayHash: boolean[];
constructor(viewSpec: ViewSpec, calendar: Calendar);
buildPrev(currentDateProfile: DateProfile, currentDate: DateMarker): DateProfile;
buildNext(currentDateProfile: DateProfile, currentDate: DateMarker): DateProfile;
build(currentDate: DateMarker, direction?: any, forceToValid?: boolean): DateProfile;
buildValidRange(): OpenDateRange;
buildCurrentRangeInfo(date: DateMarker, direction: any): {
duration: any;
unit: any;
range: any;
};
getFallbackDuration(): Duration;
adjustActiveRange(range: DateRange, minTime: Duration, maxTime: Duration): {
start: Date;
end: Date;
};
buildRangeFromDuration(date: DateMarker, direction: any, duration: Duration, unit: any): any;
buildRangeFromDayCount(date: DateMarker, direction: any, dayCount: any): {
start: Date;
end: Date;
};
buildCustomVisibleRange(date: DateMarker): OpenDateRange;
buildRenderRange(currentRange: DateRange, currentRangeUnit: any, isRangeAllDay: any): DateRange;
buildDateIncrement(fallback: any): Duration;
getRangeOption(name: any, ...otherArgs: any[]): OpenDateRange;
initHiddenDays(): void;
trimHiddenDays(range: DateRange): DateRange | null;
isHiddenDay(day: any): boolean;
skipHiddenDays(date: DateMarker, inc?: number, isExclusive?: boolean): Date;
}
export function isDateProfilesEqual(p0: DateProfile, p1: DateProfile): boolean;
}
declare module "@fullcalendar/core/View" {
import DateProfileGenerator, { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { EmitterInterface } from "@fullcalendar/core/common/EmitterMixin";
import { ViewSpec } from "@fullcalendar/core/structs/view-spec";
import { ComponentContext } from "@fullcalendar/core/component/Component";
import DateComponent from "@fullcalendar/core/component/DateComponent";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventUiHash } from "@fullcalendar/core/component/event-ui";
import { EventRenderRange } from "@fullcalendar/core/component/event-rendering";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
export interface ViewProps {
dateProfile: DateProfile;
businessHours: EventStore;
eventStore: EventStore;
eventUiBases: EventUiHash;
dateSelection: DateSpan | null;
eventSelection: string;
eventDrag: EventInteractionState | null;
eventResize: EventInteractionState | null;
}
export { View as default, View };
abstract class View extends DateComponent<ViewProps> {
usesMinMaxTime: boolean;
dateProfileGeneratorClass: any;
on: EmitterInterface['on'];
one: EmitterInterface['one'];
off: EmitterInterface['off'];
trigger: EmitterInterface['trigger'];
triggerWith: EmitterInterface['triggerWith'];
hasHandlers: EmitterInterface['hasHandlers'];
viewSpec: ViewSpec;
dateProfileGenerator: DateProfileGenerator;
type: string;
title: string;
queuedScroll: any;
eventOrderSpecs: any;
nextDayThreshold: Duration;
isNowIndicatorRendered: boolean;
initialNowDate: DateMarker;
initialNowQueriedMs: number;
nowIndicatorTimeoutID: any;
nowIndicatorIntervalID: any;
private renderDatesMem;
private renderBusinessHoursMem;
private renderDateSelectionMem;
private renderEventsMem;
private renderEventSelectionMem;
private renderEventDragMem;
private renderEventResizeMem;
constructor(context: ComponentContext, viewSpec: ViewSpec, dateProfileGenerator: DateProfileGenerator, parentEl: HTMLElement);
initialize(): void;
readonly activeStart: Date;
readonly activeEnd: Date;
readonly currentStart: Date;
readonly currentEnd: Date;
render(props: ViewProps): void;
destroy(): void;
updateSize(isResize: boolean, viewHeight: number, isAuto: boolean): void;
updateBaseSize(isResize: boolean, viewHeight: number, isAuto: boolean): void;
renderDatesWrap(dateProfile: DateProfile): void;
unrenderDatesWrap(): void;
renderDates(dateProfile: DateProfile): void;
unrenderDates(): void;
renderBusinessHours(businessHours: EventStore): void;
unrenderBusinessHours(): void;
renderDateSelectionWrap(selection: DateSpan): void;
unrenderDateSelectionWrap(selection: DateSpan): void;
renderDateSelection(selection: DateSpan): void;
unrenderDateSelection(selection: DateSpan): void;
renderEvents(eventStore: EventStore): void;
unrenderEvents(): void;
sliceEvents(eventStore: EventStore, allDay: boolean): EventRenderRange[];
renderEventSelectionWrap(instanceId: string): void;
unrenderEventSelectionWrap(instanceId: string): void;
renderEventSelection(instanceId: string): void;
unrenderEventSelection(instanceId: string): void;
renderEventDragWrap(state: EventInteractionState): void;
unrenderEventDragWrap(state: EventInteractionState): void;
renderEventDrag(state: EventInteractionState): void;
unrenderEventDrag(state: EventInteractionState): void;
renderEventResizeWrap(state: EventInteractionState): void;
unrenderEventResizeWrap(state: EventInteractionState): void;
renderEventResize(state: EventInteractionState): void;
unrenderEventResize(state: EventInteractionState): void;
startNowIndicator(dateProfile: DateProfile): void;
updateNowIndicator(): void;
stopNowIndicator(): void;
getNowIndicatorUnit(dateProfile: DateProfile): void;
renderNowIndicator(date: any): void;
unrenderNowIndicator(): void;
addScroll(scroll: any): void;
popScroll(isResize: boolean): void;
applyQueuedScroll(isResize: boolean): void;
queryScroll(): any;
applyScroll(scroll: any, isResize: boolean): void;
computeDateScroll(timeMs: number): {};
queryDateScroll(): {};
applyDateScroll(scroll: any): void;
scrollToTime(time: Duration): void;
}
}
declare module "@fullcalendar/core/types/input-types" {
import View from "@fullcalendar/core/View";
import { EventSourceInput, EventInputTransformer } from "@fullcalendar/core/structs/event-source";
import { Duration, DurationInput } from "@fullcalendar/core/datelib/duration";
import { DateInput } from "@fullcalendar/core/datelib/env";
import { FormatterInput } from "@fullcalendar/core/datelib/formatting";
import { DateRangeInput } from "@fullcalendar/core/datelib/date-range";
import { BusinessHoursInput } from "@fullcalendar/core/structs/business-hours";
import EventApi from "@fullcalendar/core/api/EventApi";
import { AllowFunc, ConstraintInput, OverlapFunc } from "@fullcalendar/core/validation";
import { PluginDef } from "@fullcalendar/core/plugin-system";
import { LocaleSingularArg, RawLocale } from "@fullcalendar/core/datelib/locale";
export interface ToolbarInput {
left?: string;
center?: string;
right?: string;
}
export interface CustomButtonInput {
text: string;
icon?: string;
themeIcon?: string;
bootstrapFontAwesome?: string;
click(element: HTMLElement): void;
}
export interface ButtonIconsInput {
prev?: string;
next?: string;
prevYear?: string;
nextYear?: string;
}
export interface ButtonTextCompoundInput {
prev?: string;
next?: string;
prevYear?: string;
nextYear?: string;
today?: string;
month?: string;
week?: string;
day?: string;
[viewId: string]: string | undefined;
}
export interface EventSegment {
event: EventApi;
start: Date;
end: Date;
isStart: boolean;
isEnd: boolean;
}
export interface CellInfo {
date: Date;
dayEl: HTMLElement;
moreEl: HTMLElement;
segs: EventSegment[];
hiddenSegs: EventSegment[];
}
export interface DropInfo {
start: Date;
end: Date;
}
export interface OptionsInputBase {
header?: boolean | ToolbarInput;
footer?: boolean | ToolbarInput;
customButtons?: {
[name: string]: CustomButtonInput;
};
buttonIcons?: boolean | ButtonIconsInput;
themeSystem?: 'standard' | string;
bootstrapFontAwesome?: boolean | ButtonIconsInput;
firstDay?: number;
dir?: 'ltr' | 'rtl' | 'auto';
weekends?: boolean;
hiddenDays?: number[];
fixedWeekCount?: boolean;
weekNumbers?: boolean;
weekNumbersWithinDays?: boolean;
weekNumberCalculation?: 'local' | 'ISO' | ((m: Date) => number);
businessHours?: BusinessHoursInput;
showNonCurrentDates?: boolean;
height?: number | 'auto' | 'parent' | (() => number);
contentHeight?: number | 'auto' | (() => number);
aspectRatio?: number;
handleWindowResize?: boolean;
windowResizeDelay?: number;
eventLimit?: boolean | number;
eventLimitClick?: 'popover' | 'week' | 'day' | string | ((cellinfo: CellInfo, jsevent: Event) => void);
timeZone?: string | boolean;
now?: DateInput | (() => DateInput);
defaultView?: string;
allDaySlot?: boolean;
allDayText?: string;
slotDuration?: DurationInput;
slotLabelFormat?: FormatterInput;
slotLabelInterval?: DurationInput;
snapDuration?: DurationInput;
scrollTime?: DurationInput;
minTime?: DurationInput;
maxTime?: DurationInput;
slotEventOverlap?: boolean;
listDayFormat?: FormatterInput | boolean;
listDayAltFormat?: FormatterInput | boolean;
noEventsMessage?: string;
defaultDate?: DateInput;
nowIndicator?: boolean;
visibleRange?: ((currentDate: Date) => DateRangeInput) | DateRangeInput;
validRange?: DateRangeInput;
dateIncrement?: DurationInput;
dateAlignment?: string;
duration?: DurationInput;
dayCount?: number;
locales?: RawLocale[];
locale?: LocaleSingularArg;
eventTimeFormat?: FormatterInput;
columnHeader?: boolean;
columnHeaderFormat?: FormatterInput;
columnHeaderText?: string | ((date: DateInput) => string);
columnHeaderHtml?: string | ((date: DateInput) => string);
titleFormat?: FormatterInput;
weekLabel?: string;
displayEventTime?: boolean;
displayEventEnd?: boolean;
eventLimitText?: string | ((eventCnt: number) => string);
dayPopoverFormat?: FormatterInput;
navLinks?: boolean;
navLinkDayClick?: string | ((date: Date, jsEvent: Event) => void);
navLinkWeekClick?: string | ((weekStart: any, jsEvent: Event) => void);
selectable?: boolean;
selectMirror?: boolean;
unselectAuto?: boolean;
unselectCancel?: string;
defaultAllDayEventDuration?: DurationInput;
defaultTimedEventDuration?: DurationInput;
cmdFormatter?: string;
defaultRangeSeparator?: string;
selectConstraint?: ConstraintInput;
selectOverlap?: boolean | OverlapFunc;
selectAllow?: AllowFunc;
editable?: boolean;
eventStartEditable?: boolean;
eventDurationEditable?: boolean;
eventConstraint?: ConstraintInput;
eventOverlap?: boolean | OverlapFunc;
eventAllow?: AllowFunc;
eventClassName?: string[] | string;
eventClassNames?: string[] | string;
eventBackgroundColor?: string;
eventBorderColor?: string;
eventTextColor?: string;
eventColor?: string;
events?: EventSourceInput;
eventSources?: EventSourceInput[];
allDayDefault?: boolean;
startParam?: string;
endParam?: string;
lazyFetching?: boolean;
nextDayThreshold?: DurationInput;
eventOrder?: string | Array<((a: EventApi, b: EventApi) => number) | (string | ((a: EventApi, b: EventApi) => number))>;
rerenderDelay?: number | null;
dragRevertDuration?: number;
dragScroll?: boolean;
longPressDelay?: number;
eventLongPressDelay?: number;
droppable?: boolean;
dropAccept?: string | ((draggable: any) => boolean);
eventDataTransform?: EventInputTransformer;
allDayMaintainDuration?: boolean;
eventResizableFromStart?: boolean;
timeGridEventMinHeight?: number;
datesRender?(arg: {
view: View;
el: HTMLElement;
}): void;
datesDestroy?(arg: {
view: View;
el: HTMLElement;
}): void;
dayRender?(arg: {
view: View;
date: Date;
allDay: boolean;
el: HTMLElement;
}): void;
windowResize?(view: View): void;
dateClick?(arg: {
date: Date;
dateStr: string;
allDay: boolean;
resource: any;
dayEl: HTMLElement;
jsEvent: MouseEvent;
view: View;
}): void;
eventClick?(arg: {
el: HTMLElement;
event: EventApi;
jsEvent: MouseEvent;
view: View;
}): boolean | void;
eventMouseEnter?(arg: {
el: HTMLElement;
event: EventApi;
jsEvent: MouseEvent;
view: View;
}): void;
eventMouseLeave?(arg: {
el: HTMLElement;
event: EventApi;
jsEvent: MouseEvent;
view: View;
}): void;
select?(arg: {
start: Date;
end: Date;
startStr: string;
endStr: string;
allDay: boolean;
resource: any;
jsEvent: MouseEvent;
view: View;
}): void;
unselect?(arg: {
view: View;
jsEvent: Event;
}): void;
loading?(isLoading: boolean, view: View): void;
eventRender?(arg: {
event: EventApi;
el: HTMLElement;
view: View;
}): void;
eventPositioned?(arg: {
event: EventApi;
el: HTMLElement;
view: View;
}): void;
_eventsPositioned?(arg: {
view: View;
}): void;
eventDestroy?(arg: {
event: EventApi;
el: HTMLElement;
view: View;
}): void;
eventDragStart?(arg: {
event: EventApi;
el: HTMLElement;
jsEvent: MouseEvent;
view: View;
}): void;
eventDragStop?(arg: {
event: EventApi;
el: HTMLElement;
jsEvent: MouseEvent;
view: View;
}): void;
eventDrop?(arg: {
el: HTMLElement;
event: EventApi;
delta: Duration;
revert: () => void;
jsEvent: Event;
view: View;
}): void;
eventResizeStart?(arg: {
el: HTMLElement;
event: EventApi;
jsEvent: MouseEvent;
view: View;
}): void;
eventResizeStop?(arg: {
el: HTMLElement;
event: EventApi;
jsEvent: MouseEvent;
view: View;
}): void;
eventResize?(arg: {
el: HTMLElement;
event: EventApi;
delta: Duration;
revert: () => void;
jsEvent: Event;
view: View;
}): void;
drop?(arg: {
date: Date;
dateStr: string;
allDay: boolean;
draggedEl: HTMLElement;
jsEvent: MouseEvent;
view: View;
}): void;
eventReceive?(arg: {
event: EventApi;
draggedEl: HTMLElement;
view: View;
}): void;
eventLeave?(arg: {
draggedEl: HTMLElement;
event: EventApi;
view: View;
}): void;
viewSkeletonRender?(arg: {
el: HTMLElement;
view: View;
}): void;
viewSkeletonDestroy?(arg: {
el: HTMLElement;
view: View;
}): void;
_destroyed?(): void;
}
export interface ViewOptionsInput extends OptionsInputBase {
type?: string;
buttonText?: string;
}
export interface OptionsInput extends OptionsInputBase {
buttonText?: ButtonTextCompoundInput;
views?: {
[viewId: string]: ViewOptionsInput;
};
plugins?: (PluginDef | string)[];
}
}
declare module "@fullcalendar/core/component/date-rendering" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import Component, { ComponentContext } from "@fullcalendar/core/component/Component";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
export function buildGotoAnchorHtml(component: Component<any>, gotoOptions: any, attrs: any, innerHtml?: any): string;
export function getAllDayHtml(component: Component<any>): any;
export function getDayClasses(date: DateMarker, dateProfile: DateProfile, context: ComponentContext, noThemeHighlight?: any): any[];
}
declare module "@fullcalendar/core/common/PositionCache" {
export { PositionCache as default, PositionCache };
class PositionCache {
originClientRect: ClientRect;
els: HTMLElement[];
originEl: HTMLElement;
isHorizontal: boolean;
isVertical: boolean;
lefts: any;
rights: any;
tops: any;
bottoms: any;
constructor(originEl: HTMLElement, els: HTMLElement[], isHorizontal: boolean, isVertical: boolean);
build(): void;
buildElHorizontals(originClientLeft: number): void;
buildElVerticals(originClientTop: number): void;
leftToIndex(leftPosition: number): any;
topToIndex(topPosition: number): any;
getWidth(leftIndex: number): number;
getHeight(topIndex: number): number;
}
}
declare module "@fullcalendar/core/common/scroll-controller" {
export abstract class ScrollController {
abstract getScrollTop(): number;
abstract getScrollLeft(): number;
abstract setScrollTop(top: number): void;
abstract setScrollLeft(left: number): void;
abstract getClientWidth(): number;
abstract getClientHeight(): number;
abstract getScrollWidth(): number;
abstract getScrollHeight(): number;
getMaxScrollTop(): number;
getMaxScrollLeft(): number;
canScrollVertically(): boolean;
canScrollHorizontally(): boolean;
canScrollUp(): boolean;
canScrollDown(): boolean;
canScrollLeft(): boolean;
canScrollRight(): boolean;
}
export class ElementScrollController extends ScrollController {
el: HTMLElement;
constructor(el: HTMLElement);
getScrollTop(): number;
getScrollLeft(): number;
setScrollTop(top: number): void;
setScrollLeft(left: number): void;
getScrollWidth(): number;
getScrollHeight(): number;
getClientHeight(): number;
getClientWidth(): number;
}
export class WindowScrollController extends ScrollController {
getScrollTop(): number;
getScrollLeft(): number;
setScrollTop(n: number): void;
setScrollLeft(n: number): void;
getScrollWidth(): number;
getScrollHeight(): number;
getClientHeight(): number;
getClientWidth(): number;
}
}
declare module "@fullcalendar/core/common/ScrollComponent" {
import { ElementScrollController } from "@fullcalendar/core/common/scroll-controller";
export interface ScrollbarWidths {
left: number;
right: number;
bottom: number;
}
export { ScrollComponent as default, ScrollComponent };
class ScrollComponent extends ElementScrollController {
overflowX: string;
overflowY: string;
constructor(overflowX: string, overflowY: string);
clear(): void;
destroy(): void;
applyOverflow(): void;
lockOverflow(scrollbarWidths: ScrollbarWidths): void;
setHeight(height: number | string): void;
getScrollbarWidths(): ScrollbarWidths;
}
}
declare module "@fullcalendar/core/formatting-api" {
import { DateInput } from "@fullcalendar/core/datelib/env";
export function formatDate(dateInput: DateInput, settings?: {}): any;
export function formatRange(startInput: DateInput, endInput: DateInput, settings: any): any;
}
declare module "@fullcalendar/core/common/table-utils" {
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import { ComponentContext } from "@fullcalendar/core/component/Component";
export function computeFallbackHeaderFormat(datesRepDistinctDays: boolean, dayCnt: number): {
weekday: string;
month?: undefined;
day?: undefined;
omitCommas?: undefined;
} | {
weekday: string;
month: string;
day: string;
omitCommas: boolean;
};
export function renderDateCell(dateMarker: DateMarker, dateProfile: DateProfile, datesRepDistinctDays: any, colCnt: any, colHeadFormat: any, context: ComponentContext, colspan?: any, otherAttrs?: any): string;
}
declare module "@fullcalendar/core/common/DayHeader" {
import Component, { ComponentContext } from "@fullcalendar/core/component/Component";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
export interface DayTableHeaderProps {
dates: DateMarker[];
dateProfile: DateProfile;
datesRepDistinctDays: boolean;
renderIntroHtml?: () => string;
}
export { DayHeader as default, DayHeader };
class DayHeader extends Component<DayTableHeaderProps> {
el: HTMLElement;
thead: HTMLElement;
constructor(context: ComponentContext, parentEl: HTMLElement);
destroy(): void;
render(props: DayTableHeaderProps): void;
}
}
declare module "@fullcalendar/core/common/DaySeries" {
import DateProfileGenerator from "@fullcalendar/core/DateProfileGenerator";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
export interface DaySeriesSeg {
firstIndex: number;
lastIndex: number;
isStart: boolean;
isEnd: boolean;
}
export { DaySeries as default, DaySeries };
class DaySeries {
cnt: number;
dates: DateMarker[];
indices: number[];
constructor(range: DateRange, dateProfileGenerator: DateProfileGenerator);
sliceRange(range: DateRange): DaySeriesSeg | null;
private getDateDayIndex;
}
}
declare module "@fullcalendar/core/common/DayTable" {
import DaySeries from "@fullcalendar/core/common/DaySeries";
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
import { Seg } from "@fullcalendar/core/component/DateComponent";
export interface DayTableSeg extends Seg {
row: number;
firstCol: number;
lastCol: number;
}
export interface DayTableCell {
date: DateMarker;
htmlAttrs?: string;
}
export { DayTable as default, DayTable };
class DayTable {
rowCnt: number;
colCnt: number;
cells: DayTableCell[][];
headerDates: DateMarker[];
private daySeries;
constructor(daySeries: DaySeries, breakOnWeeks: boolean);
private buildCells;
private buildCell;
private buildHeaderDates;
sliceRange(range: DateRange): DayTableSeg[];
}
}
declare module "@fullcalendar/core/common/slicing-utils" {
import { DateRange } from "@fullcalendar/core/datelib/date-range";
import { EventStore } from "@fullcalendar/core/structs/event-store";
import { EventUiHash } from "@fullcalendar/core/component/event-ui";
import { DateProfile } from "@fullcalendar/core/DateProfileGenerator";
import DateComponent, { Seg, EventSegUiInteractionState } from "@fullcalendar/core/component/DateComponent";
import { DateSpan } from "@fullcalendar/core/structs/date-span";
import { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
import { Duration } from "@fullcalendar/core/datelib/duration";
import { DateMarker } from "@fullcalendar/core/datelib/marker";
export interface SliceableProps {
dateSelection: DateSpan;
businessHours: EventStore;
eventStore: EventStore;
eventDrag: EventInteractionState | null;
eventResize: EventInteractionState | null;
eventSelection: string;
eventUiBases: EventUiHash;
}
export interface SlicedProps<SegType extends Seg> {
dateSelectionSegs: SegType[];
businessHourSegs: SegType[];
fgEventSegs: SegType[];
bgEventSegs: SegType[];
eventDrag: EventSegUiInteractionState | null;
eventResize: EventSegUiInteractionState | null;
eventSelection: string;
}
export { Slicer as default, Slicer };
abstract class Slicer<SegType extends Seg, ExtraArgs extends any[] = []> {
private sliceBusinessHours;
private sliceDateSelection;
private sliceEventStore;
private sliceEventDrag;
private sliceEventResize;
abstract sliceRange(dateRange: DateRange, ...extraArgs: ExtraArgs): SegType[];
sliceProps(props: SliceableProps, dateProfile: DateProfile, nextDayThreshold: Duration | null, component: DateComponent<any>, // TODO: kill
...extraArgs: ExtraArgs): SlicedProps<SegType>;
sliceNowDate(// does not memoize
date: DateMarker, component: DateComponent<any>, // TODO: kill
...extraArgs: ExtraArgs): SegType[];
private _sliceBusinessHours;
private _sliceEventStore;
private _sliceInteraction;
private _sliceDateSpan;
private sliceEventRanges;
private sliceEventRange;
}
}
declare module "@fullcalendar/core" {
export const version = "<%= version %>";
export { OptionsInput } from "@fullcalendar/core/types/input-types";
export { EventInput, EventDef, EventDefHash, EventInstance, EventInstanceHash, parseEventDef, createEventInstance, EventTuple } from "@fullcalendar/core/structs/event";
export { BusinessHoursInput, parseBusinessHours } from "@fullcalendar/core/structs/business-hours";
export { applyAll, debounce, padStart, isInt, capitaliseFirstLetter, parseFieldSpecs, compareByFieldSpecs, compareByFieldSpec, flexibleCompare, computeVisibleDayRange, refineProps, freezeRaw, matchCellWidths, uncompensateScroll, compensateScroll, subtractInnerElHeight, isMultiDayRange, distributeHeight, undistributeHeight, preventSelection, allowSelection, preventContextMenu, allowContextMenu, compareNumbers, enableCursor, disableCursor, diffDates } from "@fullcalendar/core/util/misc";
export { htmlEscape, cssToStr } from "@fullcalendar/core/util/html";
export { removeExact, isArraysEqual } from "@fullcalendar/core/util/array";
export { memoize, memoizeOutput } from "@fullcalendar/core/util/memoize";
export { memoizeRendering, MemoizedRendering } from "@fullcalendar/core/component/memoized-rendering";
export { intersectRects, Rect, pointInsideRect, constrainPoint, getRectCenter, diffPoints, Point, translateRect } from "@fullcalendar/core/util/geom";
export { mapHash, filterHash } from "@fullcalendar/core/util/object";
export { isObjectsSimilar, isValuesSimilar } from "@fullcalendar/core/util/object-similarity";
export { findElements, findChildren, htmlToElement, createElement, insertAfterElement, prependToElement, removeElement, appendToElement, applyStyle, applyStyleProp, elementMatches, elementClosest, forceClassName } from "@fullcalendar/core/util/dom-manip";
export { EventStore, filterEventStoreDefs, createEmptyEventStore, mergeEventStores, getRelevantEvents, eventTupleToStore } from "@fullcalendar/core/structs/event-store";
export { EventUiHash, EventUi, processScopedUiProps, combineEventUis } from "@fullcalendar/core/component/event-ui";
export { default as Splitter, SplittableProps } from "@fullcalendar/core/component/event-splitting";
export { buildGotoAnchorHtml, getAllDayHtml, getDayClasses } from "@fullcalendar/core/component/date-rendering";
export { preventDefault, listenBySelector, whenTransitionDone } from "@fullcalendar/core/util/dom-event";
export { computeInnerRect, computeEdges, computeHeightAndMargins, getClippingParents, computeClippingRect, computeRect } from "@fullcalendar/core/util/dom-geom";
export { unpromisify } from "@fullcalendar/core/util/promise";
export { default as EmitterMixin, EmitterInterface } from "@fullcalendar/core/common/EmitterMixin";
export { DateRange, rangeContainsMarker, intersectRanges, rangesEqual, rangesIntersect, rangeContainsRange } from "@fullcalendar/core/datelib/date-range";
export { default as Mixin } from "@fullcalendar/core/common/Mixin";
export { default as PositionCache } from "@fullcalendar/core/common/PositionCache";
export { default as ScrollComponent, ScrollbarWidths } from "@fullcalendar/core/common/ScrollComponent";
export { ScrollController, ElementScrollController, WindowScrollController } from "@fullcalendar/core/common/scroll-controller";
export { default as Theme } from "@fullcalendar/core/theme/Theme";
export { default as Component, ComponentContext } from "@fullcalendar/core/component/Component";
export { default as DateComponent, Seg, EventSegUiInteractionState } from "@fullcalendar/core/component/DateComponent";
export { default as Calendar, DatePointTransform, DateSpanTransform, DateSelectionApi } from "@fullcalendar/core/Calendar";
export { default as View, ViewProps } from "@fullcalendar/core/View";
export { default as FgEventRenderer, buildSegCompareObj } from "@fullcalendar/core/component/renderers/FgEventRenderer";
export { default as FillRenderer } from "@fullcalendar/core/component/renderers/FillRenderer";
export { default as DateProfileGenerator, DateProfile } from "@fullcalendar/core/DateProfileGenerator";
export { ViewDef } from "@fullcalendar/core/structs/view-def";
export { ViewSpec } from "@fullcalendar/core/structs/view-spec";
export { DateSpan, DateSpanApi, DatePointApi, isDateSpansEqual } from "@fullcalendar/core/structs/date-span";
export { DateMarker, addDays, startOfDay, addMs, addWeeks, diffWeeks, diffWholeWeeks, diffWholeDays, diffDayAndTime, diffDays, isValidDate } from "@fullcalendar/core/datelib/marker";
export { Duration, createDuration, isSingleDay, multiplyDuration, addDurations, asRoughMinutes, asRoughSeconds, asRoughMs, wholeDivideDurations, greatestDurationDenominator } from "@fullcalendar/core/datelib/duration";
export { DateEnv, DateMarkerMeta } from "@fullcalendar/core/datelib/env";
export { DateFormatter, createFormatter, VerboseFormattingArg, formatIsoTimeString } from "@fullcalendar/core/datelib/formatting";
export { NamedTimeZoneImpl } from "@fullcalendar/core/datelib/timezone";
export { parse as parseMarker } from "@fullcalendar/core/datelib/parsing";
export { EventSourceDef, EventSource, EventSourceHash } from "@fullcalendar/core/structs/event-source";
export { Interaction, InteractionSettings, interactionSettingsToStore, interactionSettingsStore, InteractionSettingsStore } from "@fullcalendar/core/interactions/interaction";
export { PointerDragEvent } from "@fullcalendar/core/interactions/pointer";
export { Hit } from "@fullcalendar/core/interactions/hit";
export { dateSelectionJoinTransformer } from "@fullcalendar/core/interactions/date-selecting";
export { eventDragMutationMassager } from "@fullcalendar/core/interactions/event-dragging";
export { EventResizeJoinTransforms } from "@fullcalendar/core/interactions/event-resizing";
export { default as ElementDragging } from "@fullcalendar/core/interactions/ElementDragging";
export { formatDate, formatRange } from "@fullcalendar/core/formatting-api";
export { globalDefaults, config } from "@fullcalendar/core/options";
export { RecurringType, ParsedRecurring } from "@fullcalendar/core/structs/recurring-event";
export { DragMetaInput, DragMeta, parseDragMeta } from "@fullcalendar/core/structs/drag-meta";
export { createPlugin, PluginDef, PluginDefInput, ViewPropsTransformer, ViewContainerModifier } from "@fullcalendar/core/plugin-system";
export { reducerFunc, Action, CalendarState } from "@fullcalendar/core/reducers/types";
export { CalendarComponentProps } from "@fullcalendar/core/CalendarComponent";
export { default as DayHeader } from "@fullcalendar/core/common/DayHeader";
export { computeFallbackHeaderFormat, renderDateCell } from "@fullcalendar/core/common/table-utils";
export { default as DaySeries } from "@fullcalendar/core/common/DaySeries";
export { EventInteractionState } from "@fullcalendar/core/interactions/event-interaction-state";
export { EventRenderRange, sliceEventStore, hasBgRendering, getElSeg } from "@fullcalendar/core/component/event-rendering";
export { default as DayTable, DayTableSeg, DayTableCell } from "@fullcalendar/core/common/DayTable";
export { default as Slicer, SlicedProps } from "@fullcalendar/core/common/slicing-utils";
export { EventMutation, applyMutationToEventStore } from "@fullcalendar/core/structs/event-mutation";
export { Constraint, ConstraintInput, AllowFunc, isPropsValid, isInteractionValid } from "@fullcalendar/core/validation";
export { default as EventApi } from "@fullcalendar/core/api/EventApi";
export { default as requestJson } from "@fullcalendar/core/util/requestJson";
}