Class Tempo

constructor

• new Tempo(options?: Options): Tempo

  Instantiates a new Tempo object with configuration only.

  Parameters

  • Optionaloptions: Options

    Configuration options for this specific instance.

  Returns Tempo

• new Tempo(tempo: DateTime, options?: Options): Tempo

  Instantiates a new Tempo object with a value.

  Parameters

  • tempo: DateTime

    The date-time value to parse.

  • Optionaloptions: Options

    Configuration options for this specific instance.

  Returns Tempo

StaticInterval

[toStringTag]

• get "[toStringTag]"(): "Tempo"

  Returns "Tempo"

cal

• get cal(): string

  Temporal Calendar ID (e.g., 'iso8601' | 'gregory')

  Returns string

config

• get config(): Config

  current Tempo configuration

  Returns Config

day

• get day(): dd

  Day of the month (alias for dd)

  Returns dd

dd

• get dd(): dd

  Day of the month (1-31)

  Returns dd

dow

• get dow(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

  iso weekday number: Mon=1, Sun=7

  Returns 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

eon

• get eon(): number | undefined

  Year within the era (positive integer)

  Returns number | undefined

epoch

• get epoch(): { ms: number; ns: bigint; ss: number; us: number }

  units since epoch for this date-time instance

  Returns { ms: number; ns: bigint; ss: number; us: number }

  • Readonlyms: number

    milliseconds since epoch

  • Readonlyns: bigint

    nanoseconds since epoch

  • Readonlyss: number

    seconds since epoch

  • Readonlyus: number

    microseconds since epoch

era

• get era(): string | undefined

  Era string for the calendar (e.g., 'ce', 'bce')

  Returns string | undefined

ff

• get ff(): number

  Fractional seconds (e.g., 0.123456789)

  Returns number

fmt

• get fmt(): Record<string, string | undefined>

  Formatted results for all pre-defined format codes

  Returns Record<string, string | undefined>

hh

• get hh(): hh

  Hour of the day (0-23)

  Returns hh

iso

• get iso(): string

  Standard ISO 8601 string in UTC

  Returns string

isValid

• get isValid(): boolean | ZonedDateTime

  true if the underlying date-time is valid.

  Returns boolean | ZonedDateTime

mi

• get mi(): mi

  Minutes of the hour (0-59)

  Returns mi

mm

• get mm(): mm

  Month number: Jan=1, Dec=12

  Returns mm

mmm

• get mmm(): | "All"
  | "Jan"
  | "Feb"
  | "Mar"
  | "Apr"
  | "May"
  | "Jun"
  | "Jul"
  | "Aug"
  | "Sep"
  | "Oct"
  | "Nov"
  | "Dec"

  Short month name (e.g., 'Jan')

  Returns
      | "All"
      | "Jan"
      | "Feb"
      | "Mar"
      | "Apr"
      | "May"
      | "Jun"
      | "Jul"
      | "Aug"
      | "Sep"
      | "Oct"
      | "Nov"
      | "Dec"

mon

• get mon(): | "May"
  | "Every"
  | "January"
  | "February"
  | "March"
  | "April"
  | "June"
  | "July"
  | "August"
  | "September"
  | "October"
  | "November"
  | "December"

  Full month name (e.g., 'January')

  Returns
      | "May"
      | "Every"
      | "January"
      | "February"
      | "March"
      | "April"
      | "June"
      | "July"
      | "August"
      | "September"
      | "October"
      | "November"
      | "December"

ms

• get ms(): ms

  Milliseconds of the second (0-999)

  Returns ms

nano

• get nano(): bigint

  Nanoseconds since Unix epoch (BigInt)

  Returns bigint

ns

• get ns(): ns

  Nanoseconds of the microsecond (0-999)

  Returns ns

parse

• get parse(): Parse

  Instance-specific parse rules (merged with global)

  Returns Parse

ranges

• get ranges(): Record<string, string>

  current range key for every registered term

  Returns Record<string, string>

ss

• get ss(): ss

  Seconds of the minute (0-59)

  Returns ss

term

• get term(): TempoTermRegistry

  Keyed results for all resolved terms

  Returns TempoTermRegistry

terms

• get terms(): Record<string, string[]>

  list of registered terms and their available range keys

  Returns Record<string, string[]>

ts

• get ts(): number | bigint

  Unix timestamp (defaults to milliseconds)

  Returns number | bigint

tz

• get tz(): string

  IANA Time Zone ID (e.g., 'Australia/Sydney')

  Returns string

us

• get us(): us

  Microseconds of the millisecond (0-999)

  Returns us

wkd

• get wkd(): | "Everyday"
  | "Monday"
  | "Tuesday"
  | "Wednesday"
  | "Thursday"
  | "Friday"
  | "Saturday"
  | "Sunday"

  Full weekday name (e.g., 'Monday')

  Returns
      | "Everyday"
      | "Monday"
      | "Tuesday"
      | "Wednesday"
      | "Thursday"
      | "Friday"
      | "Saturday"
      | "Sunday"

ww

• get ww(): wy

  Returns wy

  Deprecated

  use wy

www

• get www(): "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"

  Short weekday name (e.g., 'Mon')

  Returns "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"

wy

• get wy(): wy

  iso week number of the year

  Returns wy

yw

• get yw(): number

  4-digit iso week-numbering year

  Returns number

yy

• get yy(): number

  4-digit year (e.g., 2024)

  Returns number

Staticcache

• get cache(): {
      clear(count?: number): void;
      delete(key: string): boolean;
      deletePrefix(prefix: string): number;
      entries(): MapIterator<[string, string]>;
      fromEntries(
          entries: Iterable<readonly [string, string]>,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
      get(key: string): string | undefined;
      has(key: string): boolean;
      set(
          key: string,
          value: string,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
      setStatic(
          key: string,
          value: string,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
  }

  high-performance in-memory cache facade for glossary and dynamic parse results

  Returns {
      clear(count?: number): void;
      delete(key: string): boolean;
      deletePrefix(prefix: string): number;
      entries(): MapIterator<[string, string]>;
      fromEntries(
          entries: Iterable<readonly [string, string]>,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
      get(key: string): string | undefined;
      has(key: string): boolean;
      set(
          key: string,
          value: string,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
      setStatic(
          key: string,
          value: string,
      ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 4 more ...; readonly fromEntries: (entries: Iterable<...>) => ...; };
  }

StaticCACHE

• get CACHE(): EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>

  cache operation modes

  Returns EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>

Staticconfig

• get config(): any

  global Tempo configuration

  Returns any

Staticdefault

• get default(): Readonly<
      {
          calendar?: CalendarLike;
          catch?: boolean;
          debug?: DebugLevel;
          discovery?: string
          | symbol
          | Discovery;
          intl?: IntlOptions;
          license?: string;
          locale?: string | string[];
          mode?: "auto" | "strict" | "defer";
          monthDay?: boolean | MonthDay;
          pivot?: number;
          planner?: PlannerOptions;
          plugins?: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
          registry?: {
              events?:
                  | Extend<
                      {
                          christmas: "25 Dec";
                          "christmas ?eve": "24 Dec";
                          fortnight: (this: AliasContext) => AliasContext;
                          "new.?years? ?eve": "31 Dec";
                          "new.?years?(?: ?day)?": "01 Jan";
                          now: (this: AliasContext) => AliasContext;
                          ny: "01 Jan";
                          nye: "31 Dec";
                          today: (this: AliasContext) => ZonedDateTime;
                          tomorrow: (this: AliasContext) => AliasContext;
                          xmas: "25 Dec";
                          "xmas ?eve": "24 Dec";
                          yesterday: (this: AliasContext) => AliasContext;
                      },
                      string,
                      string
                      | Function,
                  >
                  | RegistryOption<Logic>;
              formats?: Property<any>;
              ignores?: Ignore;
              layouts?:
                  | Extend<{ readonly [key: symbol]: string }, symbol, string>
                  | RegistryOption<Pattern>;
              locales?: Record<string, Record<string, string | Function>>;
              modifiers?: Record<string, string | string[]>;
              periods?:
                  | Extend<
                      {
                          "after[ -]?noon": "3:00pm";
                          evening: "18:00";
                          "half[ -]?hour": (this: AliasContext) => string;
                          "mid[ -]?day": "12:00";
                          "mid[ -]?morning": "10:00";
                          "mid[ -]?night": "24:00";
                          morning: "8:00";
                          night: "20:00";
                          noon: "12:00";
                      },
                      string,
                      string
                      | Function,
                  >
                  | RegistryOption<Logic>;
              snippets?:
                  | Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
                  | RegistryOption<Pattern>;
              tokens?: Record<string, TokenEvaluator>;
          };
          scope: "default";
          silent?: boolean;
          sphere?: string;
          store?: string;
          timeStamp?: TimeStamp;
          timeZone: TimeZoneLike;
          value?: DateTime;
      },
  >

  Tempo initial default settings

  Returns Readonly<
      {
          calendar?: CalendarLike;
          catch?: boolean;
          debug?: DebugLevel;
          discovery?: string
          | symbol
          | Discovery;
          intl?: IntlOptions;
          license?: string;
          locale?: string | string[];
          mode?: "auto" | "strict" | "defer";
          monthDay?: boolean | MonthDay;
          pivot?: number;
          planner?: PlannerOptions;
          plugins?: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
          registry?: {
              events?:
                  | Extend<
                      {
                          christmas: "25 Dec";
                          "christmas ?eve": "24 Dec";
                          fortnight: (this: AliasContext) => AliasContext;
                          "new.?years? ?eve": "31 Dec";
                          "new.?years?(?: ?day)?": "01 Jan";
                          now: (this: AliasContext) => AliasContext;
                          ny: "01 Jan";
                          nye: "31 Dec";
                          today: (this: AliasContext) => ZonedDateTime;
                          tomorrow: (this: AliasContext) => AliasContext;
                          xmas: "25 Dec";
                          "xmas ?eve": "24 Dec";
                          yesterday: (this: AliasContext) => AliasContext;
                      },
                      string,
                      string
                      | Function,
                  >
                  | RegistryOption<Logic>;
              formats?: Property<any>;
              ignores?: Ignore;
              layouts?:
                  | Extend<{ readonly [key: symbol]: string }, symbol, string>
                  | RegistryOption<Pattern>;
              locales?: Record<string, Record<string, string | Function>>;
              modifiers?: Record<string, string | string[]>;
              periods?:
                  | Extend<
                      {
                          "after[ -]?noon": "3:00pm";
                          evening: "18:00";
                          "half[ -]?hour": (this: AliasContext) => string;
                          "mid[ -]?day": "12:00";
                          "mid[ -]?morning": "10:00";
                          "mid[ -]?night": "24:00";
                          morning: "8:00";
                          night: "20:00";
                          noon: "12:00";
                      },
                      string,
                      string
                      | Function,
                  >
                  | RegistryOption<Logic>;
              snippets?:
                  | Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
                  | RegistryOption<Pattern>;
              tokens?: Record<string, TokenEvaluator>;
          };
          scope: "default";
          silent?: boolean;
          sphere?: string;
          store?: string;
          timeStamp?: TimeStamp;
          timeZone: TimeZoneLike;
          value?: DateTime;
      },
  >

Staticdiscovery

• get discovery(): any

  global discovery configuration

  Returns any

Staticepoch

• get epoch(): { ms: number; ns: bigint; ss: number; us: number }

  static units since Unix epoch

  Returns { ms: number; ns: bigint; ss: number; us: number }

  • Readonlyms: number

    milliseconds since epoch

  • Readonlyns: bigint

    nanoseconds since epoch

  • Readonlyss: number

    seconds since epoch

  • Readonlyus: number

    microseconds since epoch

StaticFORMAT

• get FORMAT(): Extend<
      EnumifyType<
          {
              date: "{yyyy}-{mm}-{dd}";
              dayDate: "{dd}-{mmm}-{yyyy}";
              dayMonth: "{dd}-{mmm}";
              dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
              display: "{www}, {dd} {mmm} {yyyy}";
              logStamp: "{ymd}T{hms}.{ff}";
              sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
              time: "{hh}:{mi}:{ss}";
              weekDate: "{www}, {yyyy}-{mmm}-{dd}";
              weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
              weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
              yearMonth: "{yyyy}{mm}";
              yearMonthDay: "{ymd}";
              yearWeek: "{yw}{wy}";
          },
      >,
      string,
      string,
  >

  Pre-configured format {name -> string} pairs

  Returns Extend<
      EnumifyType<
          {
              date: "{yyyy}-{mm}-{dd}";
              dayDate: "{dd}-{mmm}-{yyyy}";
              dayMonth: "{dd}-{mmm}";
              dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
              display: "{www}, {dd} {mmm} {yyyy}";
              logStamp: "{ymd}T{hms}.{ff}";
              sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
              time: "{hh}:{mi}:{ss}";
              weekDate: "{www}, {yyyy}-{mmm}-{dd}";
              weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
              weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
              yearMonth: "{yyyy}{mm}";
              yearMonthDay: "{ymd}";
              yearWeek: "{yw}{wy}";
          },
      >,
      string,
      string,
  >

Staticformats

• get formats(): | Extend<
      EnumifyType<
          {
              date: "{yyyy}-{mm}-{dd}";
              dayDate: "{dd}-{mmm}-{yyyy}";
              dayMonth: "{dd}-{mmm}";
              dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
              display: "{www}, {dd} {mmm} {yyyy}";
              logStamp: "{ymd}T{hms}.{ff}";
              sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
              time: "{hh}:{mi}:{ss}";
              weekDate: "{www}, {yyyy}-{mmm}-{dd}";
              weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
              weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
              yearMonth: "{yyyy}{mm}";
              yearMonthDay: "{ymd}";
              yearWeek: "{yw}{wy}";
          },
      >,
      string,
      string,
  >
  | EnumifyType<any>

  Returns
      | Extend<
          EnumifyType<
              {
                  date: "{yyyy}-{mm}-{dd}";
                  dayDate: "{dd}-{mmm}-{yyyy}";
                  dayMonth: "{dd}-{mmm}";
                  dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                  display: "{www}, {dd} {mmm} {yyyy}";
                  logStamp: "{ymd}T{hms}.{ff}";
                  sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                  time: "{hh}:{mi}:{ss}";
                  weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                  weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                  weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                  yearMonth: "{yyyy}{mm}";
                  yearMonthDay: "{ymd}";
                  yearWeek: "{yw}{wy}";
              },
          >,
          string,
          string,
      >
      | EnumifyType<any>

  Deprecated

  Use Tempo.registry.formats instead

Staticignores

• get ignores(): Secure<Ignore>

  static Tempo.ignores (registry)

  Returns Secure<Ignore>

Staticinstant

• get instant(): Instant

  get the current system Instant

  Returns Instant

Staticlicense

• get license(): {
      audience?: string;
      error?: string;
      expires?: string
      | number;
      issuedAt?: string | number;
      issuer?: string;
      jti?: string;
      role?: string;
      scopes: { [k: string]: any };
      status: string;
      subject?: string;
  }

  human-readable formatted license state

  Returns {
      audience?: string;
      error?: string;
      expires?: string | number;
      issuedAt?: string | number;
      issuer?: string;
      jti?: string;
      role?: string;
      scopes: { [k: string]: any };
      status: string;
      subject?: string;
  }

StaticLIMIT

• get LIMIT(): { get maxTempo(): bigint; get minTempo(): bigint }

  some useful Dates

  Returns { get maxTempo(): bigint; get minTempo(): bigint }

  • get maxTempo(): bigint

    Tempo(31-Dec-9999.23:59:59).ns

  • get minTempo(): bigint

    Tempo(01-Jan-1000.00:00:00).ns

StaticMODE

• get MODE(): EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>

  initialization strategies

  Returns EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>

StaticMONTH_DAY

• get MONTH_DAY(): {
      layouts: readonly [
          readonly ["dayMonthYearShort", "monthDayYearShort"],
          readonly ["dayMonthYear", "monthDayYear"],
      ];
      locales: readonly ["en-US", "en-AS"];
      timezones: {
          "en-AS": readonly ["Pacific/Pago_Pago"];
          "en-US": readonly [
              "America/Adak",
              "America/Anchorage",
              "America/Boise",
              "America/Chicago",
              "America/Denver",
              "America/Detroit",
              "America/Indiana/Indianapolis",
              "America/Indiana/Knox",
              "America/Indiana/Marengo",
              "America/Indiana/Petersburg",
              "America/Indiana/Tell_City",
              "America/Indiana/Vevay",
              "America/Indiana/Vincennes",
              "America/Indiana/Winamac",
              "America/Indianapolis",
              "America/Juneau",
              "America/Kentucky/Louisville",
              "America/Kentucky/Monticello",
              "America/Los_Angeles",
              "America/Louisville",
              "America/Menominee",
              "America/Metlakatla",
              "America/New_York",
              "America/Nome",
              "America/North_Dakota/Beulah",
              "America/North_Dakota/Center",
              "America/North_Dakota/New_Salem",
              "America/Phoenix",
              "America/Sitka",
              "America/Yakutat",
              "Pacific/Honolulu",
              "US/Aleutian",
              "US/Alaska",
              "US/Arizona",
              "US/Central",
              "US/Eastern",
              "US/Mountain",
              "US/Pacific",
          ];
      };
  }

  regional date-parsing configuration

  Returns {
      layouts: readonly [
          readonly ["dayMonthYearShort", "monthDayYearShort"],
          readonly ["dayMonthYear", "monthDayYear"],
      ];
      locales: readonly ["en-US", "en-AS"];
      timezones: {
          "en-AS": readonly ["Pacific/Pago_Pago"];
          "en-US": readonly [
              "America/Adak",
              "America/Anchorage",
              "America/Boise",
              "America/Chicago",
              "America/Denver",
              "America/Detroit",
              "America/Indiana/Indianapolis",
              "America/Indiana/Knox",
              "America/Indiana/Marengo",
              "America/Indiana/Petersburg",
              "America/Indiana/Tell_City",
              "America/Indiana/Vevay",
              "America/Indiana/Vincennes",
              "America/Indiana/Winamac",
              "America/Indianapolis",
              "America/Juneau",
              "America/Kentucky/Louisville",
              "America/Kentucky/Monticello",
              "America/Los_Angeles",
              "America/Louisville",
              "America/Menominee",
              "America/Metlakatla",
              "America/New_York",
              "America/Nome",
              "America/North_Dakota/Beulah",
              "America/North_Dakota/Center",
              "America/North_Dakota/New_Salem",
              "America/Phoenix",
              "America/Sitka",
              "America/Yakutat",
              "Pacific/Honolulu",
              "US/Aleutian",
              "US/Alaska",
              "US/Arizona",
              "US/Central",
              "US/Eastern",
              "US/Mountain",
              "US/Pacific",
          ];
      };
  }

StaticNUMBER

• get NUMBER(): Extend<
      EnumifyType<
          {
              eight: 8;
              five: 5;
              four: 4;
              nine: 9;
              one: 1;
              seven: 7;
              six: 6;
              ten: 10;
              three: 3;
              two: 2;
              zero: 0;
          },
      >,
      string,
      number,
  >

  Number names (0-10)

  Returns Extend<
      EnumifyType<
          {
              eight: 8;
              five: 5;
              four: 4;
              nine: 9;
              one: 1;
              seven: 7;
              six: 6;
              ten: 10;
              three: 3;
              two: 2;
              zero: 0;
          },
      >,
      string,
      number,
  >

Staticoptions

• get options(): any

  Returns any

Staticparse

• get parse(): {
      anchor?: ZonedDateTime;
      event: {
          christmas: "25 Dec";
          "christmas ?eve": "24 Dec";
          fortnight: (this: AliasContext) => AliasContext;
          "new.?years? ?eve": "31 Dec";
          "new.?years?(?: ?day)?": "01 Jan";
          now: (this: AliasContext) => AliasContext;
          ny: "01 Jan";
          nye: "31 Dec";
          today: (this: AliasContext) => ZonedDateTime;
          tomorrow: (this: AliasContext) => AliasContext;
          xmas: "25 Dec";
          "xmas ?eve": "24 Dec";
          yesterday: (this: AliasContext) => AliasContext;
          readonly [key: string]: string | Function;
      };
      ignore: { readonly [key: string]: string };
      isAnchored?: boolean;
      layout: { readonly [key: symbol]: string };
      mode: "auto" | "strict" | "defer";
      monthDay: MonthDay;
      pattern: Registry;
      period: {
          "after[ -]?noon": "3:00pm";
          evening: "18:00";
          "half[ -]?hour": (this: AliasContext) => string;
          "mid[ -]?day": "12:00";
          "mid[ -]?morning": "10:00";
          "mid[ -]?night": "24:00";
          morning: "8:00";
          night: "20:00";
          noon: "12:00";
          readonly [key: string]: string | Function;
      };
      pivot: number;
      planner: { layoutOrder: (string | symbol)[]; preFilter: boolean };
      result: Match[];
      snippet: { readonly [key: symbol]: RegExp };
      token: Extend;
  }

  configuration governing the static 'rules' used when parsing t.DateTime argument

  Returns {
      anchor?: ZonedDateTime;
      event: {
          christmas: "25 Dec";
          "christmas ?eve": "24 Dec";
          fortnight: (this: AliasContext) => AliasContext;
          "new.?years? ?eve": "31 Dec";
          "new.?years?(?: ?day)?": "01 Jan";
          now: (this: AliasContext) => AliasContext;
          ny: "01 Jan";
          nye: "31 Dec";
          today: (this: AliasContext) => ZonedDateTime;
          tomorrow: (this: AliasContext) => AliasContext;
          xmas: "25 Dec";
          "xmas ?eve": "24 Dec";
          yesterday: (this: AliasContext) => AliasContext;
          readonly [key: string]: string | Function;
      };
      ignore: { readonly [key: string]: string };
      isAnchored?: boolean;
      layout: { readonly [key: symbol]: string };
      mode: "auto" | "strict" | "defer";
      monthDay: MonthDay;
      pattern: Registry;
      period: {
          "after[ -]?noon": "3:00pm";
          evening: "18:00";
          "half[ -]?hour": (this: AliasContext) => string;
          "mid[ -]?day": "12:00";
          "mid[ -]?morning": "10:00";
          "mid[ -]?night": "24:00";
          morning: "8:00";
          night: "20:00";
          noon: "12:00";
          readonly [key: string]: string | Function;
      };
      pivot: number;
      planner: { layoutOrder: (string | symbol)[]; preFilter: boolean };
      result: Match[];
      snippet: { readonly [key: symbol]: RegExp };
      token: Extend;
  }

  • Optional Readonlyanchor?: ZonedDateTime

    anchor value used for this parse operation

  • Readonlyevent: {
        christmas: "25 Dec";
        "christmas ?eve": "24 Dec";
        fortnight: (this: AliasContext) => AliasContext;
        "new.?years? ?eve": "31 Dec";
        "new.?years?(?: ?day)?": "01 Jan";
        now: (this: AliasContext) => AliasContext;
        ny: "01 Jan";
        nye: "31 Dec";
        today: (this: AliasContext) => ZonedDateTime;
        tomorrow: (this: AliasContext) => AliasContext;
        xmas: "25 Dec";
        "xmas ?eve": "24 Dec";
        yesterday: (this: AliasContext) => AliasContext;
        readonly [key: string]: string | Function;
    }

  • Readonlyignore: { readonly [key: string]: string }

  • Optional ReadonlyisAnchored?: boolean

    was this a nested/anchored parse?

  • Readonlylayout: { readonly [key: symbol]: string }

  • Readonlymode: "auto" | "strict" | "defer"

    initialization strategy ('auto'|'strict'|'defer')

  • ReadonlymonthDay: MonthDay

  • Readonlypattern: Registry

    Map of regex-patterns to match input-string

  • Readonlyperiod: {
        "after[ -]?noon": "3:00pm";
        evening: "18:00";
        "half[ -]?hour": (this: AliasContext) => string;
        "mid[ -]?day": "12:00";
        "mid[ -]?morning": "10:00";
        "mid[ -]?night": "24:00";
        morning: "8:00";
        night: "20:00";
        noon: "12:00";
        readonly [key: string]: string | Function;
    }

  • Readonlypivot: number

    pivot year for two-digit years

  • planner: { layoutOrder: (string | symbol)[]; preFilter: boolean }

  • Readonlyresult: Match[]

    parsing match result

  • Readonlysnippet: { readonly [key: symbol]: RegExp }

  • Readonlytoken: Extend

    Symbol registry

Staticproperties

• get properties(): SecureArray<string>

  static Tempo properties getter

  Returns SecureArray<string>

Staticregistry

• get registry(): any

  static Tempo.registry

  Returns any

Staticterms

• get terms(): SecureArray<PremiumPlugin> & Record<string, PremiumPlugin>

  static Tempo.terms (registry)

  Returns SecureArray<PremiumPlugin> & Record<string, PremiumPlugin>

StaticTIMEZONE

• get TIMEZONE(): Extend<
      {
          acst: "Australia/Adelaide";
          aest: "Australia/Sydney";
          awst: "Australia/Perth";
          cet: "Europe/Paris";
          cst: "America/Chicago";
          eet: "Europe/Helsinki";
          est: "America/New_York";
          gmt: "Europe/London";
          ist: "Asia/Kolkata";
          jst: "Asia/Tokyo";
          mst: "America/Denver";
          npt: "Asia/Kathmandu";
          nzt: "Pacific/Auckland";
          pst: "America/Los_Angeles";
          utc: "UTC";
      },
      string,
      string,
  >

  TimeZone aliases

  Returns Extend<
      {
          acst: "Australia/Adelaide";
          aest: "Australia/Sydney";
          awst: "Australia/Perth";
          cet: "Europe/Paris";
          cst: "America/Chicago";
          eet: "Europe/Helsinki";
          est: "America/New_York";
          gmt: "Europe/London";
          ist: "Asia/Kolkata";
          jst: "Asia/Tokyo";
          mst: "America/Denver";
          npt: "Asia/Kathmandu";
          nzt: "Pacific/Auckland";
          pst: "America/Los_Angeles";
          utc: "UTC";
      },
      string,
      string,
  >

Staticversion

• get version(): string

  the version of this Tempo build (stamped at build-time from package.json)

  Returns string

Staticversions

• get versions(): Readonly<Record<string, string>>

  the active versions of Tempo and any registered plugins or modules

  Returns Readonly<Record<string, string>>

[iterator]

• "[iterator]"(): ArrayIterator<EntryOf<Record<string, string | undefined>>>

  iterate over instance formats

  Returns ArrayIterator<EntryOf<Record<string, string | undefined>>>

[toPrimitive]

• "[toPrimitive]"(
      hint?: "string" | "number" | "default",
  ): string | number | bigint

  allow for auto-convert of Tempo to BigInt, Number or String

  Parameters

  • Optionalhint: "string" | "number" | "default"

  Returns string | number | bigint

add

• add(tempo?: MutateAdd, options?: Options): Tempo

  returns a new Tempo with specific duration added.

  Parameters

  • Optionaltempo: MutateAdd
  • Optionaloptions: Options

  Returns Tempo

clone

• clone(): Tempo

  returns a clone of the current Tempo instance.

  Returns Tempo

format

• format(fmt?: any, options?: any): string

  apply a custom format.

  Parameters

  • Optionalfmt: any
  • Optionaloptions: any

  Returns string

• format(options: FormatOptions): string

  applies a format to the instance.

  Parameters

  • options: FormatOptions

  Returns string

• format<S extends string>(
      fmt: string extends S
          ? S
          : string extends ValidateFormat<S> ? S : ValidateFormat<S>,
      options?: any,
  ): string

  Applies a format to the instance. Format strings are validated at compile time — any unrecognised {token} will produce an IDE error showing the bad token name.

  Type Parameters

  • S extends string

  Parameters

  • fmt: string extends S ? S : string extends ValidateFormat<S> ? S : ValidateFormat<S>
  • Optionaloptions: any

  Returns string

  See

  TempoFormatTokens to extend the token set.

• format(): string

  applies a format to the instance (zero-argument — returns a pre-built format proxy).

  Returns string

set

• set(tempo?: MutateSet, options?: Options): Tempo

  returns a new Tempo with specific offsets.

  Parameters

  • Optionaltempo: MutateSet
  • Optionaloptions: Options

  Returns Tempo

setCatchMode

• setCatchMode(catchMode: boolean): this

  explicitly enable/disable "catch" mode for this instance

  Parameters

  • catchMode: boolean

  Returns this

since

• since(dateTimeOrOpts?: Options | DateTime, opts?: Options): Duration

  time elapsed since another date-time

  Parameters

  • OptionaldateTimeOrOpts: Options | DateTime
  • Optionalopts: Options

  Returns Duration

• since(unit: Unit, opts?: Options): number

  time elapsed since another date-time

  Parameters

  • unit: Unit
  • Optionalopts: Options

  Returns number

• since(dateTimeOrOpts: Options | DateTime, unit: Unit): number

  time elapsed since another date-time

  Parameters

  • dateTimeOrOpts: Options | DateTime
  • unit: Unit

  Returns number

• since(until: Until, opts?: Options): string

  time elapsed since (with unit)

  Parameters

  • until: Until
  • Optionalopts: Options

  Returns string

• since(dateTimeOrOpts: Options | DateTime, until: Until): string

  time elapsed since another date-time (with unit)

  Parameters

  • dateTimeOrOpts: Options | DateTime
  • until: Until

  Returns string

• since(dateTimeOrOpts?: Options | DateTime, opts?: Options): string

  time elapsed since another date-time (w'out unit)

  Parameters

  • OptionaldateTimeOrOpts: Options | DateTime
  • Optionalopts: Options

  Returns string

• since(optsOrDate?: any, optsOrUntil?: any): string

  time elapsed since another date-time

  Parameters

  • OptionaloptsOrDate: any
  • OptionaloptsOrUntil: any

  Returns string

subtract

• subtract(tempo?: MutateAdd, options?: Options): Tempo

  returns a new Tempo with specific duration subtracted.

  Parameters

  • Optionaltempo: MutateAdd
  • Optionaloptions: Options

  Returns Tempo

toDate

• toDate(): Date

  the date-time as a standard Date object.

  Returns Date

toDateTime

• toDateTime(): ZonedDateTime

  returns the underlying Temporal.ZonedDateTime

  Returns ZonedDateTime

toInstant

• toInstant(): Instant

  returns the underlying Temporal.Instant

  Returns Instant

toJSON

• toJSON(): {
      calendar: CalendarLike;
      catch: boolean;
      debug: DebugLevel;
      discovery: string
      | symbol
      | Discovery;
      intl: IntlOptions;
      license?: string;
      locale: string | string[];
      mode: "auto" | "strict" | "defer";
      plugins: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
      registry: {
          formats: EnumifyType;
          locales: Record<string, Record<string, string | Function>>;
          modifiers?: Record<string, string | string[]>;
          tokens?: Record<string, TokenEvaluator>;
      };
      scope: "global"
      | "local";
      silent: boolean;
      sphere: string | undefined;
      store: string;
      timeStamp: TimeStamp;
      timeZone: TimeZoneLike;
      value: string;
  }

  Custom JSON serialization for JSON.stringify.

  Returns {
      calendar: CalendarLike;
      catch: boolean;
      debug: DebugLevel;
      discovery: string | symbol | Discovery;
      intl: IntlOptions;
      license?: string;
      locale: string | string[];
      mode: "auto" | "strict" | "defer";
      plugins: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
      registry: {
          formats: EnumifyType;
          locales: Record<string, Record<string, string | Function>>;
          modifiers?: Record<string, string | string[]>;
          tokens?: Record<string, TokenEvaluator>;
      };
      scope: "global"
      | "local";
      silent: boolean;
      sphere: string | undefined;
      store: string;
      timeStamp: TimeStamp;
      timeZone: TimeZoneLike;
      value: string;
  }

  • calendar: CalendarLike

    Temporal calendar

  • catch: boolean

    catch or throw Errors

  • debug: DebugLevel

    additional console.log for tracking

  • discovery: string | symbol | Discovery

    globalThis Discovery Symbol

  • intl: IntlOptions

    internationalization configuration (relativeTime, etc.)

  • Optionallicense?: string

    license key for premium features

  • locale: string | string[]

    locale (e.g. en-AU)

  • mode: "auto" | "strict" | "defer"

    initialization strategy ('auto'|'strict'|'defer')

  • plugins: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[]

    plugins to be automatically extended

  • registry: {
        formats: EnumifyType;
        locales: Record<string, Record<string, string | Function>>;
        modifiers?: Record<string, string | string[]>;
        tokens?: Record<string, TokenEvaluator>;
    }

    custom data augmentation registries

  • scope: "global" | "local"

    scope for configuration mutations

  • silent: boolean

    suppress console output during catch

  • sphere: string | undefined

    hemisphere for term.qtr or term.szn

  • store: string

    localStorage key

  • timeStamp: TimeStamp

    Precision to measure timestamps (ms | us)

  • timeZone: TimeZoneLike

    Temporal timeZone

  • value: string

toNow

• toNow(): ZonedDateTime

  the current system time localized to this instance.

  Returns ZonedDateTime

toPlainDate

• toPlainDate(): PlainDate

  returns a Temporal.PlainDate representation

  Returns PlainDate

toPlainDateTime

• toPlainDateTime(): PlainDateTime

  returns a Temporal.PlainDateTime representation

  Returns PlainDateTime

toPlainTime

• toPlainTime(): PlainTime

  returns a Temporal.PlainTime representation

  Returns PlainTime

toString

• toString(): string

  iso8601 string representation of the date-time.

  Returns string

until

• until(dateTimeOrOpts?: Options | DateTime, opts?: Options): Duration

  time duration until another date-time

  Parameters

  • OptionaldateTimeOrOpts: Options | DateTime
  • Optionalopts: Options

  Returns Duration

• until(unit: Unit, opts?: Options): number

  time duration until another date-time

  Parameters

  • unit: Unit
  • Optionalopts: Options

  Returns number

• until(dateTimeOrOpts: Options | DateTime, unit: Unit): number

  time duration until another date-time

  Parameters

  • dateTimeOrOpts: Options | DateTime
  • unit: Unit

  Returns number

• until(dateTimeOrOpts?: Options | DateTime, opts?: Options): Duration

  time duration until (returns Duration)

  Parameters

  • OptionaldateTimeOrOpts: Options | DateTime
  • Optionalopts: Options

  Returns Duration

• until(unit: Unit, opts?: Options): number

  time duration until (with unit, returns number)

  Parameters

  • unit: Unit
  • Optionalopts: Options

  Returns number

• until(dateTimeOrOpts: Options | DateTime, unit: Unit): number

  time duration until another date-time (with unit)

  Parameters

  • dateTimeOrOpts: Options | DateTime
  • unit: Unit

  Returns number

• until(
      optsOrDate?:
          | string
          | number
          | bigint
          | TempoBrand
          | ZonedDateTime
          | Instant
          | Options
          | PlainDate
          | PlainDateTime
          | ZonedDateTimeLikeObject
          | ISOString
          | Date
          | Tempo
          | PlainTime
          | Duration
          | Options & { unit?: Unit }
          | null,
      optsOrUntil?: Options | Until,
  ): number | Duration

  fallback: union of possible returns

  Parameters

  • OptionaloptsOrDate:
        | string
        | number
        | bigint
        | TempoBrand
        | ZonedDateTime
        | Instant
        | Options
        | PlainDate
        | PlainDateTime
        | ZonedDateTimeLikeObject
        | ISOString
        | Date
        | Tempo
        | PlainTime
        | Duration
        | Options & { unit?: Unit }
        | null
  • OptionaloptsOrUntil: Options | Until

  Returns number | Duration

Static[dispose]

• "[dispose]"(): void

  release global config and reset library to defaults

  Returns void

Static[hasInstance]

• "[hasInstance]"(instance: any): boolean

  Parameters

  • instance: any

  Returns boolean

Static[iterator]

• "[iterator]"(): ArrayIterator<string>

  iterate over Tempo properties

  Returns ArrayIterator<string>

Staticbootstrap

• bootstrap(
      options?: { configFile?: string; cwd?: string },
  ): Promise<typeof Tempo>

  Automatically discovers and loads configuration from tempo.config.* before initializing the engine.

  Parameters

  • Optionaloptions: { configFile?: string; cwd?: string }

  Returns Promise<typeof Tempo>

Staticcompare

• compare(tempo1?: Options | DateTime, tempo2?: Options | DateTime): number

  Compares two Tempo instances or date-time values. Returns -1 (earlier), 0 (equal), or 1 (later).

  Parameters

  • Optionaltempo1: Options | DateTime
  • Optionaltempo2: Options | DateTime

  Returns number

Staticcreate

• create(options?: Options): typeof Tempo

  🏭 Sandbox Factory Mode Create a fresh, isolated Tempo subclass with its own configuration and registries. Returns a new class that inherits from the caller, but maintains independent state.

  Parameters

  • options: Options = {}

  Returns typeof Tempo

Staticextend

• extend(plugin: TempoPlugin, options?: Options): typeof Tempo

  Register a plugin or term extension.

  Parameters

  • plugin: TempoPlugin

    A plugin or term extension to register.

  • Optionaloptions: Options

    Optional configuration for the plugin.

  Returns typeof Tempo

• extend(plugins: any[], options?: Options): typeof Tempo

  Register an array of plugins or term extensions.

  Parameters

  • plugins: any[]

    An array of plugins, terms, or extensions to register.

  • Optionaloptions: Options

    Optional configuration for the plugins.

  Returns typeof Tempo

• extend(...args: any[]): typeof Tempo

  Register multiple plugins or term extensions.

  Parameters

  • ...args: any[]

    A plugin, term, or list of extensions to register.

  Returns typeof Tempo

Staticfrom

• from(options?: Options): Tempo

  Creates a new Tempo instance.

  Parameters

  • Optionaloptions: Options

  Returns Tempo

• from(tempo: DateTime, options?: Options): Tempo

  Creates a new Tempo instance.

  Parameters

  • tempo: DateTime
  • Optionaloptions: Options

  Returns Tempo

Staticinit

• init(options?: Options): typeof Tempo

  Reset Tempo to its default, built-in registration state

  Parameters

  • options: Options = {}

  Returns typeof Tempo

StaticisTempo

• isTempo(instance?: any): instance is Tempo

  check if a supplied variable is a valid Tempo instance

  Parameters

  • Optionalinstance: any

  Returns instance is Tempo

Staticnow

• now(unit: "ss" | "ms" | "us"): number

  Parameters

  • unit: "ss" | "ms" | "us"

  Returns number

• now(unit?: "ns"): bigint

  Parameters

  • Optionalunit: "ns"

  Returns bigint

Staticready

• ready(): Promise<string>

  Wait for the background licensing and validation engine to finish settling. Resolves immediately if no license key or validation is pending.

  Returns Promise<string>

  The final, human-readable license status ('none', 'active', 'expired', etc.)

Staticregexp

• regexp(
      layout: string | RegExp,
      snippet?: Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>,
  ): RegExp

  translates {layout} into an anchored, case-insensitive RegExp.

  Parameters

  • layout: string | RegExp
  • Optionalsnippet: Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>

  Returns RegExp

StaticsetCatchMode

• setCatchMode(catchMode: boolean): typeof Tempo

  explicitly enable/disable "catch" mode for internal errors

  Parameters

  • catchMode: boolean

  Returns typeof Tempo