@overwolf/ow-electron 19.1.8 → 22.0.0

package/electron.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for ow-electron 19.1.8
+// Type definitions for ow-electron 22.0.0
 // Project: http://electronjs.org/
 // Definitions by: The Electron Team <https://github.com/electron/electron>
 // Definitions: https://github.com/electron/electron-typescript-definitions
@@ -410,6 +410,11 @@ declare namespace Electron {
      *
      * You should call `event.preventDefault()` if you want to handle this event.
      *
+     * As with the `open-file` event, be sure to register a listener for the `open-url`
+     * event early in your application startup to detect if the the application being
+     * is being opened to handle a URL. If you register the listener in response to a
+     * `ready` event, you'll miss URLs that trigger the launch of your application.
+     *
      * @platform darwin
      */
     on(event: 'open-url', listener: (event: Event,
@@ -864,7 +869,7 @@ declare namespace Electron {
      * response:
      *
      * Using `basic` should be preferred if only basic information like `vendorId` or
-     * `driverId` is needed.
+     * `deviceId` is needed.
      */
     getGPUInfo(infoType: 'basic' | 'complete'): Promise<unknown>;
     /**
@@ -889,7 +894,10 @@ declare namespace Electron {
      * **Note:** When distributing your packaged app, you have to also ship the
      * `locales` folder.
      *
-     * **Note:** On Windows, you have to call it after the `ready` events gets emitted.
+     * **Note:** This API must be called after the `ready` event is emitted.
+     *
+     * **Note:** To see example return values of this API compared to other locale and
+     * language APIs, see `app.getPreferredSystemLanguages()`.
      */
     getLocale(): string;
     /**
@@ -952,7 +960,72 @@ declare namespace Electron {
      * called first, a default log directory will be created equivalent to calling
      * `app.setAppLogsPath()` without a `path` parameter.
      */
-    getPath(name: 'home' | 'appData' | 'userData' | 'cache' | 'temp' | 'exe' | 'module' | 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos' | 'recent' | 'logs' | 'crashDumps'): string;
+    getPath(name: 'home' | 'appData' | 'userData' | 'sessionData' | 'temp' | 'exe' | 'module' | 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos' | 'recent' | 'logs' | 'crashDumps'): string;
+    /**
+     * The user's preferred system languages from most preferred to least preferred,
+     * including the country codes if applicable. A user can modify and add to this
+     * list on Windows or macOS through the Language and Region settings.
+     *
+     * The API uses `GlobalizationPreferences` (with a fallback to
+     * `GetSystemPreferredUILanguages`) on Windows, `\[NSLocale preferredLanguages\]`
+     * on macOS, and `g_get_language_names` on Linux.
+     *
+     * This API can be used for purposes such as deciding what language to present the
+     * application in.
+     *
+     * Here are some examples of return values of the various language and locale APIs
+     * with different configurations:
+     *
+     * * For Windows, where the application locale is German, the regional format is
+     * Finnish (Finland), and the preferred system languages from most to least
+     * preferred are French (Canada), English (US), Simplified Chinese (China),
+     * Finnish, and Spanish (Latin America):
+     *   * `app.getLocale()` returns `'de'`
+     *   * `app.getSystemLocale()` returns `'fi-FI'`
+     *   * `app.getPreferredSystemLanguages()` returns `['fr-CA', 'en-US',
+     * 'zh-Hans-CN', 'fi', 'es-419']`
+     * * On macOS, where the application locale is German, the region is Finland, and
+     * the preferred system languages from most to least preferred are French (Canada),
+     * English (US), Simplified Chinese, and Spanish (Latin America):
+     *   * `app.getLocale()` returns `'de'`
+     *   * `app.getSystemLocale()` returns `'fr-FI'`
+     *   * `app.getPreferredSystemLanguages()` returns `['fr-CA', 'en-US',
+     * 'zh-Hans-FI', 'es-419']`
+     *
+     * Both the available languages and regions and the possible return values differ
+     * between the two operating systems.
+     *
+     * As can be seen with the example above, on Windows, it is possible that a
+     * preferred system language has no country code, and that one of the preferred
+     * system languages corresponds with the language used for the regional format. On
+     * macOS, the region serves more as a default country code: the user doesn't need
+     * to have Finnish as a preferred language to use Finland as the region,and the
+     * country code `FI` is used as the country code for preferred system languages
+     * that do not have associated countries in the language name.
+     */
+    getPreferredSystemLanguages(): Array<'app.getLocale()' | 'app.getSystemLocale()' | 'app.getPreferredSystemLanguages()' | 'app.getLocale()' | 'app.getSystemLocale()' | 'app.getPreferredSystemLanguages()'>;
+    /**
+     * The current system locale. On Windows and Linux, it is fetched using Chromium's
+     * `i18n` library. On macOS, `[NSLocale currentLocale]` is used instead. To get the
+     * user's current system language, which is not always the same as the locale, it
+     * is better to use `app.getPreferredSystemLanguages()`.
+     *
+     * Different operating systems also use the regional data differently:
+     *
+     * * Windows 11 uses the regional format for numbers, dates, and times.
+     * * macOS Monterey uses the region for formatting numbers, dates, times, and for
+     * selecting the currency symbol to use.
+     *
+     * Therefore, this API can be used for purposes such as choosing a format for
+     * rendering dates and times in a calendar app, especially when the developer wants
+     * the format to be consistent with the OS.
+     *
+     * **Note:** This API must be called after the `ready` event is emitted.
+     *
+     * **Note:** To see example return values of this API compared to other locale and
+     * language APIs, see `app.getPreferredSystemLanguages()`.
+     */
+    getSystemLocale(): string;
     /**
      * The version of the loaded application. If no version is found in the
      * application's `package.json` file, the version of the current bundle or
@@ -1014,6 +1087,13 @@ declare namespace Electron {
      * whether or not the current OS version allows for native emoji pickers.
      */
     isEmojiPanelSupported(): boolean;
+    /**
+     * `true` if the application—including all of its windows—is hidden (e.g. with
+     * `Command-H`), `false` otherwise.
+     *
+     * @platform darwin
+     */
+    isHidden(): boolean;
     /**
      * Whether the application is currently running from the systems Application
      * folder. Use in combination with `app.moveToApplicationsFolder()`
@@ -1055,7 +1135,7 @@ declare namespace Electron {
      *
      * By default, if an app of the same name as the one being moved exists in the
      * Applications directory and is _not_ running, the existing app will be trashed
-     * and the active app moved into its place. If it _is_ running, the pre-existing
+     * and the active app moved into its place. If it _is_ running, the preexisting
      * running app will assume focus and the previously active app will quit itself.
      * This behavior can be changed by providing the optional conflict handler, where
      * the boolean returned by the handler determines whether or not the move conflict
@@ -1298,9 +1378,9 @@ declare namespace Electron {
      *
      * You can only override paths of a `name` defined in `app.getPath`.
      *
-     * By default, web pages' cookies and caches will be stored under the `userData`
+     * By default, web pages' cookies and caches will be stored under the `sessionData`
      * directory. If you want to change this location, you have to override the
-     * `userData` path before the `ready` event of the `app` module is emitted.
+     * `sessionData` path before the `ready` event of the `app` module is emitted.
      */
     setPath(name: string, path: string): void;
     /**
@@ -1956,6 +2036,11 @@ declare namespace Electron {
     /**
      * Emitted when scroll wheel event phase has begun.
      *
+     * > **Note** This event is deprecated beginning in Electron 22.0.0. See Breaking
+     * Changes for details of how to migrate to using the WebContents `input-event`
+     * event.
+     *
+     * @deprecated
      * @platform darwin
      */
     on(event: 'scroll-touch-begin', listener: Function): this;
@@ -1965,6 +2050,11 @@ declare namespace Electron {
     /**
      * Emitted when scroll wheel event phase filed upon reaching the edge of element.
      *
+     * > **Note** This event is deprecated beginning in Electron 22.0.0. See Breaking
+     * Changes for details of how to migrate to using the WebContents `input-event`
+     * event.
+     *
+     * @deprecated
      * @platform darwin
      */
     on(event: 'scroll-touch-edge', listener: Function): this;
@@ -1974,6 +2064,11 @@ declare namespace Electron {
     /**
      * Emitted when scroll wheel event phase has ended.
      *
+     * > **Note** This event is deprecated beginning in Electron 22.0.0. See Breaking
+     * Changes for details of how to migrate to using the WebContents `input-event`
+     * event.
+     *
+     * @deprecated
      * @platform darwin
      */
     on(event: 'scroll-touch-end', listener: Function): this;
@@ -2880,6 +2975,8 @@ declare namespace Electron {
     setSize(width: number, height: number, animate?: boolean): void;
     /**
      * Makes the window not show in the taskbar.
+     *
+     * @platform darwin,win32
      */
     setSkipTaskbar(skip: boolean): void;
     /**
@@ -3681,6 +3778,7 @@ declare namespace Electron {
 
     // Docs: https://electronjs.org/docs/api/context-bridge
 
+    exposeInIsolatedWorld(worldId: number, apiKey: string, api: any): void;
     exposeInMainWorld(apiKey: string, api: any): void;
   }
 
@@ -5058,6 +5156,19 @@ declare namespace Electron {
      * `middleButtonDown`, `rightButtonDown`, `capsLock`, `numLock`, `left`, `right`.
      */
     modifiers?: Array<'shift' | 'control' | 'ctrl' | 'alt' | 'meta' | 'command' | 'cmd' | 'isKeypad' | 'isAutoRepeat' | 'leftButtonDown' | 'middleButtonDown' | 'rightButtonDown' | 'capsLock' | 'numLock' | 'left' | 'right'>;
+    /**
+     * Can be `undefined`, `mouseDown`, `mouseUp`, `mouseMove`, `mouseEnter`,
+     * `mouseLeave`, `contextMenu`, `mouseWheel`, `rawKeyDown`, `keyDown`, `keyUp`,
+     * `char`, `gestureScrollBegin`, `gestureScrollEnd`, `gestureScrollUpdate`,
+     * `gestureFlingStart`, `gestureFlingCancel`, `gesturePinchBegin`,
+     * `gesturePinchEnd`, `gesturePinchUpdate`, `gestureTapDown`, `gestureShowPress`,
+     * `gestureTap`, `gestureTapCancel`, `gestureShortPress`, `gestureLongPress`,
+     * `gestureLongTap`, `gestureTwoFingerTap`, `gestureTapUnconfirmed`,
+     * `gestureDoubleTap`, `touchStart`, `touchMove`, `touchEnd`, `touchCancel`,
+     * `touchScrollStarted`, `pointerDown`, `pointerUp`, `pointerMove`,
+     * `pointerRawUpdate`, `pointerCancel` or `pointerCausedUaAction`.
+     */
+    type: ('undefined' | 'mouseDown' | 'mouseUp' | 'mouseMove' | 'mouseEnter' | 'mouseLeave' | 'contextMenu' | 'mouseWheel' | 'rawKeyDown' | 'keyDown' | 'keyUp' | 'char' | 'gestureScrollBegin' | 'gestureScrollEnd' | 'gestureScrollUpdate' | 'gestureFlingStart' | 'gestureFlingCancel' | 'gesturePinchBegin' | 'gesturePinchEnd' | 'gesturePinchUpdate' | 'gestureTapDown' | 'gestureShowPress' | 'gestureTap' | 'gestureTapCancel' | 'gestureShortPress' | 'gestureLongPress' | 'gestureLongTap' | 'gestureTwoFingerTap' | 'gestureTapUnconfirmed' | 'gestureDoubleTap' | 'touchStart' | 'touchMove' | 'touchEnd' | 'touchCancel' | 'touchScrollStarted' | 'pointerDown' | 'pointerUp' | 'pointerMove' | 'pointerRawUpdate' | 'pointerCancel' | 'pointerCausedUaAction');
   }
 
   interface IOCounters {
@@ -5215,14 +5326,6 @@ declare namespace Electron {
      * included. Sending Functions, Promises, Symbols, WeakMaps, or WeakSets will throw
      * an exception.
      *
-     * > **NOTE:** Sending non-standard JavaScript types such as DOM objects or special
-     * Electron objects will throw an exception.
-     *
-     * Since the main process does not have support for DOM objects such as
-     * `ImageBitmap`, `File`, `DOMMatrix` and so on, such objects cannot be sent over
-     * Electron's IPC to the main process, as the main process would have no way to
-     * decode them. Attempting to send such objects over IPC will result in an error.
-     *
      * The main process should listen for `channel` with `ipcMain.handle()`.
      *
      * For example:
@@ -5231,6 +5334,18 @@ declare namespace Electron {
      * `ipcRenderer.postMessage`.
      *
      * If you do not need a response to the message, consider using `ipcRenderer.send`.
+     *
+     * > **Note** Sending non-standard JavaScript types such as DOM objects or special
+     * Electron objects will throw an exception.
+     *
+     * Since the main process does not have support for DOM objects such as
+     * `ImageBitmap`, `File`, `DOMMatrix` and so on, such objects cannot be sent over
+     * Electron's IPC to the main process, as the main process would have no way to
+     * decode them. Attempting to send such objects over IPC will result in an error.
+     *
+     * > **Note** If the handler in the main process throws an error, the promise
+     * returned by `invoke` will reject. However, the `Error` object in the renderer
+     * process will not be the same as the one thrown in the main process.
      */
     invoke(channel: string, ...args: any[]): Promise<any>;
     /**
@@ -5456,9 +5571,9 @@ declare namespace Electron {
      */
     keyCode: string;
     /**
-     * The type of the event, can be `keyDown`, `keyUp` or `char`.
+     * The type of the event, can be `rawKeyDown`, `keyDown`, `keyUp` or `char`.
      */
-    type: ('keyDown' | 'keyUp' | 'char');
+    type: ('rawKeyDown' | 'keyDown' | 'keyUp' | 'char');
   }
 
   interface MemoryInfo {
@@ -6118,13 +6233,6 @@ declare namespace Electron {
     readonly currentlyLogging: boolean;
   }
 
-  interface NewWindowWebContentsEvent extends Event {
-
-    // Docs: https://electronjs.org/docs/api/structures/new-window-web-contents-event
-
-    newGuest?: BrowserWindow;
-  }
-
   class Notification extends NodeEventEmitter {
 
     // Docs: https://electronjs.org/docs/api/notification
@@ -6352,6 +6460,24 @@ declare namespace Electron {
     userText?: string;
   }
 
+  interface ParentPort extends NodeJS.EventEmitter {
+
+    // Docs: https://electronjs.org/docs/api/parent-port
+
+    /**
+     * Emitted when the process receives a message. Messages received on this port will
+     * be queued up until a handler is registered for this event.
+     */
+    on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    addListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    removeListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    /**
+     * Sends a message from the process to its parent.
+     */
+    postMessage(message: any): void;
+  }
+
   interface PaymentDiscount {
 
     // Docs: https://electronjs.org/docs/api/structures/payment-discount
@@ -7027,6 +7153,137 @@ declare namespace Electron {
     data: (string) | (Buffer);
   }
 
+  interface PushNotifications extends NodeJS.EventEmitter {
+
+    // Docs: https://electronjs.org/docs/api/push-notifications
+
+    /**
+     * Emitted when the app receives a remote notification while running. See:
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * com/documentation/appkit/nsapplicationdelegate/1428430-application?language=objc
+     *
+     * @platform darwin
+     */
+    on(event: 'received-apns-notification', listener: (userInfo: Record<string, any>) => void): this;
+    once(event: 'received-apns-notification', listener: (userInfo: Record<string, any>) => void): this;
+    addListener(event: 'received-apns-notification', listener: (userInfo: Record<string, any>) => void): this;
+    removeListener(event: 'received-apns-notification', listener: (userInfo: Record<string, any>) => void): this;
+    /**
+     * Registers the app with Apple Push Notification service (APNS) to receive Badge,
+     * Sound, and Alert notifications. If registration is successful, the promise will
+     * be resolved with the APNS device token. Otherwise, the promise will be rejected
+     * with an error message. See:
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * tion/appkit/nsapplication/1428476-registerforremotenotificationtyp?language=objc
+     *
+     * @platform darwin
+     */
+    registerForAPNSNotifications(): Promise<string>;
+    /**
+     * Unregisters the app from notifications received from APNS. See:
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * tion/appkit/nsapplication/1428747-unregisterforremotenotifications?language=objc
+     *
+     * @platform darwin
+     */
+    unregisterForAPNSNotifications(): void;
+  }
+
   interface Rectangle {
 
     // Docs: https://electronjs.org/docs/api/structures/rectangle
@@ -7410,11 +7667,11 @@ declare namespace Electron {
     removeListener(event: 'extension-unloaded', listener: (event: Event,
                                                extension: Extension) => void): this;
     /**
-     * Emitted when a new HID device becomes available. For example, when a new USB
-     * device is plugged in.
-     *
-     * This event will only be emitted after `navigator.hid.requestDevice` has been
-     * called and `select-hid-device` has fired.
+     * Emitted after `navigator.hid.requestDevice` has been called and
+     * `select-hid-device` has fired if a new device becomes available before the
+     * callback from `select-hid-device` is called.  This event is intended for use
+     * when using a UI to ask users to pick a device so that the UI can be updated with
+     * the newly added device.
      */
     on(event: 'hid-device-added', listener: (event: Event,
                                              details: HidDeviceAddedDetails) => void): this;
@@ -7425,11 +7682,11 @@ declare namespace Electron {
     removeListener(event: 'hid-device-added', listener: (event: Event,
                                              details: HidDeviceAddedDetails) => void): this;
     /**
-     * Emitted when a HID device has been removed.  For example, this event will fire
-     * when a USB device is unplugged.
-     *
-     * This event will only be emitted after `navigator.hid.requestDevice` has been
-     * called and `select-hid-device` has fired.
+     * Emitted after `navigator.hid.requestDevice` has been called and
+     * `select-hid-device` has fired if a device has been removed before the callback
+     * from `select-hid-device` is called.  This event is intended for use when using a
+     * UI to ask users to pick a device so that the UI can be updated to remove the
+     * specified device.
      */
     on(event: 'hid-device-removed', listener: (event: Event,
                                                details: HidDeviceRemovedDetails) => void): this;
@@ -7439,6 +7696,19 @@ declare namespace Electron {
                                                details: HidDeviceRemovedDetails) => void): this;
     removeListener(event: 'hid-device-removed', listener: (event: Event,
                                                details: HidDeviceRemovedDetails) => void): this;
+    /**
+     * Emitted after `HIDDevice.forget()` has been called.  This event can be used to
+     * help maintain persistent storage of permissions when
+     * `setDevicePermissionHandler` is used.
+     */
+    on(event: 'hid-device-revoked', listener: (event: Event,
+                                               details: HidDeviceRevokedDetails) => void): this;
+    once(event: 'hid-device-revoked', listener: (event: Event,
+                                               details: HidDeviceRevokedDetails) => void): this;
+    addListener(event: 'hid-device-revoked', listener: (event: Event,
+                                               details: HidDeviceRevokedDetails) => void): this;
+    removeListener(event: 'hid-device-revoked', listener: (event: Event,
+                                               details: HidDeviceRevokedDetails) => void): this;
     /**
      * Emitted when a render process requests preconnection to a URL, generally due to
      * a resource hint.
@@ -7528,8 +7798,10 @@ declare namespace Electron {
                                                callback: (portId: string) => void) => void): this;
     /**
      * Emitted after `navigator.serial.requestPort` has been called and
-     * `select-serial-port` has fired if a new serial port becomes available.  For
-     * example, this event will fire when a new USB device is plugged in.
+     * `select-serial-port` has fired if a new serial port becomes available before the
+     * callback from `select-serial-port` is called.  This event is intended for use
+     * when using a UI to ask users to pick a port so that the UI can be updated with
+     * the newly added port.
      */
     on(event: 'serial-port-added', listener: (event: Event,
                                               port: SerialPort,
@@ -7545,8 +7817,10 @@ declare namespace Electron {
                                               webContents: WebContents) => void): this;
     /**
      * Emitted after `navigator.serial.requestPort` has been called and
-     * `select-serial-port` has fired if a serial port has been removed.  For example,
-     * this event will fire when a USB device is unplugged.
+     * `select-serial-port` has fired if a serial port has been removed before the
+     * callback from `select-serial-port` is called.  This event is intended for use
+     * when using a UI to ask users to pick a port so that the UI can be updated to
+     * remove the specified port.
      */
     on(event: 'serial-port-removed', listener: (event: Event,
                                                 port: SerialPort,
@@ -7560,6 +7834,19 @@ declare namespace Electron {
     removeListener(event: 'serial-port-removed', listener: (event: Event,
                                                 port: SerialPort,
                                                 webContents: WebContents) => void): this;
+    /**
+     * Emitted after `SerialPort.forget()` has been called.  This event can be used to
+     * help maintain persistent storage of permissions when
+     * `setDevicePermissionHandler` is used.
+     */
+    on(event: 'serial-port-revoked', listener: (event: Event,
+                                                details: SerialPortRevokedDetails) => void): this;
+    once(event: 'serial-port-revoked', listener: (event: Event,
+                                                details: SerialPortRevokedDetails) => void): this;
+    addListener(event: 'serial-port-revoked', listener: (event: Event,
+                                                details: SerialPortRevokedDetails) => void): this;
+    removeListener(event: 'serial-port-revoked', listener: (event: Event,
+                                                details: SerialPortRevokedDetails) => void): this;
     /**
      * Emitted when a hunspell dictionary file starts downloading
      */
@@ -7783,7 +8070,8 @@ declare namespace Electron {
      * the current OS locale.  This setting is persisted across restarts.
      *
      * **Note:** On macOS the OS spellchecker is used and has its own list of
-     * languages.  This API is a no-op on macOS.
+     * languages. On macOS, this API will return whichever languages have been
+     * configured by the OS.
      */
     getSpellCheckerLanguages(): string[];
     /**
@@ -7858,6 +8146,17 @@ declare namespace Electron {
      * Resolves with the proxy information for `url`.
      */
     resolveProxy(url: string): Promise<string>;
+    /**
+     * Sets a handler to respond to Bluetooth pairing requests. This handler allows
+     * developers to handle devices that require additional validation before pairing.
+     * When a handler is not defined, any pairing on Linux or Windows that requires
+     * additional validation will be automatically cancelled. macOS does not require a
+     * handler because macOS handles the pairing automatically.  To clear the handler,
+     * call `setBluetoothPairingHandler(null)`.
+     *
+     * @platform win32,linux
+     */
+    setBluetoothPairingHandler(handler: ((details: BluetoothPairingHandlerHandlerDetails, callback: (response: Response) => void) => void) | (null)): void;
     /**
      * Sets the certificate verify proc for `session`, the `proc` will be called with
      * `proc(request, callback)` whenever a server certificate verification is
@@ -7889,12 +8188,23 @@ declare namespace Electron {
      * `navigator.hid.requestDevice`).  If this handler is not defined, the default
      * device permissions as granted through device selection (eg via
      * `navigator.hid.requestDevice`) will be used. Additionally, the default behavior
-     * of Electron is to store granted device permision through the lifetime of the
-     * corresponding WebContents.  If longer term storage is needed, a developer can
-     * store granted device permissions (eg when handling the `select-hid-device`
-     * event) and then read from that storage with `setDevicePermissionHandler`.
+     * of Electron is to store granted device permision in memory. If longer term
+     * storage is needed, a developer can store granted device permissions (eg when
+     * handling the `select-hid-device` event) and then read from that storage with
+     * `setDevicePermissionHandler`.
      */
     setDevicePermissionHandler(handler: ((details: DevicePermissionHandlerHandlerDetails) => boolean) | (null)): void;
+    /**
+     * This handler will be called when web content requests access to display media
+     * via the `navigator.mediaDevices.getDisplayMedia` API. Use the desktopCapturer
+     * API to choose which stream(s) to grant access to.
+     *
+     * Passing a WebFrameMain object as a video or audio stream will capture the video
+     * or audio stream from that frame.
+     *
+     * Passing `null` instead of a function resets the handler to its default state.
+     */
+    setDisplayMediaRequestHandler(handler: ((request: DisplayMediaRequestHandlerHandlerRequest, callback: (streams: Streams) => void) => void) | (null)): void;
     /**
      * Sets download saving directory. By default, the download directory will be the
      * `Downloads` under the respective app folder.
@@ -9182,6 +9492,9 @@ declare namespace Electron {
     removeListener(event: 'balloon-show', listener: Function): this;
     /**
      * Emitted when the tray icon is clicked.
+     *
+     * Note that on Linux this event is emitted when the tray icon receives an
+     * activation, which might not necessarily be left mouse click.
      */
     on(event: 'click', listener: (event: KeyboardEvent,
                                   /**
@@ -9657,6 +9970,89 @@ declare namespace Electron {
     url: string;
   }
 
+  class UtilityProcess extends NodeEventEmitter {
+
+    // Docs: https://electronjs.org/docs/api/utility-process
+
+    static fork(modulePath: string, args?: string[], options?: ForkOptions): UtilityProcess;
+    /**
+     * Emitted after the child process ends.
+     */
+    on(event: 'exit', listener: (
+                                 /**
+                                  * Contains the exit code for the process obtained from waitpid on posix, or
+                                  * GetExitCodeProcess on windows.
+                                  */
+                                 code: number) => void): this;
+    once(event: 'exit', listener: (
+                                 /**
+                                  * Contains the exit code for the process obtained from waitpid on posix, or
+                                  * GetExitCodeProcess on windows.
+                                  */
+                                 code: number) => void): this;
+    addListener(event: 'exit', listener: (
+                                 /**
+                                  * Contains the exit code for the process obtained from waitpid on posix, or
+                                  * GetExitCodeProcess on windows.
+                                  */
+                                 code: number) => void): this;
+    removeListener(event: 'exit', listener: (
+                                 /**
+                                  * Contains the exit code for the process obtained from waitpid on posix, or
+                                  * GetExitCodeProcess on windows.
+                                  */
+                                 code: number) => void): this;
+    /**
+     * Emitted when the child process sends a message using
+     * `process.parentPort.postMessage()`.
+     */
+    on(event: 'message', listener: (message: any) => void): this;
+    once(event: 'message', listener: (message: any) => void): this;
+    addListener(event: 'message', listener: (message: any) => void): this;
+    removeListener(event: 'message', listener: (message: any) => void): this;
+    /**
+     * Emitted once the child process has spawned successfully.
+     */
+    on(event: 'spawn', listener: Function): this;
+    once(event: 'spawn', listener: Function): this;
+    addListener(event: 'spawn', listener: Function): this;
+    removeListener(event: 'spawn', listener: Function): this;
+    /**
+     * Terminates the process gracefully. On POSIX, it uses SIGTERM but will ensure the
+     * process is reaped on exit. This function returns true if the kill is successful,
+     * and false otherwise.
+     */
+    kill(): boolean;
+    /**
+     * Send a message to the child process, optionally transferring ownership of zero
+     * or more [`MessagePortMain`][] objects.
+     *
+     * For example:
+     */
+    postMessage(message: any, transfer?: MessagePortMain[]): void;
+    /**
+     * A `Integer | undefined` representing the process identifier (PID) of the child
+     * process. If the child process fails to spawn due to errors, then the value is
+     * `undefined`. When the child process exits, then the value is `undefined` after
+     * the `exit` event is emitted.
+     */
+    pid: (number) | (undefined);
+    /**
+     * A `NodeJS.ReadableStream | null` that represents the child process's stderr. If
+     * the child was spawned with options.stdio[2] set to anything other than 'pipe',
+     * then this will be `null`. When the child process exits, then the value is `null`
+     * after the `exit` event is emitted.
+     */
+    stderr: (NodeJS.ReadableStream) | (null);
+    /**
+     * A `NodeJS.ReadableStream | null` that represents the child process's stdout. If
+     * the child was spawned with options.stdio[1] set to anything other than 'pipe',
+     * then this will be `null`. When the child process exits, then the value is `null`
+     * after the `exit` event is emitted.
+     */
+    stdout: (NodeJS.ReadableStream) | (null);
+  }
+
   class WebContents extends NodeEventEmitter {
 
     // Docs: https://electronjs.org/docs/api/web-contents
@@ -9669,6 +10065,11 @@ declare namespace Electron {
      * a WebContents instance based on its assigned TargetID.
      */
     static fromDevToolsTargetId(targetId: string): WebContents;
+    /**
+     * | undefined - A WebContents instance with the given WebFrameMain, or `undefined`
+     * if there is no WebContents associated with the given WebFrameMain.
+     */
+    static fromFrame(frame: WebFrameMain): WebContents;
     /**
      * | undefined - A WebContents instance with the given ID, or `undefined` if there
      * is no WebContents associated with the given ID.
@@ -9822,6 +10223,32 @@ declare namespace Electron {
                                              */
                                             line: number,
                                             sourceId: string) => void): this;
+    /**
+     * Emitted when the page calls `window.moveTo`, `window.resizeTo` or related APIs.
+     *
+     * By default, this will move the window. To prevent that behavior, call
+     * `event.preventDefault()`.
+     */
+    on(event: 'content-bounds-updated', listener: (event: Event,
+                                                   /**
+                                                    * requested new content bounds
+                                                    */
+                                                   bounds: Rectangle) => void): this;
+    once(event: 'content-bounds-updated', listener: (event: Event,
+                                                   /**
+                                                    * requested new content bounds
+                                                    */
+                                                   bounds: Rectangle) => void): this;
+    addListener(event: 'content-bounds-updated', listener: (event: Event,
+                                                   /**
+                                                    * requested new content bounds
+                                                    */
+                                                   bounds: Rectangle) => void): this;
+    removeListener(event: 'content-bounds-updated', listener: (event: Event,
+                                                   /**
+                                                    * requested new content bounds
+                                                    */
+                                                   bounds: Rectangle) => void): this;
     /**
      * Emitted when there is a new context menu that needs to be handled.
      */
@@ -10323,10 +10750,10 @@ declare namespace Electron {
     /**
      * Emitted when the document in the top-level frame is loaded.
      */
-    on(event: 'dom-ready', listener: (event: Event) => void): this;
-    once(event: 'dom-ready', listener: (event: Event) => void): this;
-    addListener(event: 'dom-ready', listener: (event: Event) => void): this;
-    removeListener(event: 'dom-ready', listener: (event: Event) => void): this;
+    on(event: 'dom-ready', listener: Function): this;
+    once(event: 'dom-ready', listener: Function): this;
+    addListener(event: 'dom-ready', listener: Function): this;
+    removeListener(event: 'dom-ready', listener: Function): this;
     /**
      * Emitted when the window enters a full-screen state triggered by HTML API.
      */
@@ -10373,9 +10800,24 @@ declare namespace Electron {
                                           details: FrameCreatedDetails) => void): this;
     removeListener(event: 'frame-created', listener: (event: Event,
                                           details: FrameCreatedDetails) => void): this;
+    /**
+     * Emitted when an input event is sent to the WebContents. See InputEvent for
+     * details.
+     */
+    on(event: 'input-event', listener: (event: Event,
+                                        inputEvent: InputEvent) => void): this;
+    once(event: 'input-event', listener: (event: Event,
+                                        inputEvent: InputEvent) => void): this;
+    addListener(event: 'input-event', listener: (event: Event,
+                                        inputEvent: InputEvent) => void): this;
+    removeListener(event: 'input-event', listener: (event: Event,
+                                        inputEvent: InputEvent) => void): this;
     /**
      * Emitted when the renderer process sends an asynchronous message via
      * `ipcRenderer.send()`.
+     *
+     * See also `webContents.ipc`, which provides an `IpcMain`-like interface for
+     * responding to IPC messages specifically from this WebContents.
      */
     on(event: 'ipc-message', listener: (event: Event,
                                         channel: string,
@@ -10392,6 +10834,9 @@ declare namespace Electron {
     /**
      * Emitted when the renderer process sends a synchronous message via
      * `ipcRenderer.sendSync()`.
+     *
+     * See also `webContents.ipc`, which provides an `IpcMain`-like interface for
+     * responding to IPC messages specifically from this WebContents.
      */
     on(event: 'ipc-message-sync', listener: (event: Event,
                                              channel: string,
@@ -10447,138 +10892,6 @@ declare namespace Electron {
     once(event: 'media-started-playing', listener: Function): this;
     addListener(event: 'media-started-playing', listener: Function): this;
     removeListener(event: 'media-started-playing', listener: Function): this;
-    /**
-     * Deprecated in favor of `webContents.setWindowOpenHandler`.
-     *
-     * Emitted when the page requests to open a new window for a `url`. It could be
-     * requested by `window.open` or an external link like `<a target='_blank'>`.
-     *
-     * By default a new `BrowserWindow` will be created for the `url`.
-     *
-     * Calling `event.preventDefault()` will prevent Electron from automatically
-     * creating a new `BrowserWindow`. If you call `event.preventDefault()` and
-     * manually create a new `BrowserWindow` then you must set `event.newGuest` to
-     * reference the new `BrowserWindow` instance, failing to do so may result in
-     * unexpected behavior. For example:
-     *
-     * @deprecated
-     */
-    on(event: 'new-window', listener: (event: NewWindowWebContentsEvent,
-                                       url: string,
-                                       frameName: string,
-                                       /**
-                                        * Can be `default`, `foreground-tab`, `background-tab`, `new-window`,
-                                        * `save-to-disk` and `other`.
-                                        */
-                                       disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'),
-                                       /**
-                                        * The options which will be used for creating the new `BrowserWindow`.
-                                        */
-                                       options: BrowserWindowConstructorOptions,
-                                       /**
-                                        * The non-standard features (features not handled by Chromium or Electron) given
-                                        * to `window.open()`. Deprecated, and will now always be the empty array `[]`.
-                                        */
-                                       additionalFeatures: string[],
-                                       /**
-                                        * The referrer that will be passed to the new window. May or may not result in the
-                                        * `Referer` header being sent, depending on the referrer policy.
-                                        */
-                                       referrer: Referrer,
-                                       /**
-                                        * The post data that will be sent to the new window, along with the appropriate
-                                        * headers that will be set. If no post data is to be sent, the value will be
-                                        * `null`. Only defined when the window is being created by a form that set
-                                        * `target=_blank`.
-                                        */
-                                       postBody: PostBody) => void): this;
-    once(event: 'new-window', listener: (event: NewWindowWebContentsEvent,
-                                       url: string,
-                                       frameName: string,
-                                       /**
-                                        * Can be `default`, `foreground-tab`, `background-tab`, `new-window`,
-                                        * `save-to-disk` and `other`.
-                                        */
-                                       disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'),
-                                       /**
-                                        * The options which will be used for creating the new `BrowserWindow`.
-                                        */
-                                       options: BrowserWindowConstructorOptions,
-                                       /**
-                                        * The non-standard features (features not handled by Chromium or Electron) given
-                                        * to `window.open()`. Deprecated, and will now always be the empty array `[]`.
-                                        */
-                                       additionalFeatures: string[],
-                                       /**
-                                        * The referrer that will be passed to the new window. May or may not result in the
-                                        * `Referer` header being sent, depending on the referrer policy.
-                                        */
-                                       referrer: Referrer,
-                                       /**
-                                        * The post data that will be sent to the new window, along with the appropriate
-                                        * headers that will be set. If no post data is to be sent, the value will be
-                                        * `null`. Only defined when the window is being created by a form that set
-                                        * `target=_blank`.
-                                        */
-                                       postBody: PostBody) => void): this;
-    addListener(event: 'new-window', listener: (event: NewWindowWebContentsEvent,
-                                       url: string,
-                                       frameName: string,
-                                       /**
-                                        * Can be `default`, `foreground-tab`, `background-tab`, `new-window`,
-                                        * `save-to-disk` and `other`.
-                                        */
-                                       disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'),
-                                       /**
-                                        * The options which will be used for creating the new `BrowserWindow`.
-                                        */
-                                       options: BrowserWindowConstructorOptions,
-                                       /**
-                                        * The non-standard features (features not handled by Chromium or Electron) given
-                                        * to `window.open()`. Deprecated, and will now always be the empty array `[]`.
-                                        */
-                                       additionalFeatures: string[],
-                                       /**
-                                        * The referrer that will be passed to the new window. May or may not result in the
-                                        * `Referer` header being sent, depending on the referrer policy.
-                                        */
-                                       referrer: Referrer,
-                                       /**
-                                        * The post data that will be sent to the new window, along with the appropriate
-                                        * headers that will be set. If no post data is to be sent, the value will be
-                                        * `null`. Only defined when the window is being created by a form that set
-                                        * `target=_blank`.
-                                        */
-                                       postBody: PostBody) => void): this;
-    removeListener(event: 'new-window', listener: (event: NewWindowWebContentsEvent,
-                                       url: string,
-                                       frameName: string,
-                                       /**
-                                        * Can be `default`, `foreground-tab`, `background-tab`, `new-window`,
-                                        * `save-to-disk` and `other`.
-                                        */
-                                       disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'),
-                                       /**
-                                        * The options which will be used for creating the new `BrowserWindow`.
-                                        */
-                                       options: BrowserWindowConstructorOptions,
-                                       /**
-                                        * The non-standard features (features not handled by Chromium or Electron) given
-                                        * to `window.open()`. Deprecated, and will now always be the empty array `[]`.
-                                        */
-                                       additionalFeatures: string[],
-                                       /**
-                                        * The referrer that will be passed to the new window. May or may not result in the
-                                        * `Referer` header being sent, depending on the referrer policy.
-                                        */
-                                       referrer: Referrer,
-                                       /**
-                                        * The post data that will be sent to the new window, along with the appropriate
-                                        * headers that will be set. If no post data is to be sent, the value will be
-                                        * `null`. Only defined when the window is being created by a form that set
-                                        * `target=_blank`.
-                                        */
-                                       postBody: PostBody) => void): this;
     /**
      * Emitted when page receives favicon urls.
      */
@@ -10985,6 +11298,14 @@ declare namespace Electron {
      * Clears the navigation history.
      */
     clearHistory(): void;
+    /**
+     * Closes the page, as if the web content had called `window.close()`.
+     *
+     * If the page is successfully closed (i.e. the unload is not prevented by the
+     * page, or `waitForBeforeUnload` is false or unspecified), the WebContents will be
+     * destroyed and no longer usable. The `destroyed` event will be emitted.
+     */
+    close(opts?: Opts): void;
     /**
      * Closes the devtools.
      */
@@ -11329,16 +11650,13 @@ declare namespace Electron {
     /**
      * Resolves with the generated PDF data.
      *
-     * Prints window's web page as PDF with Chromium's preview printing custom
-     * settings.
+     * Prints the window's web page as PDF.
      *
      * The `landscape` will be ignored if `@page` CSS at-rule is used in the web page.
      *
-     * By default, an empty `options` will be regarded as:
-     *
-     * Use `page-break-before: always;` CSS style to force to print to a new page.
-     *
      * An example of `webContents.printToPDF`:
+     *
+     * See Page.printToPdf for more information.
      */
     printToPDF(options: PrintToPDFOptions): Promise<Buffer>;
     /**
@@ -11597,12 +11915,48 @@ declare namespace Electron {
      *
      */
     readonly id: number;
+    /**
+     * An `IpcMain` scoped to just IPC messages sent from this WebContents.
+     *
+     * IPC messages sent with `ipcRenderer.send`, `ipcRenderer.sendSync` or
+     * `ipcRenderer.postMessage` will be delivered in the following order:
+     *
+     * * `contents.on('ipc-message')`
+     * * `contents.mainFrame.on(channel)`
+     * * `contents.ipc.on(channel)`
+     * * `ipcMain.on(channel)`
+     *
+     * Handlers registered with `invoke` will be checked in the following order. The
+     * first one that is defined will be called, the rest will be ignored.
+     *
+     * * `contents.mainFrame.handle(channel)`
+     * * `contents.handle(channel)`
+     * * `ipcMain.handle(channel)`
+     *
+     * A handler or event listener registered on the WebContents will receive IPC
+     * messages sent from any frame, including child frames. In most cases, only the
+     * main frame can send IPC messages. However, if the `nodeIntegrationInSubFrames`
+     * option is enabled, it is possible for child frames to send IPC messages also. In
+     * that case, handlers should check the `senderFrame` property of the IPC event to
+     * ensure that the message is coming from the expected frame. Alternatively,
+     * register handlers on the appropriate frame directly using the `WebFrameMain.ipc`
+     * interface.
+     *
+     */
+    readonly ipc: IpcMain;
     /**
      * A `WebFrameMain` property that represents the top frame of the page's frame
      * hierarchy.
      *
      */
     readonly mainFrame: WebFrameMain;
+    /**
+     * A `WebFrameMain` property that represents the frame that opened this
+     * WebContents, either with open(), or by navigating a link with a target
+     * attribute.
+     *
+     */
+    readonly opener: WebFrameMain;
     /**
      * A `Session` used by this webContents.
      *
@@ -11894,6 +12248,32 @@ declare namespace Electron {
      *
      */
     readonly frameTreeNodeId: number;
+    /**
+     * An `IpcMain` instance scoped to the frame.
+     *
+     * IPC messages sent with `ipcRenderer.send`, `ipcRenderer.sendSync` or
+     * `ipcRenderer.postMessage` will be delivered in the following order:
+     *
+     * * `contents.on('ipc-message')`
+     * * `contents.mainFrame.on(channel)`
+     * * `contents.ipc.on(channel)`
+     * * `ipcMain.on(channel)`
+     *
+     * Handlers registered with `invoke` will be checked in the following order. The
+     * first one that is defined will be called, the rest will be ignored.
+     *
+     * * `contents.mainFrame.handle(channel)`
+     * * `contents.handle(channel)`
+     * * `ipcMain.handle(channel)`
+     *
+     * In most cases, only the main frame of a WebContents can send or receive IPC
+     * messages. However, if the `nodeIntegrationInSubFrames` option is enabled, it is
+     * possible for child frames to send and receive IPC messages also. The
+     * `WebContents.ipc` interface may be more convenient when
+     * `nodeIntegrationInSubFrames` is not enabled.
+     *
+     */
+    readonly ipc: IpcMain;
     /**
      * A `string` representing the frame name.
      *
@@ -11979,7 +12359,7 @@ declare namespace Electron {
      *
      * Some examples of valid `urls`:
      */
-    onBeforeRequest(filter: WebRequestFilter, listener: ((details: OnBeforeRequestListenerDetails, callback: (response: Response) => void) => void) | (null)): void;
+    onBeforeRequest(filter: WebRequestFilter, listener: ((details: OnBeforeRequestListenerDetails, callback: (response: CallbackResponse) => void) => void) | (null)): void;
     /**
      * The `listener` will be called with `listener(details, callback)` when a request
      * is about to occur.
@@ -11990,7 +12370,7 @@ declare namespace Electron {
      *
      * Some examples of valid `urls`:
      */
-    onBeforeRequest(listener: ((details: OnBeforeRequestListenerDetails, callback: (response: Response) => void) => void) | (null)): void;
+    onBeforeRequest(listener: ((details: OnBeforeRequestListenerDetails, callback: (response: CallbackResponse) => void) => void) | (null)): void;
     /**
      * The `listener` will be called with `listener(details, callback)` before sending
      * an HTTP request, once the request headers are available. This may occur after a
@@ -12166,13 +12546,6 @@ declare namespace Electron {
      */
     addEventListener(event: 'found-in-page', listener: (event: FoundInPageEvent) => void, useCapture?: boolean): this;
     removeEventListener(event: 'found-in-page', listener: (event: FoundInPageEvent) => void): this;
-    /**
-     * Fired when the guest page attempts to open a new browser window.
-     *
-     * The following example code opens the new url in system's default browser.
-     */
-    addEventListener(event: 'new-window', listener: (event: NewWindowEvent) => void, useCapture?: boolean): this;
-    removeEventListener(event: 'new-window', listener: (event: NewWindowEvent) => void): this;
     /**
      * Emitted when a user or the page wants to start navigation. It can happen when
      * the `window.location` object is changed or a user clicks a link in the page.
@@ -12743,7 +13116,7 @@ declare namespace Electron {
     /**
      * The scale factor to add the image representation for.
      */
-    scaleFactor: number;
+    scaleFactor?: number;
     /**
      * Defaults to 0. Required if a bitmap buffer is specified as `buffer`.
      */
@@ -12881,6 +13254,19 @@ declare namespace Electron {
     total: number;
   }
 
+  interface BluetoothPairingHandlerHandlerDetails {
+    deviceId: string;
+    /**
+     * The type of pairing prompt being requested. One of the following values:
+     */
+    pairingKind: ('confirm' | 'confirmPin' | 'providePin');
+    frame: WebFrameMain;
+    /**
+     * The pin value to verify if `pairingKind` is `confirmPin`.
+     */
+    pin?: string;
+  }
+
   interface BrowserViewConstructorOptions {
     /**
      * See BrowserWindow.
@@ -13177,6 +13563,15 @@ declare namespace Electron {
     titleBarOverlay?: (TitleBarOverlay) | (boolean);
   }
 
+  interface CallbackResponse {
+    cancel?: boolean;
+    /**
+     * The original request is prevented from being sent or completed and is instead
+     * redirected to the given URL.
+     */
+    redirectURL?: string;
+  }
+
   interface CertificateTrustDialogOptions {
     /**
      * The certificate to trust/import.
@@ -13720,10 +14115,6 @@ declare namespace Electron {
      * the device that permission is being requested for.
      */
     device: (HIDDevice) | (SerialPort);
-    /**
-     * WebFrameMain checking the device permission.
-     */
-    frame: WebFrameMain;
   }
 
   interface DidChangeThemeColorEvent extends Event {
@@ -13843,6 +14234,29 @@ declare namespace Electron {
     respectQuietTime?: boolean;
   }
 
+  interface DisplayMediaRequestHandlerHandlerRequest {
+    /**
+     * Frame that is requesting access to media.
+     */
+    frame: WebFrameMain;
+    /**
+     * Origin of the page making the request.
+     */
+    securityOrigin: string;
+    /**
+     * true if the web content requested a video stream.
+     */
+    videoRequested: boolean;
+    /**
+     * true if the web content requested an audio stream.
+     */
+    audioRequested: boolean;
+    /**
+     * Whether a user gesture was active when this request was triggered.
+     */
+    userGesture: boolean;
+  }
+
   interface EnableNetworkEmulationOptions {
     /**
      * Whether to emulate network outage. Defaults to false.
@@ -13907,6 +14321,47 @@ declare namespace Electron {
     steal: boolean;
   }
 
+  interface ForkOptions {
+    /**
+     * Environment key-value pairs. Default is `process.env`.
+     */
+    env?: Env;
+    /**
+     * List of string arguments passed to the executable.
+     */
+    execArgv?: string[];
+    /**
+     * Current working directory of the child process.
+     */
+    cwd?: string;
+    /**
+     * Allows configuring the mode for `stdout` and `stderr` of the child process.
+     * Default is `inherit`. String value can be one of `pipe`, `ignore`, `inherit`,
+     * for more details on these values you can refer to stdio documentation from
+     * Node.js. Currently this option only supports configuring `stdout` and `stderr`
+     * to either `pipe`, `inherit` or `ignore`. Configuring `stdin` is not supported;
+     * `stdin` will always be ignored. For example, the supported values will be
+     * processed as following:
+     */
+    stdio?: (Array<'pipe' | 'ignore' | 'inherit'>) | (string);
+    /**
+     * Name of the process that will appear in `name` property of `child-process-gone`
+     * event of `app`. Default is `node.mojom.NodeService`.
+     */
+    serviceName?: string;
+    /**
+     * With this flag, the utility process will be launched via the `Electron Helper
+     * (Plugin).app` helper executable on macOS, which can be codesigned with
+     * `com.apple.security.cs.disable-library-validation` and
+     * `com.apple.security.cs.allow-unsigned-executable-memory` entitlements. This will
+     * allow the utility process to load unsigned libraries. Unless you specifically
+     * need this capability, it is best to leave this disabled. Default is `false`.
+     *
+     * @platform darwin
+     */
+    allowLoadingUnsignedLibraries?: boolean;
+  }
+
   interface FoundInPageEvent extends Event {
     result: FoundInPageResult;
   }
@@ -13991,6 +14446,14 @@ declare namespace Electron {
     frame: WebFrameMain;
   }
 
+  interface HidDeviceRevokedDetails {
+    device: HIDDevice[];
+    /**
+     * The origin that the device has been revoked from.
+     */
+    origin?: string;
+  }
+
   interface IgnoreMouseEventsOptions {
     /**
      * If true, forwards mouse move messages to Chromium, enabling mouse related events
@@ -14248,8 +14711,8 @@ declare namespace Electron {
      * `selectAll`, `reload`, `forceReload`, `toggleDevTools`, `resetZoom`, `zoomIn`,
      * `zoomOut`, `toggleSpellChecker`, `togglefullscreen`, `window`, `minimize`,
      * `close`, `help`, `about`, `services`, `hide`, `hideOthers`, `unhide`, `quit`,
-     * 'showSubstitutions', 'toggleSmartQuotes', 'toggleSmartDashes',
-     * 'toggleTextReplacement', `startSpeaking`, `stopSpeaking`, `zoom`, `front`,
+     * `showSubstitutions`, `toggleSmartQuotes`, `toggleSmartDashes`,
+     * `toggleTextReplacement`, `startSpeaking`, `stopSpeaking`, `zoom`, `front`,
      * `appMenu`, `fileMenu`, `editMenu`, `viewMenu`, `shareMenu`, `recentDocuments`,
      * `toggleTabBar`, `selectNextTab`, `selectPreviousTab`, `mergeAllWindows`,
      * `clearRecentDocuments`, `moveTabToNewWindow` or `windowMenu` - Define the action
@@ -14534,20 +14997,6 @@ declare namespace Electron {
     conflictHandler?: (conflictType: 'exists' | 'existsAndRunning') => boolean;
   }
 
-  interface NewWindowEvent extends Event {
-    url: string;
-    frameName: string;
-    /**
-     * Can be `default`, `foreground-tab`, `background-tab`, `new-window`,
-     * `save-to-disk` and `other`.
-     */
-    disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other');
-    /**
-     * The options which should be used for creating the new `BrowserWindow`.
-     */
-    options: BrowserWindowConstructorOptions;
-  }
-
   interface NotificationConstructorOptions {
     /**
      * A title for the notification, which will be shown at the top of the notification
@@ -14895,6 +15344,15 @@ declare namespace Electron {
   interface Options {
   }
 
+  interface Opts {
+    /**
+     * if true, fire the `beforeunload` event before closing the page. If the page
+     * prevents the unload, the WebContents will not be closed. The
+     * `will-prevent-unload` will be fired if the page requests prevention of unload.
+     */
+    waitForBeforeUnload: boolean;
+  }
+
   interface PageFaviconUpdatedEvent extends Event {
     /**
      * Array of URLs.
@@ -15050,39 +15508,51 @@ declare namespace Electron {
 
   interface PrintToPDFOptions {
     /**
-     * the header and footer for the PDF.
-     */
-    headerFooter?: Record<string, string>;
-    /**
-     * `true` for landscape, `false` for portrait.
+     * Paper orientation.`true` for landscape, `false` for portrait. Defaults to false.
      */
     landscape?: boolean;
     /**
-     * Specifies the type of margins to use. Uses 0 for default margin, 1 for no
-     * margin, and 2 for minimum margin. and `width` in microns.
+     * Whether to display header and footer. Defaults to false.
      */
-    marginsType?: number;
+    displayHeaderFooter?: boolean;
     /**
-     * The scale factor of the web page. Can range from 0 to 100.
+     * Whether to print background graphics. Defaults to false.
      */
-    scaleFactor?: number;
+    printBackground?: boolean;
     /**
-     * The page range to print. On macOS, only the first range is honored.
+     * Scale of the webpage rendering. Defaults to 1.
      */
-    pageRanges?: Record<string, number>;
+    scale?: number;
     /**
-     * Specify page size of the generated PDF. Can be `A3`, `A4`, `A5`, `Legal`,
-     * `Letter`, `Tabloid` or an Object containing `height`
+     * Specify page size of the generated PDF. Can be `A0`, `A1`, `A2`, `A3`, `A4`,
+     * `A5`, `A6`, `Legal`, `Letter`, `Tabloid`, `Ledger`, or an Object containing
+     * `height` and `width` in inches. Defaults to `Letter`.
      */
     pageSize?: (string) | (Size);
+    margins?: Margins;
     /**
-     * Whether to print CSS backgrounds.
+     * Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string,
+     * which means print all pages.
      */
-    printBackground?: boolean;
+    pageRanges?: string;
+    /**
+     * HTML template for the print header. Should be valid HTML markup with following
+     * classes used to inject printing values into them: `date` (formatted print date),
+     * `title` (document title), `url` (document location), `pageNumber` (current page
+     * number) and `totalPages` (total pages in the document). For example, `<span
+     * class=title></span>` would generate span containing the title.
+     */
+    headerTemplate?: string;
     /**
-     * Whether to print selection only.
+     * HTML template for the print footer. Should use the same format as the
+     * `headerTemplate`.
      */
-    printSelectionOnly?: boolean;
+    footerTemplate?: string;
+    /**
+     * Whether or not to prefer page size as defined by css. Defaults to false, in
+     * which case the content will be scaled to fit the paper size.
+     */
+    preferCSSPageSize?: boolean;
   }
 
   interface Privileges {
@@ -15209,12 +15679,18 @@ declare namespace Electron {
   }
 
   interface Response {
-    cancel?: boolean;
     /**
-     * The original request is prevented from being sent or completed and is instead
-     * redirected to the given URL.
+     * `false` should be passed in if the dialog is canceled. If the `pairingKind` is
+     * `confirm` or `confirmPin`, this value should indicate if the pairing is
+     * confirmed.  If the `pairingKind` is `providePin` the value should be `true` when
+     * a value is provided.
      */
-    redirectURL?: string;
+    confirmed: boolean;
+    /**
+     * When the `pairingKind` is `providePin` this value should be the required pin for
+     * the Bluetooth device.
+     */
+    pin?: (string) | (null);
   }
 
   interface Result {
@@ -15346,6 +15822,15 @@ declare namespace Electron {
     frame: WebFrameMain;
   }
 
+  interface SerialPortRevokedDetails {
+    port: SerialPort;
+    frame: WebFrameMain;
+    /**
+     * The origin that the device has been revoked from.
+     */
+    origin: string;
+  }
+
   interface Settings {
     /**
      * `true` to open the app at login, `false` to remove the app as a login item.
@@ -15449,6 +15934,16 @@ declare namespace Electron {
     maxFileSize?: number;
   }
 
+  interface Streams {
+    video?: (Video) | (WebFrameMain);
+    /**
+     * If a string is specified, can be `loopback` or `loopbackWithMute`. Specifying a
+     * loopback device will capture system audio, and is currently only supported on
+     * Windows. If a WebFrameMain is specified, will capture audio from that frame.
+     */
+    audio?: (('loopback' | 'loopbackWithMute')) | (WebFrameMain);
+  }
+
   interface SystemMemoryInfo {
     /**
      * The total amount of physical memory in Kilobytes available to the system.
@@ -15817,7 +16312,7 @@ declare namespace Electron {
     footer?: string;
     /**
      * Specify page size of the printed document. Can be `A3`, `A4`, `A5`, `Legal`,
-     * `Letter`, `Tabloid` or an Object containing `height`.
+     * `Letter`, `Tabloid` or an Object containing `height` and `width`.
      */
     pageSize?: (string) | (Size);
   }
@@ -15882,7 +16377,7 @@ declare namespace Electron {
     footer?: string;
     /**
      * Specify page size of the printed document. Can be `A3`, `A4`, `A5`, `Legal`,
-     * `Letter`, `Tabloid` or an Object containing `height`.
+     * `Letter`, `Tabloid` or an Object containing `height` in microns.
      */
     pageSize?: (string) | (Size);
   }
@@ -15934,6 +16429,9 @@ declare namespace Electron {
     canEditRichly: boolean;
   }
 
+  interface Env {
+  }
+
   interface FoundInPageResult {
     requestId: number;
     /**
@@ -16212,6 +16710,19 @@ declare namespace Electron {
     height?: number;
   }
 
+  interface Video {
+    /**
+     * The id of the stream being granted. This will usually come from a
+     * DesktopCapturerSource object.
+     */
+    id: string;
+    /**
+     * The name of the stream being granted. This will usually come from a
+     * DesktopCapturerSource object.
+     */
+    name: string;
+  }
+
   interface WebPreferences {
     /**
      * Whether to enable DevTools. If it is set to `false`, can not use
@@ -16495,6 +17006,7 @@ declare namespace Electron {
     powerMonitor: PowerMonitor;
     powerSaveBlocker: PowerSaveBlocker;
     protocol: Protocol;
+    pushNotifications: PushNotifications;
     safeStorage: SafeStorage;
     screen: Screen;
     session: typeof Session;
@@ -16503,6 +17015,7 @@ declare namespace Electron {
     systemPreferences: SystemPreferences;
     TouchBar: typeof TouchBar;
     Tray: typeof Tray;
+    utilityProcess: typeof UtilityProcess;
     webContents: typeof WebContents;
     webFrameMain: typeof WebFrameMain;
   }
@@ -16529,8 +17042,10 @@ declare namespace Electron {
     type BeforeSendResponse = Electron.BeforeSendResponse;
     type BitmapOptions = Electron.BitmapOptions;
     type BlinkMemoryInfo = Electron.BlinkMemoryInfo;
+    type BluetoothPairingHandlerHandlerDetails = Electron.BluetoothPairingHandlerHandlerDetails;
     type BrowserViewConstructorOptions = Electron.BrowserViewConstructorOptions;
     type BrowserWindowConstructorOptions = Electron.BrowserWindowConstructorOptions;
+    type CallbackResponse = Electron.CallbackResponse;
     type CertificateTrustDialogOptions = Electron.CertificateTrustDialogOptions;
     type ClearCodeCachesOptions = Electron.ClearCodeCachesOptions;
     type ClearStorageDataOptions = Electron.ClearStorageDataOptions;
@@ -16560,11 +17075,13 @@ declare namespace Electron {
     type DidRedirectNavigationEvent = Electron.DidRedirectNavigationEvent;
     type DidStartNavigationEvent = Electron.DidStartNavigationEvent;
     type DisplayBalloonOptions = Electron.DisplayBalloonOptions;
+    type DisplayMediaRequestHandlerHandlerRequest = Electron.DisplayMediaRequestHandlerHandlerRequest;
     type EnableNetworkEmulationOptions = Electron.EnableNetworkEmulationOptions;
     type FeedURLOptions = Electron.FeedURLOptions;
     type FileIconOptions = Electron.FileIconOptions;
     type FindInPageOptions = Electron.FindInPageOptions;
     type FocusOptions = Electron.FocusOptions;
+    type ForkOptions = Electron.ForkOptions;
     type FoundInPageEvent = Electron.FoundInPageEvent;
     type FrameCreatedDetails = Electron.FrameCreatedDetails;
     type FromPartitionOptions = Electron.FromPartitionOptions;
@@ -16573,6 +17090,7 @@ declare namespace Electron {
     type HeapStatistics = Electron.HeapStatistics;
     type HidDeviceAddedDetails = Electron.HidDeviceAddedDetails;
     type HidDeviceRemovedDetails = Electron.HidDeviceRemovedDetails;
+    type HidDeviceRevokedDetails = Electron.HidDeviceRevokedDetails;
     type IgnoreMouseEventsOptions = Electron.IgnoreMouseEventsOptions;
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type Info = Electron.Info;
@@ -16594,7 +17112,6 @@ declare namespace Electron {
     type MessageDetails = Electron.MessageDetails;
     type MessageEvent = Electron.MessageEvent;
     type MoveToApplicationsFolderOptions = Electron.MoveToApplicationsFolderOptions;
-    type NewWindowEvent = Electron.NewWindowEvent;
     type NotificationConstructorOptions = Electron.NotificationConstructorOptions;
     type OnBeforeRedirectListenerDetails = Electron.OnBeforeRedirectListenerDetails;
     type OnBeforeRequestListenerDetails = Electron.OnBeforeRequestListenerDetails;
@@ -16610,6 +17127,7 @@ declare namespace Electron {
     type OpenDialogSyncOptions = Electron.OpenDialogSyncOptions;
     type OpenExternalOptions = Electron.OpenExternalOptions;
     type Options = Electron.Options;
+    type Opts = Electron.Opts;
     type PageFaviconUpdatedEvent = Electron.PageFaviconUpdatedEvent;
     type PageTitleUpdatedEvent = Electron.PageTitleUpdatedEvent;
     type Parameters = Electron.Parameters;
@@ -16636,10 +17154,12 @@ declare namespace Electron {
     type SaveDialogReturnValue = Electron.SaveDialogReturnValue;
     type SaveDialogSyncOptions = Electron.SaveDialogSyncOptions;
     type SelectHidDeviceDetails = Electron.SelectHidDeviceDetails;
+    type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type Settings = Electron.Settings;
     type SourcesOptions = Electron.SourcesOptions;
     type SSLConfigConfig = Electron.SSLConfigConfig;
     type StartLoggingOptions = Electron.StartLoggingOptions;
+    type Streams = Electron.Streams;
     type SystemMemoryInfo = Electron.SystemMemoryInfo;
     type TitleBarOverlayOptions = Electron.TitleBarOverlayOptions;
     type TitleOptions = Electron.TitleOptions;
@@ -16665,6 +17185,7 @@ declare namespace Electron {
     type WillNavigateEvent = Electron.WillNavigateEvent;
     type WillResizeDetails = Electron.WillResizeDetails;
     type EditFlags = Electron.EditFlags;
+    type Env = Electron.Env;
     type FoundInPageResult = Electron.FoundInPageResult;
     type LaunchItems = Electron.LaunchItems;
     type Margins = Electron.Margins;
@@ -16672,6 +17193,7 @@ declare namespace Electron {
     type PageRanges = Electron.PageRanges;
     type Params = Electron.Params;
     type TitleBarOverlay = Electron.TitleBarOverlay;
+    type Video = Electron.Video;
     type WebPreferences = Electron.WebPreferences;
     type DefaultFontFamily = Electron.DefaultFontFamily;
     type BluetoothDevice = Electron.BluetoothDevice;
@@ -16704,7 +17226,6 @@ declare namespace Electron {
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
-    type NewWindowWebContentsEvent = Electron.NewWindowWebContentsEvent;
     type NotificationAction = Electron.NotificationAction;
     type NotificationResponse = Electron.NotificationResponse;
     type PaymentDiscount = Electron.PaymentDiscount;
@@ -16785,6 +17306,8 @@ declare namespace Electron {
     type PowerSaveBlocker = Electron.PowerSaveBlocker;
     const protocol: Protocol;
     type Protocol = Electron.Protocol;
+    const pushNotifications: PushNotifications;
+    type PushNotifications = Electron.PushNotifications;
     const safeStorage: SafeStorage;
     type SafeStorage = Electron.SafeStorage;
     const screen: Screen;
@@ -16807,6 +17330,8 @@ declare namespace Electron {
     type TouchBarSlider = Electron.TouchBarSlider;
     type TouchBarSpacer = Electron.TouchBarSpacer;
     class Tray extends Electron.Tray {}
+    const utilityProcess: typeof UtilityProcess;
+    type UtilityProcess = Electron.UtilityProcess;
     const webContents: typeof WebContents;
     type WebContents = Electron.WebContents;
     const webFrameMain: typeof WebFrameMain;
@@ -16823,8 +17348,10 @@ declare namespace Electron {
     type BeforeSendResponse = Electron.BeforeSendResponse;
     type BitmapOptions = Electron.BitmapOptions;
     type BlinkMemoryInfo = Electron.BlinkMemoryInfo;
+    type BluetoothPairingHandlerHandlerDetails = Electron.BluetoothPairingHandlerHandlerDetails;
     type BrowserViewConstructorOptions = Electron.BrowserViewConstructorOptions;
     type BrowserWindowConstructorOptions = Electron.BrowserWindowConstructorOptions;
+    type CallbackResponse = Electron.CallbackResponse;
     type CertificateTrustDialogOptions = Electron.CertificateTrustDialogOptions;
     type ClearCodeCachesOptions = Electron.ClearCodeCachesOptions;
     type ClearStorageDataOptions = Electron.ClearStorageDataOptions;
@@ -16854,11 +17381,13 @@ declare namespace Electron {
     type DidRedirectNavigationEvent = Electron.DidRedirectNavigationEvent;
     type DidStartNavigationEvent = Electron.DidStartNavigationEvent;
     type DisplayBalloonOptions = Electron.DisplayBalloonOptions;
+    type DisplayMediaRequestHandlerHandlerRequest = Electron.DisplayMediaRequestHandlerHandlerRequest;
     type EnableNetworkEmulationOptions = Electron.EnableNetworkEmulationOptions;
     type FeedURLOptions = Electron.FeedURLOptions;
     type FileIconOptions = Electron.FileIconOptions;
     type FindInPageOptions = Electron.FindInPageOptions;
     type FocusOptions = Electron.FocusOptions;
+    type ForkOptions = Electron.ForkOptions;
     type FoundInPageEvent = Electron.FoundInPageEvent;
     type FrameCreatedDetails = Electron.FrameCreatedDetails;
     type FromPartitionOptions = Electron.FromPartitionOptions;
@@ -16867,6 +17396,7 @@ declare namespace Electron {
     type HeapStatistics = Electron.HeapStatistics;
     type HidDeviceAddedDetails = Electron.HidDeviceAddedDetails;
     type HidDeviceRemovedDetails = Electron.HidDeviceRemovedDetails;
+    type HidDeviceRevokedDetails = Electron.HidDeviceRevokedDetails;
     type IgnoreMouseEventsOptions = Electron.IgnoreMouseEventsOptions;
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type Info = Electron.Info;
@@ -16888,7 +17418,6 @@ declare namespace Electron {
     type MessageDetails = Electron.MessageDetails;
     type MessageEvent = Electron.MessageEvent;
     type MoveToApplicationsFolderOptions = Electron.MoveToApplicationsFolderOptions;
-    type NewWindowEvent = Electron.NewWindowEvent;
     type NotificationConstructorOptions = Electron.NotificationConstructorOptions;
     type OnBeforeRedirectListenerDetails = Electron.OnBeforeRedirectListenerDetails;
     type OnBeforeRequestListenerDetails = Electron.OnBeforeRequestListenerDetails;
@@ -16904,6 +17433,7 @@ declare namespace Electron {
     type OpenDialogSyncOptions = Electron.OpenDialogSyncOptions;
     type OpenExternalOptions = Electron.OpenExternalOptions;
     type Options = Electron.Options;
+    type Opts = Electron.Opts;
     type PageFaviconUpdatedEvent = Electron.PageFaviconUpdatedEvent;
     type PageTitleUpdatedEvent = Electron.PageTitleUpdatedEvent;
     type Parameters = Electron.Parameters;
@@ -16930,10 +17460,12 @@ declare namespace Electron {
     type SaveDialogReturnValue = Electron.SaveDialogReturnValue;
     type SaveDialogSyncOptions = Electron.SaveDialogSyncOptions;
     type SelectHidDeviceDetails = Electron.SelectHidDeviceDetails;
+    type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type Settings = Electron.Settings;
     type SourcesOptions = Electron.SourcesOptions;
     type SSLConfigConfig = Electron.SSLConfigConfig;
     type StartLoggingOptions = Electron.StartLoggingOptions;
+    type Streams = Electron.Streams;
     type SystemMemoryInfo = Electron.SystemMemoryInfo;
     type TitleBarOverlayOptions = Electron.TitleBarOverlayOptions;
     type TitleOptions = Electron.TitleOptions;
@@ -16959,6 +17491,7 @@ declare namespace Electron {
     type WillNavigateEvent = Electron.WillNavigateEvent;
     type WillResizeDetails = Electron.WillResizeDetails;
     type EditFlags = Electron.EditFlags;
+    type Env = Electron.Env;
     type FoundInPageResult = Electron.FoundInPageResult;
     type LaunchItems = Electron.LaunchItems;
     type Margins = Electron.Margins;
@@ -16966,6 +17499,7 @@ declare namespace Electron {
     type PageRanges = Electron.PageRanges;
     type Params = Electron.Params;
     type TitleBarOverlay = Electron.TitleBarOverlay;
+    type Video = Electron.Video;
     type WebPreferences = Electron.WebPreferences;
     type DefaultFontFamily = Electron.DefaultFontFamily;
     type BluetoothDevice = Electron.BluetoothDevice;
@@ -16998,7 +17532,6 @@ declare namespace Electron {
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
-    type NewWindowWebContentsEvent = Electron.NewWindowWebContentsEvent;
     type NotificationAction = Electron.NotificationAction;
     type NotificationResponse = Electron.NotificationResponse;
     type PaymentDiscount = Electron.PaymentDiscount;
@@ -17054,8 +17587,10 @@ declare namespace Electron {
     type BeforeSendResponse = Electron.BeforeSendResponse;
     type BitmapOptions = Electron.BitmapOptions;
     type BlinkMemoryInfo = Electron.BlinkMemoryInfo;
+    type BluetoothPairingHandlerHandlerDetails = Electron.BluetoothPairingHandlerHandlerDetails;
     type BrowserViewConstructorOptions = Electron.BrowserViewConstructorOptions;
     type BrowserWindowConstructorOptions = Electron.BrowserWindowConstructorOptions;
+    type CallbackResponse = Electron.CallbackResponse;
     type CertificateTrustDialogOptions = Electron.CertificateTrustDialogOptions;
     type ClearCodeCachesOptions = Electron.ClearCodeCachesOptions;
     type ClearStorageDataOptions = Electron.ClearStorageDataOptions;
@@ -17085,11 +17620,13 @@ declare namespace Electron {
     type DidRedirectNavigationEvent = Electron.DidRedirectNavigationEvent;
     type DidStartNavigationEvent = Electron.DidStartNavigationEvent;
     type DisplayBalloonOptions = Electron.DisplayBalloonOptions;
+    type DisplayMediaRequestHandlerHandlerRequest = Electron.DisplayMediaRequestHandlerHandlerRequest;
     type EnableNetworkEmulationOptions = Electron.EnableNetworkEmulationOptions;
     type FeedURLOptions = Electron.FeedURLOptions;
     type FileIconOptions = Electron.FileIconOptions;
     type FindInPageOptions = Electron.FindInPageOptions;
     type FocusOptions = Electron.FocusOptions;
+    type ForkOptions = Electron.ForkOptions;
     type FoundInPageEvent = Electron.FoundInPageEvent;
     type FrameCreatedDetails = Electron.FrameCreatedDetails;
     type FromPartitionOptions = Electron.FromPartitionOptions;
@@ -17098,6 +17635,7 @@ declare namespace Electron {
     type HeapStatistics = Electron.HeapStatistics;
     type HidDeviceAddedDetails = Electron.HidDeviceAddedDetails;
     type HidDeviceRemovedDetails = Electron.HidDeviceRemovedDetails;
+    type HidDeviceRevokedDetails = Electron.HidDeviceRevokedDetails;
     type IgnoreMouseEventsOptions = Electron.IgnoreMouseEventsOptions;
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type Info = Electron.Info;
@@ -17119,7 +17657,6 @@ declare namespace Electron {
     type MessageDetails = Electron.MessageDetails;
     type MessageEvent = Electron.MessageEvent;
     type MoveToApplicationsFolderOptions = Electron.MoveToApplicationsFolderOptions;
-    type NewWindowEvent = Electron.NewWindowEvent;
     type NotificationConstructorOptions = Electron.NotificationConstructorOptions;
     type OnBeforeRedirectListenerDetails = Electron.OnBeforeRedirectListenerDetails;
     type OnBeforeRequestListenerDetails = Electron.OnBeforeRequestListenerDetails;
@@ -17135,6 +17672,7 @@ declare namespace Electron {
     type OpenDialogSyncOptions = Electron.OpenDialogSyncOptions;
     type OpenExternalOptions = Electron.OpenExternalOptions;
     type Options = Electron.Options;
+    type Opts = Electron.Opts;
     type PageFaviconUpdatedEvent = Electron.PageFaviconUpdatedEvent;
     type PageTitleUpdatedEvent = Electron.PageTitleUpdatedEvent;
     type Parameters = Electron.Parameters;
@@ -17161,10 +17699,12 @@ declare namespace Electron {
     type SaveDialogReturnValue = Electron.SaveDialogReturnValue;
     type SaveDialogSyncOptions = Electron.SaveDialogSyncOptions;
     type SelectHidDeviceDetails = Electron.SelectHidDeviceDetails;
+    type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type Settings = Electron.Settings;
     type SourcesOptions = Electron.SourcesOptions;
     type SSLConfigConfig = Electron.SSLConfigConfig;
     type StartLoggingOptions = Electron.StartLoggingOptions;
+    type Streams = Electron.Streams;
     type SystemMemoryInfo = Electron.SystemMemoryInfo;
     type TitleBarOverlayOptions = Electron.TitleBarOverlayOptions;
     type TitleOptions = Electron.TitleOptions;
@@ -17190,6 +17730,7 @@ declare namespace Electron {
     type WillNavigateEvent = Electron.WillNavigateEvent;
     type WillResizeDetails = Electron.WillResizeDetails;
     type EditFlags = Electron.EditFlags;
+    type Env = Electron.Env;
     type FoundInPageResult = Electron.FoundInPageResult;
     type LaunchItems = Electron.LaunchItems;
     type Margins = Electron.Margins;
@@ -17197,6 +17738,7 @@ declare namespace Electron {
     type PageRanges = Electron.PageRanges;
     type Params = Electron.Params;
     type TitleBarOverlay = Electron.TitleBarOverlay;
+    type Video = Electron.Video;
     type WebPreferences = Electron.WebPreferences;
     type DefaultFontFamily = Electron.DefaultFontFamily;
     type BluetoothDevice = Electron.BluetoothDevice;
@@ -17229,7 +17771,6 @@ declare namespace Electron {
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
-    type NewWindowWebContentsEvent = Electron.NewWindowWebContentsEvent;
     type NotificationAction = Electron.NotificationAction;
     type NotificationResponse = Electron.NotificationResponse;
     type PaymentDiscount = Electron.PaymentDiscount;
@@ -17320,6 +17861,8 @@ declare namespace Electron {
     type PowerSaveBlocker = Electron.PowerSaveBlocker;
     const protocol: Protocol;
     type Protocol = Electron.Protocol;
+    const pushNotifications: PushNotifications;
+    type PushNotifications = Electron.PushNotifications;
     const safeStorage: SafeStorage;
     type SafeStorage = Electron.SafeStorage;
     const screen: Screen;
@@ -17344,6 +17887,8 @@ declare namespace Electron {
     type TouchBarSlider = Electron.TouchBarSlider;
     type TouchBarSpacer = Electron.TouchBarSpacer;
     class Tray extends Electron.Tray {}
+    const utilityProcess: typeof UtilityProcess;
+    type UtilityProcess = Electron.UtilityProcess;
     const webContents: typeof WebContents;
     type WebContents = Electron.WebContents;
     const webFrame: WebFrame;
@@ -17362,8 +17907,10 @@ declare namespace Electron {
     type BeforeSendResponse = Electron.BeforeSendResponse;
     type BitmapOptions = Electron.BitmapOptions;
     type BlinkMemoryInfo = Electron.BlinkMemoryInfo;
+    type BluetoothPairingHandlerHandlerDetails = Electron.BluetoothPairingHandlerHandlerDetails;
     type BrowserViewConstructorOptions = Electron.BrowserViewConstructorOptions;
     type BrowserWindowConstructorOptions = Electron.BrowserWindowConstructorOptions;
+    type CallbackResponse = Electron.CallbackResponse;
     type CertificateTrustDialogOptions = Electron.CertificateTrustDialogOptions;
     type ClearCodeCachesOptions = Electron.ClearCodeCachesOptions;
     type ClearStorageDataOptions = Electron.ClearStorageDataOptions;
@@ -17393,11 +17940,13 @@ declare namespace Electron {
     type DidRedirectNavigationEvent = Electron.DidRedirectNavigationEvent;
     type DidStartNavigationEvent = Electron.DidStartNavigationEvent;
     type DisplayBalloonOptions = Electron.DisplayBalloonOptions;
+    type DisplayMediaRequestHandlerHandlerRequest = Electron.DisplayMediaRequestHandlerHandlerRequest;
     type EnableNetworkEmulationOptions = Electron.EnableNetworkEmulationOptions;
     type FeedURLOptions = Electron.FeedURLOptions;
     type FileIconOptions = Electron.FileIconOptions;
     type FindInPageOptions = Electron.FindInPageOptions;
     type FocusOptions = Electron.FocusOptions;
+    type ForkOptions = Electron.ForkOptions;
     type FoundInPageEvent = Electron.FoundInPageEvent;
     type FrameCreatedDetails = Electron.FrameCreatedDetails;
     type FromPartitionOptions = Electron.FromPartitionOptions;
@@ -17406,6 +17955,7 @@ declare namespace Electron {
     type HeapStatistics = Electron.HeapStatistics;
     type HidDeviceAddedDetails = Electron.HidDeviceAddedDetails;
     type HidDeviceRemovedDetails = Electron.HidDeviceRemovedDetails;
+    type HidDeviceRevokedDetails = Electron.HidDeviceRevokedDetails;
     type IgnoreMouseEventsOptions = Electron.IgnoreMouseEventsOptions;
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type Info = Electron.Info;
@@ -17427,7 +17977,6 @@ declare namespace Electron {
     type MessageDetails = Electron.MessageDetails;
     type MessageEvent = Electron.MessageEvent;
     type MoveToApplicationsFolderOptions = Electron.MoveToApplicationsFolderOptions;
-    type NewWindowEvent = Electron.NewWindowEvent;
     type NotificationConstructorOptions = Electron.NotificationConstructorOptions;
     type OnBeforeRedirectListenerDetails = Electron.OnBeforeRedirectListenerDetails;
     type OnBeforeRequestListenerDetails = Electron.OnBeforeRequestListenerDetails;
@@ -17443,6 +17992,7 @@ declare namespace Electron {
     type OpenDialogSyncOptions = Electron.OpenDialogSyncOptions;
     type OpenExternalOptions = Electron.OpenExternalOptions;
     type Options = Electron.Options;
+    type Opts = Electron.Opts;
     type PageFaviconUpdatedEvent = Electron.PageFaviconUpdatedEvent;
     type PageTitleUpdatedEvent = Electron.PageTitleUpdatedEvent;
     type Parameters = Electron.Parameters;
@@ -17469,10 +18019,12 @@ declare namespace Electron {
     type SaveDialogReturnValue = Electron.SaveDialogReturnValue;
     type SaveDialogSyncOptions = Electron.SaveDialogSyncOptions;
     type SelectHidDeviceDetails = Electron.SelectHidDeviceDetails;
+    type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type Settings = Electron.Settings;
     type SourcesOptions = Electron.SourcesOptions;
     type SSLConfigConfig = Electron.SSLConfigConfig;
     type StartLoggingOptions = Electron.StartLoggingOptions;
+    type Streams = Electron.Streams;
     type SystemMemoryInfo = Electron.SystemMemoryInfo;
     type TitleBarOverlayOptions = Electron.TitleBarOverlayOptions;
     type TitleOptions = Electron.TitleOptions;
@@ -17498,6 +18050,7 @@ declare namespace Electron {
     type WillNavigateEvent = Electron.WillNavigateEvent;
     type WillResizeDetails = Electron.WillResizeDetails;
     type EditFlags = Electron.EditFlags;
+    type Env = Electron.Env;
     type FoundInPageResult = Electron.FoundInPageResult;
     type LaunchItems = Electron.LaunchItems;
     type Margins = Electron.Margins;
@@ -17505,6 +18058,7 @@ declare namespace Electron {
     type PageRanges = Electron.PageRanges;
     type Params = Electron.Params;
     type TitleBarOverlay = Electron.TitleBarOverlay;
+    type Video = Electron.Video;
     type WebPreferences = Electron.WebPreferences;
     type DefaultFontFamily = Electron.DefaultFontFamily;
     type BluetoothDevice = Electron.BluetoothDevice;
@@ -17537,7 +18091,6 @@ declare namespace Electron {
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
-    type NewWindowWebContentsEvent = Electron.NewWindowWebContentsEvent;
     type NotificationAction = Electron.NotificationAction;
     type NotificationResponse = Electron.NotificationResponse;
     type PaymentDiscount = Electron.PaymentDiscount;
@@ -17591,14 +18144,17 @@ declare namespace Electron {
   const nativeTheme: NativeTheme;
   const net: Net;
   const netLog: NetLog;
+  const parentPort: ParentPort;
   const powerMonitor: PowerMonitor;
   const powerSaveBlocker: PowerSaveBlocker;
   const protocol: Protocol;
+  const pushNotifications: PushNotifications;
   const safeStorage: SafeStorage;
   const screen: Screen;
   const session: typeof Session;
   const shell: Shell;
   const systemPreferences: SystemPreferences;
+  const utilityProcess: typeof UtilityProcess;
   const webContents: typeof WebContents;
   const webFrame: WebFrame;
   const webFrameMain: typeof WebFrameMain;
@@ -17811,6 +18367,11 @@ declare namespace NodeJS {
      * property is used instead of the `--no-deprecation` command line flag.
      */
     noDeprecation: boolean;
+    /**
+     * A `Electron.ParentPort` property if this is a `UtilityProcess` (or `null`
+     * otherwise) allowing communication with the parent process.
+     */
+    parentPort: Electron.ParentPort;
     /**
      * A `string` representing the path to the resources directory.
      *
@@ -17848,9 +18409,10 @@ declare namespace NodeJS {
      * * `browser` - The main process
      * * `renderer` - A renderer process
      * * `worker` - In a web worker
+     * * `utility` - In a node process launched as a service
      *
      */
-    readonly type: ('browser' | 'renderer' | 'worker');
+    readonly type: ('browser' | 'renderer' | 'worker' | 'utility');
     /**
      * A `boolean`. If the app is running as a Windows Store app (appx), this property
      * is `true`, for otherwise it is `undefined`.