-spec date_to_gregorian_days(Date) -> Days when Date :: date(), Days :: non_neg_integer().

Computes the number of gregorian days starting with year 0 and ending at the specified date.

-spec date_to_gregorian_days(Year, Month, Day) -> Days
                          when
                              Year :: year(),
                              Month :: month(),
                              Day :: day(),
                              Days :: non_neg_integer().

Equivalent to date_to_gregorian_days({Year, Month, Day})

-spec datetime_to_gregorian_seconds(DateTime) -> Seconds
                                 when DateTime :: datetime(), Seconds :: non_neg_integer().

Computes the number of gregorian seconds starting with year 0 and ending at the specified date and time.

-spec day_of_the_week(Date) -> daynum() when Date :: date().

Computes the day of the week from the specified Year, Month, and Day. Returns the day of the week as 1: Monday, 2: Tuesday, and so on.

-spec day_of_the_week(Year, Month, Day) -> daynum() when Year :: year(), Month :: month(), Day :: day().

Equivalent to day_of_the_week({Year, Month, Day})

-spec gregorian_days_to_date(Days) -> date() when Days :: non_neg_integer().

Computes the date from the specified number of gregorian days.

-spec gregorian_seconds_to_datetime(Seconds) -> datetime() when Seconds :: non_neg_integer().

Computes the date and time from the specified number of gregorian seconds.

-spec is_leap_year(Year) -> boolean() when Year :: year().

Checks if the specified year is a leap year.

-spec iso_week_number() -> yearweeknum().

Returns tuple {Year, WeekNum} representing the ISO week number for the actual date. To determine the actual date, use function local_time/0.

-spec iso_week_number(Date) -> yearweeknum() when Date :: date().

Returns tuple {Year, WeekNum} representing the ISO week number for the specified date.

-spec last_day_of_the_month(Year, Month) -> LastDay
                         when Year :: year(), Month :: month(), LastDay :: ldom().

Computes the number of days in a month.

-spec local_time() -> datetime().

Returns the local time reported by the underlying operating system.

-spec local_time_to_universal_time(DateTime1) -> DateTime2
                                when DateTime1 :: datetime1970(), DateTime2 :: datetime1970().

Converts from local time to Universal Coordinated Time (UTC). DateTime1 must refer to a local date after Jan 1, 1970.

Warning

This function is deprecated. Use local_time_to_universal_time_dst/1 instead, as it gives a more correct and complete result. Especially for the period that does not exist, as it is skipped during the switch to daylight saving time, this function still returns a result.

-spec local_time_to_universal_time_dst(DateTime1) -> [DateTime]
                                    when DateTime1 :: datetime1970(), DateTime :: datetime1970().

Converts from local time to Universal Coordinated Time (UTC). DateTime1 must refer to a local date after Jan 1, 1970.

The return value is a list of 0, 1, or 2 possible UTC times:

• [] - For a local {Date1, Time1} during the period that is skipped when switching to daylight saving time, there is no corresponding UTC, as the local time is illegal (it has never occured).

• [DstDateTimeUTC, DateTimeUTC] - For a local {Date1, Time1} during the period that is repeated when switching from daylight saving time, two corresponding UTCs exist; one for the first instance of the period when daylight saving time is still active, and one for the second instance.

• [DateTimeUTC] - For all other local times only one corresponding UTC exists.

-spec now_to_datetime(Now) -> datetime1970() when Now :: erlang:timestamp().

Returns Universal Coordinated Time (UTC) converted from the return value from erlang:timestamp/0.

-spec now_to_local_time(Now) -> datetime1970() when Now :: erlang:timestamp().

Returns local date and time converted from the return value from erlang:timestamp/0.

-spec now_to_universal_time(Now) -> datetime1970() when Now :: erlang:timestamp().

Returns Universal Coordinated Time (UTC) converted from the return value from erlang:timestamp/0.

-spec rfc3339_to_system_time(DateTimeString) -> integer() when DateTimeString :: rfc3339_string().

Equivalent to rfc3339_to_system_time(DateTimeString, [])

-spec rfc3339_to_system_time(DateTimeString, Options) -> integer()
                          when
                              DateTimeString :: rfc3339_string(),
                              Options :: [Option],
                              Option :: {unit, rfc3339_time_unit()}.

Converts an RFC 3339 timestamp into system time. The data format of RFC 3339 timestamps is described by RFC 3339. Starting from OTP 25.1, the minutes part of the time zone is optional.

Valid option:

• {unit, Unit} - The time unit of the return value. The default is second.

1> calendar:rfc3339_to_system_time("2018-02-01T16:17:58+01:00").
1517498278
2> calendar:rfc3339_to_system_time("2018-02-01 15:18:02.088Z",
   [{unit, nanosecond}]).
1517498282088000000

-spec seconds_to_daystime(Seconds) -> {Days, Time}
                       when Seconds :: integer(), Days :: integer(), Time :: time().

Converts a specified number of seconds into days, hours, minutes, and seconds. Time is always non-negative, but Days is negative if argument Seconds is.

-spec seconds_to_time(Seconds) -> time() when Seconds :: secs_per_day().

Computes the time from the specified number of seconds. Seconds must be less than the number of seconds per day (86400).

-spec system_time_to_local_time(Time, TimeUnit) -> datetime()
                             when Time :: integer(), TimeUnit :: erlang:time_unit().

Converts a specified system time into local date and time.

-spec system_time_to_rfc3339(Time) -> DateTimeString
                          when Time :: integer(), DateTimeString :: rfc3339_string().

Equivalent to system_time_to_rfc3339(Time, [])

-spec system_time_to_rfc3339(Time, Options) -> DateTimeString
                          when
                              Time :: integer(),
                              Options :: [Option],
                              Option ::
                                  {offset, offset()} |
                                  {time_designator, byte()} |
                                  {unit, rfc3339_time_unit()},
                              DateTimeString :: rfc3339_string().

Converts a system time into an RFC 3339 timestamp.

The data format of RFC 3339 timestamps is described by RFC 3339. The data format of offsets is also described by RFC 3339.

Valid options:

• {offset, Offset} - The offset, either a string or an integer, to be included in the formatted string. An empty string, which is the default, is interpreted as local time. A non-empty string is included as is. The time unit of the integer is the same as the one of Time.

• {time_designator, Character} - The character used as time designator, that is, the date and time separator. The default is $T.

• {unit, Unit} - The time unit of Time. The default is second. If some other unit is given (millisecond, microsecond, nanosecond, or native), the formatted string includes a fraction of a second. The number of fractional second digits is three, six, or nine depending on what time unit is chosen. For native three fractional digits are included. Notice that trailing zeros are not removed from the fraction.

1> calendar:system_time_to_rfc3339(erlang:system_time(second)).
"2018-04-23T14:56:28+02:00"
2> calendar:system_time_to_rfc3339(erlang:system_time(second),
   [{offset, "-02:00"}]).
"2018-04-23T10:56:52-02:00"
3> calendar:system_time_to_rfc3339(erlang:system_time(second),
   [{offset, -7200}]).
"2018-04-23T10:57:05-02:00"
4> calendar:system_time_to_rfc3339(erlang:system_time(millisecond),
   [{unit, millisecond}, {time_designator, $\s}, {offset, "Z"}]).
"2018-04-23 12:57:20.482Z"

-spec system_time_to_universal_time(Time, TimeUnit) -> datetime()
                                 when Time :: integer(), TimeUnit :: erlang:time_unit().

Converts a specified system time into universal date and time.

-spec time_difference(T1, T2) -> {Days, Time}
                   when T1 :: datetime(), T2 :: datetime(), Days :: integer(), Time :: time().

Returns the difference between two {Date, Time} tuples. T2 is to refer to an epoch later than T1.

Warning

This function is obsolete. Use the conversion functions for gregorian days and seconds instead.

-spec time_to_seconds(Time) -> secs_per_day() when Time :: time().

Returns the number of seconds since midnight up to the specified time.

-spec universal_time() -> datetime().

Returns the Universal Coordinated Time (UTC) reported by the underlying operating system. Returns local time if universal time is unavailable.

-spec universal_time_to_local_time(DateTime) -> datetime() when DateTime :: datetime1970().

Converts from Universal Coordinated Time (UTC) to local time. DateTime must refer to a date after Jan 1, 1970.

-spec valid_date(Date) -> boolean() when Date :: date().

This function checks if a date is a valid.

-spec valid_date(Year, Month, Day) -> boolean()
              when Year :: integer(), Month :: integer(), Day :: integer().

Equivalent to valid_date({Year, Month, Day})