// Global namespace modules declare var DOMPurify; declare var droll; declare var Handlebars; declare var hljs; declare var localforage; declare var pdfjsLib; declare var Popper; declare var showdown; declare var showdownKatex; declare var SVGInject; declare var Readability; declare var isProbablyReaderable; declare var ePub; declare var ai; // Jquery plugins interface JQuery { pagination(method: 'getCurrentPageNum'): number; pagination(method: string, options?: any): JQuery; pagination(options?: any): JQuery; transition(options?: any, complete?: function): JQuery; autocomplete(options?: any): JQuery; autocomplete(method: string, options?: any): JQuery; slider(options?: any): JQuery; slider(method: string, func: string, options?: any): JQuery; cropper(options?: any): JQuery; izoomify(options?: any): JQuery; //#region select2 /** * Initializes or modifies a select2 instance with provided options * * @param options - Configuration options for the select2 instance * @returns The jQuery object for chaining */ select2(options?: Select2Options): JQuery; /** * Retrieves data currently selected in the select2 instance * * @param field - A string specifying the 'data' method * @returns An array of selected items */ select2(field: 'data'): any[]; /** * Calls the specified select2 method * * @param method - The name of the select2 method to invoke * @returns The jQuery object for chaining */ select2(method: 'open' | 'close' | 'destroy' | 'focus' | 'val', value?: any): JQuery; //#endregion //#region sortable /** * Initializes or updates a sortable instance with the provided options * * @param options - Configuration options for the sortable instance * @returns The jQuery object for chaining */ sortable(options?: SortableOptions): JQuery; /** * Calls a sortable method to perform actions on the instance * * @param method - The name of the sortable method to invoke * @returns The jQuery object for chaining */ sortable(method: 'destroy' | 'disable' | 'enable' | 'refresh' | 'toArray'): JQuery; /** * Retrieves the sortable's instance object. If the element does not have an associated instance, undefined is returned. * * @returns The instance of the sortable object */ sortable(method: 'instance'): object; /** * Retrieves the current option value for the specified option * * @param method - The string 'option' to retrieve an option value * @param optionName - The name of the option to retrieve * @returns The value of the specified option */ sortable(method: 'option', optionName: string): any; /** * Sets the value of the specified option * * @param method - The string 'option' to set an option value * @param optionName - The name of the option to set * @param value - The value to assign to the option * @returns The jQuery object for chaining */ sortable(method: 'option', optionName: string, value: any): JQuery; /** * Sets multiple options using an object * * @param method - The string 'option' to set options * @param options - An object containing multiple option key-value pairs * @returns The jQuery object for chaining */ sortable(method: 'option', options: SortableOptions): JQuery; //#endregion } //#region Fuse /** * Fuse.js provides fast and flexible fuzzy searching * @constructor * @param list - The list of items to search through * @param options - Configuration options for the search algorithm */ declare var Fuse: { new(list: any[], options?: FuseOptions): FuseInstance; }; /** Instead of providing a (nested) key as a string, an object can be defined that can specify weight and a custom get function */ interface FuseKey { /** * The name of they key. Supports nested paths. */ name: string; /** * You can allocate a weight to keys to give them higher (or lower) values in search results. The weight value has to be greater than 0. When a weight isn't provided, it will default to 1. * @default 1 */ weight?: number; /** * Function to retrieve an object's value at the specified path. The default searches nested paths. * @default (obj: T, path: string | string[]) => string | string[] */ getFn?: (any) => string; } /** Configuration options for the Fuse search algorithm */ interface FuseOptions { /** * List of keys that will be searched. Supports nested paths, weighted search, and searching in arrays of strings and objects. * @default [] */ keys?: string[] | FuseKey[]; /** * How much distance one character can be from another to be considered a match. * @default 100 */ distance?: number; /** * At what point the match algorithm gives up. A threshold of 0.0 requires a perfect match, while 1.0 matches everything. * @default 0.6 */ threshold?: number; /** * Whether the score should be included in the result set. A score of 0 indicates a perfect match, while a score of 1 indicates a complete mismatch. * @default false */ includeScore?: boolean; /** * Indicates whether comparisons should be case-sensitive. * @default false */ isCaseSensitive?: boolean; /** * Whether the matches should be included in the result set. When true, each record in the result set will include the indices of matched characters. * @default false */ includeMatches?: boolean; /** * Only matches whose length exceeds this value will be returned. * @default 1 */ minMatchCharLength?: number; /** * Whether to sort the result list by score. * @default true */ shouldSort?: boolean; /** * When true, the matching function will continue to the end of a search pattern even if a perfect match has already been found. * @default false */ findAllMatches?: boolean; /** * Determines approximately where in the text the pattern is expected to be found. * @default 0 */ location?: number; /** * When true, search will ignore location and distance, so it won't matter where in the string the pattern appears. * @default false */ ignoreLocation?: boolean; /** * When true, it enables the use of Unix-like search commands. * @default false */ useExtendedSearch?: boolean; /** * Function to retrieve an object's value at the specified path. The default searches nested paths. * @default (obj: T, path: string | string[]) => string | string[] */ getFn?: (obj: any, path: string | string[]) => string | string[]; /** * Function to sort the results. The default sorts by ascending relevance score. * @default (a, b) => number */ sortFn?: (a: any, b: any) => number; /** * When true, the calculation for the relevance score will ignore the field-length norm. * @default false */ ignoreFieldNorm?: boolean; /** * Determines how much the field-length norm affects scoring. 0 is equivalent to ignoring the field-length norm, while higher values increase the effect. * @default 1 */ fieldNormWeight?: number; } /** Represents an individual Fuse search result */ interface FuseResult { /** The original item that was matched */ item: any; /** The index of the item from the original input collection that was searched */ refIndex: number; /** The search score, where 0 is a perfect match and 1 is the worst */ score?: number; /** Optional list of matched search keys */ matches?: Array<{ key: string; indices: [number, number][] }>; } /** Represents a Fuse instance, used for performing searches */ interface FuseInstance { /** * Searches through the list using the specified query. * @param query - The search term or phrase to use * @returns An array of search results matching the query */ search(query: string): FuseResult[]; } //#endregion //#region select2 /** Options for configuring a select2 instance */ interface Select2Options { /** * Provides support for ajax data sources * @param params - Parameters including the search term * @param callback - A callback function to handle the results * @default null */ ajax?: { url: string; dataType?: string; delay?: number; data?: (params: any) => any; processResults?: (data: any, params: any) => any; } | { transport: (params, success, failure) => any }; /** * Provides support for clearable selections * @default false */ allowClear?: boolean; /** * See Using Select2 with AMD or CommonJS loaders * @default './i18n/' */ amdLanguageBase?: string; /** * Controls whether the dropdown is closed after a selection is made * @default true */ closeOnSelect?: boolean; /** * Allows rendering dropdown options from an array * @default null */ data?: object[]; /** * Used to override the built-in DataAdapter * @default SelectAdapter */ dataAdapter?: SelectAdapter; /** * Enable debugging messages in the browser console * @default false */ debug?: boolean; /** * Sets the dir attribute on the selection and dropdown containers to indicate the direction of the text * @default 'ltr' */ dir?: string; /** * When set to true, the select control will be disabled * @default false */ disabled?: boolean; /** * Used to override the built-in DropdownAdapter * @default DropdownAdapter */ dropdownAdapter?: DropdownAdapter; /** * @default false */ dropdownAutoWidth?: boolean; /** * Adds additional CSS classes to the dropdown container. The helper :all: can be used to add all CSS classes present on the original element * @default '' */ selectionCssClass?: string; /** * Implements automatic selection when the dropdown is closed * @default false */ selectOnClose?: boolean; sorter?: function; /** * When set to `true`, allows the user to create new tags that aren't pre-populated * Used to enable free text responses * @default false */ tags?: boolean | object[]; /** * Customizes the way that search results are rendered * @param item - The item object to format * @returns The formatted representation * @default null */ templateResult?: (item: any) => JQuery | string; /** * Customizes the way that selections are rendered * @param item - The selected item object to format * @returns The formatted representation * @default null */ templateSelection?: (item: any) => JQuery | string; /** * Allows you to set the theme * @default 'default' */ theme?: string; /** * A callback that handles automatic tokenization of free-text entry * @default null */ tokenizer?: (input: { _type: string, term: string }, selection: { options: object }, callback: (Select2Option) => any) => { term: string }; /** * The list of characters that should be used as token separators * @default null */ tokenSeparators?: string[]; /** * Supports customization of the container width * @default 'resolve' */ width?: string; /** * If true, resolves issue for multiselects using closeOnSelect: false that caused the list of results to scroll to the first selection after each select/unselect * @default false */ scrollAfterSelect?: boolean; /** * Extends Select2 v4 plugin by adding an option to set a placeholder for the 'search' input field * [Custom Field] * @default '' */ searchInputPlaceholder?: string; /** * Extends select2 plugin by adding a custom css class for the 'searcH' input field * [Custom Field] * @default '' */ searchInputCssClass?: string; } //#endregion //#region sortable /** Options for configuring a sortable instance */ interface SortableOptions { /** * When set, prevents the sortable items from being dragged unless clicked with a delay * @default 0 */ delay?: number; /** * Class name for elements to handle sorting. Elements with this class can be dragged to sort. * @default '' */ handle?: string; /** * Whether to allow sorting between different connected lists * @default false */ connectWith?: string | boolean; /** * Function called when sorting starts * @param event - The event object * @param ui - The UI object containing the helper and position information */ start?: (event: Event, ui: SortableUI) => void; /** * Function called when sorting stops * @param event - The event object * @param ui - The UI object containing the helper and position information */ stop?: (event: Event, ui: SortableUI) => void; /** * Function called when sorting updates * @param event - The event object * @param ui - The UI object containing the helper and position information */ update?: (event: Event, ui: SortableUI) => void; /** * Specifies which items inside the element should be sortable * @default '> *' */ items?: string; } /** UI object passed to sortable event handlers */ interface SortableUI { /** jQuery object representing the helper element */ helper: JQuery; /** The current position of the helper element */ position: { top: number; left: number }; /** Original position of the helper element */ originalPosition: { top: number; left: number }; /** jQuery object representing the item being sorted */ item: JQuery; /** The placeholder element used during sorting */ placeholder: JQuery; } //#endregion // MIT Licence. Copied from: // https://github.com/moment/moment/blob/develop/ts3.1-typings/moment.d.ts /** * @param strict Strict parsing disables the deprecated fallback to the native Date constructor when * parsing a string. */ declare function moment(inp?: moment.MomentInput, strict?: boolean): moment.Moment; /** * @param strict Strict parsing requires that the format and input match exactly, including delimiters. * Strict parsing is frequently the best parsing option. For more information about choosing strict vs * forgiving parsing, see the [parsing guide](https://momentjs.com/guides/#/parsing/). */ declare function moment(inp?: moment.MomentInput, format?: moment.MomentFormatSpecification, strict?: boolean): moment.Moment; /** * @param strict Strict parsing requires that the format and input match exactly, including delimiters. * Strict parsing is frequently the best parsing option. For more information about choosing strict vs * forgiving parsing, see the [parsing guide](https://momentjs.com/guides/#/parsing/). */ declare function moment(inp?: moment.MomentInput, format?: moment.MomentFormatSpecification, language?: string, strict?: boolean): moment.Moment; declare namespace moment { type RelativeTimeKey = 's' | 'ss' | 'm' | 'mm' | 'h' | 'hh' | 'd' | 'dd' | 'w' | 'ww' | 'M' | 'MM' | 'y' | 'yy'; type CalendarKey = 'sameDay' | 'nextDay' | 'lastDay' | 'nextWeek' | 'lastWeek' | 'sameElse' | string; type LongDateFormatKey = 'LTS' | 'LT' | 'L' | 'LL' | 'LLL' | 'LLLL' | 'lts' | 'lt' | 'l' | 'll' | 'lll' | 'llll'; interface Locale { calendar(key?: CalendarKey, m?: Moment, now?: Moment): string; longDateFormat(key: LongDateFormatKey): string; invalidDate(): string; ordinal(n: number): string; preparse(inp: string): string; postformat(inp: string): string; relativeTime(n: number, withoutSuffix: boolean, key: RelativeTimeKey, isFuture: boolean): string; pastFuture(diff: number, absRelTime: string): string; set(config: Object): void; months(): string[]; months(m: Moment, format?: string): string; monthsShort(): string[]; monthsShort(m: Moment, format?: string): string; monthsParse(monthName: string, format: string, strict: boolean): number; monthsRegex(strict: boolean): RegExp; monthsShortRegex(strict: boolean): RegExp; week(m: Moment): number; firstDayOfYear(): number; firstDayOfWeek(): number; weekdays(): string[]; weekdays(m: Moment, format?: string): string; weekdaysMin(): string[]; weekdaysMin(m: Moment): string; weekdaysShort(): string[]; weekdaysShort(m: Moment): string; weekdaysParse(weekdayName: string, format: string, strict: boolean): number; weekdaysRegex(strict: boolean): RegExp; weekdaysShortRegex(strict: boolean): RegExp; weekdaysMinRegex(strict: boolean): RegExp; isPM(input: string): boolean; meridiem(hour: number, minute: number, isLower: boolean): string; } interface StandaloneFormatSpec { format: string[]; standalone: string[]; isFormat?: RegExp; } interface WeekSpec { dow: number; doy?: number; } type CalendarSpecVal = string | ((m?: MomentInput, now?: Moment) => string); interface CalendarSpec { sameDay?: CalendarSpecVal; nextDay?: CalendarSpecVal; lastDay?: CalendarSpecVal; nextWeek?: CalendarSpecVal; lastWeek?: CalendarSpecVal; sameElse?: CalendarSpecVal; // any additional properties might be used with moment.calendarFormat [x: string]: CalendarSpecVal | undefined; } type RelativeTimeSpecVal = ( string | ((n: number, withoutSuffix: boolean, key: RelativeTimeKey, isFuture: boolean) => string) ); type RelativeTimeFuturePastVal = string | ((relTime: string) => string); interface RelativeTimeSpec { future?: RelativeTimeFuturePastVal; past?: RelativeTimeFuturePastVal; s?: RelativeTimeSpecVal; ss?: RelativeTimeSpecVal; m?: RelativeTimeSpecVal; mm?: RelativeTimeSpecVal; h?: RelativeTimeSpecVal; hh?: RelativeTimeSpecVal; d?: RelativeTimeSpecVal; dd?: RelativeTimeSpecVal; w?: RelativeTimeSpecVal; ww?: RelativeTimeSpecVal; M?: RelativeTimeSpecVal; MM?: RelativeTimeSpecVal; y?: RelativeTimeSpecVal; yy?: RelativeTimeSpecVal; } interface LongDateFormatSpec { LTS: string; LT: string; L: string; LL: string; LLL: string; LLLL: string; // lets forget for a sec that any upper/lower permutation will also work lts?: string; lt?: string; l?: string; ll?: string; lll?: string; llll?: string; } type MonthWeekdayFn = (momentToFormat: Moment, format?: string) => string; type WeekdaySimpleFn = (momentToFormat: Moment) => string; interface LocaleSpecification { months?: string[] | StandaloneFormatSpec | MonthWeekdayFn; monthsShort?: string[] | StandaloneFormatSpec | MonthWeekdayFn; weekdays?: string[] | StandaloneFormatSpec | MonthWeekdayFn; weekdaysShort?: string[] | StandaloneFormatSpec | WeekdaySimpleFn; weekdaysMin?: string[] | StandaloneFormatSpec | WeekdaySimpleFn; meridiemParse?: RegExp; meridiem?: (hour: number, minute:number, isLower: boolean) => string; isPM?: (input: string) => boolean; longDateFormat?: LongDateFormatSpec; calendar?: CalendarSpec; relativeTime?: RelativeTimeSpec; invalidDate?: string; ordinal?: (n: number) => string; ordinalParse?: RegExp; week?: WeekSpec; // Allow anything: in general any property that is passed as locale spec is // put in the locale object so it can be used by locale functions [x: string]: any; } interface MomentObjectOutput { years: number; /* One digit */ months: number; /* Day of the month */ date: number; hours: number; minutes: number; seconds: number; milliseconds: number; } interface argThresholdOpts { ss?: number; s?: number; m?: number; h?: number; d?: number; w?: number | null; M?: number; } interface Duration { clone(): Duration; humanize(argWithSuffix?: boolean, argThresholds?: argThresholdOpts): string; humanize(argThresholds?: argThresholdOpts): string; abs(): Duration; as(units: unitOfTime.Base): number; get(units: unitOfTime.Base): number; milliseconds(): number; asMilliseconds(): number; seconds(): number; asSeconds(): number; minutes(): number; asMinutes(): number; hours(): number; asHours(): number; days(): number; asDays(): number; weeks(): number; asWeeks(): number; months(): number; asMonths(): number; years(): number; asYears(): number; add(inp?: DurationInputArg1, unit?: DurationInputArg2): Duration; subtract(inp?: DurationInputArg1, unit?: DurationInputArg2): Duration; locale(): string; locale(locale: LocaleSpecifier): Duration; localeData(): Locale; toISOString(): string; toJSON(): string; isValid(): boolean; /** * @deprecated since version 2.8.0 */ lang(locale: LocaleSpecifier): Moment; /** * @deprecated since version 2.8.0 */ lang(): Locale; /** * @deprecated */ toIsoString(): string; } interface MomentRelativeTime { future: any; past: any; s: any; ss: any; m: any; mm: any; h: any; hh: any; d: any; dd: any; M: any; MM: any; y: any; yy: any; } interface MomentLongDateFormat { L: string; LL: string; LLL: string; LLLL: string; LT: string; LTS: string; l?: string; ll?: string; lll?: string; llll?: string; lt?: string; lts?: string; } interface MomentParsingFlags { empty: boolean; unusedTokens: string[]; unusedInput: string[]; overflow: number; charsLeftOver: number; nullInput: boolean; invalidMonth: string | null; invalidFormat: boolean; userInvalidated: boolean; iso: boolean; parsedDateParts: any[]; meridiem: string | null; } interface MomentParsingFlagsOpt { empty?: boolean; unusedTokens?: string[]; unusedInput?: string[]; overflow?: number; charsLeftOver?: number; nullInput?: boolean; invalidMonth?: string; invalidFormat?: boolean; userInvalidated?: boolean; iso?: boolean; parsedDateParts?: any[]; meridiem?: string | null; } interface MomentBuiltinFormat { __momentBuiltinFormatBrand: any; } type MomentFormatSpecification = string | MomentBuiltinFormat | (string | MomentBuiltinFormat)[]; namespace unitOfTime { type Base = ( "year" | "years" | "y" | "month" | "months" | "M" | "week" | "weeks" | "w" | "day" | "days" | "d" | "hour" | "hours" | "h" | "minute" | "minutes" | "m" | "second" | "seconds" | "s" | "millisecond" | "milliseconds" | "ms" ); type _quarter = "quarter" | "quarters" | "Q"; type _isoWeek = "isoWeek" | "isoWeeks" | "W"; type _date = "date" | "dates" | "D"; type DurationConstructor = Base | _quarter; type DurationAs = Base; type StartOf = Base | _quarter | _isoWeek | _date | null; type Diff = Base | _quarter; type MomentConstructor = Base | _date; type All = Base | _quarter | _isoWeek | _date | "weekYear" | "weekYears" | "gg" | "isoWeekYear" | "isoWeekYears" | "GG" | "dayOfYear" | "dayOfYears" | "DDD" | "weekday" | "weekdays" | "e" | "isoWeekday" | "isoWeekdays" | "E"; } interface MomentInputObject { years?: number; year?: number; y?: number; months?: number; month?: number; M?: number; days?: number; day?: number; d?: number; dates?: number; date?: number; D?: number; hours?: number; hour?: number; h?: number; minutes?: number; minute?: number; m?: number; seconds?: number; second?: number; s?: number; milliseconds?: number; millisecond?: number; ms?: number; } interface DurationInputObject extends MomentInputObject { quarters?: number; quarter?: number; Q?: number; weeks?: number; week?: number; w?: number; } interface MomentSetObject extends MomentInputObject { weekYears?: number; weekYear?: number; gg?: number; isoWeekYears?: number; isoWeekYear?: number; GG?: number; quarters?: number; quarter?: number; Q?: number; weeks?: number; week?: number; w?: number; isoWeeks?: number; isoWeek?: number; W?: number; dayOfYears?: number; dayOfYear?: number; DDD?: number; weekdays?: number; weekday?: number; e?: number; isoWeekdays?: number; isoWeekday?: number; E?: number; } interface FromTo { from: MomentInput; to: MomentInput; } type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | null | undefined; type DurationInputArg1 = Duration | number | string | FromTo | DurationInputObject | null | undefined; type DurationInputArg2 = unitOfTime.DurationConstructor; type LocaleSpecifier = string | Moment | Duration | string[] | boolean; interface MomentCreationData { input: MomentInput; format?: MomentFormatSpecification; locale: Locale; isUTC: boolean; strict?: boolean; } interface Moment extends Object { format(format?: string): string; startOf(unitOfTime: unitOfTime.StartOf): Moment; endOf(unitOfTime: unitOfTime.StartOf): Moment; add(amount?: DurationInputArg1, unit?: DurationInputArg2): Moment; /** * @deprecated reverse syntax */ add(unit: unitOfTime.DurationConstructor, amount: number|string): Moment; subtract(amount?: DurationInputArg1, unit?: DurationInputArg2): Moment; /** * @deprecated reverse syntax */ subtract(unit: unitOfTime.DurationConstructor, amount: number|string): Moment; calendar(): string; calendar(formats: CalendarSpec): string; calendar(time?: MomentInput, formats?: CalendarSpec): string; clone(): Moment; /** * @return Unix timestamp in milliseconds */ valueOf(): number; // current date/time in local mode local(keepLocalTime?: boolean): Moment; isLocal(): boolean; // current date/time in UTC mode utc(keepLocalTime?: boolean): Moment; isUTC(): boolean; /** * @deprecated use isUTC */ isUtc(): boolean; parseZone(): Moment; isValid(): boolean; invalidAt(): number; hasAlignedHourOffset(other?: MomentInput): boolean; creationData(): MomentCreationData; parsingFlags(): MomentParsingFlags; year(y: number): Moment; year(): number; /** * @deprecated use year(y) */ years(y: number): Moment; /** * @deprecated use year() */ years(): number; quarter(): number; quarter(q: number): Moment; quarters(): number; quarters(q: number): Moment; month(M: number|string): Moment; month(): number; /** * @deprecated use month(M) */ months(M: number|string): Moment; /** * @deprecated use month() */ months(): number; day(d: number|string): Moment; day(): number; days(d: number|string): Moment; days(): number; date(d: number): Moment; date(): number; /** * @deprecated use date(d) */ dates(d: number): Moment; /** * @deprecated use date() */ dates(): number; hour(h: number): Moment; hour(): number; hours(h: number): Moment; hours(): number; minute(m: number): Moment; minute(): number; minutes(m: number): Moment; minutes(): number; second(s: number): Moment; second(): number; seconds(s: number): Moment; seconds(): number; millisecond(ms: number): Moment; millisecond(): number; milliseconds(ms: number): Moment; milliseconds(): number; weekday(): number; weekday(d: number): Moment; isoWeekday(): number; isoWeekday(d: number|string): Moment; weekYear(): number; weekYear(d: number): Moment; isoWeekYear(): number; isoWeekYear(d: number): Moment; week(): number; week(d: number): Moment; weeks(): number; weeks(d: number): Moment; isoWeek(): number; isoWeek(d: number): Moment; isoWeeks(): number; isoWeeks(d: number): Moment; weeksInYear(): number; isoWeeksInYear(): number; isoWeeksInISOWeekYear(): number; dayOfYear(): number; dayOfYear(d: number): Moment; from(inp: MomentInput, suffix?: boolean): string; to(inp: MomentInput, suffix?: boolean): string; fromNow(withoutSuffix?: boolean): string; toNow(withoutPrefix?: boolean): string; diff(b: MomentInput, unitOfTime?: unitOfTime.Diff, precise?: boolean): number; toArray(): [number, number, number, number, number, number, number]; toDate(): Date; toISOString(keepOffset?: boolean): string; inspect(): string; toJSON(): string; unix(): number; isLeapYear(): boolean; /** * @deprecated in favor of utcOffset */ zone(): number; zone(b: number|string): Moment; utcOffset(): number; utcOffset(b: number|string, keepLocalTime?: boolean): Moment; isUtcOffset(): boolean; daysInMonth(): number; isDST(): boolean; zoneAbbr(): string; zoneName(): string; isBefore(inp?: MomentInput, granularity?: unitOfTime.StartOf): boolean; isAfter(inp?: MomentInput, granularity?: unitOfTime.StartOf): boolean; isSame(inp?: MomentInput, granularity?: unitOfTime.StartOf): boolean; isSameOrAfter(inp?: MomentInput, granularity?: unitOfTime.StartOf): boolean; isSameOrBefore(inp?: MomentInput, granularity?: unitOfTime.StartOf): boolean; isBetween(a: MomentInput, b: MomentInput, granularity?: unitOfTime.StartOf, inclusivity?: "()" | "[)" | "(]" | "[]"): boolean; /** * @deprecated as of 2.8.0, use locale */ lang(language: LocaleSpecifier): Moment; /** * @deprecated as of 2.8.0, use locale */ lang(): Locale; locale(): string; locale(locale: LocaleSpecifier): Moment; localeData(): Locale; /** * @deprecated no reliable implementation */ isDSTShifted(): boolean; // NOTE(constructor): Same as moment constructor /** * @deprecated as of 2.7.0, use moment.min/max */ max(inp?: MomentInput, format?: MomentFormatSpecification, strict?: boolean): Moment; /** * @deprecated as of 2.7.0, use moment.min/max */ max(inp?: MomentInput, format?: MomentFormatSpecification, language?: string, strict?: boolean): Moment; // NOTE(constructor): Same as moment constructor /** * @deprecated as of 2.7.0, use moment.min/max */ min(inp?: MomentInput, format?: MomentFormatSpecification, strict?: boolean): Moment; /** * @deprecated as of 2.7.0, use moment.min/max */ min(inp?: MomentInput, format?: MomentFormatSpecification, language?: string, strict?: boolean): Moment; get(unit: unitOfTime.All): number; set(unit: unitOfTime.All, value: number): Moment; set(objectLiteral: MomentSetObject): Moment; toObject(): MomentObjectOutput; } export var version: string; export var fn: Moment; // NOTE(constructor): Same as moment constructor /** * @param strict Strict parsing disables the deprecated fallback to the native Date constructor when * parsing a string. */ export function utc(inp?: MomentInput, strict?: boolean): Moment; /** * @param strict Strict parsing requires that the format and input match exactly, including delimiters. * Strict parsing is frequently the best parsing option. For more information about choosing strict vs * forgiving parsing, see the [parsing guide](https://momentjs.com/guides/#/parsing/). */ export function utc(inp?: MomentInput, format?: MomentFormatSpecification, strict?: boolean): Moment; /** * @param strict Strict parsing requires that the format and input match exactly, including delimiters. * Strict parsing is frequently the best parsing option. For more information about choosing strict vs * forgiving parsing, see the [parsing guide](https://momentjs.com/guides/#/parsing/). */ export function utc(inp?: MomentInput, format?: MomentFormatSpecification, language?: string, strict?: boolean): Moment; export function unix(timestamp: number): Moment; export function invalid(flags?: MomentParsingFlagsOpt): Moment; export function isMoment(m: any): m is Moment; export function isDate(m: any): m is Date; export function isDuration(d: any): d is Duration; /** * @deprecated in 2.8.0 */ export function lang(language?: string): string; /** * @deprecated in 2.8.0 */ export function lang(language?: string, definition?: Locale): string; export function locale(language?: string): string; export function locale(language?: string[]): string; export function locale(language?: string, definition?: LocaleSpecification | null | undefined): string; export function localeData(key?: string | string[]): Locale; export function duration(inp?: DurationInputArg1, unit?: DurationInputArg2): Duration; // NOTE(constructor): Same as moment constructor export function parseZone(inp?: MomentInput, format?: MomentFormatSpecification, strict?: boolean): Moment; export function parseZone(inp?: MomentInput, format?: MomentFormatSpecification, language?: string, strict?: boolean): Moment; export function months(): string[]; export function months(index: number): string; export function months(format: string): string[]; export function months(format: string, index: number): string; export function monthsShort(): string[]; export function monthsShort(index: number): string; export function monthsShort(format: string): string[]; export function monthsShort(format: string, index: number): string; export function weekdays(): string[]; export function weekdays(index: number): string; export function weekdays(format: string): string[]; export function weekdays(format: string, index: number): string; export function weekdays(localeSorted: boolean): string[]; export function weekdays(localeSorted: boolean, index: number): string; export function weekdays(localeSorted: boolean, format: string): string[]; export function weekdays(localeSorted: boolean, format: string, index: number): string; export function weekdaysShort(): string[]; export function weekdaysShort(index: number): string; export function weekdaysShort(format: string): string[]; export function weekdaysShort(format: string, index: number): string; export function weekdaysShort(localeSorted: boolean): string[]; export function weekdaysShort(localeSorted: boolean, index: number): string; export function weekdaysShort(localeSorted: boolean, format: string): string[]; export function weekdaysShort(localeSorted: boolean, format: string, index: number): string; export function weekdaysMin(): string[]; export function weekdaysMin(index: number): string; export function weekdaysMin(format: string): string[]; export function weekdaysMin(format: string, index: number): string; export function weekdaysMin(localeSorted: boolean): string[]; export function weekdaysMin(localeSorted: boolean, index: number): string; export function weekdaysMin(localeSorted: boolean, format: string): string[]; export function weekdaysMin(localeSorted: boolean, format: string, index: number): string; export function min(moments: Moment[]): Moment; export function min(...moments: Moment[]): Moment; export function max(moments: Moment[]): Moment; export function max(...moments: Moment[]): Moment; /** * Returns unix time in milliseconds. Overwrite for profit. */ export function now(): number; export function defineLocale(language: string, localeSpec: LocaleSpecification | null): Locale; export function updateLocale(language: string, localeSpec: LocaleSpecification | null): Locale; export function locales(): string[]; export function normalizeUnits(unit: unitOfTime.All): string; export function relativeTimeThreshold(threshold: string): number | boolean; export function relativeTimeThreshold(threshold: string, limit: number): boolean; export function relativeTimeRounding(fn: (num: number) => number): boolean; export function relativeTimeRounding(): (num: number) => number; export function calendarFormat(m: Moment, now: Moment): string; export function parseTwoDigitYear(input: string): number; /** * Constant used to enable explicit ISO_8601 format parsing. */ export var ISO_8601: MomentBuiltinFormat; export var RFC_2822: MomentBuiltinFormat; export var defaultFormat: string; export var defaultFormatUtc: string; export var suppressDeprecationWarnings: boolean; export var deprecationHandler: ((name: string | null, msg: string) => void) | null | undefined; export var HTML5_FMT: { DATETIME_LOCAL: string, DATETIME_LOCAL_SECONDS: string, DATETIME_LOCAL_MS: string, DATE: string, TIME: string, TIME_SECONDS: string, TIME_MS: string, WEEK: string, MONTH: string }; } declare global { const moment: typeof moment; }