luxon/000755 001751 000166 0000000000 14772617435013754 5ustar00runner000000 000000 1477261743514772617435luxon/LICENSE000644 001751 000166 0000002165 14772617435014765 0ustar00runner000000 000000 1477261743514772617435 MIT License Copyright (c) Microsoft Corporation. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE luxon/README.md000644 001751 000166 0000001015 14772617435015230 0ustar00runner000000 000000 1477261743514772617435# Installation > `npm install --save @types/luxon` # Summary This package contains type definitions for luxon (https://github.com/moment/luxon#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/luxon. ### Additional Details * Last updated: Mon, 31 Mar 2025 23:02:53 GMT * Dependencies: none # Credits These definitions were written by [Carson Full](https://github.com/carsonf), and [Piotr Błażejewicz](https://github.com/peterblazejewicz). luxon/index.d.ts000644 001751 000166 0000000135 14772617435015654 0ustar00runner000000 000000 1477261743514772617435// Minimum TypeScript Version: 4.3 export * from "./src/luxon"; export as namespace luxon; luxon/package.json000644 001751 000166 0000001716 14772617435016247 0ustar00runner000000 000000 1477261743514772617435{ "name": "@types/luxon", "version": "3.6.0", "description": "TypeScript definitions for luxon", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/luxon", "license": "MIT", "contributors": [ { "name": "Carson Full", "githubUsername": "carsonf", "url": "https://github.com/carsonf" }, { "name": "Piotr Błażejewicz", "githubUsername": "peterblazejewicz", "url": "https://github.com/peterblazejewicz" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/luxon" }, "scripts": {}, "dependencies": {}, "peerDependencies": {}, "typesPublisherContentHash": "dfd833e6b5159855e1d3cf1f0bc6e27d6b8aff63e28fb0ebe46b9833e219fe03", "typeScriptVersion": "5.1" }luxon/src/000755 001751 000166 0000000000 14772617435014543 5ustar00runner000000 000000 1477261743514772617435luxon/src/_util.d.ts000644 001751 000166 0000000776 14772617435016463 0ustar00runner000000 000000 1477261743514772617435import { TSSettings } from "./settings"; export type CanBeInvalid = TSSettings extends { throwOnInvalid: true } ? false : true; export type DefaultValidity = CanBeInvalid extends true ? boolean : true; export type IfValid = ThisIsValid extends true ? ValidType : ThisIsValid extends false ? InvalidType : CanBeInvalid extends true ? ValidType | InvalidType : ValidType; export type Valid = true; export type Invalid = false; luxon/src/datetime.d.ts000644 001751 000166 0000203130 14772617435017130 0ustar00runner000000 000000 1477261743514772617435import { CalendarSystem, DateTimeFormatOptions, NumberingSystem, StringUnitLength, ToISOFormat, ToISOTimeDurationOptions, WeekSettings, ZoneOptions, } from "../index"; import { CanBeInvalid, DefaultValidity, IfValid, Invalid, Valid } from "./_util"; import { Duration, DurationLike, DurationUnits } from "./duration"; import { Interval } from "./interval"; import { Zone } from "./zone"; export {}; // Turn off default exports export type DateTimeUnit = "year" | "quarter" | "month" | "week" | "day" | "hour" | "minute" | "second" | "millisecond"; export type ToRelativeUnit = "years" | "quarters" | "months" | "weeks" | "days" | "hours" | "minutes" | "seconds"; export type MonthNumbers = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; export type WeekdayNumbers = 1 | 2 | 3 | 4 | 5 | 6 | 7; export type DayNumbers = | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31; export type SecondNumbers = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59; export type MinuteNumbers = SecondNumbers; export type HourNumbers = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23; export type WeekNumbers = | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53; export type QuarterNumbers = 1 | 2 | 3 | 4; export type PossibleDaysInMonth = 28 | 29 | 30 | 31; export type PossibleDaysInYear = 365 | 366; export type PossibleWeeksInYear = 52 | 53; export type ToObjectOutput< IncludeConfig extends boolean | undefined = undefined, IsValid extends boolean | undefined = undefined, > = IsValid extends true ? _ToObjectOutput : CanBeInvalid extends false ? _ToObjectOutput : Partial<_ToObjectOutput>; /** @internal */ export type _ToObjectOutput = & Record<_ToObjectUnit, number> & (IncludeConfig extends true ? LocaleOptions : unknown); /** @internal */ export type _ToObjectUnit = Exclude; export interface ToRelativeOptions extends Omit { /** * @default long */ style?: StringUnitLength | undefined; /** @default true */ round?: boolean | undefined; /** * Padding in milliseconds. This allows you to round up the result if it fits inside the threshold. * Do not use this in combination with `{round: false}` because the decimal output will include the padding. * @default 0 */ padding?: number | undefined; /** * A single unit or an array of units. If an array is supplied, the method will pick the best one * to use from the array. If omitted, the method will pick the unit from a default set. */ unit?: ToRelativeUnit | ToRelativeUnit[] | undefined; } export interface ToRelativeCalendarOptions { /** * The DateTime to use as the basis to which this time is compared * @default now */ base?: DateTime | undefined; /** * Override the locale of this DateTime */ locale?: string | undefined; /** If omitted, the method will pick the unit. */ unit?: ToRelativeUnit | undefined; /** * Override the numberingSystem of this DateTime. * The Intl system may choose not to honor this. */ numberingSystem?: NumberingSystem | undefined; } export interface ToSQLOptions { /** * Include the offset, such as 'Z' or '-04:00' * @default true */ includeOffset?: boolean | undefined; /** * Include the zone, such as 'America/New_York'. Overrides includeOffset. * @default false */ includeZone?: boolean | undefined; /** * include the space between the time and the offset, such as '05:15:16.345 -04:00' * @default true */ includeOffsetSpace?: boolean; } export interface ToISODateOptions { /** * Choose between the basic and extended format * @default 'extended' */ format?: ToISOFormat | undefined; } export interface ToISOTimeOptions extends ToISOTimeDurationOptions { /** * Include the offset, such as 'Z' or '-04:00' * @default true */ includeOffset?: boolean | undefined; /** * add the time zone format extension * @default false */ extendedZone?: boolean | undefined; } /** @deprecated alias for backwards compatibility */ export type ISOTimeOptions = ToISOTimeOptions; export interface LocaleOptions { /** * @default system's locale */ locale?: string | undefined; outputCalendar?: CalendarSystem | undefined; numberingSystem?: NumberingSystem | undefined; weekSettings?: WeekSettings | undefined; } export type ResolvedLocaleOptions = Required; export interface DateTimeOptions extends LocaleOptions { /** * Use this zone if no offset is specified in the input string itself. Will also convert the time to this zone. * @default local */ zone?: string | Zone | undefined; /** * Override the zone with a fixed-offset zone specified in the string itself, if it specifies one. * @default false */ setZone?: boolean | undefined; } export type DateTimeJSOptions = Omit; /** * Note that ISO weekday and local weekday fields are mutually exclusive */ export interface DateObjectUnits { // a year, such as 1987 year?: number | undefined; // a month, 1-12 month?: number | undefined; // a day of the month, 1-31, depending on the month day?: number | undefined; // day of the year, 1-365 or 366 ordinal?: number | undefined; // an ISO week year weekYear?: number | undefined; // a week year, according to the locale localWeekYear?: number | undefined; // an ISO week number, between 1 and 52 or 53, depending on the year weekNumber?: number | undefined; // a week number, between 1 and 52 or 53, depending on the year, according to the locale localWeekNumber?: number | undefined; // an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday weekday?: WeekdayNumbers | undefined; // a weekday, 1-7, where 1 is the first day of the week, and 7 is the last, according to the locale localWeekday?: WeekdayNumbers | undefined; // hour of the day, 0-23 hour?: number | undefined; // minute of the hour, 0-59 minute?: number | undefined; // second of the minute, 0-59 second?: number | undefined; // millisecond of the second, 0-999 millisecond?: number | undefined; } export type ConversionAccuracy = "casual" | "longterm"; /** * @deprecated You should use `Intl.DateTimeFormatOptions` fields and values instead. */ export type DateTimeFormatPresetValue = "numeric" | "short" | "long"; /** * @deprecated Use `Intl.DateTimeFormatOptions` instead. */ export type DateTimeFormatPreset = Intl.DateTimeFormatOptions; export interface DiffOptions { /** * @default 'casual' */ conversionAccuracy?: ConversionAccuracy | undefined; } export interface _UseLocaleWeekOption { /** If true, use weeks based on the locale, i.e., use the locale-dependent start of the week */ useLocaleWeeks?: boolean; } export type HasSameOptions = _UseLocaleWeekOption; export type StartOfOptions = _UseLocaleWeekOption; export type EndOfOptions = _UseLocaleWeekOption; export interface ExplainedFormat { input: string; tokens: Array<{ literal: boolean; val: string }>; regex?: RegExp | undefined; rawMatches?: RegExpMatchArray | null | undefined; matches?: { [k: string]: any } | undefined; result?: { [k: string]: any } | null | undefined; zone?: Zone | null | undefined; invalidReason?: string | undefined; } export type DateTimeMaybeValid = CanBeInvalid extends true ? (DateTime | DateTime) : DateTime; declare const tokenParserBrand: unique symbol; export interface TokenParser { [tokenParserBrand]: true; } /** * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. * It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them. * * A DateTime consists of the following parts: * * A timestamp. Each DateTime instance refers to a specific millisecond of the Unix epoch. * * A time zone. Each instance is considered in the context of a specific zone (by default, the local system's zone). * * Configuration properties that affect how output strings are formatted, such as `locale`, `numberingSystem`, and `outputCalendar`. * * Here is a brief overview of the most commonly used functionality it provides: * * * **Creation**: To create a DateTime from its components, use one of its factory class methods: {@link DateTime.local}, {@link DateTime.utc}, and (most flexibly) {@link DateTime.fromObject}. * To create one from a standard string format, use {@link DateTime.fromISO}, {@link DateTime.fromHTTP}, and {@link DateTime.fromRFC2822}. * To create one from a custom string format, use {@link DateTime.fromFormat}. To create one from a native JS date, use {@link DateTime.fromJSDate}. * * **Gregorian calendar and time**: To examine the Gregorian properties of a DateTime individually (i.e. as opposed to collectively through {@link DateTime#toObject}), use the {@link DateTime#year}, * {@link DateTime#month}, {@link DateTime#day}, {@link DateTime#hour}, {@link DateTime#minute}, {@link DateTime#second}, {@link DateTime#millisecond} accessors. * * **Week calendar**: For ISO week calendar attributes, see the {@link DateTime#weekYear}, {@link DateTime#weekNumber}, and {@link DateTime#weekday} accessors. * * **Configuration** See the {@link DateTime#locale} and {@link DateTime#numberingSystem} accessors. * * **Transformation**: To transform the DateTime into other DateTimes, use {@link DateTime#set}, {@link DateTime#reconfigure}, {@link DateTime#setZone}, {@link DateTime#setLocale}, * {@link DateTime.plus}, {@link DateTime#minus}, {@link DateTime#endOf}, {@link DateTime#startOf}, {@link DateTime#toUTC}, and {@link DateTime#toLocal}. * * **Output**: To convert the DateTime to other representations, use the {@link DateTime#toRelative}, {@link DateTime#toRelativeCalendar}, {@link DateTime#toJSON}, {@link DateTime#toISO}, * {@link DateTime#toHTTP}, {@link DateTime#toObject}, {@link DateTime#toRFC2822}, {@link DateTime#toString}, {@link DateTime#toLocaleString}, {@link DateTime#toFormat}, * {@link DateTime#toMillis} and {@link DateTime#toJSDate}. * * There's plenty others documented below. In addition, for more information on subtler topics * like internationalization, time zones, alternative calendars, validity, and so on, see the external documentation. */ export class DateTime { /** * Create a DateTime for the current instant, in the system's time zone. * * Use Settings to override these default values if needed. * @example * DateTime.now().toISO() //~> now in the ISO format */ static now(): DateTime; /** * Create a local DateTime * * @param year - The calendar year. If omitted (as in, call `local()` with no arguments), the current time will be used * @param month - The month, 1-indexed * @param day - The day of the month, 1-indexed * @param hour - The hour of the day, in 24-hour time * @param minute - The minute of the hour, meaning a number between 0 and 59 * @param second - The second of the minute, meaning a number between 0 and 59 * @param millisecond - The millisecond of the second, meaning a number between 0 and 999 * @param opts * * @example * DateTime.local() //~> now * @example * DateTime.local({ zone: "America/New_York" }) //~> now, in US east coast time * @example * DateTime.local(2017) //~> 2017-01-01T00:00:00 * @example * DateTime.local(2017, 3) //~> 2017-03-01T00:00:00 * @example * DateTime.local(2017, 3, 12, { locale: "fr") //~> 2017-03-12T00:00:00, with a French locale * @example * DateTime.local(2017, 3, 12, 5) //~> 2017-03-12T05:00:00 * @example * DateTime.local(2017, 3, 12, 5, { zone: "utc" }) //~> 2017-03-12T05:00:00, in UTC * @example * DateTime.local(2017, 3, 12, 5, 45) //~> 2017-03-12T05:45:00 * @example * DateTime.local(2017, 3, 12, 5, 45, 10) //~> 2017-03-12T05:45:10 * @example * DateTime.local(2017, 3, 12, 5, 45, 10, 765) //~> 2017-03-12T05:45:10.765 */ static local( year: number, month: number, day: number, hour: number, minute: number, second: number, millisecond: number, opts?: DateTimeJSOptions, ): DateTimeMaybeValid; static local( year: number, month: number, day: number, hour: number, minute: number, second: number, opts?: DateTimeJSOptions, ): DateTimeMaybeValid; static local( year: number, month: number, day: number, hour: number, minute: number, opts?: DateTimeJSOptions, ): DateTimeMaybeValid; static local(year: number, month: number, day: number, hour: number, opts?: DateTimeJSOptions): DateTimeMaybeValid; static local(year: number, month: number, day: number, opts?: DateTimeJSOptions): DateTimeMaybeValid; static local(year: number, month: number, opts?: DateTimeJSOptions): DateTimeMaybeValid; static local(year: number, opts?: DateTimeJSOptions): DateTimeMaybeValid; static local(opts?: DateTimeJSOptions): DateTime; /** * Create a DateTime in UTC * * @param year - The calendar year. If omitted (as in, call `utc()` with no arguments), the current time will be used * @param month - The month, 1-indexed * @param day - The day of the month * @param hour - The hour of the day, in 24-hour time * @param minute - The minute of the hour, meaning a number between 0 and 59 * @param second - The second of the minute, meaning a number between 0 and 59 * @param millisecond - The millisecond of the second, meaning a number between 0 and 999 * @param options - configuration options for the DateTime * @param options.locale - a locale to set on the resulting DateTime instance * @param options.outputCalendar - the output calendar to set on the resulting DateTime instance * @param options.numberingSystem - the numbering system to set on the resulting DateTime instance * * @example * DateTime.utc() //~> now * @example * DateTime.utc(2017) //~> 2017-01-01T00:00:00Z * @example * DateTime.utc(2017, 3) //~> 2017-03-01T00:00:00Z * @example * DateTime.utc(2017, 3, 12) //~> 2017-03-12T00:00:00Z * @example * DateTime.utc(2017, 3, 12, 5) //~> 2017-03-12T05:00:00Z * @example * DateTime.utc(2017, 3, 12, 5, 45) //~> 2017-03-12T05:45:00Z * @example * DateTime.utc(2017, 3, 12, 5, 45, { locale: "fr" } ) //~> 2017-03-12T05:45:00Z with a French locale * @example * DateTime.utc(2017, 3, 12, 5, 45, 10) //~> 2017-03-12T05:45:10Z * @example * DateTime.utc(2017, 3, 12, 5, 45, 10, 765, { locale: "fr") //~> 2017-03-12T05:45:10.765Z with a French locale */ static utc( year: number, month: number, day: number, hour: number, minute: number, second: number, millisecond: number, options?: LocaleOptions, ): DateTimeMaybeValid; static utc( year: number, month: number, day: number, hour: number, minute: number, second: number, options?: LocaleOptions, ): DateTimeMaybeValid; static utc( year: number, month: number, day: number, hour: number, minute: number, options?: LocaleOptions, ): DateTimeMaybeValid; static utc(year: number, month: number, day: number, hour: number, options?: LocaleOptions): DateTimeMaybeValid; static utc(year: number, month: number, day: number, options?: LocaleOptions): DateTimeMaybeValid; static utc(year: number, month: number, options?: LocaleOptions): DateTimeMaybeValid; static utc(year: number, options?: LocaleOptions): DateTimeMaybeValid; static utc(options?: LocaleOptions): DateTime; /** * Create a DateTime from a JavaScript Date object. Uses the default zone. * * @param date - a JavaScript Date object * @param options - configuration options for the DateTime * @param options.zone - the zone to place the DateTime into */ static fromJSDate(date: Date, options?: { zone?: string | Zone }): DateTimeMaybeValid; /** * Create a DateTime from a number of milliseconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone. * * @param milliseconds - a number of milliseconds since 1970 UTC * @param options - configuration options for the DateTime * @param options.zone - the zone to place the DateTime into. Defaults to 'local'. * @param options.locale - a locale to set on the resulting DateTime instance * @param options.outputCalendar - the output calendar to set on the resulting DateTime instance * @param options.numberingSystem - the numbering system to set on the resulting DateTime instance */ static fromMillis(milliseconds: number, options?: DateTimeJSOptions): DateTimeMaybeValid; /** * Create a DateTime from a number of seconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone. * * @param seconds - a number of seconds since 1970 UTC * @param options - configuration options for the DateTime * @param options.zone - the zone to place the DateTime into. Defaults to 'local'. * @param options.locale - a locale to set on the resulting DateTime instance * @param options.outputCalendar - the output calendar to set on the resulting DateTime instance * @param options.numberingSystem - the numbering system to set on the resulting DateTime instance */ static fromSeconds(seconds: number, options?: DateTimeJSOptions): DateTime; /** * Create a DateTime from a JavaScript object with keys like 'year' and 'hour' with reasonable defaults. * * @param obj - the object to create the DateTime from * @param obj.year - a year, such as 1987 * @param obj.month - a month, 1-12 * @param obj.day - a day of the month, 1-31, depending on the month * @param obj.ordinal - day of the year, 1-365 or 366 * @param obj.weekYear - an ISO week year * @param obj.weekNumber - an ISO week number, between 1 and 52 or 53, depending on the year * @param obj.weekday - an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday * @param obj.hour - hour of the day, 0-23 * @param obj.minute - minute of the hour, 0-59 * @param obj.second - second of the minute, 0-59 * @param obj.millisecond - millisecond of the second, 0-999 * @param opts - options for creating this DateTime * @param opts.zone - interpret the numbers in the context of a particular zone. Can take any value taken as the first argument to setZone(). Defaults to 'local'. * @param opts.locale - a locale to set on the resulting DateTime instance. Defaults to 'system's locale'. * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance * @param opts.numberingSystem - the numbering system to set on the resulting DateTime instance * * @example * DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25' * @example * DateTime.fromObject({ year: 1982 }).toISODate() //=> '1982-01-01' * @example * DateTime.fromObject({ hour: 10, minute: 26, second: 6 }) //=> today at 10:26:06 * @example * DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'utc' }) * @example * DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'local' }) * @example * DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'America/New_York' }) * @example * DateTime.fromObject({ weekYear: 2016, weekNumber: 2, weekday: 3 }).toISODate() //=> '2016-01-13' * @example * DateTime.fromObject({ localWeekYear: 2022, localWeekNumber: 1, localWeekday: 1 }, { locale: 'en-US' }).toISODate() //=> '2021-12-26' */ static fromObject(obj: DateObjectUnits, opts?: DateTimeJSOptions): DateTimeMaybeValid; /** * Create a DateTime from an ISO 8601 string * * @param text - the ISO string * @param opts - options to affect the creation * @param opts.zone - use this zone if no offset is specified in the input string itself. Will also convert the time to this zone. Defaults to 'local'. * @param opts.setZone - override the zone with a fixed-offset zone specified in the string itself, if it specifies one. Defaults to false. * @param opts.locale - a locale to set on the resulting DateTime instance. Defaults to 'system's locale'. * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance * @param opts.numberingSystem - the numbering system to set on the resulting DateTime instance * * @example * DateTime.fromISO('2016-05-25T09:08:34.123') * @example * DateTime.fromISO('2016-05-25T09:08:34.123+06:00') * @example * DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true}) * @example * DateTime.fromISO('2016-05-25T09:08:34.123', {zone: 'utc'}) * @example * DateTime.fromISO('2016-W05-4') */ static fromISO(text: string, opts?: DateTimeOptions): DateTimeMaybeValid; /** * Create a DateTime from an RFC 2822 string * * @param text - the RFC 2822 string * @param opts - options to affect the creation * @param opts.zone - convert the time to this zone. Since the offset is always specified in the string itself, * this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in. Defaults to 'local' * @param opts.setZone - override the zone with a fixed-offset zone specified in the string itself, if it specifies one. Defaults to false. * @param opts.locale - a locale to set on the resulting DateTime instance. Defaults to 'system's locale'. * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance * @param opts.numberingSystem - the numbering system to set on the resulting DateTime instance * * @example * DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT') * @example * DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600') * @example * DateTime.fromRFC2822('25 Nov 2016 13:23 Z') */ static fromRFC2822(text: string, opts?: DateTimeOptions): DateTimeMaybeValid; /** * Create a DateTime from an HTTP header date * * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1 * * @param text - the HTTP header date * @param opts - options to affect the creation * @param opts.zone - convert the time to this zone. Since HTTP dates are always in UTC, * this has no effect on the interpretation of string,merely the zone the resulting DateTime is expressed in. Defaults to 'local'. * @param opts.setZone - override the zone with the fixed-offset zone specified in the string. For HTTP dates, this is always UTC, * so this option is equivalent to setting the `zone` option to 'utc', but this option is included for consistency with similar methods. Defaults to false. * @param opts.locale - a locale to set on the resulting DateTime instance. Defaults to 'system's locale'. * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance * @param opts.numberingSystem - the numbering system to set on the resulting DateTime instance * * @example * DateTime.fromHTTP('Sun, 06 Nov 1994 08:49:37 GMT') * @example * DateTime.fromHTTP('Sunday, 06-Nov-94 08:49:37 GMT') * @example * DateTime.fromHTTP('Sun Nov 6 08:49:37 1994') */ static fromHTTP(text: string, opts?: DateTimeOptions): DateTimeMaybeValid; /** * Create a DateTime from an input string and format string. * Defaults to en-US if no locale has been specified, regardless of the system's locale. For a table of tokens and their interpretations, * see [here](https://moment.github.io/luxon/#/parsing?id=table-of-tokens). * * @param text - the string to parse * @param fmt - the format the string is expected to be in (see the link below for the formats) * @param opts - options to affect the creation * @param opts.zone - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone. Defaults to 'local'. * @param opts.setZone - override the zone with a zone specified in the string itself, if it specifies one. Defaults to false. * @param opts.locale - a locale string to use when parsing. Will also set the DateTime to this locale. Defaults to 'en-US'. * @param opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance */ static fromFormat(text: string, fmt: string, opts?: DateTimeOptions): DateTimeMaybeValid; /** * @deprecated use fromFormat instead */ static fromString(text: string, format: string, options?: DateTimeOptions): DateTimeMaybeValid; /** * Create a DateTime from a SQL date, time, or datetime * Defaults to en-US if no locale has been specified, regardless of the system's locale * * @param text - the string to parse * @param opts - options to affect the creation * @param opts.zone - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone. Defaults to 'local'. * @param opts.setZone - override the zone with a zone specified in the string itself, if it specifies one. Defaults to false. * @param opts.locale - a locale string to use when parsing. Will also set the DateTime to this locale. Defaults to 'en-US'. * @param opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system * @param opts.outputCalendar - the output calendar to set on the resulting DateTime instance * * @example * DateTime.fromSQL('2017-05-15') * @example * DateTime.fromSQL('2017-05-15 09:12:34') * @example * DateTime.fromSQL('2017-05-15 09:12:34.342') * @example * DateTime.fromSQL('2017-05-15 09:12:34.342+06:00') * @example * DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles') * @example * DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles', { setZone: true }) * @example * DateTime.fromSQL('2017-05-15 09:12:34.342', { zone: 'America/Los_Angeles' }) * @example * DateTime.fromSQL('09:12:34.342') */ static fromSQL(text: string, opts?: DateTimeOptions): DateTimeMaybeValid; /** * Create an invalid DateTime. * * @param reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent * @param explanation - longer explanation, may include parameters and other useful debugging information. Defaults to null. */ static invalid(reason: string, explanation?: string): DateTime; /** * Check if an object is a DateTime. Works across context boundaries * * @param o */ static isDateTime(o: unknown): o is DateTimeMaybeValid; /** * Produce the format string for a set of options * * @param formatOpts - Intl.DateTimeFormat constructor options and configuration options * @param localeOpts - Opts to override the configuration options on this DateTime * * @example * DateTime.parseFormatForOpts(DateTime.DATETIME_FULL); //=> "MMMM d, yyyyy, h:m a ZZZ" */ static parseFormatForOpts(formatOpts?: DateTimeFormatOptions, localeOpts?: LocaleOptions): string | null; /** * Produce the fully expanded format token for the locale * Does NOT quote characters, so quoted tokens will not round trip correctly * @param fmt - the format string * @param localeOpts - Opts to override the configuration options on this DateTime */ static expandFormat(fmt: string, localeOpts?: LocaleOptions): string; private constructor(config: unknown); // INFO /** * Get the value of unit. * * @param unit - a unit such as 'minute' or 'day' * * @example * DateTime.local(2017, 7, 4).get('month'); //=> 7 * @example * DateTime.local(2017, 7, 4).get('day'); //=> 4 */ get(unit: keyof DateTime): number; /** * Get those DateTimes which have the same local time as this DateTime, but a different offset from UTC in this DateTime's zone. * During DST changes local time can be ambiguous, for example 2023-10-29T02:30:00 in Europe/Berlin can have offset +01:00 or +02:00. * This method will return both possible DateTimes if this DateTime's local time is ambiguous. */ getPossibleOffsets(): this[]; /** * Returns whether the DateTime is valid. Invalid DateTimes occur when: * * The DateTime was created from invalid calendar information, such as the 13th month or February 30 * * The DateTime was created by an operation on another invalid date */ get isValid(): IfValid; /** * Returns an error code if this DateTime is invalid, or null if the DateTime is valid */ get invalidReason(): IfValid; /** * Returns an explanation of why this DateTime became invalid, or null if the DateTime is valid */ get invalidExplanation(): IfValid; /** * Get the locale of a DateTime, such as 'en-GB'. The locale is used when formatting the DateTime */ get locale(): IfValid; /** * Get the numbering system of a DateTime, such as 'beng'. The numbering system is used when formatting the DateTime */ get numberingSystem(): IfValid; /** * Get the output calendar of a DateTime, such as 'islamic'. The output calendar is used when formatting the DateTime */ get outputCalendar(): IfValid; /** * Get the time zone associated with this DateTime. */ get zone(): Zone; /** * Get the name of the time zone. */ get zoneName(): IfValid; /** * Get the year * * @example DateTime.local(2017, 5, 25).year //=> 2017 */ get year(): IfValid; /** * Get the quarter * * @example DateTime.local(2017, 5, 25).quarter //=> 2 */ get quarter(): IfValid; /** * Get the month (1-12). * * @example DateTime.local(2017, 5, 25).month //=> 5 */ get month(): IfValid; /** * Get the day of the month (1-30ish). * * @example DateTime.local(2017, 5, 25).day //=> 25 */ get day(): IfValid; /** * Get the hour of the day (0-23). * * @example DateTime.local(2017, 5, 25, 9).hour //=> 9 */ get hour(): IfValid; /** * Get the minute of the hour (0-59). * * @example * DateTime.local(2017, 5, 25, 9, 30).minute //=> 30 */ get minute(): IfValid; /** * Get the second of the minute (0-59). * * @example * DateTime.local(2017, 5, 25, 9, 30, 52).second //=> 52 */ get second(): IfValid; /** * Get the millisecond of the second (0-999). * * @example * DateTime.local(2017, 5, 25, 9, 30, 52, 654).millisecond //=> 654 */ get millisecond(): IfValid; /** * Get the week year * @see https://en.wikipedia.org/wiki/ISO_week_date * * @example * DateTime.local(2014, 12, 31).weekYear //=> 2015 */ get weekYear(): IfValid; /** * Get the week number of the week year (1-52ish). * @see https://en.wikipedia.org/wiki/ISO_week_date * * @example * DateTime.local(2017, 5, 25).weekNumber //=> 21 */ get weekNumber(): IfValid; /** * Get the day of the week. * 1 is Monday and 7 is Sunday * @see https://en.wikipedia.org/wiki/ISO_week_date * * @example * DateTime.local(2014, 11, 31).weekday //=> 4 */ get weekday(): IfValid; /** * Returns true if this date is on a weekend, according to the locale, false otherwise */ get isWeekend(): IfValid; /** * Get the day of the week, according to the locale. * 1 is the first day of the week, and 7 is the last day of the week. * If the locale assigns Sunday as the first day of the week, then a date which is a Sunday will return 1. */ get localWeekday(): IfValid; /** * Get the week number of the week year, according to the locale. * Different locales assign week numbers differently. * The week can start on different days of the week (see {@link localWeekday}), * and because a different number of days is required for a week to count as the first week of a year. */ get localWeekNumber(): IfValid; /** * Get the week year, according to the locale. * Different locales assign week numbers (and therefore week years) differently, see {@link localWeekNumber}. */ get localWeekYear(): IfValid; /** * Get the ordinal (meaning the day of the year) * * @example * DateTime.local(2017, 5, 25).ordinal //=> 145 */ get ordinal(): IfValid; /** * Get the human readable short month name, such as 'Oct'. * Defaults to the system's locale if no locale has been specified * * @example * DateTime.local(2017, 10, 30).monthShort //=> Oct */ get monthShort(): IfValid; /** * Get the human readable long month name, such as 'October'. * Defaults to the system's locale if no locale has been specified * * @example * DateTime.local(2017, 10, 30).monthLong //=> October */ get monthLong(): IfValid; /** * Get the human readable short weekday, such as 'Mon'. * Defaults to the system's locale if no locale has been specified * * @example * DateTime.local(2017, 10, 30).weekdayShort //=> Mon */ get weekdayShort(): IfValid; /** * Get the human readable long weekday, such as 'Monday'. * Defaults to the system's locale if no locale has been specified * * @example * DateTime.local(2017, 10, 30).weekdayLong //=> Monday */ get weekdayLong(): IfValid; /** * Get the UTC offset of this DateTime in minutes * * @example * DateTime.now().offset //=> -240 * @example * DateTime.utc().offset //=> 0 */ get offset(): IfValid; /** * Get the short human name for the zone's current offset, for example "EST" or "EDT". * Defaults to the system's locale if no locale has been specified */ get offsetNameShort(): IfValid; /** * Get the long human name for the zone's current offset, for example "Eastern Standard Time" or "Eastern Daylight Time". * Defaults to the system's locale if no locale has been specified */ get offsetNameLong(): IfValid; /** * Get whether this zone's offset ever changes, as in a DST. */ get isOffsetFixed(): IfValid; /** * Get whether the DateTime is in a DST. */ get isInDST(): IfValid; /** * Returns true if this DateTime is in a leap year, false otherwise * * @example * DateTime.local(2016).isInLeapYear //=> true * @example * DateTime.local(2013).isInLeapYear //=> false */ get isInLeapYear(): boolean; /** * Returns the number of days in this DateTime's month * * @example * DateTime.local(2016, 2).daysInMonth //=> 29 * @example * DateTime.local(2016, 3).daysInMonth //=> 31 */ get daysInMonth(): IfValid; /** * Returns the number of days in this DateTime's year * * @example * DateTime.local(2016).daysInYear //=> 366 * @example * DateTime.local(2013).daysInYear //=> 365 */ get daysInYear(): IfValid; /** * Returns the number of weeks in this DateTime's year * @see https://en.wikipedia.org/wiki/ISO_week_date * * @example * DateTime.local(2004).weeksInWeekYear //=> 53 * @example * DateTime.local(2013).weeksInWeekYear //=> 52 */ get weeksInWeekYear(): IfValid; /** * Returns the number of weeks in this DateTime's local week year * * @example * DateTime.local(2020, 6, {locale: 'en-US'}).weeksInLocalWeekYear //=> 52 * @example * DateTime.local(2020, 6, {locale: 'de-DE'}).weeksInLocalWeekYear //=> 53 */ get weeksInLocalWeekYear(): IfValid; /** * Returns the resolved Intl options for this DateTime. * This is useful in understanding the behavior of formatting methods * * @param opts - the same options as toLocaleString */ resolvedLocaleOptions(opts?: LocaleOptions | DateTimeFormatOptions): ResolvedLocaleOptions; // TRANSFORM /** * "Set" the DateTime's zone to UTC. Returns a newly-constructed DateTime. * * Equivalent to {@link DateTime.setZone}('utc') * * @param offset - optionally, an offset from UTC in minutes. Defaults to 0. * @param opts - options to pass to `setZone()`. Defaults to {}. */ toUTC(offset?: number, opts?: ZoneOptions): this; /** * "Set" the DateTime's zone to the host's local zone. Returns a newly-constructed DateTime. * * Equivalent to `setZone('local')` */ toLocal(): this; /** * "Set" the DateTime's zone to specified zone. Returns a newly-constructed DateTime. * * By default, the setter keeps the underlying time the same (as in, the same timestamp), but the new instance will report different local times and consider DSTs when making computations, * as with {@link DateTime.plus}. You may wish to use {@link DateTime.toLocal} and {@link DateTime.toUTC} which provide simple convenience wrappers for commonly used zones. * * @param zone - a zone identifier. As a string, that can be any IANA zone supported by the host environment, or a fixed-offset name of the form 'UTC+3', or the strings 'local' or 'utc'. * You may also supply an instance of a {@link Zone} class. Defaults to 'local'. * @param opts - options * @param opts.keepLocalTime - If true, adjust the underlying time so that the local time stays the same, but in the target zone. You should rarely need this. Defaults to false. */ setZone(zone?: string | Zone, opts?: ZoneOptions): DateTimeMaybeValid; /** * "Set" the locale, numberingSystem, or outputCalendar. Returns a newly-constructed DateTime. * * @param properties - the properties to set * * @example * DateTime.local(2017, 5, 25).reconfigure({ locale: 'en-GB' }) */ reconfigure(properties: LocaleOptions): this; /** * "Set" the locale. Returns a newly-constructed DateTime. * Just a convenient alias for reconfigure({ locale }) * * @example * DateTime.local(2017, 5, 25).setLocale('en-GB') */ setLocale(locale: string): this; /** * "Set" the values of specified units. Returns a newly-constructed DateTime. * You can only set units with this method; for "setting" metadata, see {@link DateTime.reconfigure} and {@link DateTime.setZone}. * * This method also supports setting locale-based week units, i.e. `localWeekday`, `localWeekNumber` and `localWeekYear`. * They cannot be mixed with ISO-week units like `weekday`. * * @example * dt.set({ year: 2017 }) * @example * dt.set({ hour: 8, minute: 30 }) * @example * dt.set({ weekday: 5 }) * @example * dt.set({ year: 2005, ordinal: 234 }) */ set(values: DateObjectUnits): this; /** * Adding hours, minutes, seconds, or milliseconds increases the timestamp by the right number of milliseconds. Adding days, months, or years shifts the calendar, * accounting for DSTs and leap years along the way. Thus, `dt.plus({ hours: 24 })` may result in a different time than `dt.plus({ days: 1 })` if there's a DST shift in between. * * @param duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() * * @example * DateTime.now().plus(123) //~> in 123 milliseconds * @example * DateTime.now().plus({ minutes: 15 }) //~> in 15 minutes * @example * DateTime.now().plus({ days: 1 }) //~> this time tomorrow * @example * DateTime.now().plus({ days: -1 }) //~> this time yesterday * @example * DateTime.now().plus({ hours: 3, minutes: 13 }) //~> in 3 hr, 13 min * @example * DateTime.now().plus(Duration.fromObject({ hours: 3, minutes: 13 })) //~> in 3 hr, 13 min */ plus(duration: DurationLike): this; /** * See {@link DateTime.plus} * * @param duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() */ minus(duration: DurationLike): this; /** * "Set" this DateTime to the beginning of the given unit. * * @param unit - The unit to go to the beginning of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'. * @param opts - options * * @example * DateTime.local(2014, 3, 3).startOf('month').toISODate(); //=> '2014-03-01' * @example * DateTime.local(2014, 3, 3).startOf('year').toISODate(); //=> '2014-01-01' * @example * DateTime.local(2014, 3, 3).startOf('week').toISODate(); //=> '2014-03-03', weeks always start on Mondays * @example * DateTime.local(2014, 3, 3, 5, 30).startOf('day').toISOTime(); //=> '00:00.000-05:00' * @example * DateTime.local(2014, 3, 3, 5, 30).startOf('hour').toISOTime(); //=> '05:00:00.000-05:00' */ startOf(unit: DateTimeUnit, opts?: StartOfOptions): this; /** * "Set" this DateTime to the end (meaning the last millisecond) of a unit of time * * @param unit - The unit to go to the end of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'. * @param opts - options * * @example * DateTime.local(2014, 3, 3).endOf('month').toISO(); //=> '2014-03-31T23:59:59.999-05:00' * @example * DateTime.local(2014, 3, 3).endOf('year').toISO(); //=> '2014-12-31T23:59:59.999-05:00' * @example * DateTime.local(2014, 3, 3).endOf('week').toISO(); // => '2014-03-09T23:59:59.999-05:00', weeks start on Mondays * @example * DateTime.local(2014, 3, 3, 5, 30).endOf('day').toISO(); //=> '2014-03-03T23:59:59.999-05:00' * @example * DateTime.local(2014, 3, 3, 5, 30).endOf('hour').toISO(); //=> '2014-03-03T05:59:59.999-05:00' */ endOf(unit: DateTimeUnit, opts?: EndOfOptions): this; // OUTPUT /** * Returns a string representation of this DateTime formatted according to the specified format string. * **You may not want this.** See {@link DateTime.toLocaleString} for a more flexible formatting tool. For a table of tokens and their interpretations, * see [here](https://moment.github.io/luxon/#/formatting?id=table-of-tokens). * Defaults to en-US if no locale has been specified, regardless of the system's locale. * * @param fmt - the format string * @param opts - opts to override the configuration options on this DateTime * * @example * DateTime.now().toFormat('yyyy LLL dd') //=> '2017 Apr 22' * @example * DateTime.now().setLocale('fr').toFormat('yyyy LLL dd') //=> '2017 avr. 22' * @example * DateTime.now().toFormat('yyyy LLL dd', { locale: "fr" }) //=> '2017 avr. 22' * @example * DateTime.now().toFormat("HH 'hours and' mm 'minutes'") //=> '20 hours and 55 minutes' */ toFormat(fmt: string, opts?: LocaleOptions): IfValid; /** * Returns a localized string representing this date. Accepts the same options as the Intl.DateTimeFormat constructor and any presets defined by Luxon, * such as `DateTime.DATE_FULL` or `DateTime.TIME_SIMPLE` of the DateTime in the assigned locale. * Defaults to the system's locale if no locale has been specified * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat * * @param formatOpts - Intl.DateTimeFormat constructor options and configuration options * @param opts - opts to override the configuration options on this DateTime * * @example * DateTime.now().toLocaleString(); //=> 4/20/2017 * @example * DateTime.now().setLocale('en-gb').toLocaleString(); //=> '20/04/2017' * @example * DateTime.now().toLocaleString({ locale: 'en-gb' }); //=> '20/04/2017' * @example * DateTime.now().toLocaleString(DateTime.DATE_FULL); //=> 'April 20, 2017' * @example * DateTime.now().toLocaleString(DateTime.TIME_SIMPLE); //=> '11:32 AM' * @example * DateTime.now().toLocaleString(DateTime.DATETIME_SHORT); //=> '4/20/2017, 11:32 AM' * @example * DateTime.now().toLocaleString({ weekday: 'long', month: 'long', day: '2-digit' }); //=> 'Thursday, April 20' * @example * DateTime.now().toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> 'Thu, Apr 20, 11:27 AM' * @example * DateTime.now().toLocaleString({ hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }); //=> '11:32' */ toLocaleString( formatOpts?: DateTimeFormatOptions, opts?: LocaleOptions, ): IfValid; /** * Returns an array of format "parts", meaning individual tokens along with metadata. This is allows callers to post-process individual sections of the formatted output. * Defaults to the system's locale if no locale has been specified * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts * * @example * DateTime.now().toLocaleParts(); //=> [ * //=> { type: 'day', value: '25' }, * //=> { type: 'literal', value: '/' }, * //=> { type: 'month', value: '05' }, * //=> { type: 'literal', value: '/' }, * //=> { type: 'year', value: '1982' } * //=> ] * @example * DateTime.invalid('').toLocaleParts(); //=> [] */ toLocaleParts(opts?: DateTimeFormatOptions): Intl.DateTimeFormatPart[]; /** * Returns an ISO 8601-compliant string representation of this DateTime * * @example * DateTime.utc(1982, 5, 25).toISO() //=> '1982-05-25T00:00:00.000Z' * @example * DateTime.now().toISO() //=> '2017-04-22T20:47:05.335-04:00' * @example * DateTime.now().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335' * @example * DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400' */ toISO(opts?: ToISOTimeOptions): IfValid; /** * Returns an ISO 8601-compliant string representation of this DateTime's date component * * @param opts - options * @param opts.format - choose between the basic and extended format. Defaults to 'extended'. * * @example * DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25' * @example * DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525' */ toISODate(opts?: ToISODateOptions): IfValid; /** * Returns an ISO 8601-compliant string representation of this DateTime's week date * * @example * DateTime.utc(1982, 5, 25).toISOWeekDate() //=> '1982-W21-2' */ toISOWeekDate(): IfValid; /** * Returns an ISO 8601-compliant string representation of this DateTime's time component * * @param opts - options * @param opts.suppressMilliseconds - exclude milliseconds from the format if they're 0. Defaults to false. * @param opts.suppressSeconds - exclude seconds from the format if they're 0. Defaults to false. * @param opts.includeOffset - include the offset, such as 'Z' or '-04:00'. Defaults to true. * @param opts.includePrefix - include the `T` prefix. Defaults to false. * @param opts.format - choose between the basic and extended format. Defaults to 'extended'. * * @example * DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime() //=> '07:34:19.361Z' * @example * DateTime.utc().set({ hour: 7, minute: 34, seconds: 0, milliseconds: 0 }).toISOTime({ suppressSeconds: true }) //=> '07:34Z' * @example * DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ format: 'basic' }) //=> '073419.361Z' * @example * DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ includePrefix: true }) //=> 'T07:34:19.361Z' */ toISOTime(opts?: ToISOTimeOptions): IfValid; /** * Returns an RFC 2822-compatible string representation of this DateTime, always in UTC * * @example * DateTime.utc(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 +0000' * @example * DateTime.local(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 -0400' */ toRFC2822(): IfValid; /** * Returns a string representation of this DateTime appropriate for use in HTTP headers. * Specifically, the string conforms to RFC 1123. * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1 * * @example * DateTime.utc(2014, 7, 13).toHTTP() //=> 'Sun, 13 Jul 2014 00:00:00 GMT' * @example * DateTime.utc(2014, 7, 13, 19).toHTTP() //=> 'Sun, 13 Jul 2014 19:00:00 GMT' */ toHTTP(): IfValid; /** * Returns a string representation of this DateTime appropriate for use in SQL Date * * @example * DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13' */ toSQLDate(): IfValid; /** * Returns a string representation of this DateTime appropriate for use in SQL Time * * @example * DateTime.utc().toSQL() //=> '05:15:16.345' * @example * DateTime.now().toSQL() //=> '05:15:16.345 -04:00' * @example * DateTime.now().toSQL({ includeOffset: false }) //=> '05:15:16.345' * @example * DateTime.now().toSQL({ includeZone: false }) //=> '05:15:16.345 America/New_York' */ toSQLTime(opts?: ToSQLOptions): IfValid; /** * Returns a string representation of this DateTime for use in SQL DateTime * * @example * DateTime.utc(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 Z' * @example * DateTime.local(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 -04:00' * @example * DateTime.local(2014, 7, 13).toSQL({ includeOffset: false }) //=> '2014-07-13 00:00:00.000' * @example * DateTime.local(2014, 7, 13).toSQL({ includeZone: true }) //=> '2014-07-13 00:00:00.000 America/New_York' */ toSQL(opts?: ToSQLOptions): IfValid; /** * Returns a string representation of this DateTime appropriate for debugging */ toString(): IfValid; /** * Returns the epoch milliseconds of this DateTime. Alias of {@link DateTime.toMillis} */ valueOf(): IfValid; /** * Returns the epoch milliseconds of this DateTime. */ toMillis(): IfValid; /** * Returns the epoch seconds of this DateTime. */ toSeconds(): IfValid; /** * Returns the epoch seconds (as a whole number) of this DateTime. */ toUnixInteger(): IfValid; /** * Returns an ISO 8601 representation of this DateTime appropriate for use in JSON. */ toJSON(): IfValid; /** * Returns a BSON-serializable equivalent to this DateTime. */ toBSON(): Date; /** * Returns a JavaScript object with this DateTime's year, month, day, and so on. * * @param opts - options for generating the object * @param opts.includeConfig - include configuration attributes in the output. Defaults to false. * * @example * DateTime.now().toObject() //=> { year: 2017, month: 4, day: 22, hour: 20, minute: 49, second: 42, millisecond: 268 } */ toObject(opts?: { /** * Include configuration attributes in the output * @defaultValue false */ includeConfig?: IncludeConfig; }): ToObjectOutput; /** * Returns a JavaScript Date equivalent to this DateTime. */ toJSDate(): Date; // COMPARE /** * Return the difference between two DateTimes as a Duration. * * @param otherDateTime - the DateTime to compare this one to * @param unit - the unit or array of units to include in the duration. * Defaults to ['milliseconds']. * @param opts - options that affect the creation of the Duration * @param opts.conversionAccuracy - the conversion system to use. * Defaults to 'casual'. * * @example * let i1 = DateTime.fromISO('1982-05-25T09:45'), * i2 = DateTime.fromISO('1983-10-14T10:30'); * i2.diff(i1).toObject() //=> { milliseconds: 43807500000 } * i2.diff(i1, 'hours').toObject() //=> { hours: 12168.75 } * i2.diff(i1, ['months', 'days']).toObject() //=> { months: 16, days: 19.03125 } * i2.diff(i1, ['months', 'days', 'hours']).toObject() //=> { months: 16, days: 19, hours: 0.75 } */ diff(otherDateTime: DateTime, unit?: DurationUnits, opts?: DiffOptions): Duration; /** * Return the difference between this DateTime and right now. * See {@link DateTime.diff} * * @param unit - the unit(s) to include in the duration. Defaults to ['milliseconds']. * @param opts - options that affect the creation of the Duration * @param opts.conversionAccuracy - the conversion system to use. Defaults to 'casual'. */ diffNow(unit?: DurationUnits, opts?: DiffOptions): Duration; /** * Return an Interval spanning between this DateTime and another DateTime * * @param otherDateTime - the other end point of the Interval */ until(otherDateTime: DateTime): IfValid, DateTime, IsValid>; /** * Return whether this DateTime is in the same unit of time as another DateTime. * Note that time zones are **ignored** in this comparison, which compares the **local** calendar time. Use {@link DateTime.setZone} to convert one of the dates if needed. * * @param otherDateTime - the other DateTime * @param unit - the unit of time to check sameness on * * @example * DateTime.now().hasSame(otherDT, 'day'); //~> true if otherDT is in the same current calendar day */ hasSame(otherDateTime: DateTime, unit: DateTimeUnit, opts?: HasSameOptions): IfValid; /** * An equality check. * Two DateTimes are equal if and only if they represent the same millisecond, have the same zone and location, and are both valid. * To compare just the millisecond values, use `+dt1 === +dt2`. * * @param other - the other DateTime */ equals(other: DateTime): IfValid; /** * Returns a string representation of this time relative to now, such as "in two days". * Can only internationalize if your platform supports Intl.RelativeTimeFormat. * Rounds down by default. * * @example * DateTime.now().plus({ days: 1 }).toRelative() //=> "in 1 day" * @example * DateTime.now().setLocale("es").toRelative({ days: 1 }) //=> "dentro de 1 día" * @example * DateTime.now().plus({ days: 1 }).toRelative({ locale: "fr" }) //=> "dans 23 heures" * @example * DateTime.now().minus({ days: 2 }).toRelative() //=> "2 days ago" * @example * DateTime.now().minus({ days: 2 }).toRelative({ unit: "hours" }) //=> "48 hours ago" * @example * DateTime.now().minus({ hours: 36 }).toRelative({ round: false }) //=> "1.5 days ago" */ toRelative(options?: ToRelativeOptions): IfValid; /** * Returns a string representation of this date relative to today, such as "yesterday" or "next month". * Only internationalizes on platforms that support Intl.RelativeTimeFormat. * * @example * DateTime.now().plus({ days: 1 }).toRelativeCalendar() //=> "tomorrow" * @example * DateTime.now().setLocale("es").plus({ days: 1 }).toRelative() //=> ""mañana" * @example * DateTime.now().plus({ days: 1 }).toRelativeCalendar({ locale: "fr" }) //=> "demain" * @example * DateTime.now().minus({ days: 2 }).toRelativeCalendar() //=> "2 days ago" */ toRelativeCalendar(options?: ToRelativeCalendarOptions): IfValid; /** * Return the min of several date times * * @param dateTimes - the DateTimes from which to choose the minimum */ static min( ...dateTimes: Array> ): (AllValid extends true ? DateTime : never) | (AllValid extends false ? DateTime : never); /** * Return the max of several date times * * @param dateTimes - the DateTimes from which to choose the maximum */ static max( ...dateTimes: Array> ): (AllValid extends true ? DateTime : never) | (AllValid extends false ? DateTime : never); // MISC /** * Explain how a string would be parsed by fromFormat() * * @param text - the string to parse * @param fmt - the format the string is expected to be in (see description) * @param options - options taken by fromFormat() */ static fromFormatExplain(text: string, fmt: string, options?: DateTimeOptions): ExplainedFormat; /** * @deprecated use fromFormatExplain instead */ static fromStringExplain(text: string, fmt: string, options?: DateTimeOptions): ExplainedFormat; /** * Build a parser for fmt using the given locale. This parser can be passed to {@link DateTime.fromFormatParser} to a parse a date in this format. This can be used to optimize cases where many dates need to be parsed in a specific format. * * @param fmt - the format the string is expected to be in (see description) * @param options - the Locale options */ static buildFormatParser(fmt: string, options?: LocaleOptions): TokenParser; /** * Create a DateTime from an input string and format parser. * * The format parser must have been created with the same locale as this call. * * @param text the string to parse * @param formatParser - parser from {@link DateTime.buildFormatParser} * @param opts options taken by fromFormat() */ static fromFormatParser(text: string, formatParser: TokenParser, opts?: DateTimeOptions): DateTimeMaybeValid; // FORMAT PRESETS /** * {@link DateTime.toLocaleString} format like 10/14/1983 */ static get DATE_SHORT(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Oct 14, 1983' */ static get DATE_MED(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Fri, Oct 14, 1983' */ static get DATE_MED_WITH_WEEKDAY(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'October 14, 1983' */ static get DATE_FULL(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Tuesday, October 14, 1983' */ static get DATE_HUGE(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30 AM'. Only 12-hour if the locale is. */ static get TIME_SIMPLE(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23 AM'. Only 12-hour if the locale is. */ static get TIME_WITH_SECONDS(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23 AM EDT'. Only 12-hour if the locale is. */ static get TIME_WITH_SHORT_OFFSET(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23 AM Eastern Daylight Time'. Only 12-hour if the locale is. */ static get TIME_WITH_LONG_OFFSET(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30', always 24-hour. */ static get TIME_24_SIMPLE(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23', always 24-hour. */ static get TIME_24_WITH_SECONDS(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23 EDT', always 24-hour. */ static get TIME_24_WITH_SHORT_OFFSET(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '09:30:23 Eastern Daylight Time', always 24-hour. */ static get TIME_24_WITH_LONG_OFFSET(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '10/14/1983, 9:30 AM'. Only 12-hour if the locale is. */ static get DATETIME_SHORT(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like '10/14/1983, 9:30:33 AM'. Only 12-hour if the locale is. */ static get DATETIME_SHORT_WITH_SECONDS(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Oct 14, 1983, 9:30 AM'. Only 12-hour if the locale is. */ static get DATETIME_MED(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Oct 14, 1983, 9:30:33 AM'. Only 12-hour if the locale is. */ static get DATETIME_MED_WITH_SECONDS(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Fri, 14 Oct 1983, 9:30 AM'. Only 12-hour if the locale is. */ static get DATETIME_MED_WITH_WEEKDAY(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'October 14, 1983, 9:30 AM EDT'. Only 12-hour if the locale is. */ static get DATETIME_FULL(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'October 14, 1983, 9:30:33 AM EDT'. Only 12-hour if the locale is. */ static get DATETIME_FULL_WITH_SECONDS(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Friday, October 14, 1983, 9:30 AM Eastern Daylight Time'. Only 12-hour if the locale is. */ static get DATETIME_HUGE(): Intl.DateTimeFormatOptions; /** * {@link DateTime.toLocaleString} format like 'Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time'. Only 12-hour if the locale is. */ static get DATETIME_HUGE_WITH_SECONDS(): Intl.DateTimeFormatOptions; } luxon/src/duration.d.ts000644 001751 000166 0000044131 14772617435017165 0ustar00runner000000 000000 1477261743514772617435import { CanBeInvalid, DefaultValidity, IfValid, Invalid, Valid } from "./_util"; import { ConversionAccuracy } from "./datetime"; import { NumberingSystem } from "./misc"; export interface DurationOptions { locale?: string | undefined; numberingSystem?: NumberingSystem | undefined; conversionAccuracy?: ConversionAccuracy | undefined; } export interface DurationObjectUnits { years?: number | undefined; quarters?: number | undefined; months?: number | undefined; weeks?: number | undefined; days?: number | undefined; hours?: number | undefined; minutes?: number | undefined; seconds?: number | undefined; milliseconds?: number | undefined; } export interface DurationLikeObject extends DurationObjectUnits { year?: number | undefined; quarter?: number | undefined; month?: number | undefined; week?: number | undefined; day?: number | undefined; hour?: number | undefined; minute?: number | undefined; second?: number | undefined; millisecond?: number | undefined; } export type DurationUnit = keyof DurationLikeObject; export type DurationUnits = DurationUnit | DurationUnit[]; export type ToISOFormat = "basic" | "extended"; export interface ToISOTimeDurationOptions { /** * Include the `T` prefix * @default false */ includePrefix?: boolean | undefined; /** * Exclude milliseconds from the format if they are 0 * @default false */ suppressMilliseconds?: boolean | undefined; /** * Exclude seconds from the format if they are 0 * @default false */ suppressSeconds?: boolean | undefined; /** * Choose between the basic and extended format * @default 'extended' */ format?: ToISOFormat | undefined; } export interface ToHumanDurationOptions extends Intl.NumberFormatOptions { listStyle?: "long" | "short" | "narrow" | undefined; } /** * Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() * * @deprecated Use DurationLike instead. */ export type DurationInput = Duration | number | DurationLikeObject; /** * Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() */ export type DurationLike = Duration | DurationLikeObject | number; export type DurationMaybeValid = CanBeInvalid extends true ? (Duration | Duration) : Duration; /** * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". * Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. * They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime.plus} to add a Duration object to a DateTime, producing another DateTime. * * Here is a brief overview of commonly used methods and getters in Duration: * * * **Creation** To create a Duration, use {@link Duration.fromMillis}, {@link Duration.fromObject}, or {@link Duration.fromISO}. * * **Unit values** See the {@link Duration#years}, {@link Duration.months}, {@link Duration#weeks}, {@link Duration#days}, {@link Duration#hours}, {@link Duration#minutes}, * * {@link Duration#seconds}, {@link Duration#milliseconds} accessors. * * **Configuration** See {@link Duration#locale} and {@link Duration#numberingSystem} accessors. * * **Transformation** To create new Durations out of old ones use {@link Duration#plus}, {@link Duration#minus}, {@link Duration#normalize}, {@link Duration#set}, {@link Duration#reconfigure}, * * {@link Duration#shiftTo}, and {@link Duration#negate}. * * **Output** To convert the Duration into other representations, see {@link Duration#as}, {@link Duration#toISO}, {@link Duration#toFormat}, and {@link Duration#toJSON} * * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation. */ export class Duration { /** * Create Duration from a number of milliseconds. * * @param count - of milliseconds * @param opts - options for parsing * @param opts.locale - the locale to use * @param opts.numberingSystem - the numbering system to use * @param opts.conversionAccuracy - the conversion system to use */ static fromMillis(count: number, opts?: DurationOptions): Duration; /** * Create a Duration from a JavaScript object with keys like 'years' and 'hours'. * If this object is empty then a zero milliseconds duration is returned. * * @param obj - the object to create the Duration from * @param obj.years * @param obj.quarters * @param obj.months * @param obj.weeks * @param obj.days * @param obj.hours * @param obj.minutes * @param obj.seconds * @param obj.milliseconds * @param opts - options for creating this Duration. Defaults to {}. * @param opts.locale - the locale to use. Defaults to 'en-US'. * @param opts.numberingSystem - the numbering system to use * @param opts.conversionAccuracy - the conversion system to use. Defaults to 'casual'. */ static fromObject(obj: DurationLikeObject, opts?: DurationOptions): Duration; /** * Create a Duration from DurationLike. * * @param durationLike * Either a Luxon Duration, a number of milliseconds, or the object argument to Duration.fromObject() */ static fromDurationLike(durationLike: DurationLike): Duration; /** * Create a Duration from an ISO 8601 duration string. * @see https://en.wikipedia.org/wiki/ISO_8601#Durations * * @param text - text to parse * @param opts - options for parsing * @param opts.locale - the locale to use. Defaults to 'en-US'. * @param opts.numberingSystem - the numbering system to use * @param opts.conversionAccuracy - the conversion system to use. Defaults to 'casual'. * * @example * Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 } * @example * Duration.fromISO('PT23H').toObject() //=> { hours: 23 } * @example * Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 } */ static fromISO(text: string, opts?: DurationOptions): DurationMaybeValid; /** * Create a Duration from an ISO 8601 time string. * @see https://en.wikipedia.org/wiki/ISO_8601#Times * * @param text - text to parse * @param opts - options for parsing * @param opts.locale - the locale to use. Defaults to 'en-US'. * @param opts.numberingSystem - the numbering system to use * @param opts.conversionAccuracy - the conversion system to use. Defaults to 'casual'. * * @example * Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 } * @example * Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 } * @example * Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 } * @example * Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 } * @example * Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 } */ static fromISOTime(text: string, opts?: DurationOptions): DurationMaybeValid; /** * Create an invalid Duration. * * @param reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent * @param explanation - longer explanation, may include parameters and other useful debugging information. Defaults to null. */ static invalid(reason: string, explanation?: string): Duration; /** * Check if an object is a Duration. Works across context boundaries * * @param o */ static isDuration(o: unknown): o is DurationMaybeValid; private constructor(config: unknown); /** * Get the locale of a Duration, such as 'en-GB' */ get locale(): IfValid; /** * Get the numbering system of a Duration, such as 'beng'. The numbering system is used when formatting the Duration */ get numberingSystem(): IfValid; /** * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens: * * `S` for milliseconds * * `s` for seconds * * `m` for minutes * * `h` for hours * * `d` for days * * `M` for months * * `y` for years * Notes: * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits * * The duration will be converted to the set of units in the format string using {@link Duration.shiftTo} and the Duration's conversion accuracy setting. * * @param fmt - the format string * @param opts - options * @param opts.floor - floor numerical values. Defaults to true. * * @example * Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2" * @example * Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002" * @example * Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000" */ toFormat(fmt: string, opts?: { floor?: boolean | undefined }): IfValid; /** * Returns a string representation of a Duration with all units included * To modify its behavior use the `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant. See {@link Intl.NumberFormat}. * * @example * ```js * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 }) * dur.toHuman() //=> '1 day, 5 hours, 6 minutes' * dur.toHuman({ listStyle: "long" }) //=> '1 day, 5 hours, and 6 minutes' * dur.toHuman({ unitDisplay: "short" }) //=> '1 day, 5 hr, 6 min' * ``` */ toHuman(opts?: ToHumanDurationOptions): string; /** * Returns a JavaScript object with this Duration's values. * * @example * Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 } */ toObject(): DurationObjectUnits; /** * Returns an ISO 8601-compliant string representation of this Duration. * @see https://en.wikipedia.org/wiki/ISO_8601#Durations * * @example * Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S' * @example * Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S' * @example * Duration.fromObject({ months: 5 }).toISO() //=> 'P5M' * @example * Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M' * @example * Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S' */ toISO(): IfValid; /** * Returns an ISO 8601-compliant string representation of this Duration, formatted as a time of day. * @see https://en.wikipedia.org/wiki/ISO_8601#Times * * @param opts - options * @param opts.suppressMilliseconds - exclude milliseconds from the format if they are 0. Defaults to false. * @param opts.suppressSeconds - exclude seconds from the format if they're 0. Defaults to false. * @param opts.includePrefix - include the `T` prefix. Defaults to false. * @param opts.format - choose between the basic and extended format. Defaults to 'extended'. * * @example * Duration.fromObject({ hours: 11 }).toISOTime() //=> '11:00:00.000' * @example * Duration.fromObject({ hours: 11 }).toISOTime({ suppressMilliseconds: true }) //=> '11:00:00' * @example * Duration.fromObject({ hours: 11 }).toISOTime({ suppressSeconds: true }) //=> '11:00' * @example * Duration.fromObject({ hours: 11 }).toISOTime({ includePrefix: true }) //=> 'T11:00:00.000' * @example * Duration.fromObject({ hours: 11 }).toISOTime({ format: 'basic' }) //=> '110000.000' */ toISOTime(opts?: ToISOTimeDurationOptions): IfValid; /** * Returns an ISO 8601 representation of this Duration appropriate for use in JSON. */ toJSON(): IfValid; /** * Returns an ISO 8601 representation of this Duration appropriate for use in debugging. */ toString(): IfValid; /** * Returns a millisecond value of this Duration. */ toMillis(): IfValid; /** * Returns a millisecond value of this Duration. Alias of {@link toMillis} */ valueOf(): IfValid; /** * Make this Duration longer by the specified amount. Return a newly-constructed Duration. * * @param duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() */ plus(duration: DurationLike): this; /** * Make this Duration shorter by the specified amount. Return a newly-constructed Duration. * * @param duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject() */ minus(duration: DurationLike): this; /** * Scale this Duration by the specified amount. Return a newly-constructed Duration. * * @example * Duration.fromObject({ hours: 1, minutes: 30 }).mapUnit(x => x * 2) //=> { hours: 2, minutes: 60 } * @example * Duration.fromObject({ hours: 1, minutes: 30 }).mapUnit((x, u) => u === "hour" ? x * 2 : x) //=> { hours: 2, minutes: 30 } */ mapUnits(fn: (x: number, u?: DurationUnit) => number): this; /** * Get the value of unit. * * @param unit - a unit such as 'minute' or 'day' * * @example * Duration.fromObject({years: 2, days: 3}).get('years') //=> 2 * @example * Duration.fromObject({years: 2, days: 3}).get('months') //=> 0 * @example * Duration.fromObject({years: 2, days: 3}).get('days') //=> 3 */ get(unit: DurationUnit): IfValid; /** * "Set" the values of specified units. Return a newly-constructed Duration. * * @param values - a mapping of units to numbers * * @example * dur.set({ years: 2017 }) * @example * dur.set({ hours: 8, minutes: 30 }) */ set(values: DurationLikeObject): this; /** * "Set" the locale and/or numberingSystem. Returns a newly-constructed Duration. * * @example * dur.reconfigure({ locale: 'en-GB' }) */ reconfigure(opts?: DurationOptions): this; /** * Return the length of the duration in the specified unit. * * @param unit - a unit such as 'minutes' or 'days' * * @example * Duration.fromObject({years: 1}).as('days') //=> 365 * @example * Duration.fromObject({years: 1}).as('months') //=> 12 * @example * Duration.fromObject({hours: 60}).as('days') //=> 2.5 */ as(unit: DurationUnit): IfValid; /** * Reduce this Duration to its canonical representation in its current units. * * @example * Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 } * @example * Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 } */ normalize(): this; /** * Rescale units to its largest representation. * * @example * Duration.fromObject({ milliseconds: 90000 }).rescale().toObject() //=> { minutes: 1, seconds: 30 } */ rescale(): this; /** * Convert this Duration into its representation in a different set of units. * * @example * Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 } */ shiftTo(...units: DurationUnit[]): this; /** * Shift this Duration to all available units. * Same as shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds") */ shiftToAll(): this; /** * Return the negative of this Duration. * * @example * Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 } */ negate(): this; /** * Get the years. */ get years(): IfValid; /** * Get the quarters. */ get quarters(): IfValid; /** * Get the months. */ get months(): IfValid; /** * Get the weeks */ get weeks(): IfValid; /** * Get the days. */ get days(): IfValid; /** * Get the hours. */ get hours(): IfValid; /** * Get the minutes. */ get minutes(): IfValid; /** * Get the seconds. */ get seconds(): IfValid; /** * Get the milliseconds. */ get milliseconds(): IfValid; /** * Returns whether the Duration is invalid. * Diff operations on invalid DateTimes or Intervals return invalid Durations. */ get isValid(): IfValid; /** * Returns an error code if this Duration became invalid, or null if the Duration is valid */ get invalidReason(): IfValid; /** * Returns an explanation of why this Duration became invalid, or null if the Duration is valid */ get invalidExplanation(): IfValid; /** * Equality check * Two Durations are equal iff they have the same units and the same values for each unit. */ equals(other: Duration): IfValid; } luxon/src/info.d.ts000644 001751 000166 0000017427 14772617435016303 0ustar00runner000000 000000 1477261743514772617435import { WeekdayNumbers } from "./datetime"; import { CalendarSystem, NumberingSystem, StringUnitLength, UnitLength } from "./misc"; import { Zone } from "./zone"; export interface InfoOptions { locale?: string | undefined; } export interface InfoUnitOptions extends InfoOptions { numberingSystem?: NumberingSystem | undefined; } /** @deprecated */ export type UnitOptions = InfoUnitOptions; export interface InfoCalendarOptions extends InfoUnitOptions { /** * @default gregory */ outputCalendar?: CalendarSystem | undefined; } /** * The set of available features in this environment. Some features of Luxon are not available in all environments. */ export interface Features { /** * Whether this environment supports relative time formatting */ relative: boolean; /** * Whether this environment supports different weekdays for the start of the week based on the locale */ localeWeek: boolean; } /** * The Info class contains static methods for retrieving general time and date related data. For example, it has methods for finding out if a time zone has a DST, for listing the months in any * supported locale, and for discovering which of Luxon features are available in the current environment. */ export namespace Info { /** * Return whether the specified zone contains a DST. * * @param zone - Zone to check. Defaults to the environment's local zone. Defaults to 'local'. */ function hasDST(zone?: string | Zone): boolean; /** * Return whether the specified zone is a valid IANA specifier. * * @param zone - Zone to check */ function isValidIANAZone(zone: string): boolean; /** * Converts the input into a {@link Zone} instance. * * * If `input` is already a Zone instance, it is returned unchanged. * * If `input` is a string containing a valid time zone name, a Zone instance * with that name is returned. * * If `input` is a string that doesn't refer to a known time zone, a Zone * instance with {@link Zone.isValid} == false is returned. * * If `input is a number, a Zone instance with the specified fixed offset * in minutes is returned. * * If `input` is `null` or `undefined`, the default zone is returned. * * @param input - the value to be converted */ function normalizeZone(input?: string | Zone | number): Zone; interface LocaleInput { /** * the locale code */ locale?: string | null | undefined; /** * an existing locale object to use, instead of the locale code string */ locObj?: object | null | undefined; } /** * Get the weekday on which the week starts, * according to the given locale. */ function getStartOfWeek(input?: LocaleInput): WeekdayNumbers; /** * Get the minimum number of days necessary in a week before it is considered part of the next year, * according to the given locale. */ function getMinimumDaysInFirstWeek(input?: LocaleInput): WeekdayNumbers; /** * Get the weekdays which are considered the weekend, * according to the given locale. */ function getWeekendWeekdays(input?: LocaleInput): WeekdayNumbers[]; /** * Return an array of standalone month names. * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat * * @param length - the length of the month representation. Defaults to 'long'. * @param opts - options * @param opts.locale - the locale code * @param opts.numberingSystem - the numbering system. * @param opts.locObj - an existing locale object to use. * @param opts.outputCalendar - the calendar. Defaults to 'gregory'. * * @example * Info.months()[0] //=> 'January' * @example * Info.months('short')[0] //=> 'Jan' * @example * Info.months('numeric')[0] //=> '1' * @example * Info.months('short', { locale: 'fr-CA' } )[0] //=> 'janv.' * @example * Info.months('numeric', { locale: 'ar' })[0] //=> '١' * @example * Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I' */ function months(length?: UnitLength, opts?: InfoCalendarOptions): string[]; /** * Return an array of format month names. * Format months differ from standalone months in that they are meant to appear next to the day of the month. * In some languages, that changes the string. * See {@link Info#months} * * @param length - the length of the month representation. Defaults to 'long'. * @param opts - options * @param opts.locale - the locale code * @param opts.numberingSystem - the numbering system. * @param opts.locObj - an existing locale object to use. * @param opts.outputCalendar - the calendar. Defaults to 'gregory'. */ function monthsFormat(length?: UnitLength, opts?: InfoCalendarOptions): string[]; /** * Return an array of standalone week names. * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat * * @param length - the length of the weekday representation. Defaults to 'long'. * @param opts - options * @param opts.locale - the locale code * @param opts.numberingSystem - the numbering system. * @param opts.locObj - an existing locale object to use. * * @example * Info.weekdays()[0] //=> 'Monday' * @example * Info.weekdays('short')[0] //=> 'Mon' * @example * Info.weekdays('short', { locale: 'fr-CA' })[0] //=> 'lun.' * @example * Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين' */ function weekdays(length?: StringUnitLength, opts?: InfoUnitOptions): string[]; /** * Return an array of format week names. * Format weekdays differ from standalone weekdays in that they are meant to appear next to more date information. * In some languages, that changes the string. * See {@link Info#weekdays} * * @param length - the length of the month representation. Defaults to 'long'. * @param opts - options * @param opts.locale - the locale code. * @param opts.numberingSystem - the numbering system. * @param opts.locObj - an existing locale object to use. */ function weekdaysFormat(length?: StringUnitLength, opts?: InfoUnitOptions): string[]; /** * Return an array of meridiems. * * @param opts - options * @param opts.locale - the locale code * * @example * Info.meridiems() //=> [ 'AM', 'PM' ] * @example * Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ] */ function meridiems(opts?: InfoOptions): string[]; /** * Return an array of eras, such as ['BC', 'AD']. The locale can be specified, but the calendar system is always Gregorian. * * @param length - the length of the era representation. Defaults to 'short'. * @param opts - options * @param opts.locale - the locale code * * @example * Info.eras() //=> [ 'BC', 'AD' ] * @example * Info.eras('long') //=> [ 'Before Christ', 'Anno Domini' ] * @example * Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ] */ function eras(length?: StringUnitLength, opts?: InfoOptions): string[]; /** * Return the set of available features in this environment. * Some features of Luxon are not available in all environments. * For example, on older browsers, timezone support is not available. * Use this function to figure out if that is the case. * * @example * Info.features() //=> { intl: true, intlTokens: false, zones: true, relative: false } */ function features(): Features; } luxon/src/interval.d.ts000644 001751 000166 0000035225 14772617435017170 0ustar00runner000000 000000 1477261743514772617435import { CanBeInvalid, DefaultValidity, IfValid, Invalid, Valid } from "./_util"; import { _UseLocaleWeekOption, DateObjectUnits, DateTime, DateTimeOptions, DiffOptions, LocaleOptions, ToISOTimeOptions, } from "./datetime"; import { Duration, DurationLike, DurationMaybeValid, DurationUnit } from "./duration"; export interface IntervalObject { start?: DateTime | undefined; end?: DateTime | undefined; } export type DateInput = DateTime | DateObjectUnits | Date; export type IntervalMaybeValid = CanBeInvalid extends true ? (Interval | Interval) : Interval; export type CountOptions = _UseLocaleWeekOption; /** * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. * Conceptually, it is a container for those two endpoints, accompanied by methods for * creating, parsing, interrogating, comparing, transforming, and formatting them. * * Here is a brief overview of the most commonly used methods and getters in Interval: * * * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}. * * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end. * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, * * {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}. * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, * * {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}. * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs} * * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toLocaleString}, {@link Interval#toISO}, {@link Interval#toISODate}, * * {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}. */ export class Interval { /** * Create an invalid Interval. * * @param reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent * @param explanation - longer explanation, may include parameters and other useful debugging information. */ static invalid(reason: string, explanation?: string): Interval; /** * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end. * * @param start * @param end */ static fromDateTimes(start: DateInput, end: DateInput): IntervalMaybeValid; /** * Create an Interval from a start DateTime and a Duration to extend to. * * @param start * @param duration - the length of the Interval. */ static after(start: DateInput, duration: DurationLike): IntervalMaybeValid; /** * Create an Interval from an end DateTime and a Duration to extend backwards to. * * @param end * @param duration - the length of the Interval. */ static before(end: DateInput, duration: DurationLike): IntervalMaybeValid; /** * Create an Interval from an ISO 8601 string. * Accepts `/`, `/`, and `/` formats. * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals * * @param text - the ISO string to parse * @param opts - options to pass {@link DateTime.fromISO} and optionally {@link Duration.fromISO} */ static fromISO(text: string, opts?: DateTimeOptions): IntervalMaybeValid; /** * Check if an object is an Interval. Works across context boundaries * * @param o */ static isInterval(o: unknown): o is IntervalMaybeValid; private constructor(config: unknown); /** * Returns the start of the Interval */ get start(): IfValid, null, IsValid>; /** * Returns the end of the Interval */ get end(): IfValid, null, IsValid>; /** * Returns the last DateTime included in the interval (since end is not part of the interval) */ get lastDateTime(): IfValid, null, IsValid>; /** * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'. */ get isValid(): IfValid; /** * Returns an error code if this Interval is invalid, or null if the Interval is valid */ get invalidReason(): IfValid; /** * Returns an explanation of why this Interval became invalid, or null if the Interval is valid */ get invalidExplanation(): IfValid; /** * Returns the length of the Interval in the specified unit. * * @param unit - the unit (such as 'hours' or 'days') to return the length in. */ length(unit?: DurationUnit): IfValid; /** * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part. * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day' * asks 'what dates are included in this interval?', not 'how many days long is this interval?' * * @param unit - the unit of time to count. Defaults to 'milliseconds'. */ count(unit?: DurationUnit, opts?: CountOptions): IfValid; /** * Returns whether this Interval's start and end are both in the same unit of time * * @param unit - the unit of time to check sameness on */ hasSame(unit: DurationUnit): IfValid; /** * Return whether this Interval has the same start and end DateTimes. */ isEmpty(): boolean; /** * Return whether this Interval's start is after the specified DateTime. * * @param dateTime */ isAfter(dateTime: DateTime): IfValid; /** * Return whether this Interval's end is before the specified DateTime. * * @param dateTime */ isBefore(dateTime: DateTime): IfValid; /** * Return whether this Interval contains the specified DateTime. * * @param dateTime */ contains(dateTime: DateTime): IfValid; /** * "Sets" the start and/or end dates. Returns a newly-constructed Interval. * * @param values - the values to set * @param values.start - the starting DateTime * @param values.end - the ending DateTime */ set(values?: IntervalObject): IntervalMaybeValid; /** * Split this Interval at each of the specified DateTimes * * @param dateTimes - the unit of time to count. */ splitAt(...dateTimes: DateTime[]): IfValid; /** * Split this Interval into smaller Intervals, each of the specified length. * Left over time is grouped into a smaller interval * * @param duration - The length of each resulting interval. */ splitBy(duration: DurationLike): IfValid; /** * Split this Interval into the specified number of smaller intervals. * * @param numberOfParts - The number of Intervals to divide the Interval into. */ divideEqually(numberOfParts: number): IfValid; /** * Return whether this Interval overlaps with the specified Interval */ overlaps(other: Interval): boolean; /** * Return whether this Interval's end is adjacent to the specified Interval's start. */ abutsStart(other: Interval): IfValid; /** * Return whether this Interval's start is adjacent to the specified Interval's end. */ abutsEnd(other: Interval): IfValid; /** * Return whether this Interval engulfs the start and end of the specified Interval. */ engulfs(other: Interval): IfValid; /** * Return whether this Interval has the same start and end as the specified Interval. */ equals(other: Interval): IfValid; /** * Return an Interval representing the intersection of this Interval and the specified Interval. * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals. * Returns null if the intersection is empty, meaning the intervals do not intersect. */ intersection(other: Interval): Interval | null; /** * Return an Interval representing the union of this Interval and the specified Interval. * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals. */ union(other: Interval): IntervalMaybeValid; /** * Merge an array of Intervals into an equivalent minimal set of Intervals. * Combines overlapping and adjacent Intervals. */ static merge(intervals: Interval[]): IntervalMaybeValid[]; /** * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals. */ static xor(intervals: Interval[]): IntervalMaybeValid[]; /** * Return Intervals representing the spans of time in this Interval that not overlap with any of the specified Intervals. */ difference(...intervals: Interval[]): IntervalMaybeValid[]; /** * Returns a string representation of this Interval appropriate for debugging. */ toString(): IfValid; /** * Returns a localized string representing this Interval. Accepts the same options as the * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as * {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method * is browser-specific, but in general it will return an appropriate representation of the * Interval in the assigned locale. Defaults to the system's locale if no locale has been * specified. * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat * @param formatOpts - Either a DateTime preset or Intl.DateTimeFormat constructor options. Defaults to DateTime.DATE_SHORT * @param opts - Options to override the configuration of the start DateTime. * * @example * Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022 * @example * Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022 * @example * Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022 * @example * Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM * @example * Interval.fromISO("2022-11-07T17:00Z/2022-11-07T19:00Z").toLocaleString({ * weekday: "short", * month: "short", * day: "2-digit", * hour: "2-digit", * minute: "2-digit", * }); //=> Mon, Nov 07, 6:00 – 8:00 p */ toLocaleString( formatOpts?: Intl.DateTimeFormatOptions, opts?: LocaleOptions, ): IfValid; /** * Returns an ISO 8601-compliant string representation of this Interval. * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals * * @param opts - The same options as {@link DateTime#toISO} */ toISO(opts?: ToISOTimeOptions): IfValid; /** * Returns an ISO 8601-compliant string representation of the dates in this Interval. * The time components are ignored. * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals */ toISODate(): IfValid; /** * Returns an ISO 8601-compliant string representation of the times in this Interval. * The date components are ignored. * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals * * @param opts - The same options as {@link DateTime.toISO} */ toISOTime(opts?: ToISOTimeOptions): IfValid; /** * Returns a string representation of this Interval formatted according to the specified format string. * * @param dateFormat - the format string. This string formats the start and end time. See {@link DateTime.toFormat} for details. * @param opts - options * @param opts.separator - a separator to place between the start and end representations. Defaults to ' - '. */ toFormat( dateFormat: string, opts?: { separator?: string | undefined; }, ): IfValid; /** * Return a Duration representing the time spanned by this interval. * * @param unit - the unit or units (such as 'hours' or 'days') to include in the duration. Defaults to ['milliseconds']. * @param opts - options that affect the creation of the Duration * @param opts.conversionAccuracy - the conversion system to use. Defaults to 'casual'. * * @example * Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 } * @example * Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 } * @example * Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 } * @example * Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 } * @example * Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 } */ toDuration(unit?: DurationUnit | DurationUnit[], opts?: DiffOptions): DurationMaybeValid; /** * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes * * @example * Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC()) * @example * Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 })) */ mapEndpoints(mapFn: (d: DateTime) => DateTime): IntervalMaybeValid; } luxon/src/luxon.d.ts000644 001751 000166 0000000327 14772617435016504 0ustar00runner000000 000000 1477261743514772617435export const VERSION: string; export * from "./datetime"; export * from "./duration"; export * from "./info"; export * from "./interval"; export * from "./misc"; export * from "./settings"; export * from "./zone"; luxon/src/misc.d.ts000644 001751 000166 0000003107 14772617435016271 0ustar00runner000000 000000 1477261743514772617435export type DateTimeFormatOptions = Intl.DateTimeFormatOptions; export interface ZoneOptions { /** * If true, adjust the underlying time so that the local time stays the same, but in the target zone. * You should rarely need this. * Defaults to false. */ keepLocalTime?: boolean | undefined; /** * @deprecated since 0.2.12. Use keepLocalTime instead */ keepCalendarTime?: boolean | undefined; } /** @deprecated */ export type EraLength = StringUnitLength; export type NumberingSystem = Intl.DateTimeFormatOptions extends { numberingSystem?: infer T } ? T : | "arab" | "arabext" | "bali" | "beng" | "deva" | "fullwide" | "gujr" | "guru" | "hanidec" | "khmr" | "knda" | "laoo" | "latn" | "limb" | "mlym" | "mong" | "mymr" | "orya" | "tamldec" | "telu" | "thai" | "tibt"; export type CalendarSystem = Intl.DateTimeFormatOptions extends { calendar?: infer T } ? T : | "buddhist" | "chinese" | "coptic" | "ethioaa" | "ethiopic" | "gregory" | "hebrew" | "indian" | "islamic" | "islamicc" | "iso8601" | "japanese" | "persian" | "roc"; export type HourCycle = "h11" | "h12" | "h23" | "h24"; export type StringUnitLength = "narrow" | "short" | "long"; export type NumberUnitLength = "numeric" | "2-digit"; export type UnitLength = StringUnitLength | NumberUnitLength; luxon/src/settings.d.ts000644 001751 000166 0000005706 14772617435017205 0ustar00runner000000 000000 1477261743514772617435import { WeekdayNumbers } from "./datetime"; import { Zone, ZoneMaybeValid } from "./zone"; export interface WeekSettings { firstDay: WeekdayNumbers; minimalDays: WeekdayNumbers; weekend: WeekdayNumbers[]; } /** * `Settings` contains static getters and setters that control Luxon's overall behavior. * Luxon is a simple library with few options, but the ones it does have live here. */ // tslint:disable-next-line:no-unnecessary-class export class Settings { /** * Get the callback for returning the current timestamp. */ static get now(): () => number; /** * Set the callback for returning the current timestamp. * The function should return a number, which will be interpreted as an Epoch millisecond count * * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future * @example Settings.now = () => 0 // always pretend it is Jan 1, 1970 at midnight in UTC time */ static set now(now: () => number); /** * The default time zone object currently used to create DateTimes. Does not affect existing instances. * The default value is the system's time zone (the one set on the machine that runs this code). */ static get defaultZone(): ZoneMaybeValid; static set defaultZone(zone: Zone | string); /** * The default locale to create DateTimes with. Does not affect existing instances. */ static defaultLocale: string; /** * The default numbering system to create DateTimes with. Does not affect existing instances. */ static defaultNumberingSystem: string; /** * The default output calendar to create DateTimes with. Does not affect existing instances. */ static defaultOutputCalendar: string; /** * The cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century. */ static twoDigitCutoffYear: number; /** * Whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals * * If setting this to true, be sure to opt-out of Luxon's invalid return types. * @example * Settings.throwOnInvalid = true; * declare module 'luxon' { * interface TSSettings { * throwOnInvalid: true; * } * } */ static throwOnInvalid: boolean; /** * Reset Luxon's global caches. Should only be necessary in testing scenarios. */ static resetCaches(): void; /** * Allows overriding the default locale week settings, i.e. the start of the week, the weekend and * how many days are required in the first week of a year. * Does not affect existing instances. */ static defaultWeekSettings: WeekSettings | null; } /** * TS only settings. Consumers can declaration merge this interface to change TS options. * * @see Settings.throwOnInvalid */ // eslint-disable-next-line @typescript-eslint/no-empty-interface export interface TSSettings {} luxon/src/zone.d.ts000644 001751 000166 0000011567 14772617435016322 0ustar00runner000000 000000 1477261743514772617435import { CanBeInvalid, DefaultValidity, IfValid } from "./_util"; export interface ZoneOffsetOptions { /** * What style of offset to return. */ format?: "short" | "long" | undefined; /** * What locale to return the offset name in. */ locale?: string | undefined; } /** * What style of offset to return. * Returning '+6', '+06:00', or '+0600' respectively */ export type ZoneOffsetFormat = "narrow" | "short" | "techie"; export type ZoneMaybeValid = CanBeInvalid extends true ? Zone | Zone : Zone; export abstract class Zone { /** * The type of zone */ get type(): IfValid; /** * The name of this zone. */ get name(): string; /** * Returns whether the offset is known to be fixed for the whole year. */ get isUniversal(): IfValid; /** * Returns the offset's common name (such as EST) at the specified timestamp * * @param ts - Epoch milliseconds for which to get the name * @param options - Options to affect the format * @param options.format - What style of offset to return. * @param options.locale - What locale to return the offset name in. */ offsetName(ts: number, options: ZoneOffsetOptions): IfValid; /** * Returns the offset's value as a string * * @param ts - Epoch milliseconds for which to get the offset * @param format - What style of offset to return. * Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively */ formatOffset(ts: number, format: ZoneOffsetFormat): IfValid; /** * Return the offset in minutes for this zone at the specified timestamp. * * @param ts - Epoch milliseconds for which to compute the offset */ offset(ts: number): IfValid; /** * Return whether this Zone is equal to another zone * * @param other - the zone to compare */ equals(other: Zone): IfValid; /** * Return whether this Zone is valid. */ get isValid(): IfValid; } /** * A zone identified by an IANA identifier, like America/New_York */ export class IANAZone extends Zone { /** * Same as constructor but has caching. */ static create(name: string): CanBeInvalid extends true ? (IANAZone | IANAZone) : IANAZone; /** * Reset local caches. Should only be necessary in testing scenarios. */ static resetCache(): void; /** * Returns whether the provided string is a valid specifier. * This only checks the string's format, not that the specifier * identifies a known zone; see {@link isValidZone} for that. * * @param s - The string to check validity on * * @example * IANAZone.isValidSpecifier("America/New_York") //=> true * @example * IANAZone.isValidSpecifier("Fantasia/Castle") //=> true * @example * IANAZone.isValidSpecifier("Sport~~blorp") //=> false */ static isValidSpecifier(s: string): boolean; /** * Returns whether the provided string identifies a real zone * * @param zone - The string to check * * @example * IANAZone.isValidZone("America/New_York") //=> true * @example * IANAZone.isValidZone("Fantasia/Castle") //=> false * @example * IANAZone.isValidZone("Sport~~blorp") //=> false */ static isValidZone(zone: string): boolean; constructor(name: string); } /** * A zone with a fixed offset (meaning no DST) */ export class FixedOffsetZone extends Zone { /** * Get a singleton instance of UTC */ static get utcInstance(): FixedOffsetZone; /** * Get an instance with a specified offset * * @param offset - The offset in minutes */ static instance(offset: number): FixedOffsetZone; /** * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6" * * @param s - The offset string to parse * * @example * FixedOffsetZone.parseSpecifier("UTC+6") * @example * FixedOffsetZone.parseSpecifier("UTC+06") * @example * FixedOffsetZone.parseSpecifier("UTC-6:00") */ static parseSpecifier(s: string): FixedOffsetZone; } /** * A zone that failed to parse. You should never need to instantiate this. */ export class InvalidZone extends Zone { get type(): "invalid"; get isUniversal(): false; get offsetFormat(): ""; } /** * Represents the system zone for this JavaScript environment. */ export class SystemZone extends Zone { /** * Get a singleton instance of the system zone */ static get instance(): SystemZone; }