electron-types 44.8.0 → 44.9.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@44.8.0
+npm install -D electron-types@44.9.1
 # or
-yarn add -D electron-types@44.8.0
+yarn add -D electron-types@44.9.1
 # or
-pnpm add -D electron-types@44.8.0
+pnpm add -D electron-types@44.9.1
 ```
 
 ## Usage

package/dist/electron.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Electron 44.8.0
+// Type definitions for Electron 44.9.1
 // Project: http://electronjs.org/
 // Definitions by: The Electron Team <https://github.com/electron/electron>
 // Definitions: https://github.com/electron/typescript-definitions
@@ -187,6 +187,96 @@ declare namespace Electron {
                                                     * Contains app-specific state stored by the activity.
                                                     */
                                                    userInfo: unknown) => void): this;
+    /**
+     * Emitted when an app shim connects to your app. Shims can only connect after
+     * `app.startAppShimServer()` has been called.
+     *
+     * Any process running as the same user can connect. Verify the shim before
+     * creating windows in it, for example with `shim.satisfiesCodeRequirement()`, and
+     * call `shim.quit()` to reject a shim that you do not trust.
+     *
+     * @experimental
+     * @platform darwin
+     */
+    on(event: 'app-shim-connected', listener: (event: Event,
+                                               shim: AppShimHost) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    off(event: 'app-shim-connected', listener: (event: Event,
+                                               shim: AppShimHost) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    once(event: 'app-shim-connected', listener: (event: Event,
+                                               shim: AppShimHost) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    addListener(event: 'app-shim-connected', listener: (event: Event,
+                                               shim: AppShimHost) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    removeListener(event: 'app-shim-connected', listener: (event: Event,
+                                               shim: AppShimHost) => void): this;
+    /**
+     * Emitted when an app shim was launched but could not connect because your app's
+     * bundle has been replaced by a different version since your app started. A shim
+     * loads the version of Electron that is on disk, which cannot communicate with the
+     * version that is still running.
+     *
+     * The shim quits without showing any UI, so use this event to tell the user what
+     * happened. Shims can connect again after your app restarts.
+     *
+     * @experimental
+     * @platform darwin
+     */
+    on(event: 'app-shim-version-mismatch', listener: (event: Event,
+                                                      /**
+                                                       * The path of the app shim's bundle.
+                                                       */
+                                                      bundlePath: string) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    off(event: 'app-shim-version-mismatch', listener: (event: Event,
+                                                      /**
+                                                       * The path of the app shim's bundle.
+                                                       */
+                                                      bundlePath: string) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    once(event: 'app-shim-version-mismatch', listener: (event: Event,
+                                                      /**
+                                                       * The path of the app shim's bundle.
+                                                       */
+                                                      bundlePath: string) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    addListener(event: 'app-shim-version-mismatch', listener: (event: Event,
+                                                      /**
+                                                       * The path of the app shim's bundle.
+                                                       */
+                                                      bundlePath: string) => void): this;
+    /**
+     * @experimental
+     * @platform darwin
+     */
+    removeListener(event: 'app-shim-version-mismatch', listener: (event: Event,
+                                                      /**
+                                                       * The path of the app shim's bundle.
+                                                       */
+                                                      bundlePath: string) => void): this;
     /**
      * Emitted before the application starts closing its windows. Calling
      * `event.preventDefault()` will prevent the default behavior, which is terminating
@@ -1905,6 +1995,28 @@ declare namespace Electron {
      * @platform mas
      */
     startAccessingSecurityScopedResource(bookmarkData: string): Function;
+    /**
+     * Starts accepting connections from app shims. An `app-shim-connected` event is
+     * emitted for each shim that connects.
+     *
+     * Throws if the server cannot be started, for example because another copy of your
+     * app has already started a server with the same `name`.
+     *
+     * This method can only be called after the app is ready. It is not available in
+     * Mac App Store builds.
+     *
+     * @experimental
+     * @platform darwin
+     */
+    startAppShimServer(options?: StartAppShimServerOptions): void;
+    /**
+     * Stops accepting connections from app shims. Shims that have already connected
+     * stay connected.
+     *
+     * @experimental
+     * @platform darwin
+     */
+    stopAppShimServer(): void;
     /**
      * Updates the current activity if its type matches `type`, merging the entries
      * from `userInfo` into its current `userInfo` dictionary.
@@ -2012,6 +2124,230 @@ declare namespace Electron {
     userAgentFallback: string;
   }
 
+  class AppShimHost extends NodeEventEmitter {
+
+    // Docs: https://electronjs.org/docs/api/app-shim-host
+
+    /**
+     * Emitted when the user clicks the shim's Dock icon, or launches the shim again
+     * while it is already running.
+     *
+     * @experimental
+     */
+    on(event: 'activate', listener: (event: Event,
+                                     hasVisibleWindows: boolean) => void): this;
+    /**
+     * @experimental
+     */
+    off(event: 'activate', listener: (event: Event,
+                                     hasVisibleWindows: boolean) => void): this;
+    /**
+     * @experimental
+     */
+    once(event: 'activate', listener: (event: Event,
+                                     hasVisibleWindows: boolean) => void): this;
+    /**
+     * @experimental
+     */
+    addListener(event: 'activate', listener: (event: Event,
+                                     hasVisibleWindows: boolean) => void): this;
+    /**
+     * @experimental
+     */
+    removeListener(event: 'activate', listener: (event: Event,
+                                     hasVisibleWindows: boolean) => void): this;
+    /**
+     * Emitted when the shim's process has exited or its connection was lost. All
+     * windows that were created in the shim have already been closed.
+     *
+     * @experimental
+     */
+    on(event: 'disconnected', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    off(event: 'disconnected', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    once(event: 'disconnected', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    addListener(event: 'disconnected', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    removeListener(event: 'disconnected', listener: (event: Event) => void): this;
+    /**
+     * Emitted when the user opens a file with the shim.
+     *
+     * @experimental
+     */
+    on(event: 'open-file', listener: (event: Event,
+                                      path: string) => void): this;
+    /**
+     * @experimental
+     */
+    off(event: 'open-file', listener: (event: Event,
+                                      path: string) => void): this;
+    /**
+     * @experimental
+     */
+    once(event: 'open-file', listener: (event: Event,
+                                      path: string) => void): this;
+    /**
+     * @experimental
+     */
+    addListener(event: 'open-file', listener: (event: Event,
+                                      path: string) => void): this;
+    /**
+     * @experimental
+     */
+    removeListener(event: 'open-file', listener: (event: Event,
+                                      path: string) => void): this;
+    /**
+     * Emitted when the user opens a URL with the shim.
+     *
+     * @experimental
+     */
+    on(event: 'open-url', listener: (event: Event,
+                                     url: string) => void): this;
+    /**
+     * @experimental
+     */
+    off(event: 'open-url', listener: (event: Event,
+                                     url: string) => void): this;
+    /**
+     * @experimental
+     */
+    once(event: 'open-url', listener: (event: Event,
+                                     url: string) => void): this;
+    /**
+     * @experimental
+     */
+    addListener(event: 'open-url', listener: (event: Event,
+                                     url: string) => void): this;
+    /**
+     * @experimental
+     */
+    removeListener(event: 'open-url', listener: (event: Event,
+                                     url: string) => void): this;
+    /**
+     * Emitted when the shim is asked to quit: by the user, for example with Cmd+Q or
+     * from its Dock menu, or by macOS at logout.
+     *
+     * By default, the shim quits and its windows are closed without emitting their
+     * `close` events. To keep the shim running, call `event.preventDefault()`. You can
+     * then close its windows yourself and call `shim.quit()` when you are done.
+     *
+     * `event.preventDefault()` must be called synchronously in the listener. If your
+     * app's main process is unresponsive for more than five seconds, the shim quits
+     * without waiting for it.
+     *
+     * @experimental
+     */
+    on(event: 'quit-requested', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    off(event: 'quit-requested', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    once(event: 'quit-requested', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    addListener(event: 'quit-requested', listener: (event: Event) => void): this;
+    /**
+     * @experimental
+     */
+    removeListener(event: 'quit-requested', listener: (event: Event) => void): this;
+    /**
+     * Bounces the shim's Dock icon, in the same way that `dock.bounce()` bounces your
+     * app's.
+     *
+     * @experimental
+     */
+    bounce(type?: 'critical' | 'informational'): void;
+    /**
+     * Cancels a bounce started by `shim.bounce()`.
+     *
+     * @experimental
+     */
+    cancelBounce(): void;
+    /**
+     * Whether the shim's process is still connected.
+     *
+     * @experimental
+     */
+    isConnected(): boolean;
+    /**
+     * Quits the shim's process and closes its windows. The windows do not emit `close`
+     * events. They emit `closed` shortly after this method returns.
+     * `shim.isConnected()` returns `false` as soon as this method returns.
+     *
+     * @experimental
+     */
+    quit(): void;
+    /**
+     * Whether the code signature of the shim's process satisfies `requirement`. The
+     * check is performed on the running process that connected, not on the bundle at
+     * `shim.bundlePath`.
+     *
+     * Throws if `requirement` cannot be parsed.
+     *
+     * @experimental
+     */
+    satisfiesCodeRequirement(requirement: string): boolean;
+    /**
+     * Sets the menu bar that is shown while the shim is the active app. This is the
+     * shim's equivalent of `Menu.setApplicationMenu()`. Passing `null` restores the
+     * shim's minimal default menu.
+     *
+     * The `click` handlers of the menu's items and the menu's `menu-will-show` event
+     * run in your app's main process. Items with a `role` act on the shim instead of
+     * your app: for example, the `quit` role quits the shim. The default labels of the
+     * `about`, `hide` and `quit` roles use the shim's name.
+     *
+     * The shim displays the menu's items as they were when this method was called.
+     * Later changes to an item's `label`, `enabled`, `checked` or `visible` properties
+     * are applied when the shim becomes the active app, when one of its menus is
+     * opened, and after an item is clicked.
+     *
+     * @experimental
+     */
+    setApplicationMenu(menu: (Menu) | (null)): void;
+    /**
+     * Sets the text displayed on the shim's Dock icon. An empty string clears it.
+     *
+     * @experimental
+     */
+    setBadge(text: string): void;
+    /**
+     * A `string` representing the bundle identifier from that bundle's `Info.plist`.
+     * This value is not verified, so do not use it to decide whether to trust the
+     * shim. Use `shim.satisfiesCodeRequirement()` instead.
+     *
+     * @experimental
+     */
+    readonly bundleId: string;
+    /**
+     * A `string` representing the path of the app bundle that the shim's process was
+     * launched from.
+     *
+     * @experimental
+     */
+    readonly bundlePath: string;
+    /**
+     * A `number` representing the process ID of the shim.
+     *
+     * @experimental
+     */
+    readonly pid: number;
+  }
+
   interface AutoUpdater extends NodeJS.EventEmitter {
 
     // Docs: https://electronjs.org/docs/api/auto-updater
@@ -3849,6 +4185,15 @@ declare namespace Electron {
      * `false`. Not supported on Wayland (Linux).
      */
     alwaysOnTop?: boolean;
+    /**
+     * Creates the native window in the process of this app shim, so that it belongs to
+     * the shim's Dock icon and not to your app's. See AppShimHost for what affordances
+     * are granted to the window.
+     *
+     * @experimental
+     * @platform darwin
+     */
+    appShim?: AppShimHost;
     /**
      * Auto hide the menu bar unless the `Alt` key is pressed. Default is `false`.
      *
@@ -24098,6 +24443,16 @@ declare namespace Electron {
     fetchWindowIcons?: boolean;
   }
 
+  interface StartAppShimServerOptions {
+    /**
+     * A name for this server, which lets several running copies of your app each have
+     * their own. It can only contain letters, digits, `.`, `-` and `_`, and must match
+     * the `ElectronAppShimServerName` of the shims that connect to it. Default is
+     * `appshim`.
+     */
+    name?: string;
+  }
+
   interface StartLoggingOptions {
     /**
      * What kinds of data should be captured. By default, only metadata about requests
@@ -25580,6 +25935,7 @@ declare namespace Electron {
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type Source = Electron.Source;
     type SourcesOptions = Electron.SourcesOptions;
+    type StartAppShimServerOptions = Electron.StartAppShimServerOptions;
     type StartLoggingOptions = Electron.StartLoggingOptions;
     type StartTask = Electron.StartTask;
     type Streams = Electron.Streams;
@@ -25755,6 +26111,7 @@ declare namespace Electron {
     type Event<Params extends object = {}> = Electron.Event<Params>;
     const app: App;
     type App = Electron.App;
+    type AppShimHost = Electron.AppShimHost;
     const autoUpdater: AutoUpdater;
     type AutoUpdater = Electron.AutoUpdater;
     class BaseWindow extends Electron.BaseWindow {}
@@ -25997,6 +26354,7 @@ declare namespace Electron {
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type Source = Electron.Source;
     type SourcesOptions = Electron.SourcesOptions;
+    type StartAppShimServerOptions = Electron.StartAppShimServerOptions;
     type StartLoggingOptions = Electron.StartLoggingOptions;
     type StartTask = Electron.StartTask;
     type Streams = Electron.Streams;
@@ -26338,6 +26696,7 @@ declare namespace Electron {
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type Source = Electron.Source;
     type SourcesOptions = Electron.SourcesOptions;
+    type StartAppShimServerOptions = Electron.StartAppShimServerOptions;
     type StartLoggingOptions = Electron.StartLoggingOptions;
     type StartTask = Electron.StartTask;
     type Streams = Electron.Streams;
@@ -26678,6 +27037,7 @@ declare namespace Electron {
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type Source = Electron.Source;
     type SourcesOptions = Electron.SourcesOptions;
+    type StartAppShimServerOptions = Electron.StartAppShimServerOptions;
     type StartLoggingOptions = Electron.StartLoggingOptions;
     type StartTask = Electron.StartTask;
     type Streams = Electron.Streams;
@@ -26853,6 +27213,7 @@ declare namespace Electron {
     type Event<Params extends object = {}> = Electron.Event<Params>;
     const app: App;
     type App = Electron.App;
+    type AppShimHost = Electron.AppShimHost;
     const autoUpdater: AutoUpdater;
     type AutoUpdater = Electron.AutoUpdater;
     class BaseWindow extends Electron.BaseWindow {}
@@ -27114,6 +27475,7 @@ declare namespace Electron {
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type Source = Electron.Source;
     type SourcesOptions = Electron.SourcesOptions;
+    type StartAppShimServerOptions = Electron.StartAppShimServerOptions;
     type StartLoggingOptions = Electron.StartLoggingOptions;
     type StartTask = Electron.StartTask;
     type Streams = Electron.Streams;

package/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "electronVersion": "44.8.0",
-  "extractedAt": "2026-10-16T03:15:35.553Z"
+  "electronVersion": "44.9.1",
+  "extractedAt": "2026-10-20T03:15:26.995Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-types",
-  "version": "44.8.0",
+  "version": "44.9.1",
   "type": "module",
   "description": "TypeScript type definitions extracted from the electron package",
   "types": "./dist/electron.d.ts",