@rescript/webapi 0.1.0-experimental-2d6efc2 → 0.1.0-experimental-0781ac8

package/src/WebCrypto/SubtleCrypto.res

@@ -0,0 +1,173 @@
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/encrypt)
+*/
+@send
+external encrypt: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~data: ArrayBufferTypedArrayOrDataView.t,
+) => promise<ArrayBuffer.t> = "encrypt"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt)
+*/
+@send
+external decrypt: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~data: ArrayBufferTypedArrayOrDataView.t,
+) => promise<ArrayBuffer.t> = "decrypt"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/sign)
+*/
+@send
+external sign: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~data: ArrayBufferTypedArrayOrDataView.t,
+) => promise<JSON.t> = "sign"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/verify)
+*/
+@send
+external verify: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~signature: ArrayBufferTypedArrayOrDataView.t,
+  ~data: ArrayBufferTypedArrayOrDataView.t,
+) => promise<JSON.t> = "verify"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest)
+*/
+@send
+external digest: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~data: ArrayBufferTypedArrayOrDataView.t,
+) => promise<JSON.t> = "digest"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey)
+*/
+@send
+external generateKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithm,
+  ~extractable: bool,
+  ~keyUsages: array<WebCryptoTypes.keyUsage>,
+) => promise<JSON.t> = "generateKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey)
+*/
+@send
+external generateKey2: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: string,
+  ~extractable: bool,
+  ~keyUsages: array<WebCryptoTypes.keyUsage>,
+) => promise<JSON.t> = "generateKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey)
+*/
+@send
+external deriveKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~baseKey: WebCryptoTypes.cryptoKey,
+  ~derivedKeyType: WebCryptoTypes.algorithmIdentifier,
+  ~extractable: bool,
+  ~keyUsages: array<WebCryptoTypes.keyUsage>,
+) => promise<JSON.t> = "deriveKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits)
+*/
+@send
+external deriveBits: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: WebCryptoTypes.algorithm,
+  ~baseKey: WebCryptoTypes.cryptoKey,
+  ~length: int=?,
+) => promise<ArrayBuffer.t> = "deriveBits"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits)
+*/
+@send
+external deriveBits2: (
+  WebCryptoTypes.subtleCrypto,
+  ~algorithm: string,
+  ~baseKey: WebCryptoTypes.cryptoKey,
+  ~length: int=?,
+) => promise<ArrayBuffer.t> = "deriveBits"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey)
+*/
+@send
+external importKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~format: unknown,
+  ~keyData: ArrayBufferTypedArrayOrDataView.t,
+  ~algorithm: WebCryptoTypes.algorithmIdentifier,
+  ~extractable: bool,
+  ~keyUsages: array<WebCryptoTypes.keyUsage>,
+) => promise<WebCryptoTypes.cryptoKey> = "importKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/exportKey)
+*/
+@send
+external exportKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~format: WebCryptoTypes.keyFormat,
+  ~key: WebCryptoTypes.cryptoKey,
+) => promise<JSON.t> = "exportKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey)
+*/
+@send
+external wrapKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~format: WebCryptoTypes.keyFormat,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~wrappingKey: WebCryptoTypes.cryptoKey,
+  ~wrapAlgorithm: WebCryptoTypes.algorithm,
+) => promise<JSON.t> = "wrapKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey)
+*/
+@send
+external wrapKey2: (
+  WebCryptoTypes.subtleCrypto,
+  ~format: WebCryptoTypes.keyFormat,
+  ~key: WebCryptoTypes.cryptoKey,
+  ~wrappingKey: WebCryptoTypes.cryptoKey,
+  ~wrapAlgorithm: string,
+) => promise<JSON.t> = "wrapKey"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey)
+*/
+@send
+external unwrapKey: (
+  WebCryptoTypes.subtleCrypto,
+  ~format: WebCryptoTypes.keyFormat,
+  ~wrappedKey: ArrayBufferTypedArrayOrDataView.t,
+  ~unwrappingKey: WebCryptoTypes.cryptoKey,
+  ~unwrapAlgorithm: WebCryptoTypes.algorithmIdentifier,
+  ~unwrappedKeyAlgorithm: WebCryptoTypes.algorithmIdentifier,
+  ~extractable: bool,
+  ~keyUsages: array<WebCryptoTypes.keyUsage>,
+) => promise<WebCryptoTypes.cryptoKey> = "unwrapKey"

package/src/{WebCryptoAPI.res → WebCrypto/WebCryptoTypes.res}

@@ -1,7 +1,5 @@
 @@warning("-30")
 
-open Prelude
-
 type keyType =
   | @as("private") Private
   | @as("public") Public
@@ -30,14 +28,14 @@ This Web Crypto API interface provides a number of low-level cryptographic funct
 [See SubtleCrypto on MDN](https://developer.mozilla.org/docs/Web/API/SubtleCrypto)
 */
 @editor.completeFrom(SubtleCrypto)
-type subtleCrypto = {}
+type subtleCrypto = private {}
 
 /**
 Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives.
 [See Crypto on MDN](https://developer.mozilla.org/docs/Web/API/Crypto)
 */
 @editor.completeFrom(Crypto)
-type crypto = {
+type crypto = private {
   /**
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Crypto/subtle)
     */
@@ -68,6 +66,6 @@ type cryptoKey = {
   usages: array<keyUsage>,
 }
 
-type algorithmIdentifier = any
+type algorithmIdentifier = unknown
 
 type algorithm = {mutable name: string}

package/src/WebLocks/LockManager.res

@@ -0,0 +1,26 @@
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/LockManager/request)
+*/
+@send
+external request: (
+  WebLocksTypes.lockManager,
+  ~name: string,
+  ~callback: WebLocksTypes.lockGrantedCallback,
+) => promise<JSON.t> = "request"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/LockManager/request)
+*/
+@send
+external request2: (
+  WebLocksTypes.lockManager,
+  ~name: string,
+  ~options: WebLocksTypes.lockOptions,
+  ~callback: WebLocksTypes.lockGrantedCallback,
+) => promise<JSON.t> = "request"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/LockManager/query)
+*/
+@send
+external query: WebLocksTypes.lockManager => promise<WebLocksTypes.lockManagerSnapshot> = "query"

package/src/{WebLocksAPI.res → WebLocks/WebLocksTypes.res}

@@ -1,7 +1,5 @@
 @@warning("-30")
 
-open EventAPI
-
 type lockMode =
   | @as("exclusive") Exclusive
   | @as("shared") Shared
@@ -10,7 +8,7 @@ type lockMode =
 [See LockManager on MDN](https://developer.mozilla.org/docs/Web/API/LockManager)
 */
 @editor.completeFrom(LockManager)
-type lockManager = {}
+type lockManager = private {}
 
 /**
 [See Lock on MDN](https://developer.mozilla.org/docs/Web/API/Lock)
@@ -41,7 +39,7 @@ type lockOptions = {
   mutable mode?: lockMode,
   mutable ifAvailable?: bool,
   mutable steal?: bool,
-  mutable signal?: abortSignal,
+  mutable signal?: EventTypes.abortSignal,
 }
 
 type lockGrantedCallback = lock => promise<JSON.t>

package/src/WebMIDI/WebMIDI.res

@@ -0,0 +1,7 @@
+type t = WebMidiTypes.midiAccess = {...WebMidiTypes.midiAccess}
+
+include EventTarget.Impl({type t = t})
+
+type midiOptions = WebMidiTypes.midiOptions = {...WebMidiTypes.midiOptions}
+
+module Types = WebMidiTypes

package/src/{WebMIDIAPI.res → WebMIDI/WebMidiTypes.res}

@@ -1,7 +1,5 @@
 @@warning("-30")
 
-open EventAPI
-
 /**
 [See MIDIInputMap on MDN](https://developer.mozilla.org/docs/Web/API/MIDIInputMap)
 */
@@ -16,7 +14,7 @@ type midiOutputMap = {}
 [See MIDIAccess on MDN](https://developer.mozilla.org/docs/Web/API/MIDIAccess)
 */
 type midiAccess = {
-  ...eventTarget,
+  ...EventTypes.eventTarget,
   /**
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MIDIAccess/inputs)
     */

package/src/WebSockets/CloseEvent.res

@@ -0,0 +1,10 @@
+include Event.Impl({type t = WebSocketsTypes.closeEvent})
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/CloseEvent)
+*/
+@new
+external make: (
+  ~type_: string,
+  ~eventInitDict: WebSocketsTypes.closeEventInit=?,
+) => WebSocketsTypes.closeEvent = "CloseEvent"

package/src/{WebSocketsAPI → WebSockets}/MessageEvent.res

@@ -1,38 +1,43 @@
-open EventAPI
-open WebSocketsAPI
+type event = EventTypes.event
+type eventTarget = EventTypes.eventTarget
+type messageEventSource = WebSocketsTypes.messageEventSource
+
+type messageEvent<'t> = WebSocketsTypes.messageEvent<'t>
+type messageEventInit<'t> = WebSocketsTypes.messageEventInit<'t>
+
+type t<'t> = messageEvent<'t>
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MessageEvent)
 */
 @new
-external make: (~type_: string, ~eventInitDict: messageEventInit<'t>=?) => messageEvent<'t> =
-  "MessageEvent"
+external make: (~type_: string, ~eventInitDict: messageEventInit<'t>=?) => t<'t> = "MessageEvent"
 
-external asEvent: messageEvent<'t> => event = "%identity"
+external asEvent: t<'t> => event = "%identity"
 /**
 Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Event/composedPath)
 */
 @send
-external composedPath: messageEvent<'t> => array<eventTarget> = "composedPath"
+external composedPath: t<'t> => array<eventTarget> = "composedPath"
 
 /**
 When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Event/stopPropagation)
 */
 @send
-external stopPropagation: messageEvent<'t> => unit = "stopPropagation"
+external stopPropagation: t<'t> => unit = "stopPropagation"
 
 /**
 Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Event/stopImmediatePropagation)
 */
 @send
-external stopImmediatePropagation: messageEvent<'t> => unit = "stopImmediatePropagation"
+external stopImmediatePropagation: t<'t> => unit = "stopImmediatePropagation"
 
 /**
 If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Event/preventDefault)
 */
 @send
-external preventDefault: messageEvent<'t> => unit = "preventDefault"
+external preventDefault: t<'t> => unit = "preventDefault"

package/src/WebSockets/WebSocket.res

@@ -0,0 +1,71 @@
+type t = WebSocketsTypes.webSocket = private {...WebSocketsTypes.webSocket}
+type binaryType = WebSocketsTypes.binaryType
+type messageEvent<'t> = WebSocketsTypes.messageEvent<'t> = {...WebSocketsTypes.messageEvent<'t>}
+type closeEvent = WebSocketsTypes.closeEvent = private {...WebSocketsTypes.closeEvent}
+type messageEventSource = WebSocketsTypes.messageEventSource
+
+/**
+`fromURL(~url: string, ~protocols: string=?)`
+
+Creates a new `WebSocket` from a URL and an optional single protocol.
+
+```res
+let socket = WebSocket.fromURL(~url="wss://example.com/socket")
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket)
+*/
+@new
+external fromURL: (~url: string, ~protocols: string=?) => t = "WebSocket"
+
+/**
+`fromURLWithProtocols(~url: string, ~protocols: array<string>)`
+
+Creates a new `WebSocket` from a URL and multiple protocols.
+
+```res
+let socket =
+  WebSocket.fromURLWithProtocols(
+    ~url="wss://example.com/socket",
+    ~protocols=["chat", "superchat"],
+  )
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket)
+*/
+@new
+external fromURLWithProtocols: (~url: string, ~protocols: array<string>) => t = "WebSocket"
+
+include EventTarget.Impl({type t = t})
+
+/**
+Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/close)
+*/
+@send
+external close: (t, ~code: int=?, ~reason: string=?) => unit = "close"
+
+/**
+Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
+*/
+@send
+external send: (t, DataView.t) => unit = "send"
+
+/**
+Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
+*/
+external sendArrayBuffer: (t, ArrayBuffer.t) => unit = "send"
+
+/**
+Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
+*/
+external sendBlob: (t, Blob.t) => unit = "send"
+
+/**
+Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
+*/
+external sendString: (t, string) => unit = "send"

package/src/{WebSocketsAPI.res → WebSockets/WebSocketsTypes.res}

@@ -1,24 +1,21 @@
 @@warning("-30")
 
-open Prelude
-open EventAPI
-open ChannelMessagingAPI
-
 type binaryType =
   | @as("arraybuffer") Arraybuffer
   | @as("blob") Blob
 
-type messageEventSource = any
+type messageEventSource = unknown
 
 /**
 Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
 [See WebSocket on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket)
+TODO: mark as private once mutating fields of private records is allowed
 */
 @editor.completeFrom(WebSocket)
 type webSocket = {
-  ...eventTarget,
+  ...EventTypes.eventTarget,
   /**
-    Returns the URL that was used to establish the WebSocket connection.
+    Returns the WebApiURL that was used to establish the WebSocket connection.
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket/url)
     */
   url: string,
@@ -54,12 +51,12 @@ Can be set, to change how binary data is returned. The default is "blob".
 }
 
 /**
-A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute.
+A CloseEvent is sent to clients using WebApiWebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute.
 [See CloseEvent on MDN](https://developer.mozilla.org/docs/Web/API/CloseEvent)
 */
 @editor.completeFrom(CloseEvent)
-type closeEvent = {
-  ...event,
+type closeEvent = private {
+  ...EventTypes.event,
   /**
     Returns true if the connection closed cleanly; false otherwise.
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/CloseEvent/wasClean)
@@ -82,7 +79,7 @@ A message received by a target object.
 [See MessageEvent on MDN](https://developer.mozilla.org/docs/Web/API/MessageEvent)
 */
 type messageEvent<'t> = {
-  ...event,
+  ...EventTypes.event,
   /**
     Returns the data of the message.
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MessageEvent/data)
@@ -107,21 +104,21 @@ type messageEvent<'t> = {
     Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MessageEvent/ports)
     */
-  ports: array<messagePort>,
+  ports: array<ChannelMessagingTypes.messagePort>,
 }
 
 type closeEventInit = {
-  ...eventInit,
+  ...EventTypes.eventInit,
   mutable wasClean?: bool,
   mutable code?: int,
   mutable reason?: string,
 }
 
 type messageEventInit<'t> = {
-  ...eventInit,
+  ...EventTypes.eventInit,
   mutable data?: 't,
   mutable origin?: string,
   mutable lastEventId?: string,
   mutable source?: Null.t<messageEventSource>,
-  mutable ports?: array<messagePort>,
+  mutable ports?: array<ChannelMessagingTypes.messagePort>,
 }

package/src/{WebSpeechAPI → WebSpeech}/SpeechSynthesis.res

@@ -1,33 +1,33 @@
-open WebSpeechAPI
-
-include EventTarget.Impl({type t = speechSynthesis})
+include EventTarget.Impl({type t = WebSpeechTypes.speechSynthesis})
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/speak)
 */
 @send
-external speak: (speechSynthesis, speechSynthesisUtterance) => unit = "speak"
+external speak: (WebSpeechTypes.speechSynthesis, WebSpeechTypes.speechSynthesisUtterance) => unit =
+  "speak"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/cancel)
 */
 @send
-external cancel: speechSynthesis => unit = "cancel"
+external cancel: WebSpeechTypes.speechSynthesis => unit = "cancel"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/pause)
 */
 @send
-external pause: speechSynthesis => unit = "pause"
+external pause: WebSpeechTypes.speechSynthesis => unit = "pause"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/resume)
 */
 @send
-external resume: speechSynthesis => unit = "resume"
+external resume: WebSpeechTypes.speechSynthesis => unit = "resume"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/getVoices)
 */
 @send
-external getVoices: speechSynthesis => array<speechSynthesisVoice> = "getVoices"
+external getVoices: WebSpeechTypes.speechSynthesis => array<WebSpeechTypes.speechSynthesisVoice> =
+  "getVoices"

package/src/WebSpeech/SpeechSynthesisUtterance.res

@@ -0,0 +1,8 @@
+include EventTarget.Impl({type t = WebSpeechTypes.speechSynthesisUtterance})
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance)
+*/
+@new
+external make: (~text: string=?) => WebSpeechTypes.speechSynthesisUtterance =
+  "SpeechSynthesisUtterance"

package/src/{WebSpeechAPI.res → WebSpeech/WebSpeechTypes.res}

@@ -1,14 +1,12 @@
 @@warning("-30")
 
-open EventAPI
-
 /**
 This Web Speech API interface is the controller interface for the speech service; this can be used to retrieve information about the synthesis voices available on the device, start and pause speech, and other commands besides.
 [See SpeechSynthesis on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis)
 */
 @editor.completeFrom(SpeechSynthesis)
-type speechSynthesis = {
-  ...eventTarget,
+type speechSynthesis = private {
+  ...EventTypes.eventTarget,
   /**
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesis/pending)
     */
@@ -53,10 +51,11 @@ type speechSynthesisVoice = {
 /**
 This Web Speech API interface represents a speech request. It contains the content the speech service should read and information about how to read it (e.g. language, pitch and volume.)
 [See SpeechSynthesisUtterance on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance)
+TODO: mark as private once mutating fields of private records is allowed
 */
 @editor.completeFrom(SpeechSynthesisUtterance)
 type speechSynthesisUtterance = {
-  ...eventTarget,
+  ...EventTypes.eventTarget,
   /**
     [Read more on MDN](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/text)
     */

package/src/{WebStorageAPI → WebStorage}/Storage.res

@@ -1,44 +1,42 @@
-open WebStorageAPI
-
 /**
 Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Storage/key)
 */
 @send
-external key: (storage, int) => Null.t<string> = "key"
+external key: (WebStorageTypes.storage, int) => Null.t<string> = "key"
 
 /**
 Returns the current value associated with the given key, or null if the given key does not exist.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Storage/getItem)
 */
 @send
-external getItem: (storage, string) => Null.t<string> = "getItem"
+external getItem: (WebStorageTypes.storage, string) => Null.t<string> = "getItem"
 
 /**
 Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
 
 Throws a "QuotaExceededError" DOMException exception if the new value couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site, or if the quota has been exceeded.)
 
-Dispatches a storage event on Window objects holding an equivalent Storage object.
+Dispatches a storage event on Window objects holding an equivalent WebApiStorage object.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Storage/setItem)
 */
 @send
-external setItem: (storage, ~key: string, ~value: string) => unit = "setItem"
+external setItem: (WebStorageTypes.storage, ~key: string, ~value: string) => unit = "setItem"
 
 /**
 Removes the key/value pair with the given key, if a key/value pair with the given key exists.
 
-Dispatches a storage event on Window objects holding an equivalent Storage object.
+Dispatches a storage event on Window objects holding an equivalent WebApiStorage object.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Storage/removeItem)
 */
 @send
-external removeItem: (storage, string) => unit = "removeItem"
+external removeItem: (WebStorageTypes.storage, string) => unit = "removeItem"
 
 /**
 Removes all key/value pairs, if there are any.
 
-Dispatches a storage event on Window objects holding an equivalent Storage object.
+Dispatches a storage event on Window objects holding an equivalent WebApiStorage object.
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Storage/clear)
 */
 @send
-external clear: storage => unit = "clear"
+external clear: WebStorageTypes.storage => unit = "clear"

package/src/WebStorage/StorageEvent.res

@@ -0,0 +1,10 @@
+include Event.Impl({type t = WebStorageTypes.storageEvent})
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/StorageEvent)
+*/
+@new
+external make: (
+  ~type_: string,
+  ~eventInitDict: WebStorageTypes.storageEventInit=?,
+) => WebStorageTypes.storageEvent = "StorageEvent"