@magmacomputing/tempo 1.0.0

package/dist/tempo.config/plugins/term.import.d.ts

@@ -0,0 +1,42 @@
+/**
+ * import of plugins
+ */
+import * as qtr from '../../tempo.config/plugins/term.quarter.js';
+declare const _default: {
+    key: string;
+    scope: string;
+    description: string;
+    define: typeof qtr.define;
+}[];
+export default _default;
+/**
+ * Usage:
+ * show only the 'key' field from the pre-defined range
+ * new Tempo('20-May-1957').term.qtr		# range of Fiscal Quarters
+ * 			> 'Q2'
+ * show the 'range' object that relates to the Tempo instance
+ * new Tempo('28-Aug-1968').term.quarter
+ * 			> {key: 'Q2', day: 1, month: 4, fiscal: 1969}
+ *
+ * Notes:
+ * A 'term' has two parts:
+ * 1) an array of objects that define the DateTime lower boundaries of a range
+ * (e.g.  [{key: 'Summer', day: 1, month: 12}, {key: 'Autumn', day: 1, month: 3}...])
+ * these are statically defined when the Tempo class is first imported.
+ *
+ * 2) a function which determines where a Tempo instance fits within the above range array.
+ * this function is assigned to a getter on the 'term' property for each new Tempo instance.
+ *
+ * The 'export default' is an object that stashes the plugin definitions.
+ * Tempo will use this object to define getter properties on each instance (under the 'term' property).
+ * (for example, new Tempo().term.season)
+ * The getter will not execute the code until actually referenced (lazy-loaded).
+ * In this way, we can defer the execution of the lookup until it is needed
+ * and keep a Tempo instance as light-weight as possible.
+ *
+ * In addition, the getter will be auto-replaced with the return-value of the plugin definition.
+ * (for example, the
+ * Object.defineProperty(..., ..., { get: () => { ... } })	will be overridden after first access with
+ * Object.defineProperty(..., ..., { value: ... })
+ * In this way, we can memoize the result of the plugin definition, and avoid the need to execute the lookup again.
+ */ 

package/dist/tempo.config/plugins/term.import.js

@@ -0,0 +1,44 @@
+/**
+ * import of plugins
+ */
+import * as qtr from '../../tempo.config/plugins/term.quarter.js';
+import * as szn from '../../tempo.config/plugins/term.season.js';
+import * as zdc from '../../tempo.config/plugins/term.zodiac.js';
+import * as per from '../../tempo.config/plugins/term.timeline.js';
+export default [
+    { key: qtr.key, scope: qtr.scope, description: qtr.description, define: qtr.define },
+    { key: szn.key, scope: szn.scope, description: szn.description, define: szn.define },
+    { key: zdc.key, scope: zdc.scope, description: zdc.description, define: zdc.define },
+    { key: per.key, scope: per.scope, description: per.description, define: per.define },
+];
+/**
+ * Usage:
+ * show only the 'key' field from the pre-defined range
+ * new Tempo('20-May-1957').term.qtr		# range of Fiscal Quarters
+ * 			> 'Q2'
+ * show the 'range' object that relates to the Tempo instance
+ * new Tempo('28-Aug-1968').term.quarter
+ * 			> {key: 'Q2', day: 1, month: 4, fiscal: 1969}
+ *
+ * Notes:
+ * A 'term' has two parts:
+ * 1) an array of objects that define the DateTime lower boundaries of a range
+ * (e.g.  [{key: 'Summer', day: 1, month: 12}, {key: 'Autumn', day: 1, month: 3}...])
+ * these are statically defined when the Tempo class is first imported.
+ *
+ * 2) a function which determines where a Tempo instance fits within the above range array.
+ * this function is assigned to a getter on the 'term' property for each new Tempo instance.
+ *
+ * The 'export default' is an object that stashes the plugin definitions.
+ * Tempo will use this object to define getter properties on each instance (under the 'term' property).
+ * (for example, new Tempo().term.season)
+ * The getter will not execute the code until actually referenced (lazy-loaded).
+ * In this way, we can defer the execution of the lookup until it is needed
+ * and keep a Tempo instance as light-weight as possible.
+ *
+ * In addition, the getter will be auto-replaced with the return-value of the plugin definition.
+ * (for example, the
+ * Object.defineProperty(..., ..., { get: () => { ... } })	will be overridden after first access with
+ * Object.defineProperty(..., ..., { value: ... })
+ * In this way, we can memoize the result of the plugin definition, and avoid the need to execute the lookup again.
+ */ 

package/dist/tempo.config/plugins/term.quarter.d.ts

@@ -0,0 +1,7 @@
+import { type Range } from '../../tempo.config/plugins/term.utils.js';
+import type { Tempo } from '../../tempo.class.js';
+export declare const key = "qtr";
+export declare const scope = "quarter";
+export declare const description = "Fiscal Quarter";
+/** determine where the current Tempo instance fits within the above range */
+export declare function define(this: Tempo, key?: boolean): PropertyKey | Range | undefined;

package/dist/tempo.config/plugins/term.quarter.js

@@ -0,0 +1,28 @@
+import { cloneify } from '../../serialize.library.js';
+import { COMPASS } from '../../tempo.config/tempo.enum.js';
+import { getTermRange } from '../../tempo.config/plugins/term.utils.js';
+/** definition of fiscal quarter ranges */
+const ranges = [
+    [
+        { key: 'Q1', day: 1, month: 1, fiscal: 0, sphere: COMPASS.North },
+        { key: 'Q2', day: 1, month: 4, fiscal: 0, sphere: COMPASS.North },
+        { key: 'Q3', day: 1, month: 7, fiscal: 0, sphere: COMPASS.North },
+        { key: 'Q4', day: 1, month: 10, fiscal: 0, sphere: COMPASS.North },
+    ], [
+        { key: 'Q1', day: 1, month: 7, fiscal: 1, sphere: COMPASS.South },
+        { key: 'Q2', day: 1, month: 10, fiscal: 1, sphere: COMPASS.South },
+        { key: 'Q3', day: 1, month: 1, fiscal: 0, sphere: COMPASS.South },
+        { key: 'Q4', day: 1, month: 4, fiscal: 0, sphere: COMPASS.South },
+    ]
+];
+export const key = 'qtr';
+export const scope = 'quarter';
+export const description = 'Fiscal Quarter';
+/** determine where the current Tempo instance fits within the above range */
+export function define(key) {
+    const { yy, config: { sphere } } = this;
+    const south = sphere !== COMPASS.North; // false = North, true = South
+    const list = cloneify(ranges[+south]); // deep clone the range
+    list.forEach(itm => itm.fiscal += yy); // calc the fiscal-year for quarter
+    return getTermRange(this, list, key);
+}

package/dist/tempo.config/plugins/term.season.d.ts

@@ -0,0 +1,7 @@
+import { type Range } from '../../tempo.config/plugins/term.utils.js';
+import type { Tempo } from '../../tempo.class.js';
+export declare const key = "szn";
+export declare const scope = "season";
+export declare const description = "Meteorlogical season";
+/** determine where the current Tempo instance fits within the above range */
+export declare function define(this: Tempo, keyOnly?: boolean): PropertyKey | Range | undefined;

package/dist/tempo.config/plugins/term.season.js

@@ -0,0 +1,36 @@
+import { cloneify } from '../../serialize.library.js';
+import { COMPASS } from '../../tempo.config/tempo.enum.js';
+import { getTermRange } from '../../tempo.config/plugins/term.utils.js';
+/** definition of meteorological season ranges */
+const ranges = [
+    [
+        { key: 'Spring', day: 20, month: 3, symbol: 'Flower', sphere: COMPASS.North },
+        { key: 'Summer', day: 21, month: 6, symbol: 'Sun', sphere: COMPASS.North },
+        { key: 'Autumn', day: 23, month: 9, symbol: 'Leaf', sphere: COMPASS.North },
+        { key: 'Winter', day: 22, month: 12, symbol: 'Snowflake', sphere: COMPASS.North },
+    ], [
+        { key: 'Spring', day: 1, month: 9, symbol: 'Flower', sphere: COMPASS.South },
+        { key: 'Summer', day: 1, month: 12, symbol: 'Sun', sphere: COMPASS.South },
+        { key: 'Autumn', day: 1, month: 3, symbol: 'Leaf', sphere: COMPASS.South },
+        { key: 'Winter', day: 1, month: 6, symbol: 'Snowflake', sphere: COMPASS.South },
+    ], [
+        { key: 'Spring', day: 1, month: 3, symbol: 'Flower', trait: 'A time of renewal and growth' },
+        { key: 'Summer', day: 1, month: 6, symbol: 'Sun', trait: 'A period of heat and fruition' },
+        { key: 'Autumn', day: 1, month: 9, symbol: 'Leaf', trait: 'A time for harvest and contraction' },
+        { key: 'Winter', day: 1, month: 12, symbol: 'Snowflake', trait: 'A period of stillness and consolidation' },
+    ]
+];
+export const key = 'szn';
+export const scope = 'season';
+export const description = 'Meteorlogical season';
+/** determine where the current Tempo instance fits within the above range */
+export function define(keyOnly) {
+    const { config: { sphere } } = this;
+    const south = sphere !== COMPASS.North; // false = North, true = South
+    const list = cloneify(ranges[+south]);
+    if (!keyOnly) {
+        const cn = getTermRange(this, ranges[2], false); // get the chinese season for the current day/month
+        list.forEach(item => item['CN'] = cn); // add the chinese season to each range item
+    }
+    return getTermRange(this, list, keyOnly);
+}

package/dist/tempo.config/plugins/term.timeline.d.ts

@@ -0,0 +1,7 @@
+import { type Range } from '../../tempo.config/plugins/term.utils.js';
+import type { Tempo } from '../../tempo.class.js';
+export declare const key = "per";
+export declare const scope = "period";
+export declare const description = "Daily time period";
+/** determine where the current Tempo instance fits within the above range */
+export declare function define(this: Tempo, keyOnly?: boolean): PropertyKey | Range | undefined;

package/dist/tempo.config/plugins/term.timeline.js

@@ -0,0 +1,19 @@
+import { getTermRange } from '../../tempo.config/plugins/term.utils.js';
+/** definition of daily time periods */
+const ranges = [
+    { key: 'midnight', hour: 0 },
+    { key: 'early', hour: 4 },
+    { key: 'morning', hour: 8 },
+    { key: 'midmorning', hour: 10 },
+    { key: 'midday', hour: 12 },
+    { key: 'afternoon', hour: 15, minute: 30 },
+    { key: 'evening', hour: 18 },
+    { key: 'night', hour: 20 },
+];
+export const key = 'per';
+export const scope = 'period';
+export const description = 'Daily time period';
+/** determine where the current Tempo instance fits within the above range */
+export function define(keyOnly) {
+    return getTermRange(this, ranges, keyOnly);
+}

package/dist/tempo.config/plugins/term.utils.d.ts

@@ -0,0 +1,17 @@
+import type { Tempo } from '../../tempo.class.js';
+/** Tempo.Terms lets us know where a DateTime fits within pre-defined Ranges */
+/** use this type to define a Range with a DateTime qualifier */
+export type Range = {
+    key: PropertyKey;
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    [str: PropertyKey]: any;
+};
+/**
+ * find where a Tempo fits within a range of DateTime
+ */
+export declare function getTermRange(tempo: Tempo, list: Range[], keyOnly?: boolean): PropertyKey | Range | undefined;

package/dist/tempo.config/plugins/term.utils.js

@@ -0,0 +1,38 @@
+import { isDefined } from '../../type.library.js';
+const SCHEMA = [
+    ['year', 'yy'],
+    ['month', 'mm'],
+    ['day', 'dd'],
+    ['hour', 'hh'],
+    ['minute', 'mi'],
+    ['second', 'ss'],
+    ['millisecond', 'ms'],
+    ['microsecond', 'us'],
+    ['nanosecond', 'ns']
+];
+/**
+ * find where a Tempo fits within a range of DateTime
+ */
+export function getTermRange(tempo, list, keyOnly = true) {
+    const sorted = [...list]
+        .sortBy('year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond')
+        .toReversed();
+    const match = sorted
+        .find(range => {
+        for (const [rKey, sKey] of SCHEMA) {
+            const val = range[rKey];
+            if (isDefined(val)) {
+                const sVal = tempo[sKey];
+                if (sVal > val)
+                    return true;
+                if (sVal < val)
+                    return false;
+            }
+        }
+        return true; // fallback if DateTime exactly matches a range criteria
+    })
+        ?? sorted.at(0); // fallback to wraparound at first item
+    return keyOnly
+        ? match?.key
+        : match;
+}

package/dist/tempo.config/plugins/term.zodiac.d.ts

@@ -0,0 +1,7 @@
+import { type Range } from '../../tempo.config/plugins/term.utils.js';
+import type { Tempo } from '../../tempo.class.js';
+export declare const key = "zdc";
+export declare const scope = "zodiac";
+export declare const description = "Astrological Zodiac sign";
+/** determine where the current Tempo instance fits within the above ranges */
+export declare function define(this: Tempo, keyOnly?: boolean): PropertyKey | Range | undefined;

package/dist/tempo.config/plugins/term.zodiac.js

@@ -0,0 +1,62 @@
+import { cloneify } from '../../serialize.library.js';
+import { getTermRange } from '../../tempo.config/plugins/term.utils.js';
+/** definition of astrological zodiac ranges */
+const ranges = [
+    [
+        { key: 'Aquarius', day: 20, month: 1, symbol: 'Ram', longitude: 300, planet: 'Uranus' },
+        { key: 'Pisces', day: 19, month: 2, symbol: 'Fish', longitude: 330, planet: 'Neptune' },
+        { key: 'Aries', day: 21, month: 3, symbol: 'Ram', longitude: 0, planet: 'Mars' },
+        { key: 'Taurus', day: 20, month: 4, symbol: 'Bull', longitude: 30, planet: 'Venus' },
+        { key: 'Gemini', day: 21, month: 5, symbol: 'Twins', longitude: 60, planet: 'Mercury' },
+        { key: 'Cancer', day: 22, month: 6, symbol: 'Crab', longitude: 90, planet: 'Moon' },
+        { key: 'Leo', day: 23, month: 7, symbol: 'Lion', longitude: 120, planet: 'Sun' },
+        { key: 'Virgo', day: 23, month: 8, symbol: 'Maiden', longitude: 150, planet: 'Mercury' },
+        { key: 'Libra', day: 23, month: 9, symbol: 'Scales', longitude: 180, planet: 'Venus' },
+        { key: 'Scorpio', day: 23, month: 10, symbol: 'Scorpion', longitude: 210, planet: 'Pluto & Mars' },
+        { key: 'Sagittarius', day: 22, month: 11, symbol: 'Centaur', longitude: 240, planet: 'Jupiter' },
+        { key: 'Capricorn', day: 22, month: 12, symbol: 'Goat', longitude: 270, planet: 'Saturn' },
+    ], [
+        { key: 'Rat', traits: 'Adaptable, clever' },
+        { key: 'Ox', traits: 'Diligent, strong' },
+        { key: 'Tiger', traits: 'Passionate, courageous' },
+        { key: 'Rabbit', traits: 'Artistic, gentle' },
+        { key: 'Dragon', traits: 'Powerful, charismatic' },
+        { key: 'Snake', traits: 'Wise, intuitive' },
+        { key: 'Horse', traits: 'Energetic, independent' },
+        { key: 'Goat', traits: 'Empathetic, calm' },
+        { key: 'Monkey', traits: 'Smart, curious' },
+        { key: 'Rooster', traits: 'Observant, hardworking' },
+        { key: 'Dog', traits: 'Loyal, honest' },
+        { key: 'Pig', traits: 'Compassionate, generous' },
+    ], [
+        { key: 'Wood' },
+        { key: 'Fire' },
+        { key: 'Earth' },
+        { key: 'Metal' },
+        { key: 'Water' },
+    ]
+];
+export const key = 'zdc';
+export const scope = 'zodiac';
+export const description = 'Astrological Zodiac sign';
+/** determine where the current Tempo instance fits within the above ranges */
+export function define(keyOnly) {
+    const list = cloneify(ranges[0]); // make a copy of the ranges array
+    if (!keyOnly) {
+        const cn = getChineseZodiac(this.yy); // get the chinese zodiac for the current year
+        list.forEach(item => item['CN'] = cn); // add the chinese zodiac to each item
+    }
+    return getTermRange(this, list, keyOnly);
+}
+/** get the chinese zodiac for a given year */
+function getChineseZodiac(year) {
+    const animalIndex = (year - 4) % 12; // calculate the animal index
+    const elementIndex = Math.floor(((year - 4) % 10) / 2); // calculate the element index based on the last digit of the year
+    const yinYang = year % 2 === 0 ? 'Yang' : 'Yin'; // determine Yin or Yang
+    return {
+        animal: ranges[1][animalIndex].key,
+        traits: ranges[1][animalIndex].traits,
+        element: ranges[2][elementIndex].key,
+        yinYang: yinYang
+    };
+}

package/dist/tempo.config/tempo.default.d.ts

@@ -0,0 +1,169 @@
+import type { Tempo } from '../tempo.class.js';
+/** common RegExp patterns */
+export declare const Match: {
+    /** match all {} pairs, if they start with a word char */ readonly braces: RegExp;
+    /** named capture-group, if it starts with a letter */ readonly captures: RegExp;
+    /** event */ readonly event: RegExp;
+    /** period */ readonly period: RegExp;
+    /** two digit year */ readonly twoDigit: RegExp;
+    /** hour-minute-second with no separator */ readonly hhmiss: RegExp;
+    /** separator characters (/ - . ,) */ readonly separator: RegExp;
+    /** modifier characters (+-<>=) */ readonly modifier: RegExp;
+    /** offset post keywords (ago|hence) */ readonly affix: RegExp;
+    /** strip out these characters from a string */ readonly strips: RegExp;
+};
+/** Tempo Symbol registry */
+export declare const Token: import("../type.library.js").Extend<{
+    /** year */ readonly yy: symbol;
+    /** month */ readonly mm: symbol;
+    /** day */ readonly dd: symbol;
+    /** hour */ readonly hh: symbol;
+    /** minute */ readonly mi: symbol;
+    /** second */ readonly ss: symbol;
+    /** fraction */ readonly ff: symbol;
+    /** meridiem */ readonly mer: symbol;
+    /** short weekday name */ readonly www: symbol;
+    /** relative-suffix */ readonly afx: symbol;
+    /** time-suffix */ readonly sfx: symbol;
+    /** time unit */ readonly unt: symbol;
+    /** separator */ readonly sep: symbol;
+    /** modifier */ readonly mod: symbol;
+    /** generic number */ readonly nbr: symbol;
+    /** Tempo event */ readonly evt: symbol;
+    /** Tempo period */ readonly per: symbol;
+    /** time zone offset */ readonly tzd: symbol;
+    /** date */ readonly dt: symbol;
+    /** time */ readonly tm: symbol;
+    /** date and time */ readonly dtm: symbol;
+    /** day-month-year */ readonly dmy: symbol;
+    /** month-day-year */ readonly mdy: symbol;
+    /** year-month-day */ readonly ymd: symbol;
+    /** day of month offset */ readonly off: symbol;
+    /** weekDay */ readonly wkd: symbol;
+    /** relative offset (years, days, hours, etc) */ readonly rel: symbol;
+}, string, symbol>;
+export type Token = typeof Token;
+/**
+ * user will need to know these in order to configure their own patterns
+ * Tempo.Snippet is a simple regex pattern object						, e.g. { Symbol('yy'): /(([0-9]{2})?[0-9]{2})/ }
+ * Tempo.Layout is a string-combination of Snippet names		, e.g. '{yy}{sep}{mm}({sep}{dd})?{sfx}?'
+ * Tempo.Pattern is a translation of a Layout/Snippets into an anchored regex.
+ * The {pattern} is used to parse a string | number in the Tempo constructor {DateTime} argument
+ */
+/**
+ * a {snippet} is a simple, reusable regex pattern for a component of a date-time string (e.g. 'hh' or 'yy')
+ */
+export declare const Snippet: import("../type.library.js").Extend<{
+    readonly [Token.yy]: RegExp;
+    readonly [Token.mm]: RegExp;
+    readonly [Token.dd]: RegExp;
+    readonly [Token.hh]: RegExp;
+    readonly [Token.mi]: RegExp;
+    readonly [Token.ss]: RegExp;
+    readonly [Token.ff]: RegExp;
+    readonly [Token.mer]: RegExp;
+    readonly [Token.sfx]: RegExp;
+    readonly [Token.wkd]: RegExp;
+    readonly [Token.tzd]: RegExp;
+    readonly [Token.nbr]: RegExp;
+    readonly [Token.afx]: RegExp;
+    readonly [Token.mod]: RegExp;
+    readonly [Token.sep]: RegExp;
+    readonly [Token.unt]: RegExp;
+}, symbol, RegExp>;
+export type Snippet = typeof Snippet;
+/**
+ * a {layout} is a Record of snippet-combinations describing an input DateTime argument
+ * the Layout's keys are in the order that they will be checked against an input value
+ */
+export declare const Layout: import("../type.library.js").Extend<{
+    readonly [Token.dt]: "{dd}{sep}?{mm}({sep}?{yy})?|{mod}?({evt})";
+    readonly [Token.tm]: "({hh}{mi}?{ss}?{ff}?{mer}?|{per})";
+    readonly [Token.dtm]: "({dt}){sfx}?";
+    readonly [Token.dmy]: "({wkd}{sep}+)?{dd}{sep}?{mm}({sep}?{yy})?{sfx}?";
+    readonly [Token.mdy]: "({wkd}{sep}+)?{mm}{sep}?{dd}({sep}?{yy})?{sfx}?";
+    readonly [Token.ymd]: "({wkd}{sep}+)?{yy}{sep}?{mm}({sep}?{dd})?{sfx}?";
+    readonly [Token.wkd]: "{mod}?{wkd}{afx}?{sfx}?";
+    readonly [Token.off]: "{mod}?{dd}{afx}?";
+    readonly [Token.rel]: "{nbr}{sep}?{unt}{sep}?{afx}";
+}, symbol, string>;
+export type Layout = typeof Layout;
+/**
+ * an {event} is a Record of regex-pattern-like-string keys that describe Date strings.
+ * values can be a string or a function.
+ * if assigning a function, use standard 'function()' syntax to allow for 'this' binding.
+ * also, a function should always have a .toString() method which returns a parse-able Date string
+ */
+export declare const Event: import("../type.library.js").Extend<{
+    readonly 'new.?years? ?eve': "31 Dec";
+    readonly nye: "31 Dec";
+    readonly 'new.?years?( ?day)?': "01 Jan";
+    readonly ny: "01 Jan";
+    readonly 'christmas ?eve': "24 Dec";
+    readonly christmas: "25 Dec";
+    readonly 'xmas ?eve': "24 Dec";
+    readonly xmas: "25 Dec";
+    readonly now: (this: any) => Temporal.Instant;
+    readonly today: (this: any) => Temporal.PlainDate;
+    readonly tomorrow: (this: any) => Temporal.PlainDate;
+    readonly yesterday: (this: any) => Temporal.PlainDate;
+}, string, string | Function>;
+export type Event = typeof Event;
+/**
+ * a {period} is a Record of regex-pattern-like keys that describe pre-defined Time strings.
+ * values can be a string or a function.
+ * if using a function, use regular 'function()' syntax to allow for 'this' binding.
+ */
+export declare const Period: import("../type.library.js").Extend<{
+    readonly 'mid[ -]?night': "24:00";
+    readonly morning: "8:00";
+    readonly 'mid[ -]?morning': "10:00";
+    readonly 'mid[ -]?day': "12:00";
+    readonly noon: "12:00";
+    readonly 'after[ -]?noon': "3:00pm";
+    readonly evening: "18:00";
+    readonly night: "20:00";
+}, string, string | Function>;
+export type Period = typeof Period;
+/**
+ * a {timeZone} alias dictionary mapping common abbreviations to IANA strings.
+ * Tempo will check this registry to convert abbreviations before passing them to Temporal.
+ */
+export declare const TimeZone: import("../type.library.js").Extend<{
+    readonly utc: "UTC";
+    readonly gmt: "Europe/London";
+    readonly est: "America/New_York";
+    readonly cst: "America/Chicago";
+    readonly mst: "America/Denver";
+    readonly pst: "America/Los_Angeles";
+    readonly aest: "Australia/Sydney";
+    readonly acst: "Australia/Adelaide";
+    readonly awst: "Australia/Perth";
+    readonly nzt: "Pacific/Auckland";
+    readonly cet: "Europe/Paris";
+    readonly eet: "Europe/Helsinki";
+    readonly ist: "Asia/Kolkata";
+    readonly npt: "Asia/Kathmandu";
+    readonly jst: "Asia/Tokyo";
+}, string, string>;
+export type TimeZone = typeof TimeZone;
+/** Reasonable default options for initial Tempo config */
+export declare const Options: readonly ["value", "mdyLocales", "mdyLayouts", "store", "debug", "catch", "timeZone", "calendar", "locale", "pivot", "sphere", "timeStamp", "snippet", "layout", "event", "period"];
+export declare const Default: import("../type.library.js").SecureObject<Partial<{
+    store: string;
+    debug: boolean | undefined;
+    catch: boolean | undefined;
+    timeZone: string;
+    calendar: string;
+    locale: string;
+    pivot: number;
+    sphere: Tempo.COMPASS | undefined;
+    timeStamp: Tempo.TimeStamp;
+    mdyLocales: string | string[];
+    mdyLayouts: [string, string][];
+    snippet: Snippet | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]);
+    layout: Layout | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | (string | RegExp | Record<string | symbol, string | RegExp> | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]);
+    event: Event | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]);
+    period: Period | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | (string | Function | Record<string | symbol, string | Function> | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]);
+    value: Tempo.DateTime;
+}>>;