moment

  • Version 2.29.1
  • Published
  • 4.21 MB
  • No dependencies
  • MIT license

Install

npm i moment
yarn add moment
pnpm add moment

Overview

Parse, validate, manipulate, and display dates

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

variable defaultFormat

var defaultFormat: string;

    variable defaultFormatUtc

    var defaultFormatUtc: string;

      variable deprecationHandler

      var deprecationHandler: void | ((name: string | void, msg: string) => void);

        variable fn

        var fn: Moment;

          variable HTML5_FMT

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

            variable ISO_8601

            var ISO_8601: MomentBuiltinFormat;
            • Constant used to enable explicit ISO_8601 format parsing.

            variable RFC_2822

            var RFC_2822: MomentBuiltinFormat;

              variable suppressDeprecationWarnings

              var suppressDeprecationWarnings: boolean;

                variable version

                var version: string;

                  Functions

                  function calendarFormat

                  calendarFormat: (m: Moment, now: Moment) => string;

                    function defineLocale

                    defineLocale: (
                    language: string,
                    localeSpec: LocaleSpecification | void
                    ) => Locale;

                      function duration

                      duration: (inp?: DurationInputArg1, unit?: DurationInputArg2) => Duration;

                        function invalid

                        invalid: (flags?: MomentParsingFlagsOpt) => Moment;

                          function isDate

                          isDate: (m: any) => m is Date;

                            function isDuration

                            isDuration: (d: any) => d is Duration;

                              function isMoment

                              isMoment: (m: any) => m is Moment;

                                function lang

                                lang: {
                                (language?: string): string;
                                (language?: string, definition?: Locale): string;
                                };
                                • Deprecated

                                  in 2.8.0

                                function locale

                                locale: {
                                (language?: string): string;
                                (language?: string[]): string;
                                (language?: string, definition?: void | LocaleSpecification): string;
                                };

                                  function localeData

                                  localeData: (key?: string | string[]) => Locale;

                                    function locales

                                    locales: () => string[];

                                      function max

                                      max: { (moments: Moment[]): Moment; (...moments: Moment[]): Moment };

                                        function min

                                        min: { (moments: Moment[]): Moment; (...moments: Moment[]): Moment };

                                          function moment

                                          moment: typeof moment;
                                          • Parameter strict

                                            Strict parsing disables the deprecated fallback to the native Date constructor when parsing a string.

                                          • Parameter 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/).

                                          function months

                                          months: {
                                          (): string[];
                                          (index: number): string;
                                          (format: string): string[];
                                          (format: string, index: number): string;
                                          };

                                            function monthsShort

                                            monthsShort: {
                                            (): string[];
                                            (index: number): string;
                                            (format: string): string[];
                                            (format: string, index: number): string;
                                            };

                                              function normalizeUnits

                                              normalizeUnits: (unit: unitOfTime.All) => string;

                                                function now

                                                now: () => number;
                                                • Returns unix time in milliseconds. Overwrite for profit.

                                                function parseTwoDigitYear

                                                parseTwoDigitYear: (input: string) => number;

                                                  function parseZone

                                                  parseZone: {
                                                  (
                                                  inp?: MomentInput,
                                                  format?: MomentFormatSpecification,
                                                  strict?: boolean
                                                  ): Moment;
                                                  (
                                                  inp?: MomentInput,
                                                  format?: MomentFormatSpecification,
                                                  language?: string,
                                                  strict?: boolean
                                                  ): Moment;
                                                  };

                                                    function relativeTimeRounding

                                                    relativeTimeRounding: {
                                                    (fn: (num: number) => number): boolean;
                                                    (): (num: number) => number;
                                                    };

                                                      function relativeTimeThreshold

                                                      relativeTimeThreshold: {
                                                      (threshold: string): number | boolean;
                                                      (threshold: string, limit: number): boolean;
                                                      };

                                                        function unix

                                                        unix: (timestamp: number) => Moment;

                                                          function updateLocale

                                                          updateLocale: (
                                                          language: string,
                                                          localeSpec: LocaleSpecification | void
                                                          ) => Locale;

                                                            function utc

                                                            utc: {
                                                            (inp?: MomentInput, strict?: boolean): Moment;
                                                            (
                                                            inp?: MomentInput,
                                                            format?: MomentFormatSpecification,
                                                            strict?: boolean
                                                            ): Moment;
                                                            (
                                                            inp?: MomentInput,
                                                            format?: MomentFormatSpecification,
                                                            language?: string,
                                                            strict?: boolean
                                                            ): Moment;
                                                            };
                                                            • Parameter strict

                                                              Strict parsing disables the deprecated fallback to the native Date constructor when parsing a string.

                                                            • Parameter 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/).

                                                            function weekdays

                                                            weekdays: {
                                                            (): string[];
                                                            (index: number): string;
                                                            (format: string): string[];
                                                            (format: string, index: number): string;
                                                            (localeSorted: boolean): string[];
                                                            (localeSorted: boolean, index: number): string;
                                                            (localeSorted: boolean, format: string): string[];
                                                            (localeSorted: boolean, format: string, index: number): string;
                                                            };

                                                              function weekdaysMin

                                                              weekdaysMin: {
                                                              (): string[];
                                                              (index: number): string;
                                                              (format: string): string[];
                                                              (format: string, index: number): string;
                                                              (localeSorted: boolean): string[];
                                                              (localeSorted: boolean, index: number): string;
                                                              (localeSorted: boolean, format: string): string[];
                                                              (localeSorted: boolean, format: string, index: number): string;
                                                              };

                                                                function weekdaysShort

                                                                weekdaysShort: {
                                                                (): string[];
                                                                (index: number): string;
                                                                (format: string): string[];
                                                                (format: string, index: number): string;
                                                                (localeSorted: boolean): string[];
                                                                (localeSorted: boolean, index: number): string;
                                                                (localeSorted: boolean, format: string): string[];
                                                                (localeSorted: boolean, format: string, index: number): string;
                                                                };

                                                                  Interfaces

                                                                  interface argThresholdOpts

                                                                  interface argThresholdOpts {}

                                                                    property d

                                                                    d?: number;

                                                                      property h

                                                                      h?: number;

                                                                        property m

                                                                        m?: number;

                                                                          property M

                                                                          M?: number;

                                                                            property s

                                                                            s?: number;

                                                                              property ss

                                                                              ss?: number;

                                                                                property w

                                                                                w?: number | void;

                                                                                  interface CalendarSpec

                                                                                  interface CalendarSpec {}

                                                                                    property lastDay

                                                                                    lastDay?: CalendarSpecVal;

                                                                                      property lastWeek

                                                                                      lastWeek?: CalendarSpecVal;

                                                                                        property nextDay

                                                                                        nextDay?: CalendarSpecVal;

                                                                                          property nextWeek

                                                                                          nextWeek?: CalendarSpecVal;

                                                                                            property sameDay

                                                                                            sameDay?: CalendarSpecVal;

                                                                                              property sameElse

                                                                                              sameElse?: CalendarSpecVal;

                                                                                                index signature

                                                                                                [x: string]: CalendarSpecVal | void;

                                                                                                  interface Duration

                                                                                                  interface Duration {}

                                                                                                    method abs

                                                                                                    abs: () => Duration;

                                                                                                      method add

                                                                                                      add: (inp?: DurationInputArg1, unit?: DurationInputArg2) => Duration;

                                                                                                        method as

                                                                                                        as: (units: unitOfTime.Base) => number;

                                                                                                          method asDays

                                                                                                          asDays: () => number;

                                                                                                            method asHours

                                                                                                            asHours: () => number;

                                                                                                              method asMilliseconds

                                                                                                              asMilliseconds: () => number;

                                                                                                                method asMinutes

                                                                                                                asMinutes: () => number;

                                                                                                                  method asMonths

                                                                                                                  asMonths: () => number;

                                                                                                                    method asSeconds

                                                                                                                    asSeconds: () => number;

                                                                                                                      method asWeeks

                                                                                                                      asWeeks: () => number;

                                                                                                                        method asYears

                                                                                                                        asYears: () => number;

                                                                                                                          method clone

                                                                                                                          clone: () => Duration;

                                                                                                                            method days

                                                                                                                            days: () => number;

                                                                                                                              method get

                                                                                                                              get: (units: unitOfTime.Base) => number;

                                                                                                                                method hours

                                                                                                                                hours: () => number;

                                                                                                                                  method humanize

                                                                                                                                  humanize: {
                                                                                                                                  (argWithSuffix?: boolean, argThresholds?: argThresholdOpts): string;
                                                                                                                                  (argThresholds?: argThresholdOpts): string;
                                                                                                                                  };

                                                                                                                                    method isValid

                                                                                                                                    isValid: () => boolean;

                                                                                                                                      method lang

                                                                                                                                      lang: { (locale: LocaleSpecifier): Moment; (): Locale };
                                                                                                                                      • Deprecated

                                                                                                                                        since version 2.8.0

                                                                                                                                      method locale

                                                                                                                                      locale: { (): string; (locale: LocaleSpecifier): Duration };

                                                                                                                                        method localeData

                                                                                                                                        localeData: () => Locale;

                                                                                                                                          method milliseconds

                                                                                                                                          milliseconds: () => number;

                                                                                                                                            method minutes

                                                                                                                                            minutes: () => number;

                                                                                                                                              method months

                                                                                                                                              months: () => number;

                                                                                                                                                method seconds

                                                                                                                                                seconds: () => number;

                                                                                                                                                  method subtract

                                                                                                                                                  subtract: (inp?: DurationInputArg1, unit?: DurationInputArg2) => Duration;

                                                                                                                                                    method toIsoString

                                                                                                                                                    toIsoString: () => string;
                                                                                                                                                    • Deprecated

                                                                                                                                                    method toISOString

                                                                                                                                                    toISOString: () => string;

                                                                                                                                                      method toJSON

                                                                                                                                                      toJSON: () => string;

                                                                                                                                                        method weeks

                                                                                                                                                        weeks: () => number;

                                                                                                                                                          method years

                                                                                                                                                          years: () => number;

                                                                                                                                                            interface DurationInputObject

                                                                                                                                                            interface DurationInputObject extends MomentInputObject {}

                                                                                                                                                              property Q

                                                                                                                                                              Q?: numberlike;

                                                                                                                                                                property quarter

                                                                                                                                                                quarter?: numberlike;

                                                                                                                                                                  property quarters

                                                                                                                                                                  quarters?: numberlike;

                                                                                                                                                                    property w

                                                                                                                                                                    w?: numberlike;

                                                                                                                                                                      property week

                                                                                                                                                                      week?: numberlike;

                                                                                                                                                                        property weeks

                                                                                                                                                                        weeks?: numberlike;

                                                                                                                                                                          interface EraSpec

                                                                                                                                                                          interface EraSpec {}

                                                                                                                                                                            property abbr

                                                                                                                                                                            abbr: string;

                                                                                                                                                                              property name

                                                                                                                                                                              name: string;

                                                                                                                                                                                property narrow

                                                                                                                                                                                narrow: string;

                                                                                                                                                                                  property offset

                                                                                                                                                                                  offset: number;

                                                                                                                                                                                    property since

                                                                                                                                                                                    since: string | number;

                                                                                                                                                                                      property until

                                                                                                                                                                                      until: string | number;

                                                                                                                                                                                        interface FromTo

                                                                                                                                                                                        interface FromTo {}

                                                                                                                                                                                          property from

                                                                                                                                                                                          from: MomentInput;

                                                                                                                                                                                            property to

                                                                                                                                                                                            to: MomentInput;

                                                                                                                                                                                              interface Locale

                                                                                                                                                                                              interface Locale {}

                                                                                                                                                                                                method calendar

                                                                                                                                                                                                calendar: (key?: CalendarKey, m?: Moment, now?: Moment) => string;

                                                                                                                                                                                                  method firstDayOfWeek

                                                                                                                                                                                                  firstDayOfWeek: () => number;

                                                                                                                                                                                                    method firstDayOfYear

                                                                                                                                                                                                    firstDayOfYear: () => number;

                                                                                                                                                                                                      method invalidDate

                                                                                                                                                                                                      invalidDate: () => string;

                                                                                                                                                                                                        method isPM

                                                                                                                                                                                                        isPM: (input: string) => boolean;

                                                                                                                                                                                                          method longDateFormat

                                                                                                                                                                                                          longDateFormat: (key: LongDateFormatKey) => string;

                                                                                                                                                                                                            method meridiem

                                                                                                                                                                                                            meridiem: (hour: number, minute: number, isLower: boolean) => string;

                                                                                                                                                                                                              method months

                                                                                                                                                                                                              months: { (): string[]; (m: Moment, format?: string): string };

                                                                                                                                                                                                                method monthsParse

                                                                                                                                                                                                                monthsParse: (monthName: string, format: string, strict: boolean) => number;

                                                                                                                                                                                                                  method monthsRegex

                                                                                                                                                                                                                  monthsRegex: (strict: boolean) => RegExp;

                                                                                                                                                                                                                    method monthsShort

                                                                                                                                                                                                                    monthsShort: { (): string[]; (m: Moment, format?: string): string };

                                                                                                                                                                                                                      method monthsShortRegex

                                                                                                                                                                                                                      monthsShortRegex: (strict: boolean) => RegExp;

                                                                                                                                                                                                                        method ordinal

                                                                                                                                                                                                                        ordinal: (n: number) => string;

                                                                                                                                                                                                                          method pastFuture

                                                                                                                                                                                                                          pastFuture: (diff: number, absRelTime: string) => string;

                                                                                                                                                                                                                            method postformat

                                                                                                                                                                                                                            postformat: (inp: string) => string;

                                                                                                                                                                                                                              method preparse

                                                                                                                                                                                                                              preparse: (inp: string) => string;

                                                                                                                                                                                                                                method relativeTime

                                                                                                                                                                                                                                relativeTime: (
                                                                                                                                                                                                                                n: number,
                                                                                                                                                                                                                                withoutSuffix: boolean,
                                                                                                                                                                                                                                key: RelativeTimeKey,
                                                                                                                                                                                                                                isFuture: boolean
                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                  method set

                                                                                                                                                                                                                                  set: (config: Object) => void;

                                                                                                                                                                                                                                    method week

                                                                                                                                                                                                                                    week: (m: Moment) => number;

                                                                                                                                                                                                                                      method weekdays

                                                                                                                                                                                                                                      weekdays: { (): string[]; (m: Moment, format?: string): string };

                                                                                                                                                                                                                                        method weekdaysMin

                                                                                                                                                                                                                                        weekdaysMin: { (): string[]; (m: Moment): string };

                                                                                                                                                                                                                                          method weekdaysMinRegex

                                                                                                                                                                                                                                          weekdaysMinRegex: (strict: boolean) => RegExp;

                                                                                                                                                                                                                                            method weekdaysParse

                                                                                                                                                                                                                                            weekdaysParse: (weekdayName: string, format: string, strict: boolean) => number;

                                                                                                                                                                                                                                              method weekdaysRegex

                                                                                                                                                                                                                                              weekdaysRegex: (strict: boolean) => RegExp;

                                                                                                                                                                                                                                                method weekdaysShort

                                                                                                                                                                                                                                                weekdaysShort: { (): string[]; (m: Moment): string };

                                                                                                                                                                                                                                                  method weekdaysShortRegex

                                                                                                                                                                                                                                                  weekdaysShortRegex: (strict: boolean) => RegExp;

                                                                                                                                                                                                                                                    interface LocaleSpecification

                                                                                                                                                                                                                                                    interface LocaleSpecification {}

                                                                                                                                                                                                                                                      property calendar

                                                                                                                                                                                                                                                      calendar?: CalendarSpec;

                                                                                                                                                                                                                                                        property eras

                                                                                                                                                                                                                                                        eras?: EraSpec[];

                                                                                                                                                                                                                                                          property invalidDate

                                                                                                                                                                                                                                                          invalidDate?: string;

                                                                                                                                                                                                                                                            property isPM

                                                                                                                                                                                                                                                            isPM?: (input: string) => boolean;

                                                                                                                                                                                                                                                              property longDateFormat

                                                                                                                                                                                                                                                              longDateFormat?: LongDateFormatSpec;

                                                                                                                                                                                                                                                                property meridiem

                                                                                                                                                                                                                                                                meridiem?: (hour: number, minute: number, isLower: boolean) => string;

                                                                                                                                                                                                                                                                  property meridiemParse

                                                                                                                                                                                                                                                                  meridiemParse?: RegExp;

                                                                                                                                                                                                                                                                    property months

                                                                                                                                                                                                                                                                    months?: string[] | StandaloneFormatSpec | MonthWeekdayFn;

                                                                                                                                                                                                                                                                      property monthsShort

                                                                                                                                                                                                                                                                      monthsShort?: string[] | StandaloneFormatSpec | MonthWeekdayFn;

                                                                                                                                                                                                                                                                        property ordinal

                                                                                                                                                                                                                                                                        ordinal?: (n: number) => string;

                                                                                                                                                                                                                                                                          property ordinalParse

                                                                                                                                                                                                                                                                          ordinalParse?: RegExp;

                                                                                                                                                                                                                                                                            property relativeTime

                                                                                                                                                                                                                                                                            relativeTime?: RelativeTimeSpec;

                                                                                                                                                                                                                                                                              property week

                                                                                                                                                                                                                                                                              week?: WeekSpec;

                                                                                                                                                                                                                                                                                property weekdays

                                                                                                                                                                                                                                                                                weekdays?: string[] | StandaloneFormatSpec | MonthWeekdayFn;

                                                                                                                                                                                                                                                                                  property weekdaysMin

                                                                                                                                                                                                                                                                                  weekdaysMin?: string[] | StandaloneFormatSpec | WeekdaySimpleFn;

                                                                                                                                                                                                                                                                                    property weekdaysShort

                                                                                                                                                                                                                                                                                    weekdaysShort?: string[] | StandaloneFormatSpec | WeekdaySimpleFn;

                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                      [x: string]: any;

                                                                                                                                                                                                                                                                                        interface LongDateFormatSpec

                                                                                                                                                                                                                                                                                        interface LongDateFormatSpec {}

                                                                                                                                                                                                                                                                                          property l

                                                                                                                                                                                                                                                                                          l?: string;

                                                                                                                                                                                                                                                                                            property L

                                                                                                                                                                                                                                                                                            L: string;

                                                                                                                                                                                                                                                                                              property ll

                                                                                                                                                                                                                                                                                              ll?: string;

                                                                                                                                                                                                                                                                                                property LL

                                                                                                                                                                                                                                                                                                LL: string;

                                                                                                                                                                                                                                                                                                  property lll

                                                                                                                                                                                                                                                                                                  lll?: string;

                                                                                                                                                                                                                                                                                                    property LLL

                                                                                                                                                                                                                                                                                                    LLL: string;

                                                                                                                                                                                                                                                                                                      property llll

                                                                                                                                                                                                                                                                                                      llll?: string;

                                                                                                                                                                                                                                                                                                        property LLLL

                                                                                                                                                                                                                                                                                                        LLLL: string;

                                                                                                                                                                                                                                                                                                          property lt

                                                                                                                                                                                                                                                                                                          lt?: string;

                                                                                                                                                                                                                                                                                                            property LT

                                                                                                                                                                                                                                                                                                            LT: string;

                                                                                                                                                                                                                                                                                                              property lts

                                                                                                                                                                                                                                                                                                              lts?: string;

                                                                                                                                                                                                                                                                                                                property LTS

                                                                                                                                                                                                                                                                                                                LTS: string;

                                                                                                                                                                                                                                                                                                                  interface Moment

                                                                                                                                                                                                                                                                                                                  interface Moment extends Object {}

                                                                                                                                                                                                                                                                                                                    method add

                                                                                                                                                                                                                                                                                                                    add: {
                                                                                                                                                                                                                                                                                                                    (amount?: DurationInputArg1, unit?: DurationInputArg2): Moment;
                                                                                                                                                                                                                                                                                                                    (unit: unitOfTime.DurationConstructor, amount: string | number): Moment;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                      reverse syntax

                                                                                                                                                                                                                                                                                                                    method calendar

                                                                                                                                                                                                                                                                                                                    calendar: {
                                                                                                                                                                                                                                                                                                                    (): string;
                                                                                                                                                                                                                                                                                                                    (formats: CalendarSpec): string;
                                                                                                                                                                                                                                                                                                                    (time: MomentInput, formats?: CalendarSpec): string;
                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                      method clone

                                                                                                                                                                                                                                                                                                                      clone: () => Moment;

                                                                                                                                                                                                                                                                                                                        method creationData

                                                                                                                                                                                                                                                                                                                        creationData: () => MomentCreationData;

                                                                                                                                                                                                                                                                                                                          method date

                                                                                                                                                                                                                                                                                                                          date: { (d: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                            method dates

                                                                                                                                                                                                                                                                                                                            dates: { (d: number): Moment; (): number };
                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                              use date(d)

                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                              use date()

                                                                                                                                                                                                                                                                                                                            method day

                                                                                                                                                                                                                                                                                                                            day: { (d: number | string): Moment; (): number };

                                                                                                                                                                                                                                                                                                                              method dayOfYear

                                                                                                                                                                                                                                                                                                                              dayOfYear: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                method days

                                                                                                                                                                                                                                                                                                                                days: { (d: number | string): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                  method daysInMonth

                                                                                                                                                                                                                                                                                                                                  daysInMonth: () => number;

                                                                                                                                                                                                                                                                                                                                    method diff

                                                                                                                                                                                                                                                                                                                                    diff: (
                                                                                                                                                                                                                                                                                                                                    b: MomentInput,
                                                                                                                                                                                                                                                                                                                                    unitOfTime?: unitOfTime.Diff,
                                                                                                                                                                                                                                                                                                                                    precise?: boolean
                                                                                                                                                                                                                                                                                                                                    ) => number;

                                                                                                                                                                                                                                                                                                                                      method endOf

                                                                                                                                                                                                                                                                                                                                      endOf: (unitOfTime: unitOfTime.StartOf) => Moment;

                                                                                                                                                                                                                                                                                                                                        method format

                                                                                                                                                                                                                                                                                                                                        format: (format?: string) => string;

                                                                                                                                                                                                                                                                                                                                          method from

                                                                                                                                                                                                                                                                                                                                          from: (inp: MomentInput, suffix?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                            method fromNow

                                                                                                                                                                                                                                                                                                                                            fromNow: (withoutSuffix?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                                                                                                                              get: (unit: unitOfTime.All) => number;

                                                                                                                                                                                                                                                                                                                                                method hasAlignedHourOffset

                                                                                                                                                                                                                                                                                                                                                hasAlignedHourOffset: (other?: MomentInput) => boolean;

                                                                                                                                                                                                                                                                                                                                                  method hour

                                                                                                                                                                                                                                                                                                                                                  hour: { (h: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                    method hours

                                                                                                                                                                                                                                                                                                                                                    hours: { (h: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                      method inspect

                                                                                                                                                                                                                                                                                                                                                      inspect: () => string;

                                                                                                                                                                                                                                                                                                                                                        method invalidAt

                                                                                                                                                                                                                                                                                                                                                        invalidAt: () => number;

                                                                                                                                                                                                                                                                                                                                                          method isAfter

                                                                                                                                                                                                                                                                                                                                                          isAfter: (inp?: MomentInput, granularity?: unitOfTime.StartOf) => boolean;

                                                                                                                                                                                                                                                                                                                                                            method isBefore

                                                                                                                                                                                                                                                                                                                                                            isBefore: (inp?: MomentInput, granularity?: unitOfTime.StartOf) => boolean;

                                                                                                                                                                                                                                                                                                                                                              method isBetween

                                                                                                                                                                                                                                                                                                                                                              isBetween: (
                                                                                                                                                                                                                                                                                                                                                              a: MomentInput,
                                                                                                                                                                                                                                                                                                                                                              b: MomentInput,
                                                                                                                                                                                                                                                                                                                                                              granularity?: unitOfTime.StartOf,
                                                                                                                                                                                                                                                                                                                                                              inclusivity?: '()' | '[)' | '(]' | '[]'
                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                method isDST

                                                                                                                                                                                                                                                                                                                                                                isDST: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                  method isDSTShifted

                                                                                                                                                                                                                                                                                                                                                                  isDSTShifted: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                    no reliable implementation

                                                                                                                                                                                                                                                                                                                                                                  method isLeapYear

                                                                                                                                                                                                                                                                                                                                                                  isLeapYear: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                    method isLocal

                                                                                                                                                                                                                                                                                                                                                                    isLocal: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                      method isoWeek

                                                                                                                                                                                                                                                                                                                                                                      isoWeek: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                        method isoWeekday

                                                                                                                                                                                                                                                                                                                                                                        isoWeekday: { (): number; (d: string | number): Moment };

                                                                                                                                                                                                                                                                                                                                                                          method isoWeeks

                                                                                                                                                                                                                                                                                                                                                                          isoWeeks: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                            method isoWeeksInISOWeekYear

                                                                                                                                                                                                                                                                                                                                                                            isoWeeksInISOWeekYear: () => number;

                                                                                                                                                                                                                                                                                                                                                                              method isoWeeksInYear

                                                                                                                                                                                                                                                                                                                                                                              isoWeeksInYear: () => number;

                                                                                                                                                                                                                                                                                                                                                                                method isoWeekYear

                                                                                                                                                                                                                                                                                                                                                                                isoWeekYear: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                  method isSame

                                                                                                                                                                                                                                                                                                                                                                                  isSame: (inp?: MomentInput, granularity?: unitOfTime.StartOf) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                    method isSameOrAfter

                                                                                                                                                                                                                                                                                                                                                                                    isSameOrAfter: (inp?: MomentInput, granularity?: unitOfTime.StartOf) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                      method isSameOrBefore

                                                                                                                                                                                                                                                                                                                                                                                      isSameOrBefore: (inp?: MomentInput, granularity?: unitOfTime.StartOf) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                        method isUtc

                                                                                                                                                                                                                                                                                                                                                                                        isUtc: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                          use isUTC

                                                                                                                                                                                                                                                                                                                                                                                        method isUTC

                                                                                                                                                                                                                                                                                                                                                                                        isUTC: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                          method isUtcOffset

                                                                                                                                                                                                                                                                                                                                                                                          isUtcOffset: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                            method isValid

                                                                                                                                                                                                                                                                                                                                                                                            isValid: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                              method lang

                                                                                                                                                                                                                                                                                                                                                                                              lang: { (language: LocaleSpecifier): Moment; (): Locale };
                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                as of 2.8.0, use locale

                                                                                                                                                                                                                                                                                                                                                                                              method local

                                                                                                                                                                                                                                                                                                                                                                                              local: (keepLocalTime?: boolean) => Moment;

                                                                                                                                                                                                                                                                                                                                                                                                method locale

                                                                                                                                                                                                                                                                                                                                                                                                locale: { (): string; (locale: LocaleSpecifier): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                  method localeData

                                                                                                                                                                                                                                                                                                                                                                                                  localeData: () => Locale;

                                                                                                                                                                                                                                                                                                                                                                                                    method max

                                                                                                                                                                                                                                                                                                                                                                                                    max: {
                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                    inp?: MomentInput,
                                                                                                                                                                                                                                                                                                                                                                                                    format?: MomentFormatSpecification,
                                                                                                                                                                                                                                                                                                                                                                                                    strict?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                    ): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                    inp?: MomentInput,
                                                                                                                                                                                                                                                                                                                                                                                                    format?: MomentFormatSpecification,
                                                                                                                                                                                                                                                                                                                                                                                                    language?: string,
                                                                                                                                                                                                                                                                                                                                                                                                    strict?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                    ): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                      as of 2.7.0, use moment.min/max

                                                                                                                                                                                                                                                                                                                                                                                                    method millisecond

                                                                                                                                                                                                                                                                                                                                                                                                    millisecond: { (ms: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                      method milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                      milliseconds: { (ms: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                        method min

                                                                                                                                                                                                                                                                                                                                                                                                        min: {
                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                        inp?: MomentInput,
                                                                                                                                                                                                                                                                                                                                                                                                        format?: MomentFormatSpecification,
                                                                                                                                                                                                                                                                                                                                                                                                        strict?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                        ): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                        inp?: MomentInput,
                                                                                                                                                                                                                                                                                                                                                                                                        format?: MomentFormatSpecification,
                                                                                                                                                                                                                                                                                                                                                                                                        language?: string,
                                                                                                                                                                                                                                                                                                                                                                                                        strict?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                        ): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                          as of 2.7.0, use moment.min/max

                                                                                                                                                                                                                                                                                                                                                                                                        method minute

                                                                                                                                                                                                                                                                                                                                                                                                        minute: { (m: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                          method minutes

                                                                                                                                                                                                                                                                                                                                                                                                          minutes: { (m: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                            method month

                                                                                                                                                                                                                                                                                                                                                                                                            month: { (M: number | string): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                              method months

                                                                                                                                                                                                                                                                                                                                                                                                              months: { (M: number | string): Moment; (): number };
                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                use month(M)

                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                use month()

                                                                                                                                                                                                                                                                                                                                                                                                              method parseZone

                                                                                                                                                                                                                                                                                                                                                                                                              parseZone: () => Moment;

                                                                                                                                                                                                                                                                                                                                                                                                                method parsingFlags

                                                                                                                                                                                                                                                                                                                                                                                                                parsingFlags: () => MomentParsingFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                  method quarter

                                                                                                                                                                                                                                                                                                                                                                                                                  quarter: { (): number; (q: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                    method quarters

                                                                                                                                                                                                                                                                                                                                                                                                                    quarters: { (): number; (q: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                      method second

                                                                                                                                                                                                                                                                                                                                                                                                                      second: { (s: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                                        method seconds

                                                                                                                                                                                                                                                                                                                                                                                                                        seconds: { (s: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                                                                                                                          set: {
                                                                                                                                                                                                                                                                                                                                                                                                                          (unit: unitOfTime.All, value: number): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                                          (objectLiteral: MomentSetObject): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            method startOf

                                                                                                                                                                                                                                                                                                                                                                                                                            startOf: (unitOfTime: unitOfTime.StartOf) => Moment;

                                                                                                                                                                                                                                                                                                                                                                                                                              method subtract

                                                                                                                                                                                                                                                                                                                                                                                                                              subtract: {
                                                                                                                                                                                                                                                                                                                                                                                                                              (amount?: DurationInputArg1, unit?: DurationInputArg2): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                                              (unit: unitOfTime.DurationConstructor, amount: string | number): Moment;
                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                reverse syntax

                                                                                                                                                                                                                                                                                                                                                                                                                              method to

                                                                                                                                                                                                                                                                                                                                                                                                                              to: (inp: MomentInput, suffix?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                toArray: () => number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  method toDate

                                                                                                                                                                                                                                                                                                                                                                                                                                  toDate: () => Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method toISOString

                                                                                                                                                                                                                                                                                                                                                                                                                                    toISOString: (keepOffset?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                      toJSON: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toNow

                                                                                                                                                                                                                                                                                                                                                                                                                                        toNow: (withoutPrefix?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                          toObject: () => MomentObjectOutput;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method unix

                                                                                                                                                                                                                                                                                                                                                                                                                                            unix: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method utc

                                                                                                                                                                                                                                                                                                                                                                                                                                              utc: (keepLocalTime?: boolean) => Moment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method utcOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                utcOffset: { (): number; (b: string | number, keepLocalTime?: boolean): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method valueOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                  valueOf: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Unix timestamp in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method week

                                                                                                                                                                                                                                                                                                                                                                                                                                                  week: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method weekday

                                                                                                                                                                                                                                                                                                                                                                                                                                                    weekday: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method weeks

                                                                                                                                                                                                                                                                                                                                                                                                                                                      weeks: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method weeksInWeekYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                        weeksInWeekYear: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method weeksInYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                          weeksInYear: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method weekYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                            weekYear: { (): number; (d: number): Moment };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method year

                                                                                                                                                                                                                                                                                                                                                                                                                                                              year: { (y: number): Moment; (): number };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method years

                                                                                                                                                                                                                                                                                                                                                                                                                                                                years: { (y: number): Moment; (): number };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  use year(y)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  use year()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                zone: { (): number; (b: string | number): Moment };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  in favor of utcOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zoneAbbr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                zoneAbbr: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method zoneName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zoneName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MomentBuiltinFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MomentBuiltinFormat {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MomentCreationData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MomentCreationData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        format?: MomentFormatSpecification;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          input: MomentInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isUTC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isUTC: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              locale: Locale;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                strict?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MomentInputObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MomentInputObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    d?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      D?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        date?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dates?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property day

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            day?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property days

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              days?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                h?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hour

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hour?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hours

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hours?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property m

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      m?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property M

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        M?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property millisecond

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          millisecond?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            milliseconds?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property minute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              minute?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property minutes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                minutes?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property month

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  month?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property months

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    months?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ms?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property second

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property seconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seconds?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              y?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                year?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property years

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  years?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MomentLongDateFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MomentLongDateFormat {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property l

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      l?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property L

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        L: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ll?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property LL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lll?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property LLL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LLL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property llll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  llll?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property LLLL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LLLL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lt?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property LT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LT: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property lts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lts?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property LTS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LTS: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MomentObjectOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MomentObjectOutput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                date: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hours

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hours: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    milliseconds: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property minutes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      minutes: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property months

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        months: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property seconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          seconds: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property years

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            years: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MomentParsingFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MomentParsingFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property charsLeftOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                charsLeftOver: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  empty: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property invalidFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    invalidFormat: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property invalidMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      invalidMonth: string | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property iso

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iso: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property meridiem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          meridiem: string | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property nullInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nullInput: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property overflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              overflow: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parsedDateParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parsedDateParts: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property unusedInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unusedInput: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property unusedTokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unusedTokens: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userInvalidated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userInvalidated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MomentParsingFlagsOpt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MomentParsingFlagsOpt {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property charsLeftOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          charsLeftOver?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            empty?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property invalidFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              invalidFormat?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property invalidMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                invalidMonth?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property iso

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iso?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property meridiem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    meridiem?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nullInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nullInput?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property overflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        overflow?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parsedDateParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parsedDateParts?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property unusedInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unusedInput?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property unusedTokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unusedTokens?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property userInvalidated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                userInvalidated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MomentRelativeTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MomentRelativeTime {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    d: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dd: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property future

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        future: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          h: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hh: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property m

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              m: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property M

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mm: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property MM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MM: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property past

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      past: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ss: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property yy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yy: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MomentSetObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MomentSetObject extends MomentInputObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dayOfYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dayOfYear?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property dayOfYears

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dayOfYears?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DDD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DDD?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        e?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property E

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property gg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gg?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property GG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GG?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isoWeek

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isoWeek?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isoWeekday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isoWeekday?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isoWeekdays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isoWeekdays?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isoWeeks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isoWeeks?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isoWeekYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isoWeekYear?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isoWeekYears

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isoWeekYears?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Q?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              quarter?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property quarters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                quarters?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property w

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  w?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property W

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    W?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property week

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      week?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property weekday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        weekday?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property weekdays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          weekdays?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property weeks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            weeks?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property weekYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              weekYear?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property weekYears

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                weekYears?: numberlike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RelativeTimeSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RelativeTimeSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    d?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dd?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property future

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        future?: RelativeTimeFuturePastVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          h?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hh?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property m

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              m?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property M

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                M?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mm?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property MM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MM?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property past

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      past?: RelativeTimeFuturePastVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ss?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property w

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            w?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ww

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ww?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                y?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property yy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  yy?: RelativeTimeSpecVal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface StandaloneFormatSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface StandaloneFormatSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      format: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isFormat?: RegExp;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property standalone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          standalone: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WeekSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WeekSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dow: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property doy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                doy?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CalendarKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CalendarKey =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'sameDay'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'nextDay'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'lastDay'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'nextWeek'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'lastWeek'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'sameElse'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CalendarSpecVal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CalendarSpecVal = string | ((m?: MomentInput, now?: Moment) => string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DurationInputArg1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DurationInputArg1 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | FromTo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | DurationInputObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DurationInputArg2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DurationInputArg2 = unitOfTime.DurationConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocaleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocaleSpecifier = string | Moment | Duration | string[] | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LongDateFormatKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LongDateFormatKey =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LTS'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LT'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'L'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LL'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LLL'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LLLL'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'lts'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'lt'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'l'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'lll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'llll';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MomentFormatSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MomentFormatSpecification =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MomentBuiltinFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | (string | MomentBuiltinFormat)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MomentInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MomentInput =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Moment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (number | string)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | MomentInputObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MonthWeekdayFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MonthWeekdayFn = (momentToFormat: Moment, format?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type numberlike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type numberlike = number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RelativeTimeFuturePastVal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RelativeTimeFuturePastVal = string | ((relTime: string) => string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RelativeTimeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RelativeTimeKey =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 's'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'ss'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'm'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'mm'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'h'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'hh'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'd'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'dd'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'w'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'ww'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'M'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'MM'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'y'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'yy';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RelativeTimeSpecVal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RelativeTimeSpecVal =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          n: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          withoutSuffix: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: RelativeTimeKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isFuture: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WeekdaySimpleFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WeekdaySimpleFn = (momentToFormat: Moment) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace unitOfTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace unitOfTime {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type All

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type All =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Base
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | _quarter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | _isoWeek
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | _date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'weekYear'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'weekYears'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'gg'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'isoWeekYear'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'isoWeekYears'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'GG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'dayOfYear'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'dayOfYears'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'DDD'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'weekday'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'weekdays'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'e'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'isoWeekday'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'isoWeekdays'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'E';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Base

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 Diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Diff = Base | _quarter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DurationAs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DurationAs = Base;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DurationConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DurationConstructor = Base | _quarter | _isoWeek;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MomentConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MomentConstructor = Base | _date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StartOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StartOf = Base | _quarter | _isoWeek | _date | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (33)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

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

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

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