mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
1520 lines
64 KiB
TypeScript
1520 lines
64 KiB
TypeScript
// Type definitions for timezonecomplete 1.15.0
|
|
// Project: https://github.com/SpiritIT/timezonecomplete
|
|
// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
|
|
declare module 'timezonecomplete' {
|
|
import basics = require("__timezonecomplete/basics");
|
|
export import TimeUnit = basics.TimeUnit;
|
|
export import WeekDay = basics.WeekDay;
|
|
export import timeUnitToMilliseconds = basics.timeUnitToMilliseconds;
|
|
export import isLeapYear = basics.isLeapYear;
|
|
export import daysInMonth = basics.daysInMonth;
|
|
export import daysInYear = basics.daysInYear;
|
|
export import firstWeekDayOfMonth = basics.firstWeekDayOfMonth;
|
|
export import lastWeekDayOfMonth = basics.lastWeekDayOfMonth;
|
|
export import weekDayOnOrAfter = basics.weekDayOnOrAfter;
|
|
export import weekDayOnOrBefore = basics.weekDayOnOrBefore;
|
|
export import weekNumber = basics.weekNumber;
|
|
export import weekOfMonth = basics.weekOfMonth;
|
|
export import dayOfYear = basics.dayOfYear;
|
|
export import secondOfDay = basics.secondOfDay;
|
|
export import timeUnitToString = basics.timeUnitToString;
|
|
export import stringToTimeUnit = basics.stringToTimeUnit;
|
|
import datetime = require("__timezonecomplete/datetime");
|
|
export import DateTime = datetime.DateTime;
|
|
export import now = datetime.now;
|
|
export import nowLocal = datetime.nowLocal;
|
|
export import nowUtc = datetime.nowUtc;
|
|
import duration = require("__timezonecomplete/duration");
|
|
export import Duration = duration.Duration;
|
|
export import years = duration.years;
|
|
export import months = duration.months;
|
|
export import days = duration.days;
|
|
export import hours = duration.hours;
|
|
export import minutes = duration.minutes;
|
|
export import seconds = duration.seconds;
|
|
export import milliseconds = duration.milliseconds;
|
|
import javascript = require("__timezonecomplete/javascript");
|
|
export import DateFunctions = javascript.DateFunctions;
|
|
import period = require("__timezonecomplete/period");
|
|
export import Period = period.Period;
|
|
export import PeriodDst = period.PeriodDst;
|
|
export import periodDstToString = period.periodDstToString;
|
|
import timesource = require("__timezonecomplete/timesource");
|
|
export import TimeSource = timesource.TimeSource;
|
|
export import RealTimeSource = timesource.RealTimeSource;
|
|
import timezone = require("__timezonecomplete/timezone");
|
|
export import NormalizeOption = timezone.NormalizeOption;
|
|
export import TimeZoneKind = timezone.TimeZoneKind;
|
|
export import TimeZone = timezone.TimeZone;
|
|
export import local = timezone.local;
|
|
export import utc = timezone.utc;
|
|
export import zone = timezone.zone;
|
|
import globals = require("__timezonecomplete/globals");
|
|
export import min = globals.min;
|
|
export import max = globals.max;
|
|
}
|
|
|
|
declare module '__timezonecomplete/basics' {
|
|
import javascript = require("__timezonecomplete/javascript");
|
|
import DateFunctions = javascript.DateFunctions;
|
|
/**
|
|
* Day-of-week. Note the enum values correspond to JavaScript day-of-week:
|
|
* Sunday = 0, Monday = 1 etc
|
|
*/
|
|
export enum WeekDay {
|
|
Sunday = 0,
|
|
Monday = 1,
|
|
Tuesday = 2,
|
|
Wednesday = 3,
|
|
Thursday = 4,
|
|
Friday = 5,
|
|
Saturday = 6,
|
|
}
|
|
/**
|
|
* Time units
|
|
*/
|
|
export enum TimeUnit {
|
|
Millisecond = 0,
|
|
Second = 1,
|
|
Minute = 2,
|
|
Hour = 3,
|
|
Day = 4,
|
|
Week = 5,
|
|
Month = 6,
|
|
Year = 7,
|
|
/**
|
|
* End-of-enum marker, do not use
|
|
*/
|
|
MAX = 8,
|
|
}
|
|
/**
|
|
* Approximate number of milliseconds for a time unit.
|
|
* A day is assumed to have 24 hours, a month is assumed to equal 30 days
|
|
* and a year is set to 360 days (because 12 months of 30 days).
|
|
*
|
|
* @param unit Time unit e.g. TimeUnit.Month
|
|
* @returns The number of milliseconds.
|
|
*/
|
|
export function timeUnitToMilliseconds(unit: TimeUnit): number;
|
|
/**
|
|
* Time unit to lowercase string. If amount is specified, then the string is put in plural form
|
|
* if necessary.
|
|
* @param unit The unit
|
|
* @param amount If this is unequal to -1 and 1, then the result is pluralized
|
|
*/
|
|
export function timeUnitToString(unit: TimeUnit, amount?: number): string;
|
|
export function stringToTimeUnit(s: string): TimeUnit;
|
|
/**
|
|
* @return True iff the given year is a leap year.
|
|
*/
|
|
export function isLeapYear(year: number): boolean;
|
|
/**
|
|
* The days in a given year
|
|
*/
|
|
export function daysInYear(year: number): number;
|
|
/**
|
|
* @param year The full year
|
|
* @param month The month 1-12
|
|
* @return The number of days in the given month
|
|
*/
|
|
export function daysInMonth(year: number, month: number): number;
|
|
/**
|
|
* Returns the day of the year of the given date [0..365]. January first is 0.
|
|
*
|
|
* @param year The year e.g. 1986
|
|
* @param month Month 1-12
|
|
* @param day Day of month 1-31
|
|
*/
|
|
export function dayOfYear(year: number, month: number, day: number): number;
|
|
/**
|
|
* Returns the last instance of the given weekday in the given month
|
|
*
|
|
* @param year The year
|
|
* @param month the month 1-12
|
|
* @param weekDay the desired week day
|
|
*
|
|
* @return the last occurrence of the week day in the month
|
|
*/
|
|
export function lastWeekDayOfMonth(year: number, month: number, weekDay: WeekDay): number;
|
|
/**
|
|
* Returns the first instance of the given weekday in the given month
|
|
*
|
|
* @param year The year
|
|
* @param month the month 1-12
|
|
* @param weekDay the desired week day
|
|
*
|
|
* @return the first occurrence of the week day in the month
|
|
*/
|
|
export function firstWeekDayOfMonth(year: number, month: number, weekDay: WeekDay): number;
|
|
/**
|
|
* Returns the day-of-month that is on the given weekday and which is >= the given day.
|
|
* Throws if the month has no such day.
|
|
*/
|
|
export function weekDayOnOrAfter(year: number, month: number, day: number, weekDay: WeekDay): number;
|
|
/**
|
|
* Returns the day-of-month that is on the given weekday and which is <= the given day.
|
|
* Throws if the month has no such day.
|
|
*/
|
|
export function weekDayOnOrBefore(year: number, month: number, day: number, weekDay: WeekDay): number;
|
|
/**
|
|
* The week of this month. There is no official standard for this,
|
|
* but we assume the same rules for the weekNumber (i.e.
|
|
* week 1 is the week that has the 4th day of the month in it)
|
|
*
|
|
* @param year The year
|
|
* @param month The month [1-12]
|
|
* @param day The day [1-31]
|
|
* @return Week number [1-5]
|
|
*/
|
|
export function weekOfMonth(year: number, month: number, day: number): number;
|
|
/**
|
|
* The ISO 8601 week number for the given date. Week 1 is the week
|
|
* that has January 4th in it, and it starts on Monday.
|
|
* See https://en.wikipedia.org/wiki/ISO_week_date
|
|
*
|
|
* @param year Year e.g. 1988
|
|
* @param month Month 1-12
|
|
* @param day Day of month 1-31
|
|
*
|
|
* @return Week number 1-53
|
|
*/
|
|
export function weekNumber(year: number, month: number, day: number): number;
|
|
/**
|
|
* Convert a unix milli timestamp into a TimeT structure.
|
|
* This does NOT take leap seconds into account.
|
|
*/
|
|
export function unixToTimeNoLeapSecs(unixMillis: number): TimeStruct;
|
|
/**
|
|
* Convert a year, month, day etc into a unix milli timestamp.
|
|
* This does NOT take leap seconds into account.
|
|
*
|
|
* @param year Year e.g. 1970
|
|
* @param month Month 1-12
|
|
* @param day Day 1-31
|
|
* @param hour Hour 0-23
|
|
* @param minute Minute 0-59
|
|
* @param second Second 0-59 (no leap seconds)
|
|
* @param milli Millisecond 0-999
|
|
*/
|
|
export function timeToUnixNoLeapSecs(year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, milli?: number): number;
|
|
/**
|
|
* Convert a TimeT structure into a unix milli timestamp.
|
|
* This does NOT take leap seconds into account.
|
|
*/
|
|
export function timeToUnixNoLeapSecs(tm: TimeStruct): number;
|
|
/**
|
|
* Return the day-of-week.
|
|
* This does NOT take leap seconds into account.
|
|
*/
|
|
export function weekDayNoLeapSecs(unixMillis: number): WeekDay;
|
|
/**
|
|
* N-th second in the day, counting from 0
|
|
*/
|
|
export function secondOfDay(hour: number, minute: number, second: number): number;
|
|
/**
|
|
* Basic representation of a date and time
|
|
*/
|
|
export class TimeStruct {
|
|
/**
|
|
* Year, 1970-...
|
|
*/
|
|
year: number;
|
|
/**
|
|
* Month 1-12
|
|
*/
|
|
month: number;
|
|
/**
|
|
* Day of month, 1-31
|
|
*/
|
|
day: number;
|
|
/**
|
|
* Hour 0-23
|
|
*/
|
|
hour: number;
|
|
/**
|
|
* Minute 0-59
|
|
*/
|
|
minute: number;
|
|
/**
|
|
* Seconds, 0-59
|
|
*/
|
|
second: number;
|
|
/**
|
|
* Milliseconds 0-999
|
|
*/
|
|
milli: number;
|
|
/**
|
|
* Create a TimeStruct from a number of unix milliseconds
|
|
*/
|
|
static fromUnix(unixMillis: number): TimeStruct;
|
|
/**
|
|
* Create a TimeStruct from a JavaScript date
|
|
*
|
|
* @param d The date
|
|
* @param df Which functions to take (getX() or getUTCX())
|
|
*/
|
|
static fromDate(d: Date, df: DateFunctions): TimeStruct;
|
|
/**
|
|
* Returns a TimeStruct from an ISO 8601 string WITHOUT time zone
|
|
*/
|
|
static fromString(s: string): TimeStruct;
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @param year Year e.g. 1970
|
|
* @param month Month 1-12
|
|
* @param day Day 1-31
|
|
* @param hour Hour 0-23
|
|
* @param minute Minute 0-59
|
|
* @param second Second 0-59 (no leap seconds)
|
|
* @param milli Millisecond 0-999
|
|
*/
|
|
constructor(
|
|
/**
|
|
* Year, 1970-...
|
|
*/
|
|
year?: number,
|
|
/**
|
|
* Month 1-12
|
|
*/
|
|
month?: number,
|
|
/**
|
|
* Day of month, 1-31
|
|
*/
|
|
day?: number,
|
|
/**
|
|
* Hour 0-23
|
|
*/
|
|
hour?: number,
|
|
/**
|
|
* Minute 0-59
|
|
*/
|
|
minute?: number,
|
|
/**
|
|
* Seconds, 0-59
|
|
*/
|
|
second?: number,
|
|
/**
|
|
* Milliseconds 0-999
|
|
*/
|
|
milli?: number);
|
|
/**
|
|
* Validate a TimeStruct, returns false if invalid.
|
|
*/
|
|
validate(): boolean;
|
|
/**
|
|
* The day-of-year 0-365
|
|
*/
|
|
yearDay(): number;
|
|
/**
|
|
* Returns this time as a unix millisecond timestamp
|
|
* Does NOT take leap seconds into account.
|
|
*/
|
|
toUnixNoLeapSecs(): number;
|
|
/**
|
|
* Deep equals
|
|
*/
|
|
equals(other: TimeStruct): boolean;
|
|
/**
|
|
* < operator
|
|
*/
|
|
lessThan(other: TimeStruct): boolean;
|
|
clone(): TimeStruct;
|
|
valueOf(): number;
|
|
/**
|
|
* ISO 8601 string YYYY-MM-DDThh:mm:ss.nnn
|
|
*/
|
|
toString(): string;
|
|
inspect(): string;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/datetime' {
|
|
import basics = require("__timezonecomplete/basics");
|
|
import WeekDay = basics.WeekDay;
|
|
import TimeUnit = basics.TimeUnit;
|
|
import duration = require("__timezonecomplete/duration");
|
|
import Duration = duration.Duration;
|
|
import javascript = require("__timezonecomplete/javascript");
|
|
import DateFunctions = javascript.DateFunctions;
|
|
import timesource = require("__timezonecomplete/timesource");
|
|
import TimeSource = timesource.TimeSource;
|
|
import timezone = require("__timezonecomplete/timezone");
|
|
import TimeZone = timezone.TimeZone;
|
|
/**
|
|
* Current date+time in local time
|
|
*/
|
|
export function nowLocal(): DateTime;
|
|
/**
|
|
* Current date+time in UTC time
|
|
*/
|
|
export function nowUtc(): DateTime;
|
|
/**
|
|
* Current date+time in the given time zone
|
|
* @param timeZone The desired time zone (optional, defaults to UTC).
|
|
*/
|
|
export function now(timeZone?: TimeZone): DateTime;
|
|
/**
|
|
* DateTime class which is time zone-aware
|
|
* and which can be mocked for testing purposes.
|
|
*/
|
|
export class DateTime {
|
|
/**
|
|
* Actual time source in use. Setting this property allows to
|
|
* fake time in tests. DateTime.nowLocal() and DateTime.nowUtc()
|
|
* use this property for obtaining the current time.
|
|
*/
|
|
static timeSource: TimeSource;
|
|
/**
|
|
* Current date+time in local time
|
|
*/
|
|
static nowLocal(): DateTime;
|
|
/**
|
|
* Current date+time in UTC time
|
|
*/
|
|
static nowUtc(): DateTime;
|
|
/**
|
|
* Current date+time in the given time zone
|
|
* @param timeZone The desired time zone (optional, defaults to UTC).
|
|
*/
|
|
static now(timeZone?: TimeZone): DateTime;
|
|
/**
|
|
* Create a DateTime from a Lotus 123 / Microsoft Excel date-time value
|
|
* i.e. a double representing days since 1-1-1900 where 1900 is incorrectly seen as leap year
|
|
*/
|
|
static fromExcel(n: number, timeZone?: TimeZone): DateTime;
|
|
/**
|
|
* Constructor. Creates current time in local timezone.
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Constructor
|
|
* Non-existing local times are normalized by rounding up to the next DST offset.
|
|
*
|
|
* @param isoString String in ISO 8601 format. Instead of ISO time zone,
|
|
* it may include a space and then and IANA time zone.
|
|
* e.g. "2007-04-05T12:30:40.500" (no time zone, naive date)
|
|
* e.g. "2007-04-05T12:30:40.500+01:00" (UTC offset without daylight saving time)
|
|
* or "2007-04-05T12:30:40.500Z" (UTC)
|
|
* or "2007-04-05T12:30:40.500 Europe/Amsterdam" (IANA time zone, with daylight saving time if applicable)
|
|
* @param timeZone if given, the date in the string is assumed to be in this time zone.
|
|
* Note that it is NOT CONVERTED to the time zone. Useful
|
|
* for strings without a time zone
|
|
*/
|
|
constructor(isoString: string, timeZone?: TimeZone);
|
|
/**
|
|
* Constructor. You provide a date, then you say whether to take the
|
|
* date.getYear()/getXxx methods or the date.getUTCYear()/date.getUTCXxx methods,
|
|
* and then you state which time zone that date is in.
|
|
* Non-existing local times are normalized by rounding up to the next DST offset.
|
|
* Note that the Date class has bugs and inconsistencies when constructing them with times around
|
|
* DST changes.
|
|
*
|
|
* @param date A date object.
|
|
* @param getters Specifies which set of Date getters contains the date in the given time zone: the
|
|
* Date.getXxx() methods or the Date.getUTCXxx() methods.
|
|
* @param timeZone The time zone that the given date is assumed to be in (may be null for unaware dates)
|
|
*/
|
|
constructor(date: Date, getFuncs: DateFunctions, timeZone?: TimeZone);
|
|
/**
|
|
* Constructor. Note that unlike JavaScript dates we require fields to be in normal ranges.
|
|
* Use the add(duration) or sub(duration) for arithmetic.
|
|
* @param year The full year (e.g. 2014)
|
|
* @param month The month [1-12] (note this deviates from JavaScript Date)
|
|
* @param day The day of the month [1-31]
|
|
* @param hour The hour of the day [0-24)
|
|
* @param minute The minute of the hour [0-59]
|
|
* @param second The second of the minute [0-59]
|
|
* @param millisecond The millisecond of the second [0-999]
|
|
* @param timeZone The time zone, or null (for unaware dates)
|
|
*/
|
|
constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, timeZone?: TimeZone);
|
|
/**
|
|
* Constructor
|
|
* @param unixTimestamp milliseconds since 1970-01-01T00:00:00.000
|
|
* @param timeZone the time zone that the timestamp is assumed to be in (usually UTC).
|
|
*/
|
|
constructor(unixTimestamp: number, timeZone?: TimeZone);
|
|
/**
|
|
* @return a copy of this object
|
|
*/
|
|
clone(): DateTime;
|
|
/**
|
|
* @return The time zone that the date is in. May be null for unaware dates.
|
|
*/
|
|
zone(): TimeZone;
|
|
/**
|
|
* Zone name abbreviation at this time
|
|
* @param dstDependent (default true) set to false for a DST-agnostic abbreviation
|
|
* @return The abbreviation
|
|
*/
|
|
zoneAbbreviation(dstDependent?: boolean): string;
|
|
/**
|
|
* @return the offset w.r.t. UTC in minutes. Returns 0 for unaware dates and for UTC dates.
|
|
*/
|
|
offset(): number;
|
|
/**
|
|
* @return The full year e.g. 2014
|
|
*/
|
|
year(): number;
|
|
/**
|
|
* @return The month 1-12 (note this deviates from JavaScript Date)
|
|
*/
|
|
month(): number;
|
|
/**
|
|
* @return The day of the month 1-31
|
|
*/
|
|
day(): number;
|
|
/**
|
|
* @return The hour 0-23
|
|
*/
|
|
hour(): number;
|
|
/**
|
|
* @return the minutes 0-59
|
|
*/
|
|
minute(): number;
|
|
/**
|
|
* @return the seconds 0-59
|
|
*/
|
|
second(): number;
|
|
/**
|
|
* @return the milliseconds 0-999
|
|
*/
|
|
millisecond(): number;
|
|
/**
|
|
* @return the day-of-week (the enum values correspond to JavaScript
|
|
* week day numbers)
|
|
*/
|
|
weekDay(): WeekDay;
|
|
/**
|
|
* Returns the day number within the year: Jan 1st has number 0,
|
|
* Jan 2nd has number 1 etc.
|
|
*
|
|
* @return the day-of-year [0-366]
|
|
*/
|
|
dayOfYear(): number;
|
|
/**
|
|
* The ISO 8601 week number. Week 1 is the week
|
|
* that has January 4th in it, and it starts on Monday.
|
|
* See https://en.wikipedia.org/wiki/ISO_week_date
|
|
*
|
|
* @return Week number [1-53]
|
|
*/
|
|
weekNumber(): number;
|
|
/**
|
|
* The week of this month. There is no official standard for this,
|
|
* but we assume the same rules for the weekNumber (i.e.
|
|
* week 1 is the week that has the 4th day of the month in it)
|
|
*
|
|
* @return Week number [1-5]
|
|
*/
|
|
weekOfMonth(): number;
|
|
/**
|
|
* Returns the number of seconds that have passed on the current day
|
|
* Does not consider leap seconds
|
|
*
|
|
* @return seconds [0-86399]
|
|
*/
|
|
secondOfDay(): number;
|
|
/**
|
|
* @return Milliseconds since 1970-01-01T00:00:00.000Z
|
|
*/
|
|
unixUtcMillis(): number;
|
|
/**
|
|
* @return The full year e.g. 2014
|
|
*/
|
|
utcYear(): number;
|
|
/**
|
|
* @return The UTC month 1-12 (note this deviates from JavaScript Date)
|
|
*/
|
|
utcMonth(): number;
|
|
/**
|
|
* @return The UTC day of the month 1-31
|
|
*/
|
|
utcDay(): number;
|
|
/**
|
|
* @return The UTC hour 0-23
|
|
*/
|
|
utcHour(): number;
|
|
/**
|
|
* @return The UTC minutes 0-59
|
|
*/
|
|
utcMinute(): number;
|
|
/**
|
|
* @return The UTC seconds 0-59
|
|
*/
|
|
utcSecond(): number;
|
|
/**
|
|
* Returns the UTC day number within the year: Jan 1st has number 0,
|
|
* Jan 2nd has number 1 etc.
|
|
*
|
|
* @return the day-of-year [0-366]
|
|
*/
|
|
utcDayOfYear(): number;
|
|
/**
|
|
* @return The UTC milliseconds 0-999
|
|
*/
|
|
utcMillisecond(): number;
|
|
/**
|
|
* @return the UTC day-of-week (the enum values correspond to JavaScript
|
|
* week day numbers)
|
|
*/
|
|
utcWeekDay(): WeekDay;
|
|
/**
|
|
* The ISO 8601 UTC week number. Week 1 is the week
|
|
* that has January 4th in it, and it starts on Monday.
|
|
* See https://en.wikipedia.org/wiki/ISO_week_date
|
|
*
|
|
* @return Week number [1-53]
|
|
*/
|
|
utcWeekNumber(): number;
|
|
/**
|
|
* The week of this month. There is no official standard for this,
|
|
* but we assume the same rules for the weekNumber (i.e.
|
|
* week 1 is the week that has the 4th day of the month in it)
|
|
*
|
|
* @return Week number [1-5]
|
|
*/
|
|
utcWeekOfMonth(): number;
|
|
/**
|
|
* Returns the number of seconds that have passed on the current day
|
|
* Does not consider leap seconds
|
|
*
|
|
* @return seconds [0-86399]
|
|
*/
|
|
utcSecondOfDay(): number;
|
|
/**
|
|
* Convert this date to the given time zone (in-place).
|
|
* Throws if this date does not have a time zone.
|
|
* @return this (for chaining)
|
|
*/
|
|
convert(zone?: TimeZone): DateTime;
|
|
/**
|
|
* Returns this date converted to the given time zone.
|
|
* Unaware dates can only be converted to unaware dates (clone)
|
|
* Converting an unaware date to an aware date throws an exception. Use the constructor
|
|
* if you really need to do that.
|
|
*
|
|
* @param zone The new time zone. This may be null to create unaware date.
|
|
* @return The converted date
|
|
*/
|
|
toZone(zone?: TimeZone): DateTime;
|
|
/**
|
|
* Convert to JavaScript date with the zone time in the getX() methods.
|
|
* Unless the timezone is local, the Date.getUTCX() methods will NOT be correct.
|
|
* This is because Date calculates getUTCX() from getX() applying local time zone.
|
|
*/
|
|
toDate(): Date;
|
|
/**
|
|
* Add a time duration relative to UTC.
|
|
* @return this + duration
|
|
*/
|
|
add(duration: Duration): DateTime;
|
|
/**
|
|
* Add an amount of time relative to UTC, as regularly as possible.
|
|
*
|
|
* Adding e.g. 1 hour will increment the utcHour() field, adding 1 month
|
|
* increments the utcMonth() field.
|
|
* Adding an amount of units leaves lower units intact. E.g.
|
|
* adding a month will leave the day() field untouched if possible.
|
|
*
|
|
* Note adding Months or Years will clamp the date to the end-of-month if
|
|
* the start date was at the end of a month, i.e. contrary to JavaScript
|
|
* Date#setUTCMonth() it will not overflow into the next month
|
|
*
|
|
* In case of DST changes, the utc time fields are still untouched but local
|
|
* time fields may shift.
|
|
*/
|
|
add(amount: number, unit: TimeUnit): DateTime;
|
|
/**
|
|
* Add an amount of time to the zone time, as regularly as possible.
|
|
*
|
|
* Adding e.g. 1 hour will increment the hour() field of the zone
|
|
* date by one. In case of DST changes, the time fields may additionally
|
|
* increase by the DST offset, if a non-existing local time would
|
|
* be reached otherwise.
|
|
*
|
|
* Adding a unit of time will leave lower-unit fields intact, unless the result
|
|
* would be a non-existing time. Then an extra DST offset is added.
|
|
*
|
|
* Note adding Months or Years will clamp the date to the end-of-month if
|
|
* the start date was at the end of a month, i.e. contrary to JavaScript
|
|
* Date#setUTCMonth() it will not overflow into the next month
|
|
*/
|
|
addLocal(duration: Duration): DateTime;
|
|
addLocal(amount: number, unit: TimeUnit): DateTime;
|
|
/**
|
|
* Same as add(-1*duration);
|
|
*/
|
|
sub(duration: Duration): DateTime;
|
|
/**
|
|
* Same as add(-1*amount, unit);
|
|
*/
|
|
sub(amount: number, unit: TimeUnit): DateTime;
|
|
/**
|
|
* Same as addLocal(-1*amount, unit);
|
|
*/
|
|
subLocal(duration: Duration): DateTime;
|
|
subLocal(amount: number, unit: TimeUnit): DateTime;
|
|
/**
|
|
* Time difference between two DateTimes
|
|
* @return this - other
|
|
*/
|
|
diff(other: DateTime): Duration;
|
|
/**
|
|
* Chops off the time part, yields the same date at 00:00:00.000
|
|
* @return a new DateTime
|
|
*/
|
|
startOfDay(): DateTime;
|
|
/**
|
|
* @return True iff (this < other)
|
|
*/
|
|
lessThan(other: DateTime): boolean;
|
|
/**
|
|
* @return True iff (this <= other)
|
|
*/
|
|
lessEqual(other: DateTime): boolean;
|
|
/**
|
|
* @return True iff this and other represent the same moment in time in UTC
|
|
*/
|
|
equals(other: DateTime): boolean;
|
|
/**
|
|
* @return True iff this and other represent the same time and the same zone
|
|
*/
|
|
identical(other: DateTime): boolean;
|
|
/**
|
|
* @return True iff this > other
|
|
*/
|
|
greaterThan(other: DateTime): boolean;
|
|
/**
|
|
* @return True iff this >= other
|
|
*/
|
|
greaterEqual(other: DateTime): boolean;
|
|
/**
|
|
* @return The minimum of this and other
|
|
*/
|
|
min(other: DateTime): DateTime;
|
|
/**
|
|
* @return The maximum of this and other
|
|
*/
|
|
max(other: DateTime): DateTime;
|
|
/**
|
|
* Proper ISO 8601 format string with any IANA zone converted to ISO offset
|
|
* E.g. "2014-01-01T23:15:33+01:00" for Europe/Amsterdam
|
|
*/
|
|
toIsoString(): string;
|
|
/**
|
|
* Return a string representation of the DateTime according to the
|
|
* specified format. The format is implemented as the LDML standard
|
|
* (http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns)
|
|
*
|
|
* @param formatString The format specification (e.g. "dd/MM/yyyy HH:mm:ss")
|
|
* @return The string representation of this DateTime
|
|
*/
|
|
format(formatString: string): string;
|
|
/**
|
|
* Modified ISO 8601 format string with IANA name if applicable.
|
|
* E.g. "2014-01-01T23:15:33.000 Europe/Amsterdam"
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* Used by util.inspect()
|
|
*/
|
|
inspect(): string;
|
|
/**
|
|
* The valueOf() method returns the primitive value of the specified object.
|
|
*/
|
|
valueOf(): any;
|
|
/**
|
|
* Modified ISO 8601 format string in UTC without time zone info
|
|
*/
|
|
toUtcString(): string;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/duration' {
|
|
import basics = require("__timezonecomplete/basics");
|
|
import TimeUnit = basics.TimeUnit;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of years (may be fractional or negative)
|
|
* @return A duration of n years
|
|
*/
|
|
export function years(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of months (may be fractional or negative)
|
|
* @return A duration of n months
|
|
*/
|
|
export function months(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of days (may be fractional or negative)
|
|
* @return A duration of n days
|
|
*/
|
|
export function days(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of hours (may be fractional or negative)
|
|
* @return A duration of n hours
|
|
*/
|
|
export function hours(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of minutes (may be fractional or negative)
|
|
* @return A duration of n minutes
|
|
*/
|
|
export function minutes(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of seconds (may be fractional or negative)
|
|
* @return A duration of n seconds
|
|
*/
|
|
export function seconds(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of milliseconds (may be fractional or negative)
|
|
* @return A duration of n milliseconds
|
|
*/
|
|
export function milliseconds(n: number): Duration;
|
|
/**
|
|
* Time duration which is represented as an amount and a unit e.g.
|
|
* '1 Month' or '166 Seconds'. The unit is preserved through calculations.
|
|
*
|
|
* It has two sets of getter functions:
|
|
* - second(), minute(), hour() etc, singular form: these can be used to create string representations.
|
|
* These return a part of your string representation. E.g. for 2500 milliseconds, the millisecond() part would be 500
|
|
* - seconds(), minutes(), hours() etc, plural form: these return the total amount represented in the corresponding unit.
|
|
*/
|
|
export class Duration {
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of years (may be fractional or negative)
|
|
* @return A duration of n years
|
|
*/
|
|
static years(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of months (may be fractional or negative)
|
|
* @return A duration of n months
|
|
*/
|
|
static months(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of days (may be fractional or negative)
|
|
* @return A duration of n days
|
|
*/
|
|
static days(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of hours (may be fractional or negative)
|
|
* @return A duration of n hours
|
|
*/
|
|
static hours(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of minutes (may be fractional or negative)
|
|
* @return A duration of n minutes
|
|
*/
|
|
static minutes(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of seconds (may be fractional or negative)
|
|
* @return A duration of n seconds
|
|
*/
|
|
static seconds(n: number): Duration;
|
|
/**
|
|
* Construct a time duration
|
|
* @param n Number of milliseconds (may be fractional or negative)
|
|
* @return A duration of n milliseconds
|
|
*/
|
|
static milliseconds(n: number): Duration;
|
|
/**
|
|
* Construct a time duration of 0
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Construct a time duration from a string in one of two formats:
|
|
* 1) [-]hhhh[:mm[:ss[.nnn]]] e.g. '-01:00:30.501'
|
|
* 2) amount and unit e.g. '-1 days' or '1 year'. The unit may be in singular or plural form and is case-insensitive
|
|
*/
|
|
constructor(input: string);
|
|
/**
|
|
* Construct a duration from an amount and a time unit.
|
|
* @param amount Number of units
|
|
* @param unit A time unit i.e. TimeUnit.Second, TimeUnit.Hour etc. Default Millisecond.
|
|
*/
|
|
constructor(amount: number, unit?: TimeUnit);
|
|
/**
|
|
* @return another instance of Duration with the same value.
|
|
*/
|
|
clone(): Duration;
|
|
/**
|
|
* Returns this duration expressed in different unit (positive or negative, fractional).
|
|
* This is precise for Year <-> Month and for time-to-time conversion (i.e. Hour-or-less to Hour-or-less).
|
|
* It is approximate for any other conversion
|
|
*/
|
|
as(unit: TimeUnit): number;
|
|
/**
|
|
* Convert this duration to a Duration in another unit. You always get a clone even if you specify
|
|
* the same unit.
|
|
* This is precise for Year <-> Month and for time-to-time conversion (i.e. Hour-or-less to Hour-or-less).
|
|
* It is approximate for any other conversion
|
|
*/
|
|
convert(unit: TimeUnit): Duration;
|
|
/**
|
|
* The entire duration in milliseconds (negative or positive)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
*/
|
|
milliseconds(): number;
|
|
/**
|
|
* The millisecond part of the duration (always positive)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 400 for a -01:02:03.400 duration
|
|
*/
|
|
millisecond(): number;
|
|
/**
|
|
* The entire duration in seconds (negative or positive, fractional)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 1.5 for a 1500 milliseconds duration
|
|
*/
|
|
seconds(): number;
|
|
/**
|
|
* The second part of the duration (always positive)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 3 for a -01:02:03.400 duration
|
|
*/
|
|
second(): number;
|
|
/**
|
|
* The entire duration in minutes (negative or positive, fractional)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 1.5 for a 90000 milliseconds duration
|
|
*/
|
|
minutes(): number;
|
|
/**
|
|
* The minute part of the duration (always positive)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 2 for a -01:02:03.400 duration
|
|
*/
|
|
minute(): number;
|
|
/**
|
|
* The entire duration in hours (negative or positive, fractional)
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 1.5 for a 5400000 milliseconds duration
|
|
*/
|
|
hours(): number;
|
|
/**
|
|
* The hour part of a duration. This assumes that a day has 24 hours (which is not the case
|
|
* during DST changes).
|
|
*/
|
|
hour(): number;
|
|
/**
|
|
* DEPRECATED
|
|
* The hour part of the duration (always positive).
|
|
* Note that this part can exceed 23 hours, because for
|
|
* now, we do not have a days() function
|
|
* For Day/Month/Year durations, this is approximate!
|
|
* @return e.g. 25 for a -25:02:03.400 duration
|
|
*/
|
|
wholeHours(): number;
|
|
/**
|
|
* The entire duration in days (negative or positive, fractional)
|
|
* This is approximate if this duration is not in days!
|
|
*/
|
|
days(): number;
|
|
/**
|
|
* The day part of a duration. This assumes that a month has 30 days.
|
|
*/
|
|
day(): number;
|
|
/**
|
|
* The entire duration in days (negative or positive, fractional)
|
|
* This is approximate if this duration is not in Months or Years!
|
|
*/
|
|
months(): number;
|
|
/**
|
|
* The month part of a duration.
|
|
*/
|
|
month(): number;
|
|
/**
|
|
* The entire duration in years (negative or positive, fractional)
|
|
* This is approximate if this duration is not in Months or Years!
|
|
*/
|
|
years(): number;
|
|
/**
|
|
* Non-fractional positive years
|
|
*/
|
|
wholeYears(): number;
|
|
/**
|
|
* Amount of units (positive or negative, fractional)
|
|
*/
|
|
amount(): number;
|
|
/**
|
|
* The unit this duration was created with
|
|
*/
|
|
unit(): TimeUnit;
|
|
/**
|
|
* Sign
|
|
* @return "-" if the duration is negative
|
|
*/
|
|
sign(): string;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return True iff (this < other)
|
|
*/
|
|
lessThan(other: Duration): boolean;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return True iff (this <= other)
|
|
*/
|
|
lessEqual(other: Duration): boolean;
|
|
/**
|
|
* Similar but not identical
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return True iff this and other represent the same time duration
|
|
*/
|
|
equals(other: Duration): boolean;
|
|
/**
|
|
* Similar but not identical
|
|
* Returns false if we cannot determine whether they are equal in all time zones
|
|
* so e.g. 60 minutes equals 1 hour, but 24 hours do NOT equal 1 day
|
|
*
|
|
* @return True iff this and other represent the same time duration
|
|
*/
|
|
equalsExact(other: Duration): boolean;
|
|
/**
|
|
* Same unit and same amount
|
|
*/
|
|
identical(other: Duration): boolean;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return True iff this > other
|
|
*/
|
|
greaterThan(other: Duration): boolean;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return True iff this >= other
|
|
*/
|
|
greaterEqual(other: Duration): boolean;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return The minimum (most negative) of this and other
|
|
*/
|
|
min(other: Duration): Duration;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* @return The maximum (most positive) of this and other
|
|
*/
|
|
max(other: Duration): Duration;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* Multiply with a fixed number.
|
|
* @return a new Duration of (this * value)
|
|
*/
|
|
multiply(value: number): Duration;
|
|
/**
|
|
* Approximate if the durations have units that cannot be converted
|
|
* Divide by a fixed number.
|
|
* @return a new Duration of (this / value)
|
|
*/
|
|
divide(value: number): Duration;
|
|
/**
|
|
* Add a duration.
|
|
* @return a new Duration of (this + value) with the unit of this duration
|
|
*/
|
|
add(value: Duration): Duration;
|
|
/**
|
|
* Subtract a duration.
|
|
* @return a new Duration of (this - value) with the unit of this duration
|
|
*/
|
|
sub(value: Duration): Duration;
|
|
/**
|
|
* Return the absolute value of the duration i.e. remove the sign.
|
|
*/
|
|
abs(): Duration;
|
|
/**
|
|
* DEPRECATED
|
|
* String in [-]hhhh:mm:ss.nnn notation. All fields are
|
|
* always present except the sign.
|
|
*/
|
|
toFullString(): string;
|
|
/**
|
|
* String in [-]hhhh:mm[:ss[.nnn]] notation.
|
|
* @param full If true, then all fields are always present except the sign. Otherwise, seconds and milliseconds
|
|
* are chopped off if zero
|
|
*/
|
|
toHmsString(full?: boolean): string;
|
|
/**
|
|
* String in ISO 8601 notation e.g. 'P1M' for one month or 'PT1M' for one minute
|
|
*/
|
|
toIsoString(): string;
|
|
/**
|
|
* String representation with amount and unit e.g. '1.5 years' or '-1 day'
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* Used by util.inspect()
|
|
*/
|
|
inspect(): string;
|
|
/**
|
|
* The valueOf() method returns the primitive value of the specified object.
|
|
*/
|
|
valueOf(): any;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/javascript' {
|
|
/**
|
|
* Indicates how a Date object should be interpreted.
|
|
* Either we can take getYear(), getMonth() etc for our field
|
|
* values, or we can take getUTCYear(), getUtcMonth() etc to do that.
|
|
*/
|
|
export enum DateFunctions {
|
|
/**
|
|
* Use the Date.getFullYear(), Date.getMonth(), ... functions.
|
|
*/
|
|
Get = 0,
|
|
/**
|
|
* Use the Date.getUTCFullYear(), Date.getUTCMonth(), ... functions.
|
|
*/
|
|
GetUTC = 1,
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/period' {
|
|
import basics = require("__timezonecomplete/basics");
|
|
import TimeUnit = basics.TimeUnit;
|
|
import duration = require("__timezonecomplete/duration");
|
|
import Duration = duration.Duration;
|
|
import datetime = require("__timezonecomplete/datetime");
|
|
import DateTime = datetime.DateTime;
|
|
/**
|
|
* Specifies how the period should repeat across the day
|
|
* during DST changes.
|
|
*/
|
|
export enum PeriodDst {
|
|
/**
|
|
* Keep repeating in similar intervals measured in UTC,
|
|
* unaffected by Daylight Saving Time.
|
|
* E.g. a repetition of one hour will take one real hour
|
|
* every time, even in a time zone with DST.
|
|
* Leap seconds, leap days and month length
|
|
* differences will still make the intervals different.
|
|
*/
|
|
RegularIntervals = 0,
|
|
/**
|
|
* Ensure that the time at which the intervals occur stay
|
|
* at the same place in the day, local time. So e.g.
|
|
* a period of one day, starting at 8:05AM Europe/Amsterdam time
|
|
* will always start at 8:05 Europe/Amsterdam. This means that
|
|
* in UTC time, some intervals will be 25 hours and some
|
|
* 23 hours during DST changes.
|
|
* Another example: an hourly interval will be hourly in local time,
|
|
* skipping an hour in UTC for a DST backward change.
|
|
*/
|
|
RegularLocalTime = 1,
|
|
/**
|
|
* End-of-enum marker
|
|
*/
|
|
MAX = 2,
|
|
}
|
|
/**
|
|
* Convert a PeriodDst to a string: "regular intervals" or "regular local time"
|
|
*/
|
|
export function periodDstToString(p: PeriodDst): string;
|
|
/**
|
|
* Repeating time period: consists of a starting point and
|
|
* a time length. This class accounts for leap seconds and leap days.
|
|
*/
|
|
export class Period {
|
|
/**
|
|
* Constructor
|
|
* LIMITATION: if dst equals RegularLocalTime, and unit is Second, Minute or Hour,
|
|
* then the amount must be a factor of 24. So 120 seconds is allowed while 121 seconds is not.
|
|
* This is due to the enormous processing power required by these cases. They are not
|
|
* implemented and you will get an assert.
|
|
*
|
|
* @param start The start of the period. If the period is in Months or Years, and
|
|
* the day is 29 or 30 or 31, the results are maximised to end-of-month.
|
|
* @param interval The interval of the period
|
|
* @param dst Specifies how to handle Daylight Saving Time. Not relevant
|
|
* if the time zone of the start datetime does not have DST.
|
|
* Defaults to RegularLocalTime.
|
|
*/
|
|
constructor(start: DateTime, interval: Duration, dst?: PeriodDst);
|
|
/**
|
|
* Constructor
|
|
* LIMITATION: if dst equals RegularLocalTime, and unit is Second, Minute or Hour,
|
|
* then the amount must be a factor of 24. So 120 seconds is allowed while 121 seconds is not.
|
|
* This is due to the enormous processing power required by these cases. They are not
|
|
* implemented and you will get an assert.
|
|
*
|
|
* @param start The start of the period. If the period is in Months or Years, and
|
|
* the day is 29 or 30 or 31, the results are maximised to end-of-month.
|
|
* @param amount The amount of units.
|
|
* @param unit The unit.
|
|
* @param dst Specifies how to handle Daylight Saving Time. Not relevant
|
|
* if the time zone of the start datetime does not have DST.
|
|
* Defaults to RegularLocalTime.
|
|
*/
|
|
constructor(start: DateTime, amount: number, unit: TimeUnit, dst?: PeriodDst);
|
|
/**
|
|
* The start date
|
|
*/
|
|
start(): DateTime;
|
|
/**
|
|
* The interval
|
|
*/
|
|
interval(): Duration;
|
|
/**
|
|
* DEPRECATED
|
|
* The amount of units of the interval
|
|
*/
|
|
amount(): number;
|
|
/**
|
|
* DEPRECATED
|
|
* The unit of the interval
|
|
*/
|
|
unit(): TimeUnit;
|
|
/**
|
|
* The dst handling mode
|
|
*/
|
|
dst(): PeriodDst;
|
|
/**
|
|
* The first occurrence of the period greater than
|
|
* the given date. The given date need not be at a period boundary.
|
|
* Pre: the fromdate and startdate must either both have timezones or not
|
|
* @param fromDate: the date after which to return the next date
|
|
* @return the first date matching the period after fromDate, given
|
|
* in the same zone as the fromDate.
|
|
*/
|
|
findFirst(fromDate: DateTime): DateTime;
|
|
/**
|
|
* Returns the next timestamp in the period. The given timestamp must
|
|
* be at a period boundary, otherwise the answer is incorrect.
|
|
* This function has MUCH better performance than findFirst.
|
|
* Returns the datetime "count" times away from the given datetime.
|
|
* @param prev Boundary date. Must have a time zone (any time zone) iff the period start date has one.
|
|
* @param count Optional, must be >= 1 and whole.
|
|
* @return (prev + count * period), in the same timezone as prev.
|
|
*/
|
|
findNext(prev: DateTime, count?: number): DateTime;
|
|
/**
|
|
* Checks whether the given date is on a period boundary
|
|
* (expensive!)
|
|
*/
|
|
isBoundary(occurrence: DateTime): boolean;
|
|
/**
|
|
* Returns true iff this period has the same effect as the given one.
|
|
* i.e. a period of 24 hours is equal to one of 1 day if they have the same UTC start moment
|
|
* and same dst.
|
|
*/
|
|
equals(other: Period): boolean;
|
|
/**
|
|
* Returns true iff this period was constructed with identical arguments to the other one.
|
|
*/
|
|
identical(other: Period): boolean;
|
|
/**
|
|
* Returns an ISO duration string e.g.
|
|
* 2014-01-01T12:00:00.000+01:00/P1H
|
|
* 2014-01-01T12:00:00.000+01:00/PT1M (one minute)
|
|
* 2014-01-01T12:00:00.000+01:00/P1M (one month)
|
|
*/
|
|
toIsoString(): string;
|
|
/**
|
|
* A string representation e.g.
|
|
* "10 years, starting at 2014-03-01T12:00:00 Europe/Amsterdam, keeping regular intervals".
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* Used by util.inspect()
|
|
*/
|
|
inspect(): string;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/timesource' {
|
|
/**
|
|
* For testing purposes, we often need to manipulate what the current
|
|
* time is. This is an interface for a custom time source object
|
|
* so in tests you can use a custom time source.
|
|
*/
|
|
export interface TimeSource {
|
|
/**
|
|
* Return the current date+time as a javascript Date object
|
|
*/
|
|
now(): Date;
|
|
}
|
|
/**
|
|
* Default time source, returns actual time
|
|
*/
|
|
export class RealTimeSource implements TimeSource {
|
|
now(): Date;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/timezone' {
|
|
import javascript = require("__timezonecomplete/javascript");
|
|
import DateFunctions = javascript.DateFunctions;
|
|
/**
|
|
* The local time zone for a given date as per OS settings. Note that time zones are cached
|
|
* so you don't necessarily get a new object each time.
|
|
*/
|
|
export function local(): TimeZone;
|
|
/**
|
|
* Coordinated Universal Time zone. Note that time zones are cached
|
|
* so you don't necessarily get a new object each time.
|
|
*/
|
|
export function utc(): TimeZone;
|
|
/**
|
|
* @param offset offset w.r.t. UTC in minutes, e.g. 90 for +01:30. Note that time zones are cached
|
|
* so you don't necessarily get a new object each time.
|
|
* @returns a time zone with the given fixed offset
|
|
*/
|
|
export function zone(offset: number): TimeZone;
|
|
/**
|
|
* Time zone for an offset string or an IANA time zone string. Note that time zones are cached
|
|
* so you don't necessarily get a new object each time.
|
|
* @param s Empty string for no time zone (null is returned),
|
|
* "localtime" for local time,
|
|
* a TZ database time zone name (e.g. Europe/Amsterdam),
|
|
* or an offset string (either +01:30, +0130, +01, Z). For a full list of names, see:
|
|
* https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
|
|
* @param dst Optional, default true: adhere to Daylight Saving Time if applicable. Note for
|
|
* "localtime", timezonecomplete will adhere to the computer settings, the DST flag
|
|
* does not have any effect.
|
|
*/
|
|
export function zone(name: string, dst?: boolean): TimeZone;
|
|
/**
|
|
* The type of time zone
|
|
*/
|
|
export enum TimeZoneKind {
|
|
/**
|
|
* Local time offset as determined by JavaScript Date class.
|
|
*/
|
|
Local = 0,
|
|
/**
|
|
* Fixed offset from UTC, without DST.
|
|
*/
|
|
Offset = 1,
|
|
/**
|
|
* IANA timezone managed through Olsen TZ database. Includes
|
|
* DST if applicable.
|
|
*/
|
|
Proper = 2,
|
|
}
|
|
/**
|
|
* Option for TimeZone#normalizeLocal()
|
|
*/
|
|
export enum NormalizeOption {
|
|
/**
|
|
* Normalize non-existing times by ADDING the DST offset
|
|
*/
|
|
Up = 0,
|
|
/**
|
|
* Normalize non-existing times by SUBTRACTING the DST offset
|
|
*/
|
|
Down = 1,
|
|
}
|
|
/**
|
|
* Time zone. The object is immutable because it is cached:
|
|
* requesting a time zone twice yields the very same object.
|
|
* Note that we use time zone offsets inverted w.r.t. JavaScript Date.getTimezoneOffset(),
|
|
* i.e. offset 90 means +01:30.
|
|
*
|
|
* Time zones come in three flavors: the local time zone, as calculated by JavaScript Date,
|
|
* a fixed offset ("+01:30") without DST, or a IANA timezone ("Europe/Amsterdam") with DST
|
|
* applied depending on the time zone rules.
|
|
*/
|
|
export class TimeZone {
|
|
/**
|
|
* The local time zone for a given date. Note that
|
|
* the time zone varies with the date: amsterdam time for
|
|
* 2014-01-01 is +01:00 and amsterdam time for 2014-07-01 is +02:00
|
|
*/
|
|
static local(): TimeZone;
|
|
/**
|
|
* The UTC time zone.
|
|
*/
|
|
static utc(): TimeZone;
|
|
/**
|
|
* Time zone with a fixed offset
|
|
* @param offset offset w.r.t. UTC in minutes, e.g. 90 for +01:30
|
|
*/
|
|
static zone(offset: number): TimeZone;
|
|
/**
|
|
* Time zone for an offset string or an IANA time zone string. Note that time zones are cached
|
|
* so you don't necessarily get a new object each time.
|
|
* @param s Empty string for no time zone (null is returned),
|
|
* "localtime" for local time,
|
|
* a TZ database time zone name (e.g. Europe/Amsterdam),
|
|
* or an offset string (either +01:30, +0130, +01, Z). For a full list of names, see:
|
|
* https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
|
|
* TZ database zone name may be suffixed with " without DST" to indicate no DST should be applied.
|
|
* In that case, the dst parameter is ignored.
|
|
* @param dst Optional, default true: adhere to Daylight Saving Time if applicable. Note for
|
|
* "localtime", timezonecomplete will adhere to the computer settings, the DST flag
|
|
* does not have any effect.
|
|
*/
|
|
static zone(s: string, dst?: boolean): TimeZone;
|
|
/**
|
|
* Do not use this constructor, use the static
|
|
* TimeZone.zone() method instead.
|
|
* @param name NORMALIZED name, assumed to be correct
|
|
* @param dst Adhere to Daylight Saving Time if applicable, ignored for local time and fixed offsets
|
|
*/
|
|
constructor(name: string, dst?: boolean);
|
|
/**
|
|
* The time zone identifier. Can be an offset "-01:30" or an
|
|
* IANA time zone name "Europe/Amsterdam", or "localtime" for
|
|
* the local time zone.
|
|
*/
|
|
name(): string;
|
|
dst(): boolean;
|
|
/**
|
|
* The kind of time zone (Local/Offset/Proper)
|
|
*/
|
|
kind(): TimeZoneKind;
|
|
/**
|
|
* Equality operator. Maps zero offsets and different names for UTC onto
|
|
* each other. Other time zones are not mapped onto each other.
|
|
*/
|
|
equals(other: TimeZone): boolean;
|
|
/**
|
|
* Returns true iff the constructor arguments were identical, so UTC !== GMT
|
|
*/
|
|
identical(other: TimeZone): boolean;
|
|
/**
|
|
* Is this zone equivalent to UTC?
|
|
*/
|
|
isUtc(): boolean;
|
|
/**
|
|
* Does this zone have Daylight Saving Time at all?
|
|
*/
|
|
hasDst(): boolean;
|
|
/**
|
|
* Calculate timezone offset from a UTC time.
|
|
*
|
|
* @param year Full year
|
|
* @param month Month 1-12 (note this deviates from JavaScript date)
|
|
* @param day Day of month 1-31
|
|
* @param hour Hour 0-23
|
|
* @param minute Minute 0-59
|
|
* @param second Second 0-59
|
|
* @param millisecond Millisecond 0-999
|
|
*
|
|
* @return the offset of this time zone with respect to UTC at the given time, in minutes.
|
|
*/
|
|
offsetForUtc(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number): number;
|
|
/**
|
|
* Calculate timezone offset from a zone-local time (NOT a UTC time).
|
|
* @param year local full year
|
|
* @param month local month 1-12 (note this deviates from JavaScript date)
|
|
* @param day local day of month 1-31
|
|
* @param hour local hour 0-23
|
|
* @param minute local minute 0-59
|
|
* @param second local second 0-59
|
|
* @param millisecond local millisecond 0-999
|
|
* @return the offset of this time zone with respect to UTC at the given time, in minutes.
|
|
*/
|
|
offsetForZone(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number): number;
|
|
/**
|
|
* Note: will be removed in version 2.0.0
|
|
*
|
|
* Convenience function, takes values from a Javascript Date
|
|
* Calls offsetForUtc() with the contents of the date
|
|
*
|
|
* @param date: the date
|
|
* @param funcs: the set of functions to use: get() or getUTC()
|
|
*/
|
|
offsetForUtcDate(date: Date, funcs: DateFunctions): number;
|
|
/**
|
|
* Note: will be removed in version 2.0.0
|
|
*
|
|
* Convenience function, takes values from a Javascript Date
|
|
* Calls offsetForUtc() with the contents of the date
|
|
*
|
|
* @param date: the date
|
|
* @param funcs: the set of functions to use: get() or getUTC()
|
|
*/
|
|
offsetForZoneDate(date: Date, funcs: DateFunctions): number;
|
|
/**
|
|
* Zone abbreviation at given UTC timestamp e.g. CEST for Central European Summer Time.
|
|
*
|
|
* @param year Full year
|
|
* @param month Month 1-12 (note this deviates from JavaScript date)
|
|
* @param day Day of month 1-31
|
|
* @param hour Hour 0-23
|
|
* @param minute Minute 0-59
|
|
* @param second Second 0-59
|
|
* @param millisecond Millisecond 0-999
|
|
* @param dstDependent (default true) set to false for a DST-agnostic abbreviation
|
|
*
|
|
* @return "local" for local timezone, the offset for an offset zone, or the abbreviation for a proper zone.
|
|
*/
|
|
abbreviationForUtc(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, dstDependent?: boolean): string;
|
|
/**
|
|
* Normalizes non-existing local times by adding a forward offset change.
|
|
* During a forward standard offset change or DST offset change, some amount of
|
|
* local time is skipped. Therefore, this amount of local time does not exist.
|
|
* This function adds the amount of forward change to any non-existing time. After all,
|
|
* this is probably what the user meant.
|
|
*
|
|
* @param localUnixMillis Unix timestamp in zone time
|
|
* @param opt (optional) Round up or down? Default: up
|
|
*
|
|
* @returns Unix timestamp in zone time, normalized.
|
|
*/
|
|
normalizeZoneTime(localUnixMillis: number, opt?: NormalizeOption): number;
|
|
/**
|
|
* The time zone identifier (normalized).
|
|
* Either "localtime", IANA name, or "+hh:mm" offset.
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* Used by util.inspect()
|
|
*/
|
|
inspect(): string;
|
|
/**
|
|
* Convert an offset number into an offset string
|
|
* @param offset The offset in minutes from UTC e.g. 90 minutes
|
|
* @return the offset in ISO notation "+01:30" for +90 minutes
|
|
*/
|
|
static offsetToString(offset: number): string;
|
|
/**
|
|
* String to offset conversion.
|
|
* @param s Formats: "-01:00", "-0100", "-01", "Z"
|
|
* @return offset w.r.t. UTC in minutes
|
|
*/
|
|
static stringToOffset(s: string): number;
|
|
}
|
|
}
|
|
|
|
declare module '__timezonecomplete/globals' {
|
|
import datetime = require("__timezonecomplete/datetime");
|
|
import DateTime = datetime.DateTime;
|
|
import duration = require("__timezonecomplete/duration");
|
|
import Duration = duration.Duration;
|
|
/**
|
|
* Returns the minimum of two DateTimes
|
|
*/
|
|
export function min(d1: DateTime, d2: DateTime): DateTime;
|
|
/**
|
|
* Returns the minimum of two Durations
|
|
*/
|
|
export function min(d1: Duration, d2: Duration): Duration;
|
|
/**
|
|
* Returns the maximum of two DateTimes
|
|
*/
|
|
export function max(d1: DateTime, d2: DateTime): DateTime;
|
|
/**
|
|
* Returns the maximum of two Durations
|
|
*/
|
|
export function max(d1: Duration, d2: Duration): Duration;
|
|
/**
|
|
* Returns the absolute value of a Duration
|
|
*/
|
|
export function abs(d: Duration): Duration;
|
|
}
|