moment

moment

Version 2.30.1
Published 1 year ago
4.35 MB
No dependencies
MIT license

Install

npm i moment

yarn add moment

pnpm add moment

Overview

Parse, validate, manipulate, and display dates

Index

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)

moment.d.ts

Dependencies (0)

No dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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>

Updated 1 year ago.
Package analyzed in 7427 ms.
Missing or incorrect documentation? Open an issue for this package.

moment

Install

Overview

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

variable defaultFormat

variable defaultFormatUtc

variable deprecationHandler

variable fn

variable HTML5_FMT

variable ISO_8601

variable RFC_2822

variable suppressDeprecationWarnings

variable version

Functions

function calendarFormat

function defineLocale

function duration

function invalid

function isDate

function isDuration

function isMoment

function lang

Deprecated

function locale

function localeData

function locales

function max

function min

function moment

Parameter strict

Parameter strict

function months

function monthsShort

function normalizeUnits

function now

function parseTwoDigitYear

function parseZone

function relativeTimeRounding

function relativeTimeThreshold

function unix

function updateLocale

function utc

Parameter strict

Parameter strict

function weekdays

function weekdaysMin

function weekdaysShort

Interfaces

interface argThresholdOpts

property d

property h

property m

property M

property s

property ss

property w

interface CalendarSpec

property lastDay

property lastWeek

property nextDay

property nextWeek

property sameDay

property sameElse

index signature

interface Duration

method abs

method add

method as

method asDays

method asHours

method asMilliseconds

method asMinutes

method asMonths

method asSeconds