electron-types 45.0.0-beta.7 → 46.0.0-alpha.1

package/README.md

@@ -14,11 +14,11 @@ The official `electron` package is ~200MB because it includes the Electron binar
 Since this package only provides TypeScript types, install it as a dev dependency. **Install the version that matches your Electron version** (see [Version Matching](#version-matching)):
 
 ```bash
-npm install -D electron-types@45.0.0-beta.7
+npm install -D electron-types@46.0.0-alpha.1
 # or
-yarn add -D electron-types@45.0.0-beta.7
+yarn add -D electron-types@46.0.0-alpha.1
 # or
-pnpm add -D electron-types@45.0.0-beta.7
+pnpm add -D electron-types@46.0.0-alpha.1
 ```
 
 ## Usage

package/dist/electron.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Electron 45.0.0-beta.7
+// Type definitions for Electron 46.0.0-alpha.1
 // Project: http://electronjs.org/
 // Definitions by: The Electron Team <https://github.com/electron/electron>
 // Definitions: https://github.com/electron/typescript-definitions
@@ -1114,6 +1114,21 @@ declare namespace Electron {
      * @platform darwin,win32
      */
     addRecentDocument(path: string): void;
+    /**
+     * `true` when the app runs with a full administrator token while UAC is enabled
+     * (for example because it was started with "Run as administrator", from an
+     * elevated installer or from an elevated shell), so that a filtered, non-elevated
+     * token exists to relaunch with. It is `false` when the app is not elevated, for
+     * the built-in Administrator account, and when UAC is turned off.
+     *
+     * Chromium's sandbox cannot always launch child processes from an elevated browser
+     * process, and code that was not written to run elevated should not. An app that
+     * does not need elevation can restart itself with the user's normal token before
+     * doing anything else:
+     *
+     * @platform win32
+     */
+    canDeElevate(): boolean;
     /**
      * Clears the recent documents list.
      *
@@ -5932,7 +5947,10 @@ declare namespace Electron {
      * whole visible page. If the page is not visible, `rect` may be empty. The page is
      * considered visible when its browser window is hidden and the capturer count is
      * non-zero. If you would like the page to stay hidden, you should ensure that
-     * `stayHidden` is set to true.
+     * `stayHidden` is set to true. The image has the page's device scale factor (for
+     * offscreen rendering, `webPreferences.offscreen.deviceScaleFactor`), so
+     * `image.getSize()` is in DIPs and `image.toBitmap()` holds the full-resolution
+     * pixels.
      */
     capturePage(rect?: Rectangle, opts?: Opts): Promise<Electron.NativeImage>;
     /**
@@ -8135,6 +8153,20 @@ declare namespace Electron {
 
     // Docs: https://electronjs.org/docs/api/desktop-capturer
 
+    /**
+     * The current restore token for the source, or an empty string if it has none.
+     *
+     * The system may replace the token each time the source is opened, which happens
+     * once in `desktopCapturer.getSources` and again when a stream is started from the
+     * source, and then only the newest token works on the next launch. Read it with
+     * this method once the stream is running, or before the app quits, and store that
+     * value rather than the one `getSources` returned. See Restoring a source on
+     * Wayland.
+     *
+     * @experimental
+     * @platform linux
+     */
+    getRestoreToken(sourceId: string): string;
     /**
      * Resolves with an array of `DesktopCapturerSource` objects, each
      * `DesktopCapturerSource` represents a screen or an individual window that can be
@@ -8180,6 +8212,15 @@ declare namespace Electron {
      * the name of a window source will match the window title.
      */
     name: string;
+    /**
+     * A token that lets a later `desktopCapturer.getSources` call reopen this source
+     * without showing the system picker, or an empty string if the system did not
+     * issue one. See Restoring a source on Wayland.
+     *
+     * @experimental
+     * @platform linux
+     */
+    restoreToken: string;
     /**
      * A thumbnail image. **Note:** There is no guarantee that the size of the
      * thumbnail is the same as the `thumbnailSize` specified in the `options` passed
@@ -9006,10 +9047,85 @@ declare namespace Electron {
     isDirectory?: boolean;
   }
 
-  interface GlobalShortcut {
+  interface GlobalShortcut extends NodeJS.EventEmitter {
 
     // Docs: https://electronjs.org/docs/api/global-shortcut
 
+    /**
+     * Emitted on Linux Wayland when the `org.freedesktop.portal.GlobalShortcuts`
+     * portal resolves a registration request. The bind on this path is asynchronous
+     * and consent-gated, so the boolean returned by `register()` only refers to if the
+     * request was successfully submitted; this event reports the real outcome. `bound`
+     * is `false` when the portal denied the bind (for example an invalid app identity
+     * — see `app.setDesktopName()` — or a dismissed consent dialog) or the portal is
+     * unavailable.
+     *
+     * The event is always emitted asynchronously, and may be emitted more than once
+     * for the same accelerator: registering an additional shortcut re-binds the whole
+     * set, which re-resolves previously bound accelerators.
+     *
+     * This event is not emitted on X11 or on other platforms, where the return value
+     * of `register()` is already authoritative.
+     *
+     * @platform linux
+     */
+    on(event: 'registration-resolved', listener: (
+                                                  /**
+                                                   * The accelerator, as it was passed to `register()`.
+                                                   */
+                                                  accelerator: string,
+                                                  /**
+                                                   * Whether the portal accepted the bind request.
+                                                   */
+                                                  bound: boolean) => void): this;
+    /**
+     * @platform linux
+     */
+    off(event: 'registration-resolved', listener: (
+                                                  /**
+                                                   * The accelerator, as it was passed to `register()`.
+                                                   */
+                                                  accelerator: string,
+                                                  /**
+                                                   * Whether the portal accepted the bind request.
+                                                   */
+                                                  bound: boolean) => void): this;
+    /**
+     * @platform linux
+     */
+    once(event: 'registration-resolved', listener: (
+                                                  /**
+                                                   * The accelerator, as it was passed to `register()`.
+                                                   */
+                                                  accelerator: string,
+                                                  /**
+                                                   * Whether the portal accepted the bind request.
+                                                   */
+                                                  bound: boolean) => void): this;
+    /**
+     * @platform linux
+     */
+    addListener(event: 'registration-resolved', listener: (
+                                                  /**
+                                                   * The accelerator, as it was passed to `register()`.
+                                                   */
+                                                  accelerator: string,
+                                                  /**
+                                                   * Whether the portal accepted the bind request.
+                                                   */
+                                                  bound: boolean) => void): this;
+    /**
+     * @platform linux
+     */
+    removeListener(event: 'registration-resolved', listener: (
+                                                  /**
+                                                   * The accelerator, as it was passed to `register()`.
+                                                   */
+                                                  accelerator: string,
+                                                  /**
+                                                   * Whether the portal accepted the bind request.
+                                                   */
+                                                  bound: boolean) => void): this;
     /**
      * Whether this application has registered `accelerator`.
      *
@@ -9032,6 +9148,10 @@ declare namespace Electron {
      * silently fail. This behavior is intended by operating systems, since they don't
      * want applications to fight for global shortcuts.
      *
+     * On Linux Wayland, the return value only indicates that the bind request was
+     * submitted to the desktop portal; the portal resolves it asynchronously and the
+     * actual outcome is reported by the `registration-resolved` event.
+     *
      * The following accelerators will not be registered successfully on macOS 10.14
      * Mojave unless the app has been authorized as a trusted accessibility client:
      *
@@ -11855,6 +11975,14 @@ declare namespace Electron {
 
     // Docs: https://electronjs.org/docs/api/structures/preload-script
 
+    /**
+     * Glob patterns for URLs the script will not run in.
+     */
+    excludeGlobs?: string[];
+    /**
+     * Match patterns for URLs the script will not run in.
+     */
+    excludeMatches?: string[];
     /**
      * Path of the script file. Must be an absolute path.
      */
@@ -11863,6 +11991,29 @@ declare namespace Electron {
      * Unique ID of preload script.
      */
     id: string;
+    /**
+     * Glob patterns applied after `matches`. A URL must also match one of these globs.
+     * `*` matches any sequence of characters and `?` matches any single character.
+     */
+    includeGlobs?: string[];
+    /**
+     * Match patterns for URLs the script runs in. A custom protocol can be used if its
+     * scheme is registered as `standard` with `protocol.registerSchemesAsPrivileged`.
+     * To filter documents served from a non-standard scheme, use `includeGlobs` or
+     * `excludeGlobs`, which match against the whole URL. If omitted, the script runs
+     * for all URLs not excluded by other filters.
+     */
+    matches?: string[];
+    /**
+     * Whether a document whose URL has no origin of its own (`about:`, `blob:`,
+     * `data:` or `filesystem:`) is matched by the origin of the frame that created it
+     * instead of by its URL. This includes documents with an opaque origin, such as a
+     * `data:` frame or a sandboxed `<iframe srcdoc>`. For example, an `about:blank`
+     * popup opened by `https://example.com/page` is matched as `https://example.com/`.
+     * When set, every pattern in `matches` must have a path of `/*`. Only applies to
+     * `frame` contexts. Default is `false`.
+     */
+    matchOriginAsFallback?: boolean;
     /**
      * Context type where the preload script will be executed. Possible values include
      * `frame` or `service-worker`.
@@ -11874,6 +12025,14 @@ declare namespace Electron {
 
     // Docs: https://electronjs.org/docs/api/structures/preload-script-registration
 
+    /**
+     * Glob patterns for URLs the script will not run in.
+     */
+    excludeGlobs?: string[];
+    /**
+     * Match patterns for URLs the script will not run in.
+     */
+    excludeMatches?: string[];
     /**
      * Path of the script file. Must be an absolute path.
      */
@@ -11882,6 +12041,30 @@ declare namespace Electron {
      * Unique ID of preload script. Defaults to a random UUID.
      */
     id?: string;
+    /**
+     * Glob patterns applied after `matches`. A URL must also match one of these globs.
+     * `*` matches any sequence of characters and `?` matches any single character.
+     * Must not be empty.
+     */
+    includeGlobs?: string[];
+    /**
+     * Match patterns for URLs the script runs in. A custom protocol can be used if its
+     * scheme is registered as `standard` with `protocol.registerSchemesAsPrivileged`.
+     * To filter documents served from a non-standard scheme, use `includeGlobs` or
+     * `excludeGlobs`, which match against the whole URL. If omitted, the script runs
+     * for all URLs not excluded by other filters. Must not be empty.
+     */
+    matches?: string[];
+    /**
+     * Whether a document whose URL has no origin of its own (`about:`, `blob:`,
+     * `data:` or `filesystem:`) is matched by the origin of the frame that created it
+     * instead of by its URL. This includes documents with an opaque origin, such as a
+     * `data:` frame or a sandboxed `<iframe srcdoc>`. For example, an `about:blank`
+     * popup opened by `https://example.com/page` is matched as `https://example.com/`.
+     * When set, every pattern in `matches` must have a path of `/*`. Only applies to
+     * `frame` contexts. Default is `false`.
+     */
+    matchOriginAsFallback?: boolean;
     /**
      * Context type where the preload script will be executed. Possible values include
      * `frame` or `service-worker`.
@@ -12706,17 +12889,6 @@ declare namespace Electron {
 
     // Docs: https://electronjs.org/docs/api/safe-storage
 
-    /**
-     * the decrypted string. Decrypts the encrypted buffer obtained  with
-     * `safeStorage.encryptString` back into a string.
-     *
-     * **Deprecated:** Use `safeStorage.decryptStringAsync(encrypted)` instead. Data
-     * encrypted with `safeStorage.encryptString` can be decrypted with
-     * `safeStorage.decryptStringAsync`.
-     *
-     * @deprecated
-     */
-    decryptString(encrypted: Buffer): string;
     /**
      * Resolve with an object containing the following:
      *
@@ -12727,16 +12899,6 @@ declare namespace Electron {
      * * `result` string - the decrypted string.
      */
     decryptStringAsync(encrypted: Buffer): Promise<Electron.DecryptStringAsyncReturnValue>;
-    /**
-     * An array of bytes representing the encrypted string.
-     *
-     * This function will throw an error if encryption fails.
-     *
-     * **Deprecated:** Use `safeStorage.encryptStringAsync(plainText)` instead.
-     *
-     * @deprecated
-     */
-    encryptString(plainText: string): Buffer;
     /**
      * An array of bytes representing the encrypted string.
      */
@@ -12772,18 +12934,6 @@ declare namespace Electron {
      * The returned promise resolves once initialization completes.
      */
     isAsyncEncryptionAvailable(): Promise<boolean>;
-    /**
-     * Whether encryption is available.
-     *
-     * On Linux, returns true if the app has emitted the `ready` event and the secret
-     * key is available. On MacOS, returns true if Keychain is available. On Windows,
-     * returns true once the app has emitted the `ready` event.
-     *
-     * **Deprecated:** Use `safeStorage.isAsyncEncryptionAvailable()` instead.
-     *
-     * @deprecated
-     */
-    isEncryptionAvailable(): boolean;
     /**
      * This function on Linux will force the module to use an in memory password for
      * creating symmetric key that is used for encrypt/decrypt functions when a valid
@@ -14112,7 +14262,33 @@ declare namespace Electron {
     /**
      * Registers preload script that will be executed in its associated context type in
      * this session. For `frame` contexts, this will run prior to any preload defined
-     * in the web preferences of a WebContents.
+     * in the web preferences of a WebContents. In-page navigations do not rerun the
+     * preload script.
+     *
+     * URL filters can limit which documents or service workers a script runs in. They
+     * behave like content script URL matching. A script runs for a URL that meets all
+     * of these conditions:
+     *
+     * * It matches at least one pattern in `matches`, if set.
+     * * It matches at least one glob in `includeGlobs`, if set.
+     * * It does not match any pattern in `excludeMatches`.
+     * * It does not match any glob in `excludeGlobs`.
+     *
+     * The URL that the filters are matched against depends on the context type:
+     *
+     * * For `service-worker` contexts, it is the service worker's scope.
+     * * For `frame` contexts, it is the URL of the document being loaded, with these
+     * special cases:
+     *   * The initial empty document of a frame or popup is matched as `about:blank`.
+     * Set `matchOriginAsFallback` to match such documents by the origin of the frame
+     * that created them instead, for example to keep a script out of the `about:blank`
+     * popups of an excluded site.
+     *   * A `data:` URL loaded with `baseURLForDataURL` is matched by its base URL.
+     *   * The error page of a failed navigation is matched by the URL that failed to
+     * load.
+     *
+     * Throws an error if any of the URL patterns are invalid, or if `matches` or
+     * `includeGlobs` is an empty array.
      *
      * The ID of the registered preload script.
      */
@@ -16778,9 +16954,12 @@ declare namespace Electron {
     addListener(event: 'spawn', listener: () => void): this;
     removeListener(event: 'spawn', listener: () => void): 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.
+     * Terminates the process gracefully. On POSIX, it sends `SIGTERM`; on Windows, it
+     * terminates the process. Like Node's `child_process.kill()`, this delivers the
+     * signal but does not guarantee that the process exits: a child that handles
+     * `SIGTERM` decides when, or whether, to exit. On POSIX, the child is reaped by
+     * Electron once it exits. Returns `true` if the signal was delivered, and `false`
+     * otherwise.
      */
     kill(): boolean;
     /**
@@ -18220,7 +18399,8 @@ declare namespace Electron {
                                                explicitSet: boolean) => void): this;
     /**
      * Emitted when a new frame is generated. Only the dirty area is passed in the
-     * buffer.
+     * buffer. `image` has the view's device scale factor, so `image.getSize()` is in
+     * DIPs, while `dirtyRect` is in the pixels of `image.toBitmap()`.
      *
      * When using shared texture (set `webPreferences.offscreen.useSharedTexture` to
      * `true`) feature, you can pass the texture handle to external rendering pipeline
@@ -18816,7 +18996,9 @@ declare namespace Electron {
      * will be called with `callback(image, dirtyRect)` when there is a presentation
      * event.
      *
-     * The `image` is an instance of NativeImage that stores the captured frame.
+     * The `image` is an instance of NativeImage that stores the captured frame. It has
+     * the page's device scale factor, so `image.getSize()` is in DIPs, while
+     * `dirtyRect` is in the pixels of `image.toBitmap()`.
      *
      * The `dirtyRect` is an object with `x, y, width, height` properties that
      * describes which part of the page was repainted. If `onlyDirty` is set to `true`,
@@ -18828,7 +19010,9 @@ declare namespace Electron {
      * will be called with `callback(image, dirtyRect)` when there is a presentation
      * event.
      *
-     * The `image` is an instance of NativeImage that stores the captured frame.
+     * The `image` is an instance of NativeImage that stores the captured frame. It has
+     * the page's device scale factor, so `image.getSize()` is in DIPs, while
+     * `dirtyRect` is in the pixels of `image.toBitmap()`.
      *
      * The `dirtyRect` is an object with `x, y, width, height` properties that
      * describes which part of the page was repainted. If `onlyDirty` is set to `true`,
@@ -18867,7 +19051,10 @@ declare namespace Electron {
      * Captures a snapshot of the page within `rect`. Omitting `rect` will capture the
      * whole visible page. The page is considered visible when its browser window is
      * hidden and the capturer count is non-zero. If you would like the page to stay
-     * hidden, you should ensure that `stayHidden` is set to true.
+     * hidden, you should ensure that `stayHidden` is set to true. The image has the
+     * page's device scale factor (for offscreen rendering,
+     * `webPreferences.offscreen.deviceScaleFactor`), so `image.getSize()` is in DIPs
+     * and `image.toBitmap()` holds the full-resolution pixels.
      */
     capturePage(rect?: Rectangle, opts?: Opts): Promise<Electron.NativeImage>;
     /**
@@ -20094,9 +20281,9 @@ declare namespace Electron {
     send(channel: string, ...args: any[]): void;
     /**
      * A `Boolean` representing whether the frame is detached from the frame tree. If a
-     * frame is accessed while the corresponding page is running any unload listeners,
-     * it may become detached as the newly navigated page replaced it in the frame
-     * tree.
+     * frame is accessed while the corresponding page is running any `pagehide` or
+     * `unload` listeners, it may become detached as the newly navigated page replaced
+     * it in the frame tree.
      *
      */
     readonly detached: boolean;
@@ -20321,10 +20508,6 @@ declare namespace Electron {
      * `WebContents` when the preferred size changes. Default is `false`.
      */
     enablePreferredSizeMode?: boolean;
-    /**
-     * Whether to enable the WebSQL api. Default is `true`.
-     */
-    enableWebSQL?: boolean;
     /**
      * Enables Chromium's experimental features. Default is `false`.
      */
@@ -21037,7 +21220,9 @@ declare namespace Electron {
      * Resolves with a NativeImage
      *
      * Captures a snapshot of the page within `rect`. Omitting `rect` will capture the
-     * whole visible page.
+     * whole visible page. The image has the page's device scale factor (for offscreen
+     * rendering, `webPreferences.offscreen.deviceScaleFactor`), so `image.getSize()`
+     * is in DIPs and `image.toBitmap()` holds the full-resolution pixels.
      */
     capturePage(rect?: Rectangle): Promise<Electron.NativeImage>;
     /**
@@ -21361,7 +21546,7 @@ declare namespace Electron {
      */
     nodeintegration: boolean;
     /**
-     * A `boolean` for the experimental option for enabling NodeJS support in
+     * A `boolean` for the experimental option for enabling Node.js support in
      * sub-frames such as iframes inside the `webview`. All your preloads will load for
      * every iframe, you can use `process.isMainFrame` to determine if you are in the
      * main frame or not. This option is disabled by default in the guest page.
@@ -21425,10 +21610,9 @@ declare namespace Electron {
      *
      * Security-critical preferences cannot be used to make the guest less secure than
      * its embedder. When the embedder has any of `contextIsolation`, `javascript`,
-     * `nodeIntegration`, `nodeIntegrationInWorker`, `sandbox`,
-     * `nodeIntegrationInSubFrames` or `enableWebSQL` set to its more secure value, the
-     * guest inherits that value and the corresponding `webpreferences` entry is
-     * ignored.
+     * `nodeIntegration`, `nodeIntegrationInWorker`, `sandbox` or
+     * `nodeIntegrationInSubFrames` set to its more secure value, the guest inherits
+     * that value and the corresponding `webpreferences` entry is ignored.
      */
     webpreferences: string;
   }
@@ -21773,7 +21957,7 @@ declare namespace Electron {
      * can potentially include data types not explicitly listed here. (See Chromium's
      * `BrowsingDataRemover` for the full list.)
      */
-    dataTypes?: Array<'backgroundFetch' | 'cache' | 'cookies' | 'downloads' | 'fileSystems' | 'indexedDB' | 'localStorage' | 'serviceWorkers' | 'webSQL'>;
+    dataTypes?: Array<'backgroundFetch' | 'cache' | 'cookies' | 'downloads' | 'fileSystems' | 'indexedDB' | 'localStorage' | 'serviceWorkers'>;
     /**
      * Clear data for only these origins. Cannot be used with `excludeOrigins`.
      */
@@ -24439,6 +24623,13 @@ declare namespace Electron {
   interface RelaunchOptions {
     args?: string[];
     execPath?: string;
+    /**
+     * Start the new instance with the user's normal token instead of the current
+     * elevated one. See `app.canDeElevate()`.
+     *
+     * @platform win32
+     */
+    deElevate?: boolean;
   }
 
   interface RenderProcessGoneEvent extends DOMEvent {
@@ -24871,6 +25062,30 @@ declare namespace Electron {
      * type screen.
      */
     fetchWindowIcons?: boolean;
+    /**
+     * Can be `transient` or `persistent`. How long the source the user picks in the
+     * system picker can be reopened without showing the picker again. `transient`, the
+     * default, lasts at most until the app exits. `persistent` lasts across launches
+     * until the user revokes it; store the returned source's `restoreToken` to use it
+     * on a later launch. See Restoring a source on Wayland.
+     *
+     * @experimental
+     * @platform linux
+     */
+    persistMode?: ('transient' | 'persistent');
+    /**
+     * A `restoreToken` from an earlier call; `persistMode` must be passed with it. If
+     * the system still honors the token, the promise resolves with that source and no
+     * picker is shown. A token that was revoked or names a source that no longer
+     * exists is ignored and the picker is shown as if no token was passed; a value
+     * that is not a token the system issued makes the promise reject. Pass
+     * `persistMode: 'persistent'` with a persistent token every time: restoring it as
+     * `transient` ends the persistent grant.
+     *
+     * @experimental
+     * @platform linux
+     */
+    restoreToken?: string;
   }
 
   interface StartAppShimServerOptions {

package/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "electronVersion": "45.0.0-beta.7",
-  "extractedAt": "2026-10-21T04:15:43.973Z"
+  "electronVersion": "46.0.0-alpha.1",
+  "extractedAt": "2026-10-23T16:14:40.337Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-types",
-  "version": "45.0.0-beta.7",
+  "version": "46.0.0-alpha.1",
   "type": "module",
   "description": "TypeScript type definitions extracted from the electron package",
   "types": "./dist/electron.d.ts",