diff --git a/CHANGELOG.md b/CHANGELOG.md
index 53eb5f61..e3c1527a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 - Remove internal async/await helpers that do not need to be exposed in `Core`.
 - Add locale and formatting options to `localeDateString`, `localeString` and `localTimeString` functions https://github.com/rescript-association/rescript-core/pull/30
 - Change `RegExp.source` to return a `string`. Was previously returning a `bool`, which is wrong. https://github.com/rescript-association/rescript-core/pull/47
+- Remove `Date.valueOf` as it returns the same as `Date.getTime`. https://github.com/rescript-association/rescript-core/pull/61
 
 ### Documentation
 
@@ -24,3 +25,4 @@
 - Docstrings for `Int`. https://github.com/rescript-association/rescript-core/pull/37
 - Docstrings for `Dict`. https://github.com/rescript-association/rescript-core/pull/40
 - Docstrings for `RegExp`. https://github.com/rescript-association/rescript-core/pull/47
+- Docstrings for `Date`. https://github.com/rescript-association/rescript-core/pull/61
diff --git a/src/Core__Date.res b/src/Core__Date.res
index cde07732..02f639b9 100644
--- a/src/Core__Date.res
+++ b/src/Core__Date.res
@@ -1,6 +1,6 @@
 type t = Js.Date.t
 
-type time = float
+type msSinceEpoch = float
 
 type localeOptions = {
   dateStyle?: [#full | #long | #medium | #short],
@@ -16,11 +16,9 @@ type localeOptions = {
   timeZoneName?: [#long | #short],
 }
 
-@send external valueOf: t => time = "valueOf"
-
 @new external make: unit => t = "Date"
 @new external fromString: string => t = "Date"
-@new external fromTime: time => t = "Date"
+@new external fromTime: msSinceEpoch => t = "Date"
 
 @new external makeWithYM: (~year: int, ~month: int) => t = "Date"
 @new external makeWithYMD: (~year: int, ~month: int, ~date: int) => t = "Date"
@@ -49,10 +47,11 @@ external makeWithYMDHMSM: (
 ) => t = "Date"
 
 module UTC = {
-  @val external makeWithYM: (~year: int, ~month: int) => time = "Date.UTC"
-  @val external makeWithYMD: (~year: int, ~month: int, ~date: int) => time = "Date.UTC"
+  @val external makeWithYM: (~year: int, ~month: int) => msSinceEpoch = "Date.UTC"
+  @val external makeWithYMD: (~year: int, ~month: int, ~date: int) => msSinceEpoch = "Date.UTC"
   @val
-  external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => time = "Date.UTC"
+  external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => msSinceEpoch =
+    "Date.UTC"
   @val
   external makeWithYMDHM: (
     ~year: int,
@@ -60,7 +59,7 @@ module UTC = {
     ~date: int,
     ~hours: int,
     ~minutes: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
   @val
   external makeWithYMDHMS: (
     ~year: int,
@@ -69,7 +68,7 @@ module UTC = {
     ~hours: int,
     ~minutes: int,
     ~seconds: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
   @val
   external makeWithYMDHMSM: (
     ~year: int,
@@ -79,12 +78,12 @@ module UTC = {
     ~minutes: int,
     ~seconds: int,
     ~milliseconds: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
 }
 
-@val external now: unit => time = "Date.now"
+@val external now: unit => msSinceEpoch = "Date.now"
 
-@send external getTime: t => time = "getTime"
+@send external getTime: t => msSinceEpoch = "getTime"
 @send external getTimezoneOffset: t => int = "getTimezoneOffset"
 
 // Locale
diff --git a/src/Core__Date.resi b/src/Core__Date.resi
index 6c0e2945..b97a16f2 100644
--- a/src/Core__Date.resi
+++ b/src/Core__Date.resi
@@ -2,8 +2,16 @@
   Functions for interacting with JavaScript Dates.
 */
 
+/** 
+A type representing a JavaScript date.
+*/
 type t = Js.Date.t
-type time = float
+
+/** 
+Time, in milliseconds, since / until the UNIX epoch (January 1, 1970 00:00:00 UTC).
+Positive numbers represent dates after, negative numbers dates before epoch.
+*/
+type msSinceEpoch = float
 
 /**
 A type representing date time format options.
@@ -35,16 +43,192 @@ type localeOptions = {
   timeZoneName?: [#long | #short],
 }
 
-@send external valueOf: t => time = "valueOf"
-@new external make: unit => t = "Date"
-@new external fromString: string => t = "Date"
-@new external fromTime: time => t = "Date"
-@new external makeWithYM: (~year: int, ~month: int) => t = "Date"
-@new external makeWithYMD: (~year: int, ~month: int, ~date: int) => t = "Date"
-@new external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => t = "Date"
+/** 
+`make()`
+
+Creates a date object with the current date time as value.
+
+## Examples
+```rescript
+Date.make()
+```
+*/
+@new
+external make: unit => t = "Date"
+
+/** 
+`fromString(dateTimeString)` 
+
+Creates a date object from given date time string.
+The string has to be in the ISO 8601 format YYYY-MM-DDTHH:mm:ss.sssZ (https://tc39.es/ecma262/#sec-date-time-string-format).
+
+Invalid date time strings will create invalid dates.
+You can use the result like any valid date, but many functions like `toString` will return "Invalid Date" or functions like `Date.getTime` will return NaN.
+
+## Examples
+```rescript
+Date.fromString("2023")
+// 2023-01-01T00:00:00.000Z
+
+Date.fromString("2023-02-20")
+// 2023-02-20T00:00:00.000Z
+
+Date.fromString("2023-02-20T16:40:00.00Z")
+// 2023-02-20T16:40:00.000Z
+
+Date.fromString("")
+// Invalid Date
+
+Date.fromString("")->getTime
+// NaN
+```
+*/
+@new
+external fromString: string => t = "Date"
+
+/** 
+`fromTime(msSinceEpoch)` 
+
+Creates a date object from the given time in milliseconds since / until UNIX epoch (January 1, 1970 00:00:00 UTC).
+Positive numbers create dates after epoch, negative numbers create dates before epoch.
+
+## Examples
+```rescript
+Date.fromTime(0.0)
+// 1970-01-01T00:00:00.000Z
+
+Date.fromTime(-86_400_000.0)
+// 1969-12-31T00:00:00.000Z
+
+Date.fromTime(86_400_000.0)
+// 1970-01-02T00:00:00.000Z
+```
+*/
+@new
+external fromTime: msSinceEpoch => t = "Date"
+
+/** 
+Creates a date object with the given year and month.
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYM(~year=2023, ~month=0)
+// 2023-01-01T00:00:00.000Z
+
+Date.makeWithYM(~year=2023, ~month=11)
+// 2023-12-01T00:00:00.000Z
+
+Date.makeWithYM(~year=2023, ~month=12)
+// 2024-01-01T00:00:00.000Z
+
+Date.makeWithYM(~year=2023, ~month=-1)
+// 2022-12-01T00:00:00.000Z
+
+// Note: The output depends on your local time zone.
+// In nodejs you can change it by using the TZ env (`export TZ='Europe/London' && node index.bs.js`)
+
+```
+*/
+@new
+external makeWithYM: (~year: int, ~month: int) => t = "Date"
+
+/** 
+Creates a date object with the given year, month and date (day of month).
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYMD(~year=2023, ~month=1, ~date=20)
+// 2023-02-20T00:00:00.000Z
+
+Date.makeWithYMD(~year=2023, ~month=1, ~date=-1)
+// 2022-11-29T00:00:00.000Z
+
+Date.makeWithYMD(~year=2023, ~month=1, ~date=29)
+// 2023-03-01T00:00:00.000Z
+```
+*/
+@new
+external makeWithYMD: (~year: int, ~month: int, ~date: int) => t = "Date"
+
+/** 
+Creates a date object with the given year, month, date (day of month) and hours.
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=16)
+// 2023-02-20T16:00:00.000Z
+
+Date.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=24)
+// 2023-02-21T00:00:00.000Z
+
+Date.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=-1)
+// 2023-02-19T23:00:00.000Z
+
+// Note: The output depends on your local time zone.
+// In nodejs you can change it by using the TZ env (`export TZ='Europe/London' && node index.bs.js`)
+
+```
+*/
+@new
+external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => t = "Date"
+
+/** 
+Creates a date object with the given year, month, date (day of month), hours and minutes.
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40)
+// 2023-02-20T16:40:00.000Z
+
+Date.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=60)
+// 2023-02-20T17:00:00.000Z
+
+Date.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=-1)
+// 2023-02-20T15:59:00.000Z
+
+// Note: The output depends on your local time zone.
+// In nodejs you can change it by using the TZ env (`export TZ='Europe/London' && node index.bs.js`)
+
+```
+*/
 @new
 external makeWithYMDHM: (~year: int, ~month: int, ~date: int, ~hours: int, ~minutes: int) => t =
   "Date"
+
+/** 
+Creates a date object with the given year, month, date (day of month), hours, minutes and seconds.
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0)
+// 2023-02-20T16:40:00.000Z
+
+Date.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=60)
+// 2023-02-20T16:41:00.000Z
+
+Date.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=-1)
+// 2023-02-20T16:39:59.000Z
+
+// Note: The output depends on your local time zone.
+// In nodejs you can change it by using the TZ env (`export TZ='Europe/London' && node index.bs.js`)
+
+```
+*/
 @new
 external makeWithYMDHMS: (
   ~year: int,
@@ -54,6 +238,29 @@ external makeWithYMDHMS: (
   ~minutes: int,
   ~seconds: int,
 ) => t = "Date"
+
+/** 
+Creates a date object with the given year, month, date (day of month), hours, minutes, seconds and milliseconds.
+Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+Months are 0-indexed (0 = January, 11 = December).
+Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+## Examples
+```rescript
+Date.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=0)
+// 2023-02-20T16:40:00.000Z
+
+Date.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=1000)
+// 2023-02-20T16:40:01.000Z
+
+Date.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=-1)
+// 2023-02-20T16:39:59.999Z
+
+// Note: The output depends on your local time zone.
+// In nodejs you can change it by using the TZ env (`export TZ='Europe/London' && node index.bs.js`)
+
+```
+*/
 @new
 external makeWithYMDHMSM: (
   ~year: int,
@@ -65,10 +272,91 @@ external makeWithYMDHMSM: (
   ~milliseconds: int,
 ) => t = "Date"
 module UTC: {
-  @val external makeWithYM: (~year: int, ~month: int) => time = "Date.UTC"
-  @val external makeWithYMD: (~year: int, ~month: int, ~date: int) => time = "Date.UTC"
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  Date.UTC.makeWithYM(~year=2023, ~month=0)
+  // 1672531200000
+
+  Date.UTC.makeWithYM(~year=2023, ~month=11)
+  // 1701388800000
+
+  Date.UTC.makeWithYM(~year=2023, ~month=12)
+  // 1704067200000
+
+  Date.UTC.makeWithYM(~year=2023, ~month=-1)
+  // 1669852800000
+  ```
+  */
+  @val
+  external makeWithYM: (~year: int, ~month: int) => msSinceEpoch = "Date.UTC"
+
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  Date.UTC.makeWithYMD(~year=2023, ~month=1, ~date=20)
+  // 1676851200000
+
+  Date.UTC.makeWithYMD(~year=2023, ~month=1, ~date=-1)
+  // 1675036800000
+
+  Date.UTC.makeWithYMD(~year=2023, ~month=1, ~date=29)
+  // 1677628800000
+  ```
+  */
+  @val
+  external makeWithYMD: (~year: int, ~month: int, ~date: int) => msSinceEpoch = "Date.UTC"
+
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  Date.UTC.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=16)
+  // 1676908800000
+
+  Date.UTC.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=24)
+  // 1676937600000
+
+  Date.UTC.makeWithYMDH(~year=2023, ~month=1, ~date=20, ~hours=-1)
+  // 1676847600000
+  ```
+  */
   @val
-  external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => time = "Date.UTC"
+  external makeWithYMDH: (~year: int, ~month: int, ~date: int, ~hours: int) => msSinceEpoch =
+    "Date.UTC"
+
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  Date.UTC.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40)
+  // 1676911200000
+
+  Date.UTC.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=60)
+  // 1676912400000
+
+  Date.UTC.makeWithYMDHM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=-1)
+  // 1676908740000
+  ```
+  */
   @val
   external makeWithYMDHM: (
     ~year: int,
@@ -76,7 +364,26 @@ module UTC: {
     ~date: int,
     ~hours: int,
     ~minutes: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
+
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  Date.UTC.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0)
+  // 1676911200000
+
+  Date.UTC.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=60)
+  // 1676911260000
+
+  Date.UTC.makeWithYMDHMS(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=-1)
+  // 1676911199000
+  ```
+  */
   @val
   external makeWithYMDHMS: (
     ~year: int,
@@ -85,7 +392,26 @@ module UTC: {
     ~hours: int,
     ~minutes: int,
     ~seconds: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
+
+  /** 
+  Returns the time, in milliseconds, since UNIX epoch (January 1, 1970 00:00:00 UTC).
+  Be aware of using a value for year < 100, because it behaves inconsistent (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years).
+  Months are 0-indexed (0 = January, 11 = December).
+  Values, which are out of range, will be carried over to the next bigger unit (s. example).
+
+  ## Examples
+  ```rescript
+  ```
+  Date.UTC.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=0)->Console.log
+  // 1676911200000
+
+  Date.UTC.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=1000)->Console.log
+  // 1676911201000
+
+  Date.UTC.makeWithYMDHMSM(~year=2023, ~month=1, ~date=20, ~hours=16, ~minutes=40, ~seconds=0, ~milliseconds=-1)->Console.log
+  // 1676911199999
+  */
   @val
   external makeWithYMDHMSM: (
     ~year: int,
@@ -95,215 +421,949 @@ module UTC: {
     ~minutes: int,
     ~seconds: int,
     ~milliseconds: int,
-  ) => time = "Date.UTC"
+  ) => msSinceEpoch = "Date.UTC"
 }
-@val external now: unit => time = "Date.now"
-@send external getTime: t => time = "getTime"
-@send external getTimezoneOffset: t => int = "getTimezoneOffset"
-@send external getFullYear: t => int = "getFullYear"
-@send external getMonth: t => int = "getMonth"
-@send external getDate: t => int = "getDate"
-@send external getHours: t => int = "getHours"
-@send external getMinutes: t => int = "getMinutes"
-@send external getSeconds: t => int = "getSeconds"
-@send external getMilliseconds: t => int = "getMilliseconds"
-@send external getDay: t => int = "getDay"
-@send external setFullYear: (t, int) => unit = "setFullYear"
-@send external setFullYearM: (t, ~year: int, ~month: int) => unit = "setFullYear"
-@send external setFullYearMD: (t, ~year: int, ~month: int, ~date: int) => unit = "setFullYear"
-@send external setMonth: (t, int) => unit = "setMonth"
-@send external setDate: (t, int) => unit = "setDate"
-@send external setHours: (t, int) => unit = "setHours"
-@send external setHoursM: (t, ~hours: int, ~minutes: int) => unit = "setHours"
-@send external setHoursMS: (t, ~hours: int, ~minutes: int, ~seconds: int) => unit = "setHours"
-@send
-external setHoursMSMs: (t, ~hours: int, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit =
-  "setHours"
-@send external setMinutes: (t, int) => unit = "setMinutes"
-@send external setMinutesS: (t, ~minutes: int, ~seconds: int) => unit = "setMinutes"
-@send
-external setMinutesSMs: (t, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit = "setMinutes"
-@send external setSeconds: (t, int) => unit = "setSeconds"
-@send external setSecondsMs: (t, ~seconds: int, ~milliseconds: int) => unit = "setSeconds"
-@send external setMilliseconds: (t, int) => unit = "setMilliseconds"
-@send external getUTCFullYear: t => int = "getUTCFullYear"
-@send external getUTCMonth: t => int = "getUTCMonth"
-@send external getUTCDate: t => int = "getUTCDate"
-@send external getUTCHours: t => int = "getUTCHours"
-@send external getUTCMinutes: t => int = "getUTCMinutes"
-@send external getUTCSeconds: t => int = "getUTCSeconds"
-@send external getUTCMilliseconds: t => int = "getUTCMilliseconds"
-@send external getUTCDay: t => int = "getUTCDay"
-@send external setUTCFullYear: (t, int) => unit = "setUTCFullYear"
-@send external setUTCFullYearM: (t, ~year: int, ~month: int) => unit = "setUTCFullYear"
-@send
-external setUTCFullYearMD: (t, ~year: int, ~month: int, ~date: int) => unit = "setUTCFullYear"
-@send external setUTCMonth: (t, int) => unit = "setUTCMonth"
-@send external setUTCDate: (t, int) => unit = "setUTCDate"
-@send external setUTCHours: (t, int) => unit = "setUTCHours"
-@send external setUTCHoursM: (t, ~hours: int, ~minutes: int) => unit = "setUTCHours"
-@send
-external setUTCHoursMS: (t, ~hours: int, ~minutes: int, ~seconds: int) => unit = "setUTCHours"
+
+/**
+`now()`
+
+Returns the time, in milliseconds, between UNIX epoch (January 1, 1970 00:00:00 UTC) and the current date time.
+*/
+@val
+external now: unit => msSinceEpoch = "Date.now"
+
+/** 
+`getTime(date)`
+
+Returns the time, in milliseconds, between UNIX epoch (January 1, 1970 00:00:00 UTC) and the current date time.
+Invalid dates will return NaN.
+Dates before epoch will return negative numbers.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20")->Date.getTime
+// 1676851200000
+```
+*/
 @send
-external setUTCHoursMSMs: (
-  t,
-  ~hours: int,
-  ~minutes: int,
-  ~seconds: int,
-  ~milliseconds: int,
-) => unit = "setUTCHours"
-@send external setUTCMinutes: (t, int) => unit = "setUTCMinutes"
-@send external setUTCMinutesS: (t, ~minutes: int, ~seconds: int) => unit = "setUTCMinutes"
+external getTime: t => msSinceEpoch = "getTime"
+
+/** 
+`getTimezoneOffset(date)`
+
+Returns the time in minutes between the UTC time and the locale time.
+The timezone of the given date doesn't matter.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01")->Date.getTimezoneOffset
+// -60 with local time zone = Europe/Berlin
+
+Date.fromString("2023-06-01")->Date.getTimezoneOffset
+// -120 with local time zone = Europe/Berlin
+```
+*/
 @send
-external setUTCMinutesSMs: (t, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit =
-  "setUTCMinutes"
-@send external setUTCSeconds: (t, int) => unit = "setUTCSeconds"
-@send external setUTCSecondsMs: (t, ~seconds: int, ~milliseconds: int) => unit = "setUTCSeconds"
-@send external setUTCMilliseconds: (t, int) => unit = "setUTCMilliseconds"
-@send external toDateString: t => string = "toDateString"
-@send external toString: t => string = "toString"
-@send external toTimeString: t => string = "toTimeString"
+external getTimezoneOffset: t => int = "getTimezoneOffset"
 
 /** 
-`toLocaleDateString(date)`
+`getFullYear(date)`
 
-Converts a JavaScript date to a localized date string. It will use the current locale.
+Returns the year of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleDateString->Console.log
-// 2/19/2023
+Date.fromString("2023-02-20")->Date.getFullYear
+// 2023
 ```
 */
 @send
-external toLocaleDateString: t => string = "toLocaleDateString"
+external getFullYear: t => int = "getFullYear"
 
 /** 
-`toLocaleDateStringWithLocale(date, locale)`
+`getMonth(date)`
 
-Converts a JavaScript date to a localized date string. It will use the specified locale.
+Returns the month (0-indexed) of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleDateStringWithLocale("en-US")->Console.log
-// 2/19/2023
+Date.fromString("2023-01-01")->Date.getMonth
+// 0
 ```
 */
 @send
-external toLocaleDateStringWithLocale: (t, string) => string = "toLocaleDateString"
+external getMonth: t => int = "getMonth"
 
 /** 
-`toLocaleDateStringWithLocaleAndOptions(date, locale, options)`
+`getDate(date)`
 
-Converts a JavaScript date to a localized date string. It will use the specified locale and formatting options.
+Returns the date (day of month) of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("en-US", { dateStyle: #long })->Console.log
-// February 19, 2023
+Date.fromString("2023-02-20T16:40:00.00")->Date.getDate
+// 20
+```
+*/
+@send
+external getDate: t => int = "getDate"
 
-Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("de", { hour: #"2-digit", minute: #"2-digit" })->Console.log
-// 19.2.2023, 15:40
+/** 
+`getHours(date)`
 
-Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("de", { year: #numeric })->Console.log
-// 2023
+Returns the hours of a given date (according to local time).
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.getHours
+// 16
 ```
 */
 @send
-external toLocaleDateStringWithLocaleAndOptions: (t, string, localeOptions) => string =
-  "toLocaleDateString"
+external getHours: t => int = "getHours"
 
 /** 
-`toLocaleString(date)`
+`getMinutes(date)`
 
-Converts a JavaScript date to a localized date-time string. It will use the current locale.
+Returns the minutes of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleString->Console.log
-// 2/19/2023, 3:40:00 PM
+Date.fromString("2023-02-20T16:40:00.00")->Date.getMinutes
+// 40
 ```
 */
 @send
-external toLocaleString: t => string = "toLocaleString"
+external getMinutes: t => int = "getMinutes"
 
 /** 
-`toLocaleStringWithLocale(date, locale)`
+`getSeconds(date)`
 
-Converts a JavaScript date to a localized date-time string. It will use the specified locale.
+Returns the seconds of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleStringWithLocale("en-US")->Console.log
-// 2/19/2023, 3:40:00 PM
+Date.fromString("2023-02-20T16:40:00.00")->Date.getSeconds
+// 0
 ```
 */
 @send
-external toLocaleStringWithLocale: (t, string) => string = "toLocaleString"
+external getSeconds: t => int = "getSeconds"
 
 /** 
-`toLocaleStringWithLocaleAndOptions(date, locale, options)`
+`getMilliseconds(date)`
 
-Converts a JavaScript date to a localized date-time string. It will use the specified locale and formatting options.
+Returns the milliseconds of a given date (according to local time).
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleStringWithLocaleAndOptions("en", { dateStyle: #short, timeStyle: #short })->Console.log
-// 2/19/23, 3:40 PM
+Date.fromString("2023-02-20T16:40:00.00")->Date.getMilliseconds
+// 0
+```
+*/
+@send
+external getMilliseconds: t => int = "getMilliseconds"
 
-Date.make()->Date.toLocaleStringWithLocaleAndOptions("en", { era: #long, year: #numeric, month: #"2-digit", day: #"2-digit", hour: #numeric, timeZoneName: #short })->Console.log
-// 02/19/2023 Anno Domini, 3 PM GMT+1
+/** 
+`getDay(date)`
+
+Returns the day of week of a given date (according to local time).
+0 = Sunday, 1 = Monday, ... 6 = Saturday
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.getDay
+// 1
 ```
 */
 @send
-external toLocaleStringWithLocaleAndOptions: (t, string, localeOptions) => string = "toLocaleString"
+external getDay: t => int = "getDay"
 
 /** 
-`toLocaleTimeString(date)`
+`setFullYear(date, year)`
 
-Converts a JavaScript date to a localized time string. It will use the current locale.
+Sets the year of a date (according to local time).
+Beware this will *mutate* the date.
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleTimeString->Console.log
-// 3:40:00 PM
+Date.fromString("2023-02-20T16:40:00.00")->Date.setFullYear(2024)
 ```
 */
 @send
-external toLocaleTimeString: t => string = "toLocaleTimeString"
+external setFullYear: (t, int) => unit = "setFullYear"
 
 /** 
-`toLocaleTimeStringWithLocale(date, locale)`
+`setFullYearM(date, ~year, ~month)`
 
-Converts a JavaScript date to a localized time string. It will use the specified locale.
+Sets the year and month of a date (according to local time).
+Beware this will *mutate* the date.
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleTimeStringWithLocale("en-US")->Console.log
-// 3:40:00 PM
+Date.fromString("2023-02-20T16:40:00.00")->Date.setFullYearM(~year=2024, ~month=0)
 ```
 */
 @send
-external toLocaleTimeStringWithLocale: (t, string) => string = "toLocaleTimeString"
+external setFullYearM: (t, ~year: int, ~month: int) => unit = "setFullYear"
 
 /** 
-`toLocaleTimeStringWithLocaleAndOptions(date, locale, options)`
+`setFullYearMD(date, ~year, ~month, ~date)`
 
-Converts a JavaScript date to a localized time string. It will use the specified locale and formatting options.
+Sets the year, month and date (day of month) of a date (according to local time).
+Beware this will *mutate* the date.
 
 ## Examples
 ```rescript
-Date.make()->Date.toLocaleTimeStringWithLocaleAndOptions("en-US", { timeStyle: #long })->Console.log
-// 3:40:00 PM GMT+1
+Date.fromString("2023-02-20T16:40:00.00")->Date.setFullYearMD(~year=2024, ~month=0, ~date=1)
+```
+*/
+@send
+external setFullYearMD: (t, ~year: int, ~month: int, ~date: int) => unit = "setFullYear"
 
-Date.make()->Date.toLocaleTimeStringWithLocaleAndOptions("de", { hour: #"2-digit", minute: #"2-digit" })->Console.log
-// 15:40
+/** 
+`setMonth(date, month)`
+
+Sets the month of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setMonth(0)
 ```
 */
 @send
-external toLocaleTimeStringWithLocaleAndOptions: (t, string, localeOptions) => string =
-  "toLocaleTimeString"
+external setMonth: (t, int) => unit = "setMonth"
+
+/** 
+`setDate(date, day)`
 
-@send external toISOString: t => string = "toISOString"
-@send external toUTCString: t => string = "toUTCString"
-@return(nullable) @send external toJSON: t => option<string> = "toJSON"
+Sets the date (day of month) of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setDate(1)
+```
+*/
+@send
+external setDate: (t, int) => unit = "setDate"
+
+/** 
+`setHours(date, hours)`
+
+Sets the hours of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setHours(0)
+```
+*/
+@send
+external setHours: (t, int) => unit = "setHours"
+
+/** 
+`setHoursM(date, ~hours, ~minutes)`
+
+Sets the hours and minutes of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setHoursM(~hours=0, ~minutes=0)
+```
+*/
+@send
+external setHoursM: (t, ~hours: int, ~minutes: int) => unit = "setHours"
+
+/** 
+`setHoursMS(date, ~hours, ~minutes, ~seconds)`
+
+Sets the hours, minutes and seconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setHoursMS(~hours=0, ~minutes=0, ~seconds=0)
+```
+*/
+@send
+external setHoursMS: (t, ~hours: int, ~minutes: int, ~seconds: int) => unit = "setHours"
+
+/** 
+`setHoursMSMs(date, ~hours, ~minutes, ~seconds, ~milliseconds)`
+
+Sets the hours, minutes, seconds and milliseconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setHoursMSMs(~hours=0, ~minutes=0, ~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setHoursMSMs: (t, ~hours: int, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit =
+  "setHours"
+
+/** 
+`setMinutes(date, minutes)`
+
+Sets the minutes of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setMinutes(0)
+```
+*/
+@send
+external setMinutes: (t, int) => unit = "setMinutes"
+
+/** 
+`setMinutesS(date, ~minutes, ~seconds)`
+
+Sets the minutes and seconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setMinutesS(~minutes=0, ~seconds=0)
+```
+*/
+@send
+external setMinutesS: (t, ~minutes: int, ~seconds: int) => unit = "setMinutes"
+
+/** 
+`setMinutesSMs(date, ~minutes, ~seconds, ~milliseconds)`
+
+Sets the minutes, seconds and milliseconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setMinutesSMs(~minutes=0, ~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setMinutesSMs: (t, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit = "setMinutes"
+
+/** 
+`setSeconds(date, seconds)`
+
+Sets the seconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setSeconds(0)
+```
+*/
+@send
+external setSeconds: (t, int) => unit = "setSeconds"
+
+/** 
+`setSecondsMs(date, ~seconds, ~milliseconds)`
+
+Sets the seconds and milliseconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setSecondsMs(~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setSecondsMs: (t, ~seconds: int, ~milliseconds: int) => unit = "setSeconds"
+
+/** 
+`setMilliseconds(date, milliseconds)`
+
+Sets the milliseconds of a date (according to local time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setMilliseconds(0)
+```
+*/
+@send
+external setMilliseconds: (t, int) => unit = "setMilliseconds"
+
+/** 
+`getUTCFullYear(date)`
+
+Returns the year of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCFullYear
+// 2022
+```
+*/
+@send
+external getUTCFullYear: t => int = "getUTCFullYear"
+
+/** 
+`getUTCMonth(date)`
+
+Returns the month of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCMonth
+// 11
+```
+*/
+@send
+external getUTCMonth: t => int = "getUTCMonth"
+
+/** 
+`getUTCDate(date)`
+
+Returns the date (day of month) of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCDate
+// 31
+```
+*/
+@send
+external getUTCDate: t => int = "getUTCDate"
+
+/** 
+`getUTCHours(date)`
+
+Returns the hours of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCHours
+// 23
+```
+*/
+@send
+external getUTCHours: t => int = "getUTCHours"
+
+/** 
+`getUTCMinutes(date)`
+
+Returns the minutes of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCMinutes
+// 0
+```
+*/
+@send
+external getUTCMinutes: t => int = "getUTCMinutes"
+
+/** 
+`getUTCSeconds(date)`
+
+Returns the seconds of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCSeconds
+// 0
+```
+*/
+@send
+external getUTCSeconds: t => int = "getUTCSeconds"
+
+/** 
+`getUTCMilliseconds(date)`
+
+Returns the milliseconds of a given date (according to UTC time).
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCMilliseconds
+// 0
+```
+*/
+@send
+external getUTCMilliseconds: t => int = "getUTCMilliseconds"
+
+/** 
+`getUTCDay(date)`
+
+Returns the day (day of week) of a given date (according to UTC time).
+0 = Sunday, 1 = Monday, ... 6 = Saturday
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00").getUTCDay
+// 6
+```
+*/
+@send
+external getUTCDay: t => int = "getUTCDay"
+
+/** 
+`setUTCFullYear(date, year)`
+
+Sets the year of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCFullYear(2024)
+```
+*/
+@send
+external setUTCFullYear: (t, int) => unit = "setUTCFullYear"
+
+/** 
+`setUTCFullYearM(date, ~year, ~month)`
+
+Sets the year and month of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCFullYearM(~year=2024, ~month=0)
+```
+*/
+@send
+external setUTCFullYearM: (t, ~year: int, ~month: int) => unit = "setUTCFullYear"
+
+/** 
+`setUTCFullYearMD(date, ~year, ~month, ~date)`
+
+Sets the year, month and date (day of month) of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCFullYearMD(~year=2024, ~month=0, ~date=1)
+```
+*/
+@send
+external setUTCFullYearMD: (t, ~year: int, ~month: int, ~date: int) => unit = "setUTCFullYear"
+
+/** 
+`setUTCMonth(date, month)`
+
+Sets the month of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCMonth(0)
+```
+*/
+@send
+external setUTCMonth: (t, int) => unit = "setUTCMonth"
+
+/** 
+`setDate(date, day)`
+
+Sets the date (day of month) of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCDate(1)
+```
+*/
+@send
+external setUTCDate: (t, int) => unit = "setUTCDate"
+
+/** 
+`setUTCHours(date, hours)`
+
+Sets the hours of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCHours(0)
+```
+*/
+@send
+external setUTCHours: (t, int) => unit = "setUTCHours"
+
+/** 
+`setHoursM(date, ~hours, ~minutes)`
+
+Sets the hours and minutes of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCHoursM(~hours=0, ~minutes=0)
+```
+*/
+@send
+external setUTCHoursM: (t, ~hours: int, ~minutes: int) => unit = "setUTCHours"
+
+/** 
+`setUTCHoursMS(date, ~hours, ~minutes, ~seconds)`
+
+Sets the hours, minutes and seconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCHoursMS(~hours=0, ~minutes=0, ~seconds=0)
+```
+*/
+@send
+external setUTCHoursMS: (t, ~hours: int, ~minutes: int, ~seconds: int) => unit = "setUTCHours"
+
+/** 
+`setUTCHoursMSMs(date, ~hours, ~minutes, ~seconds, ~milliseconds)`
+
+Sets the hours, minutes, seconds and milliseconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCHoursMSMs(~hours=0, ~minutes=0, ~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setUTCHoursMSMs: (
+  t,
+  ~hours: int,
+  ~minutes: int,
+  ~seconds: int,
+  ~milliseconds: int,
+) => unit = "setUTCHours"
+
+/** 
+`setUTCMinutes(date, minutes)`
+
+Sets the minutes of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCMinutes(0)
+```
+*/
+@send
+external setUTCMinutes: (t, int) => unit = "setUTCMinutes"
+
+/** 
+`setUTCMinutesS(date, ~minutes, ~seconds)`
+
+Sets the minutes and seconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCMinutesS(~minutes=0, ~seconds=0)
+```
+*/
+@send
+external setUTCMinutesS: (t, ~minutes: int, ~seconds: int) => unit = "setUTCMinutes"
+
+/** 
+`setUTCMinutesSMs(date, ~minutes, ~seconds, ~milliseconds)`
+
+Sets the minutes, seconds and milliseconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCMinutesSMs(~minutes=0, ~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setUTCMinutesSMs: (t, ~minutes: int, ~seconds: int, ~milliseconds: int) => unit =
+  "setUTCMinutes"
+
+/** 
+`setUTCSeconds(date, seconds)`
+
+Sets the seconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCSeconds(0)
+```
+*/
+@send
+external setUTCSeconds: (t, int) => unit = "setUTCSeconds"
+
+/** 
+`setUTCSecondsMs(date, ~seconds, ~milliseconds)`
+
+Sets the seconds and milliseconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCSecondsMs(~seconds=0, ~milliseconds=0)
+```
+*/
+@send
+external setUTCSecondsMs: (t, ~seconds: int, ~milliseconds: int) => unit = "setUTCSeconds"
+
+/** 
+`setUTCMilliseconds(date, milliseconds)`
+
+Sets the milliseconds of a date (according to UTC time).
+Beware this will *mutate* the date.
+
+## Examples
+```rescript
+Date.fromString("2023-02-20T16:40:00.00")->Date.setUTCMilliseconds(0)
+```
+*/
+@send
+external setUTCMilliseconds: (t, int) => unit = "setUTCMilliseconds"
+
+/** 
+`toDateString(date)`
+
+Converts a JavaScript date to a standard date string. The date will be mapped to the current time zone.
+If you want to convert it to a localized string, use `Date.toLocaleDateString` instead.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00")->Date.toDateString->Console.log
+// Sun Jan 01 2023
+
+Date.fromString("2023-01-01T00:00:00.00+08:00")->Date.toDateString->Console.log
+// Sat Dec 31 2022
+```
+*/
+@send
+external toDateString: t => string = "toDateString"
+
+/** 
+`toString(date)`
+
+Converts a JavaScript date to a standard date time string. The date will be mapped to the current time zone.
+If you want to convert it to a localized string, use `Date.toLocaleString` instead.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00")->Date.toString->Console.log
+// Sun Jan 01 2023 00:00:00 GMT+0100 (Central European Standard Time)
+
+Date.fromString("2023-06-01T00:00:00.00+01:00")->Date.toString->Console.log
+// Thu Jun 01 2023 01:00:00 GMT+0200 (Central European Summer Time)
+```
+*/
+@send
+external toString: t => string = "toString"
+
+/** 
+`toTimeString(date)`
+
+Converts a JavaScript date to a standard time string. The date will be mapped to the current time zone.
+If you want to convert it to a localized string, use `Date.toLocaleStimeString` instead.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+01:00")->Date.toTimeString->Console.log
+// 00:00:00 GMT+0100 (Central European Standard Time)
+
+Date.fromString("2023-01-01T00:00:00.00+08:00")->Date.toTimeString->Console.log
+// 17:00:00 GMT+0100 (Central European Standard Time)
+```
+*/
+@send
+external toTimeString: t => string = "toTimeString"
+
+/** 
+`toLocaleDateString(date)`
+
+Converts a JavaScript date to a localized date string. It will use the current locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleDateString->Console.log
+// 2/19/2023
+```
+*/
+@send
+external toLocaleDateString: t => string = "toLocaleDateString"
+
+/** 
+`toLocaleDateStringWithLocale(date, locale)`
+
+Converts a JavaScript date to a localized date string. It will use the specified locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleDateStringWithLocale("en-US")->Console.log
+// 2/19/2023
+```
+*/
+@send
+external toLocaleDateStringWithLocale: (t, string) => string = "toLocaleDateString"
+
+/** 
+`toLocaleDateStringWithLocaleAndOptions(date, locale, options)`
+
+Converts a JavaScript date to a localized date string. It will use the specified locale and formatting options.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("en-US", { dateStyle: #long })->Console.log
+// February 19, 2023
+
+Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("de", { hour: #"2-digit", minute: #"2-digit" })->Console.log
+// 19.2.2023, 15:40
+
+Date.make()->Date.toLocaleDateStringWithLocaleAndOptions("de", { year: #numeric })->Console.log
+// 2023
+```
+*/
+@send
+external toLocaleDateStringWithLocaleAndOptions: (t, string, localeOptions) => string =
+  "toLocaleDateString"
+
+/** 
+`toLocaleString(date)`
+
+Converts a JavaScript date to a localized date-time string. It will use the current locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleString->Console.log
+// 2/19/2023, 3:40:00 PM
+```
+*/
+@send
+external toLocaleString: t => string = "toLocaleString"
+
+/** 
+`toLocaleStringWithLocale(date, locale)`
+
+Converts a JavaScript date to a localized date-time string. It will use the specified locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleStringWithLocale("en-US")->Console.log
+// 2/19/2023, 3:40:00 PM
+```
+*/
+@send
+external toLocaleStringWithLocale: (t, string) => string = "toLocaleString"
+
+/** 
+`toLocaleStringWithLocaleAndOptions(date, locale, options)`
+
+Converts a JavaScript date to a localized date-time string. It will use the specified locale and formatting options.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleStringWithLocaleAndOptions("en", { dateStyle: #short, timeStyle: #short })->Console.log
+// 2/19/23, 3:40 PM
+
+Date.make()->Date.toLocaleStringWithLocaleAndOptions("en", { era: #long, year: #numeric, month: #"2-digit", day: #"2-digit", hour: #numeric, timeZoneName: #short })->Console.log
+// 02/19/2023 Anno Domini, 3 PM GMT+1
+```
+*/
+@send
+external toLocaleStringWithLocaleAndOptions: (t, string, localeOptions) => string = "toLocaleString"
+
+/** 
+`toLocaleTimeString(date)`
+
+Converts a JavaScript date to a localized time string. It will use the current locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleTimeString->Console.log
+// 3:40:00 PM
+```
+*/
+@send
+external toLocaleTimeString: t => string = "toLocaleTimeString"
+
+/** 
+`toLocaleTimeStringWithLocale(date, locale)`
+
+Converts a JavaScript date to a localized time string. It will use the specified locale.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleTimeStringWithLocale("en-US")->Console.log
+// 3:40:00 PM
+```
+*/
+@send
+external toLocaleTimeStringWithLocale: (t, string) => string = "toLocaleTimeString"
+
+/** 
+`toLocaleTimeStringWithLocaleAndOptions(date, locale, options)`
+
+Converts a JavaScript date to a localized time string. It will use the specified locale and formatting options.
+
+## Examples
+```rescript
+Date.make()->Date.toLocaleTimeStringWithLocaleAndOptions("en-US", { timeStyle: #long })->Console.log
+// 3:40:00 PM GMT+1
+
+Date.make()->Date.toLocaleTimeStringWithLocaleAndOptions("de", { hour: #"2-digit", minute: #"2-digit" })->Console.log
+// 15:40
+```
+*/
+@send
+external toLocaleTimeStringWithLocaleAndOptions: (t, string, localeOptions) => string =
+  "toLocaleTimeString"
+
+/** 
+`toISOString(date)`
+
+Converts a JavaScript date to a ISO 8601 string (YYYY-MM-DDTHH:mm:ss.sssZ). The date will be mapped to the UTC time.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+00:00")->Date.toISOString->Console.log
+// 2023-01-01T00:00:00.000Z
+
+Date.fromString("2023-01-01T00:00:00.00+08:00")->Date.toISOString->Console.log
+// 2022-12-31T16:00:00.000Z
+```
+*/
+@send
+external toISOString: t => string = "toISOString"
+
+/** 
+`toUTCString(date)`
+
+Converts a JavaScript date to date time string. The date will be mapped to the UTC time.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+00:00")->Date.toUTCString->Console.log
+// Sun, 01 Jan 2023 00:00:00 GMT
+
+Date.fromString("2023-01-01T00:00:00.00+08:00")->Date.toUTCString->Console.log
+// Sat, 31 Dec 2022 16:00:00 GMT
+```
+*/
+@send
+external toUTCString: t => string = "toUTCString"
+
+/** 
+`toJSON(date)`
+
+Converts a JavaScript date to a string.
+If the date is valid, the function will return the same result as `Date.toISOString`.
+Invalid dates will return `None`.
+
+## Examples
+```rescript
+Date.fromString("2023-01-01T00:00:00.00+00:00")->Date.toJSON
+// Some("2023-01-01T00:00:00.000Z")
+
+Date.fromString("")->Date.toJSON
+// None
+```
+*/
+@return(nullable)
+@send
+external toJSON: t => option<string> = "toJSON"