electron-types 44.0.0-beta.6 → 45.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@44.0.0-beta.6
+npm install -D electron-types@45.0.0-alpha.1
 # or
-yarn add -D electron-types@44.0.0-beta.6
+yarn add -D electron-types@45.0.0-alpha.1
 # or
-pnpm add -D electron-types@44.0.0-beta.6
+pnpm add -D electron-types@45.0.0-alpha.1
 ```
 
 ## Usage

package/dist/electron.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Electron 44.0.0-beta.6
+// Type definitions for Electron 45.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
@@ -518,27 +518,27 @@ declare namespace Electron {
      * page.
      */
     on(event: 'login', listener: (event: Event,
-                                  webContents: WebContents,
+                                  webContents: (WebContents) | (null),
                                   authenticationResponseDetails: AuthenticationResponseDetails,
                                   authInfo: AuthInfo,
                                   callback: (username?: string, password?: string) => void) => void): this;
     off(event: 'login', listener: (event: Event,
-                                  webContents: WebContents,
+                                  webContents: (WebContents) | (null),
                                   authenticationResponseDetails: AuthenticationResponseDetails,
                                   authInfo: AuthInfo,
                                   callback: (username?: string, password?: string) => void) => void): this;
     once(event: 'login', listener: (event: Event,
-                                  webContents: WebContents,
+                                  webContents: (WebContents) | (null),
                                   authenticationResponseDetails: AuthenticationResponseDetails,
                                   authInfo: AuthInfo,
                                   callback: (username?: string, password?: string) => void) => void): this;
     addListener(event: 'login', listener: (event: Event,
-                                  webContents: WebContents,
+                                  webContents: (WebContents) | (null),
                                   authenticationResponseDetails: AuthenticationResponseDetails,
                                   authInfo: AuthInfo,
                                   callback: (username?: string, password?: string) => void) => void): this;
     removeListener(event: 'login', listener: (event: Event,
-                                  webContents: WebContents,
+                                  webContents: (WebContents) | (null),
                                   authenticationResponseDetails: AuthenticationResponseDetails,
                                   authInfo: AuthInfo,
                                   callback: (username?: string, password?: string) => void) => void): this;
@@ -815,27 +815,27 @@ declare namespace Electron {
      * event is not emitted.
      */
     on(event: 'select-client-certificate', listener: (event: Event,
-                                                      webContents: WebContents,
+                                                      webContents: (WebContents) | (null),
                                                       url: string,
                                                       certificateList: Certificate[],
                                                       callback: (certificate?: Certificate) => void) => void): this;
     off(event: 'select-client-certificate', listener: (event: Event,
-                                                      webContents: WebContents,
+                                                      webContents: (WebContents) | (null),
                                                       url: string,
                                                       certificateList: Certificate[],
                                                       callback: (certificate?: Certificate) => void) => void): this;
     once(event: 'select-client-certificate', listener: (event: Event,
-                                                      webContents: WebContents,
+                                                      webContents: (WebContents) | (null),
                                                       url: string,
                                                       certificateList: Certificate[],
                                                       callback: (certificate?: Certificate) => void) => void): this;
     addListener(event: 'select-client-certificate', listener: (event: Event,
-                                                      webContents: WebContents,
+                                                      webContents: (WebContents) | (null),
                                                       url: string,
                                                       certificateList: Certificate[],
                                                       callback: (certificate?: Certificate) => void) => void): this;
     removeListener(event: 'select-client-certificate', listener: (event: Event,
-                                                      webContents: WebContents,
+                                                      webContents: (WebContents) | (null),
                                                       url: string,
                                                       certificateList: Certificate[],
                                                       callback: (certificate?: Certificate) => void) => void): this;
@@ -1060,7 +1060,71 @@ declare namespace Electron {
      * generates and persists a per-`session` metadata secret so that credentials
      * created in one partition are not visible to another.
      *
-     * With the matching entitlement in your app's `entitlements.plist`:
+     * When `platformPasskeys` is `true`, passkey operations use Apple's
+     * `ASAuthorizationController` which delegates to the system's configured
+     * Credential Provider Extensions. This enables the same passkey experience as
+     * Safari — credentials are available across all devices signed into the same
+     * account. Unlike Touch ID credentials, platform passkeys are stored by the
+     * credential provider and scoped to the relying party, not to Electron: they are
+     * shared across all `session` partitions and with any other app or browser
+     * associated with the same domain. Platform passkeys cannot serve cross-origin
+     * (iframe) requests; those requests are left to the other available authenticators
+     * (Touch ID supports iframes) and a warning is logged to the DevTools console. The
+     * `prf` and `largeBlob` WebAuthn extensions are not currently supported by this
+     * authenticator — `prf` inputs are ignored, and a `create()` call with `largeBlob:
+     * { support: 'required' }` fails.
+     *
+     * With the matching entitlements in your app's `entitlements.plist`:
+     *
+     * For platform passkeys, your app needs the Associated Domains entitlement plus an
+     * application identifier, both in the same `entitlements.plist`:
+     *
+     * Listing these entitlements is **not** sufficient on its own — unlike most
+     * entitlements, `com.apple.developer.associated-domains` is _provisioning-profile
+     * backed_. For platform passkeys to work, **all** of the following must hold:
+     *
+     * * In the Apple Developer portal, your App ID (`com.example.app`) has the
+     * **Associated Domains** capability enabled, and you have created a provisioning
+     * profile for that App ID.
+     * * That provisioning profile is **embedded in the built app bundle** at
+     * `Contents/embedded.provisionprofile`. This is what authorizes the
+     * associated-domains entitlement at runtime; without an embedded profile macOS
+     * silently ignores the `webcredentials` association and the request fails. (Xcode
+     * and `@electron/osx-sign` embed the profile for you; if you sign manually, copy
+     * it into the bundle before signing.)
+     * * The app is signed (ad-hoc / unsigned builds do not qualify). Both distribution
+     * and development signing work — for development builds, use the developer-mode
+     * path described below.
+     * * `com.apple.application-identifier` matches the profile's App ID. Without it,
+     * `ASAuthorizationController` fails with "The calling process does not have an
+     * application identifier" — this is `ASAuthorizationError` code 1004.
+     * * The relying party's domain (`example.com` above) serves a valid
+     * `apple-app-site-association` file over HTTPS at
+     * `/.well-known/apple-app-site-association` containing a `webcredentials` entry
+     * whose `apps` array lists this app's `<TEAM_ID>.<BUNDLE_ID>`.
+     * * The relying party ID of each request matches that associated domain.
+     *
+     * If these aren't satisfied, `ASAuthorizationController` fails before it can
+     * present the passkey sheet. The request surfaces to the page as a bare
+     * `NotAllowedError` with no further detail (Electron logs an explanatory message
+     * to the DevTools console on this path). Because the association is domain-based,
+     * platform passkeys always require a real associated domain and its AASA file —
+     * there is no `localhost` rpId escape hatch as there is in browsers.
+     *
+     * To test against your domain with a development-signed build (before shipping a
+     * distribution profile), append `?mode=developer` to the entitlement value and
+     * enable developer mode on the machine with `swcutil developer-mode -e true`. This
+     * makes macOS fetch the AASA directly from the domain — bypassing Apple's CDN
+     * cache — and honor the association for a development-signed app. You still need
+     * the embedded development provisioning profile described above:
+     *
+     * > [!NOTE] Because the request is fulfilled by the system credential provider
+     * (not a browser), the `clientDataJSON` returned to the page reports `origin:
+     * "https://<rpId>"` — the associated domain — rather than the page's own origin.
+     * Relying-party servers that enforce a strict `expectedOrigin` allowlist must
+     * include `https://<rpId>` for verification to succeed. This also means the
+     * relying party cannot distinguish which subdomain of the associated domain
+     * initiated the ceremony.
      *
      * > [!NOTE] Touch ID WebAuthn credentials are device-bound and are not synced via
      * iCloud Keychain. They are only available on Macs with a Secure Enclave (Apple
@@ -9452,12 +9516,184 @@ declare namespace Electron {
     type: ('rawKeyDown' | 'keyDown' | 'keyUp' | 'char');
   }
 
+  interface LanguageModelAppendOptions {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-append-options
+
+    signal: AbortSignal;
+  }
+
+  interface LanguageModelCloneOptions {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-clone-options
+
+    signal: AbortSignal;
+  }
+
+  interface LanguageModelCreateCoreOptions {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-create-core-options
+
+    expectedInputs?: LanguageModelExpected[];
+    expectedOutputs?: LanguageModelExpected[];
+  }
+
+  interface LanguageModelCreateOptions extends LanguageModelCreateCoreOptions {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-create-options
+
+    initialPrompts?: LanguageModelMessage[];
+    signal: AbortSignal;
+  }
+
+  interface LanguageModelExpected {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-expected
+
+    languages?: string[];
+    /**
+     * Can be one of the following values:
+     */
+    type: ('text' | 'image' | 'audio');
+  }
+
+  interface LanguageModelMessage {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-message
+
+    content: LanguageModelMessageContent[];
+    prefix?: boolean;
+    /**
+     * Can be one of the following values:
+     */
+    role: ('system' | 'user' | 'assistant');
+  }
+
+  interface LanguageModelMessageContent {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-message-content
+
+    /**
+     * Can be one of the following values:
+     */
+    type: ('text' | 'image' | 'audio');
+    value: (ArrayBuffer) | (string);
+  }
+
+  interface LanguageModelPromptOptions {
+
+    // Docs: https://electronjs.org/docs/api/structures/language-model-prompt-options
+
+    /**
+     * a JSON schema object or a `RegExp` used to constrain the response to match the
+     * specified restraints.
+     */
+    responseConstraint?: (ResponseConstraint) | (RegExp);
+    signal: AbortSignal;
+  }
+
+  class LanguageModelUtility {
+
+    // Docs: https://electronjs.org/docs/api/language-model-utility
+
+    /**
+     * LanguageModelUtility
+     */
+    constructor(initialState: InitialState);
+    /**
+     * Determines the availability of the language model and returns one of the
+     * following strings:
+     *
+     * * `available`
+     * * `downloadable`
+     * * `downloading`
+     * * `unavailable`
+     *
+     * @experimental
+     */
+    static availability(options?: LanguageModelCreateCoreOptions): Promise<string>;
+    /**
+     * Creates a new `LanguageModelUtility` with the provided `options`.
+     *
+     * @experimental
+     */
+    static create(options: LanguageModelCreateOptions): Promise<Electron.LanguageModelUtility>;
+    /**
+     * Append a message without prompting for a response.
+     *
+     * @experimental
+     */
+    append(input: LanguageModelMessage[], options: LanguageModelAppendOptions): Promise<undefined>;
+    /**
+     * Clones the `LanguageModelUtility` such that the context and initial prompt
+     * should be preserved.
+     *
+     * @experimental
+     */
+    clone(options: LanguageModelCloneOptions): Promise<Electron.LanguageModelUtility>;
+    /**
+     * Destroys the model, and any ongoing executions are aborted.
+     *
+     * @experimental
+     */
+    destroy(): void;
+    /**
+     * Measure how many tokens the input would use.
+     *
+     * @experimental
+     */
+    measureContextUsage(input: LanguageModelMessage[], options: LanguageModelPromptOptions): Promise<number>;
+    /**
+     * Prompt the model for a response.
+     *
+     * @experimental
+     */
+    prompt(input: LanguageModelMessage[], options: LanguageModelPromptOptions): (Promise<string>) | (Promise<import('stream/web').ReadableStream<string>>);
+    /**
+     * A `number` representing how many tokens are currently in the context window.
+     *
+     * @experimental
+     */
+    contextUsage: number;
+    /**
+     * A `number` representing the size of the context window, in tokens.
+     *
+     * @experimental
+     */
+    contextWindow: number;
+  }
+
+  interface LocalAIHandler {
+
+    // Docs: https://electronjs.org/docs/api/local-ai-handler
+
+    /**
+     * Sets the handler for new Prompt API binding requests from the renderer process.
+     * This happens once per pair of `webContentsId` and `securityOrigin`. Returning
+     * `null` from the handler will reject the creation of a new Prompt API session in
+     * the renderer. If you want to invalidate existing Prompt API sessions, clear the
+     * local AI handler for the session using `ses.registerLocalAIHandler(null)`.
+     *
+     * > [!NOTE] If a renderer calls the Prompt API before `setPromptAPIHandler()` has
+     * been called, the request is queued. Once the handler is set, all queued requests
+     * are flushed. If too many requests are queued, the oldest pending request is
+     * dropped and pending promises in the renderer will be rejected. To avoid this, be
+     * sure to call `setPromptAPIHandler()` as early as possible.
+     *
+     * @experimental
+     */
+    setPromptAPIHandler(promptAPIHandler: (details: PromptAPIHandlerDetails) => (typeof LanguageModelUtility) | (null)): void;
+  }
+
   interface MediaAccessPermissionRequest extends PermissionRequest {
 
     // Docs: https://electronjs.org/docs/api/structures/media-access-permission-request
 
     /**
      * The types of media access being requested - elements can be `video` or `audio`.
+     * For a `media` permission request these are the camera and microphone
+     * respectively; for a `display-capture` permission request they are the screen,
+     * window or tab video and its audio.
      */
     mediaTypes?: Array<'video' | 'audio'>;
     /**
@@ -9618,6 +9854,15 @@ declare namespace Electron {
      * @platform darwin
      */
     accessibilityLabel: string;
+    /**
+     * A `MenuItemBadge` (optional) indicating the badge for the menu item.
+     *
+     * This property can be dynamically changed; setting it to `undefined` removes the
+     * badge. Only available on macOS 14 and up.
+     *
+     * @platform darwin
+     */
+    badge?: MenuItemBadge;
     /**
      * A `boolean` indicating whether the item is checked.
      *
@@ -9678,6 +9923,8 @@ declare namespace Electron {
      * or just displayed.
      *
      * This property can be dynamically changed.
+     *
+     * @platform linux,win32
      */
     registerAccelerator: boolean;
     /**
@@ -9743,6 +9990,27 @@ declare namespace Electron {
     visible: boolean;
   }
 
+  interface MenuItemBadge {
+
+    // Docs: https://electronjs.org/docs/api/structures/menu-item-badge
+
+    /**
+     * A custom string to display in the badge. Required for, and only usable with, the
+     * `none` type.
+     */
+    content?: string;
+    /**
+     * The number of items the badge displays. Required for the `alerts`, `updates` and
+     * `new-items` types; cannot be used with `none`.
+     */
+    count?: number;
+    /**
+     * Can be `alerts`, `updates`, `new-items` or `none`. Default is `none`. See
+     * Creating badges of a specific type for further explanation of these types.
+     */
+    type?: ('alerts' | 'updates' | 'new-items' | 'none');
+  }
+
   class MessageChannelMain {
 
     // Docs: https://electronjs.org/docs/api/message-channel-main
@@ -12702,11 +12970,18 @@ declare namespace Electron {
      * discoverable WebAuthn credentials and the user must choose one. `callback`
      * should be called with the `credentialId` of the selected account; passing no
      * arguments — or a `credentialId` that does not match one of the provided accounts
-     * — will cancel the request and the page will receive a `NotAllowedError`. If no
-     * listener is registered for this event, the request is cancelled with the same
-     * error. The credential request remains pending until the listener invokes the
-     * callback, so always invoke it exactly once — typically from a `try { … } finally
-     * { callback(…) }` block.
+     * — will cancel the request and the page will receive a `NotAllowedError`. The
+     * credential request remains pending until the listener invokes the callback, so
+     * always invoke it exactly once — typically from a `try { … } finally {
+     * callback(…) }` block.
+     *
+     * > [!NOTE] If no listener is registered for this event,
+     * `navigator.credentials.get()` calls that resolve discoverable Touch ID
+     * credentials are cancelled with a `NotAllowedError` — even when only a single
+     * credential matches. Register a listener if your app supports
+     * discoverable-credential (passkey) sign-in. Assertions fulfilled by
+     * `platformPasskeys` select the account in the system sheet and do not use this
+     * event.
      *
      * On macOS, the Touch ID platform authenticator surfaces accounts via this event
      * once it has been configured with `app.configureWebAuthn`. The event may also
@@ -12728,6 +13003,43 @@ declare namespace Electron {
     removeListener(event: 'select-webauthn-account', listener: (event: Event,
                                                     details: SelectWebauthnAccountDetails,
                                                     callback: (credentialId?: (string) | (null)) => void) => void): this;
+    /**
+     * Emitted when both `touchID` and `platformPasskeys` are configured via
+     * `app.configureWebAuthn` and a WebAuthn request needs to choose which platform
+     * authenticator to use. `callback` should be called with one of the names from
+     * `event.authenticators`; passing no arguments or a name that does not match will
+     * cancel the request and the page will receive a `NotAllowedError`. The request
+     * remains pending until the listener invokes the callback, so always invoke it
+     * exactly once — typically from a `try { … } finally { callback(…) }` block. If no
+     * listener is registered, `platformPasskeys` is used by default; a listener that
+     * throws before invoking the callback is treated as unhandled and the default
+     * applies. If only one authenticator is available for the request, this event is
+     * not emitted and that authenticator is used automatically.
+     *
+     * @platform darwin
+     */
+    on(event: 'select-webauthn-authenticator', listener: (event: Event<SessionSelectWebauthnAuthenticatorEventParams>,
+                                                          callback: (authenticatorName?: (string) | (null)) => void) => void): this;
+    /**
+     * @platform darwin
+     */
+    off(event: 'select-webauthn-authenticator', listener: (event: Event<SessionSelectWebauthnAuthenticatorEventParams>,
+                                                          callback: (authenticatorName?: (string) | (null)) => void) => void): this;
+    /**
+     * @platform darwin
+     */
+    once(event: 'select-webauthn-authenticator', listener: (event: Event<SessionSelectWebauthnAuthenticatorEventParams>,
+                                                          callback: (authenticatorName?: (string) | (null)) => void) => void): this;
+    /**
+     * @platform darwin
+     */
+    addListener(event: 'select-webauthn-authenticator', listener: (event: Event<SessionSelectWebauthnAuthenticatorEventParams>,
+                                                          callback: (authenticatorName?: (string) | (null)) => void) => void): this;
+    /**
+     * @platform darwin
+     */
+    removeListener(event: 'select-webauthn-authenticator', listener: (event: Event<SessionSelectWebauthnAuthenticatorEventParams>,
+                                                          callback: (authenticatorName?: (string) | (null)) => void) => void): this;
     /**
      * Emitted after `navigator.serial.requestPort` has been called and
      * `select-serial-port` has fired if a new serial port becomes available before the
@@ -13253,6 +13565,14 @@ declare namespace Electron {
      * Preconnects the given number of sockets to an origin.
      */
     preconnect(options: PreconnectOptions): void;
+    /**
+     * Registers a local AI handler `UtilityProcess`. To clear the handler, call
+     * `registerLocalAIHandler(null)`, which will disconnect any existing Prompt API
+     * sessions and destroy any `LanguageModelUtility` instances.
+     *
+     * @experimental
+     */
+    registerLocalAIHandler(handler: (UtilityProcess) | (null)): void;
     /**
      * 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
@@ -13373,7 +13693,7 @@ declare namespace Electron {
      * > [!NOTE] `isMainFrame` will always be `false` for a `fileSystem` request as a
      * result of Chromium limitations.
      */
-    setPermissionCheckHandler(handler: ((webContents: (WebContents) | (null), permission: 'clipboard-read' | 'clipboard-sanitized-write' | 'geolocation' | 'fullscreen' | 'hid' | 'idle-detection' | 'media' | 'mediaKeySystem' | 'midi' | 'midiSysex' | 'notifications' | 'openExternal' | 'pointerLock' | 'serial' | 'storage-access' | 'top-level-storage-access' | 'usb' | 'deprecated-sync-clipboard-read' | 'fileSystem', requestingOrigin: string, details: PermissionCheckHandlerHandlerDetails) => boolean) | (null)): void;
+    setPermissionCheckHandler(handler: ((webContents: (WebContents) | (null), permission: 'ar' | 'automatic-fullscreen' | 'background-fetch' | 'background-sync' | 'captured-surface-control' | 'clipboard-read' | 'clipboard-sanitized-write' | 'deprecated-sync-clipboard-read' | 'display-capture' | 'fileSystem' | 'fullscreen' | 'geolocation' | 'geolocation-approximate' | 'hand-tracking' | 'hid' | 'idle-detection' | 'keyboardLock' | 'local-fonts' | 'local-network' | 'local-network-access' | 'loopback-network' | 'media' | 'mediaKeySystem' | 'midi' | 'midiSysex' | 'nfc' | 'notifications' | 'openExternal' | 'payment-handler' | 'periodic-background-sync' | 'persistent-storage' | 'pointerLock' | 'screen-wake-lock' | 'sensors' | 'serial' | 'smart-card' | 'speaker-selection' | 'storage-access' | 'system-wake-lock' | 'top-level-storage-access' | 'usb' | 'vr' | 'web-app-installation' | 'web-printing' | 'window-management' | 'unknown', requestingOrigin: string, details: PermissionCheckHandlerHandlerDetails) => boolean) | (null)): void;
     /**
      * Sets the handler which can be used to respond to permission requests for the
      * `session`. Calling `callback(true)` will allow the permission and
@@ -13381,8 +13701,16 @@ declare namespace Electron {
      * `setPermissionRequestHandler(null)`.  Please note that you must also implement
      * `setPermissionCheckHandler` to get complete permission handling. Most web APIs
      * do a permission check and then make a permission request if the check is denied.
+     *
+     * Both `media` and `display-capture` requests carry a MediaAccessPermissionRequest
+     * as `details`. A `media` request is for camera and/or microphone devices, while a
+     * `display-capture` request is for the screen, a window or a tab (whether made
+     * through `getDisplayMedia` or through `getUserMedia` with `chromeMediaSource`
+     * constraints). Applications that allow camera and microphone access but want to
+     * control screen sharing separately should handle the two permissions
+     * individually:
      */
-    setPermissionRequestHandler(handler: ((webContents: WebContents, permission: 'clipboard-read' | 'clipboard-sanitized-write' | 'display-capture' | 'fullscreen' | 'geolocation' | 'idle-detection' | 'media' | 'mediaKeySystem' | 'midi' | 'midiSysex' | 'notifications' | 'pointerLock' | 'keyboardLock' | 'openExternal' | 'speaker-selection' | 'storage-access' | 'top-level-storage-access' | 'window-management' | 'unknown' | 'fileSystem', callback: (permissionGranted: boolean) => void, details: (PermissionRequest) | (FilesystemPermissionRequest) | (MediaAccessPermissionRequest) | (OpenExternalPermissionRequest)) => void) | (null)): void;
+    setPermissionRequestHandler(handler: ((webContents: WebContents, permission: 'ar' | 'automatic-fullscreen' | 'background-fetch' | 'background-sync' | 'captured-surface-control' | 'clipboard-read' | 'clipboard-sanitized-write' | 'deprecated-sync-clipboard-read' | 'display-capture' | 'fileSystem' | 'fullscreen' | 'geolocation' | 'geolocation-approximate' | 'hand-tracking' | 'hid' | 'idle-detection' | 'keyboardLock' | 'local-fonts' | 'local-network' | 'local-network-access' | 'loopback-network' | 'media' | 'mediaKeySystem' | 'midi' | 'midiSysex' | 'nfc' | 'notifications' | 'openExternal' | 'payment-handler' | 'periodic-background-sync' | 'persistent-storage' | 'pointerLock' | 'screen-wake-lock' | 'sensors' | 'serial' | 'smart-card' | 'speaker-selection' | 'storage-access' | 'system-wake-lock' | 'top-level-storage-access' | 'usb' | 'vr' | 'web-app-installation' | 'web-printing' | 'window-management' | 'unknown', callback: (permissionGranted: boolean) => void, details: (PermissionRequest) | (FilesystemPermissionRequest) | (MediaAccessPermissionRequest) | (OpenExternalPermissionRequest)) => void) | (null)): void;
     /**
      * Adds scripts that will be executed on ALL web contents that are associated with
      * this session just before normal `preload` scripts run.
@@ -18271,6 +18599,10 @@ declare namespace Electron {
      * greater than 0.
      */
     isBeingCaptured(): boolean;
+    /**
+     * Whether caret browsing is enabled for this page.
+     */
+    isCaretBrowsingEnabled(): boolean;
     /**
      * Whether the renderer process has crashed.
      */
@@ -18506,6 +18838,10 @@ declare namespace Electron {
      * when the page becomes backgrounded. This also affects the Page Visibility API.
      */
     setBackgroundThrottling(allowed: boolean): void;
+    /**
+     * Sets whether caret browsing is enabled on the current web page.
+     */
+    setCaretBrowsingEnabled(enabled: boolean): void;
     /**
      * Changes the title of the DevTools window to `title`. This will only be visible
      * if DevTools is opened in `undocked` or `detach` mode.
@@ -18673,6 +19009,25 @@ declare namespace Electron {
      * affects the Page Visibility API.
      */
     backgroundThrottling: boolean;
+    /**
+     * A `boolean` property that determines whether caret browsing is enabled for this
+     * page.
+     *
+     * When enabled, a movable cursor is placed in the page's text, allowing the user
+     * to navigate and select content with the keyboard. Changes apply to the live page
+     * without reloading it.
+     *
+     * A `<webview>` guest inherits this value from its embedder when it is created and
+     * then tracks it independently, so disabling caret browsing on the embedder leaves
+     * an existing guest enabled.
+     *
+     * While any `WebContents` in the process has caret browsing enabled, assistive
+     * technology is notified process-wide that caret browsing is active, so that
+     * screen readers report the caret's position as it moves. That notification is
+     * only withdrawn once every `WebContents` that enabled caret browsing has either
+     * disabled it or been destroyed.
+     */
+    caretBrowsingEnabled: boolean;
     /**
      * A `Debugger` instance for this webContents.
      *
@@ -18816,10 +19171,39 @@ declare namespace Electron {
     readonly webContents: WebContents;
   }
 
-  interface WebFrame {
+  interface WebFrame extends NodeJS.EventEmitter {
 
     // Docs: https://electronjs.org/docs/api/web-frame
 
+    /**
+     * Emitted when a new isolated world is created for `webFrame`. This event does not
+     * fire for the main world (ID `0`) or Electron's preload world (ID `999`).
+     */
+    on(event: 'isolated-world-created', listener: (
+                                                   /**
+                                                    * The ID of the isolated world that was just created.
+                                                    */
+                                                   worldId: number) => void): this;
+    off(event: 'isolated-world-created', listener: (
+                                                   /**
+                                                    * The ID of the isolated world that was just created.
+                                                    */
+                                                   worldId: number) => void): this;
+    once(event: 'isolated-world-created', listener: (
+                                                   /**
+                                                    * The ID of the isolated world that was just created.
+                                                    */
+                                                   worldId: number) => void): this;
+    addListener(event: 'isolated-world-created', listener: (
+                                                   /**
+                                                    * The ID of the isolated world that was just created.
+                                                    */
+                                                   worldId: number) => void): this;
+    removeListener(event: 'isolated-world-created', listener: (
+                                                   /**
+                                                    * The ID of the isolated world that was just created.
+                                                    */
+                                                   worldId: number) => void): this;
     /**
      * Attempts to free memory that is no longer being used (like images from a
      * previous navigation).
@@ -18876,6 +19260,15 @@ declare namespace Electron {
      * current renderer process.
      */
     getFrameForSelector(selector: string): (WebFrame) | (null);
+    /**
+     * The IDs of isolated worlds that currently exist for this frame. This does not
+     * include the main world (ID `0`) or Electron's preload world (ID `999`).
+     *
+     * This can be used to discover existing isolated worlds before calling APIs such
+     * as `webFrame.executeJavaScriptInIsolatedWorld(...)` or
+     * `contextBridge.exposeInIsolatedWorld(...)`.
+     */
+    getIsolatedWorlds(): number[];
     /**
      * * `images` MemoryUsageDetails
      * * `scripts` MemoryUsageDetails
@@ -19334,6 +19727,10 @@ declare namespace Electron {
      * Default is `false`.
      */
     disableHtmlFullscreenWindowResize?: boolean;
+    /**
+     * Whether to disable the wake locks of the WebContents. Default is `false`.
+     */
+    disableWakeLocks?: boolean;
     /**
      * A list of feature strings separated by `,`, like `CSSVariables,KeyboardEventKey`
      * to enable. The full list of supported feature strings can be found in the
@@ -21099,6 +21496,14 @@ declare namespace Electron {
      * Authentication requests.
      */
     touchID?: TouchId;
+    /**
+     * Enables passkeys via Apple's `ASAuthorizationController`. When enabled, passkey
+     * operations present the system credential provider sheet (iCloud Keychain,
+     * 1Password, Bitwarden, etc.) and credentials sync across the user's devices.
+     * Defaults to `false`. Passing `null`/`undefined` (or omitting the key) leaves the
+     * previous setting unchanged.
+     */
+    platformPasskeys?: boolean;
   }
 
   interface ConsoleMessageEvent extends DOMEvent {
@@ -22065,6 +22470,11 @@ declare namespace Electron {
     name?: string;
   }
 
+  interface InitialState {
+    contextUsage: number;
+    contextWindow: number;
+  }
+
   interface Input {
     /**
      * Either `keyUp` or `keyDown`.
@@ -22376,6 +22786,13 @@ declare namespace Electron {
      * containing group after the containing group of the item with the specified id.
      */
     afterGroupContaining?: string[];
+    /**
+     * A badge shown alongside the label, either a system-styled count (`alerts`,
+     * `updates`, `new-items`) or a custom string. Only available on macOS 14 and up.
+     *
+     * @platform darwin
+     */
+    badge?: MenuItemBadge;
   }
 
   interface MessageBoxOptions {
@@ -23309,6 +23726,25 @@ declare namespace Electron {
     mode: ('none' | 'normal' | 'indeterminate' | 'error' | 'paused');
   }
 
+  interface PromptAPIHandlerDetails {
+    /**
+     * The unique id of the WebContents calling the Prompt API.
+     */
+    webContentsId: number;
+    /**
+     * Origin of the page calling the Prompt API.
+     */
+    securityOrigin: string;
+    /**
+     * The frame token of the frame calling the Prompt API.
+     */
+    frameToken: string;
+    /**
+     * The process id of the renderer process hosting the frame calling the Prompt API.
+     */
+    renderProcessId: number;
+  }
+
   interface Provider {
     spellCheck: (words: string[], callback: (misspeltWords: string[]) => void) => void;
   }
@@ -23439,6 +23875,9 @@ declare namespace Electron {
     pin?: (string) | (null);
   }
 
+  interface ResponseConstraint {
+  }
+
   interface RestoreOptions {
     /**
      * Result of a prior `getAllEntries()` call
@@ -23650,6 +24089,23 @@ declare namespace Electron {
     runningStatus: ('starting' | 'running' | 'stopping' | 'stopped');
   }
 
+  interface SessionSelectWebauthnAuthenticatorEventParams {
+    /**
+     * The relying party identifier from the WebAuthn request.
+     */
+    relyingPartyId: string;
+    /**
+     * The available authenticator names. Possible values are `'touchID'` and
+     * `'platformPasskeys'`.
+     */
+    authenticators: string[];
+    /**
+     * The frame initiating this event. May be `null` if accessed after the frame has
+     * either navigated or been destroyed.
+     */
+    frame: (WebFrameMain) | (null);
+  }
+
   interface Settings {
     /**
      * `true` to open the app at login, `false` to remove the app as a login item.
@@ -25136,6 +25592,7 @@ declare namespace Electron {
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type ImportSharedTextureOptions = Electron.ImportSharedTextureOptions;
     type Info = Electron.Info;
+    type InitialState = Electron.InitialState;
     type Input = Electron.Input;
     type InsertCSSOptions = Electron.InsertCSSOptions;
     type IpcMessageEvent = Electron.IpcMessageEvent;
@@ -25186,6 +25643,7 @@ declare namespace Electron {
     type PreconnectOptions = Electron.PreconnectOptions;
     type Privileges = Electron.Privileges;
     type ProgressBarOptions = Electron.ProgressBarOptions;
+    type PromptAPIHandlerDetails = Electron.PromptAPIHandlerDetails;
     type Provider = Electron.Provider;
     type PurchaseProductOpts = Electron.PurchaseProductOpts;
     type ReceivedSharedTextureData = Electron.ReceivedSharedTextureData;
@@ -25197,6 +25655,7 @@ declare namespace Electron {
     type ResolveHostOptions = Electron.ResolveHostOptions;
     type ResourceUsage = Electron.ResourceUsage;
     type Response = Electron.Response;
+    type ResponseConstraint = Electron.ResponseConstraint;
     type RestoreOptions = Electron.RestoreOptions;
     type Result = Electron.Result;
     type SaveDialogOptions = Electron.SaveDialogOptions;
@@ -25208,6 +25667,7 @@ declare namespace Electron {
     type SendSharedTextureOptions = Electron.SendSharedTextureOptions;
     type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type ServiceWorkersRunningStatusChangedEventParams = Electron.ServiceWorkersRunningStatusChangedEventParams;
+    type SessionSelectWebauthnAuthenticatorEventParams = Electron.SessionSelectWebauthnAuthenticatorEventParams;
     type Settings = Electron.Settings;
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type SourcesOptions = Electron.SourcesOptions;
@@ -25308,9 +25768,18 @@ declare namespace Electron {
     type JumpListItem = Electron.JumpListItem;
     type KeyboardEvent = Electron.KeyboardEvent;
     type KeyboardInputEvent = Electron.KeyboardInputEvent;
+    type LanguageModelAppendOptions = Electron.LanguageModelAppendOptions;
+    type LanguageModelCloneOptions = Electron.LanguageModelCloneOptions;
+    type LanguageModelCreateCoreOptions = Electron.LanguageModelCreateCoreOptions;
+    type LanguageModelCreateOptions = Electron.LanguageModelCreateOptions;
+    type LanguageModelExpected = Electron.LanguageModelExpected;
+    type LanguageModelMessage = Electron.LanguageModelMessage;
+    type LanguageModelMessageContent = Electron.LanguageModelMessageContent;
+    type LanguageModelPromptOptions = Electron.LanguageModelPromptOptions;
     type MediaAccessPermissionRequest = Electron.MediaAccessPermissionRequest;
     type MemoryInfo = Electron.MemoryInfo;
     type MemoryUsageDetails = Electron.MemoryUsageDetails;
+    type MenuItemBadge = Electron.MenuItemBadge;
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
@@ -25548,6 +26017,7 @@ declare namespace Electron {
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type ImportSharedTextureOptions = Electron.ImportSharedTextureOptions;
     type Info = Electron.Info;
+    type InitialState = Electron.InitialState;
     type Input = Electron.Input;
     type InsertCSSOptions = Electron.InsertCSSOptions;
     type IpcMessageEvent = Electron.IpcMessageEvent;
@@ -25598,6 +26068,7 @@ declare namespace Electron {
     type PreconnectOptions = Electron.PreconnectOptions;
     type Privileges = Electron.Privileges;
     type ProgressBarOptions = Electron.ProgressBarOptions;
+    type PromptAPIHandlerDetails = Electron.PromptAPIHandlerDetails;
     type Provider = Electron.Provider;
     type PurchaseProductOpts = Electron.PurchaseProductOpts;
     type ReceivedSharedTextureData = Electron.ReceivedSharedTextureData;
@@ -25609,6 +26080,7 @@ declare namespace Electron {
     type ResolveHostOptions = Electron.ResolveHostOptions;
     type ResourceUsage = Electron.ResourceUsage;
     type Response = Electron.Response;
+    type ResponseConstraint = Electron.ResponseConstraint;
     type RestoreOptions = Electron.RestoreOptions;
     type Result = Electron.Result;
     type SaveDialogOptions = Electron.SaveDialogOptions;
@@ -25620,6 +26092,7 @@ declare namespace Electron {
     type SendSharedTextureOptions = Electron.SendSharedTextureOptions;
     type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type ServiceWorkersRunningStatusChangedEventParams = Electron.ServiceWorkersRunningStatusChangedEventParams;
+    type SessionSelectWebauthnAuthenticatorEventParams = Electron.SessionSelectWebauthnAuthenticatorEventParams;
     type Settings = Electron.Settings;
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type SourcesOptions = Electron.SourcesOptions;
@@ -25720,9 +26193,18 @@ declare namespace Electron {
     type JumpListItem = Electron.JumpListItem;
     type KeyboardEvent = Electron.KeyboardEvent;
     type KeyboardInputEvent = Electron.KeyboardInputEvent;
+    type LanguageModelAppendOptions = Electron.LanguageModelAppendOptions;
+    type LanguageModelCloneOptions = Electron.LanguageModelCloneOptions;
+    type LanguageModelCreateCoreOptions = Electron.LanguageModelCreateCoreOptions;
+    type LanguageModelCreateOptions = Electron.LanguageModelCreateOptions;
+    type LanguageModelExpected = Electron.LanguageModelExpected;
+    type LanguageModelMessage = Electron.LanguageModelMessage;
+    type LanguageModelMessageContent = Electron.LanguageModelMessageContent;
+    type LanguageModelPromptOptions = Electron.LanguageModelPromptOptions;
     type MediaAccessPermissionRequest = Electron.MediaAccessPermissionRequest;
     type MemoryInfo = Electron.MemoryInfo;
     type MemoryUsageDetails = Electron.MemoryUsageDetails;
+    type MenuItemBadge = Electron.MenuItemBadge;
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
@@ -25884,6 +26366,7 @@ declare namespace Electron {
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type ImportSharedTextureOptions = Electron.ImportSharedTextureOptions;
     type Info = Electron.Info;
+    type InitialState = Electron.InitialState;
     type Input = Electron.Input;
     type InsertCSSOptions = Electron.InsertCSSOptions;
     type IpcMessageEvent = Electron.IpcMessageEvent;
@@ -25934,6 +26417,7 @@ declare namespace Electron {
     type PreconnectOptions = Electron.PreconnectOptions;
     type Privileges = Electron.Privileges;
     type ProgressBarOptions = Electron.ProgressBarOptions;
+    type PromptAPIHandlerDetails = Electron.PromptAPIHandlerDetails;
     type Provider = Electron.Provider;
     type PurchaseProductOpts = Electron.PurchaseProductOpts;
     type ReceivedSharedTextureData = Electron.ReceivedSharedTextureData;
@@ -25945,6 +26429,7 @@ declare namespace Electron {
     type ResolveHostOptions = Electron.ResolveHostOptions;
     type ResourceUsage = Electron.ResourceUsage;
     type Response = Electron.Response;
+    type ResponseConstraint = Electron.ResponseConstraint;
     type RestoreOptions = Electron.RestoreOptions;
     type Result = Electron.Result;
     type SaveDialogOptions = Electron.SaveDialogOptions;
@@ -25956,6 +26441,7 @@ declare namespace Electron {
     type SendSharedTextureOptions = Electron.SendSharedTextureOptions;
     type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type ServiceWorkersRunningStatusChangedEventParams = Electron.ServiceWorkersRunningStatusChangedEventParams;
+    type SessionSelectWebauthnAuthenticatorEventParams = Electron.SessionSelectWebauthnAuthenticatorEventParams;
     type Settings = Electron.Settings;
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type SourcesOptions = Electron.SourcesOptions;
@@ -26056,9 +26542,18 @@ declare namespace Electron {
     type JumpListItem = Electron.JumpListItem;
     type KeyboardEvent = Electron.KeyboardEvent;
     type KeyboardInputEvent = Electron.KeyboardInputEvent;
+    type LanguageModelAppendOptions = Electron.LanguageModelAppendOptions;
+    type LanguageModelCloneOptions = Electron.LanguageModelCloneOptions;
+    type LanguageModelCreateCoreOptions = Electron.LanguageModelCreateCoreOptions;
+    type LanguageModelCreateOptions = Electron.LanguageModelCreateOptions;
+    type LanguageModelExpected = Electron.LanguageModelExpected;
+    type LanguageModelMessage = Electron.LanguageModelMessage;
+    type LanguageModelMessageContent = Electron.LanguageModelMessageContent;
+    type LanguageModelPromptOptions = Electron.LanguageModelPromptOptions;
     type MediaAccessPermissionRequest = Electron.MediaAccessPermissionRequest;
     type MemoryInfo = Electron.MemoryInfo;
     type MemoryUsageDetails = Electron.MemoryUsageDetails;
+    type MenuItemBadge = Electron.MenuItemBadge;
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
@@ -26131,6 +26626,9 @@ declare namespace Electron {
     type Event<Params extends object = {}> = Electron.Event<Params>;
     type ClientRequest = Electron.ClientRequest;
     type IncomingMessage = Electron.IncomingMessage;
+    class LanguageModelUtility extends Electron.LanguageModelUtility {}
+    const localAIHandler: LocalAIHandler;
+    type LocalAIHandler = Electron.LocalAIHandler;
     const net: Net;
     type Net = Electron.Net;
     const parentPort: ParentPort;
@@ -26219,6 +26717,7 @@ declare namespace Electron {
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type ImportSharedTextureOptions = Electron.ImportSharedTextureOptions;
     type Info = Electron.Info;
+    type InitialState = Electron.InitialState;
     type Input = Electron.Input;
     type InsertCSSOptions = Electron.InsertCSSOptions;
     type IpcMessageEvent = Electron.IpcMessageEvent;
@@ -26269,6 +26768,7 @@ declare namespace Electron {
     type PreconnectOptions = Electron.PreconnectOptions;
     type Privileges = Electron.Privileges;
     type ProgressBarOptions = Electron.ProgressBarOptions;
+    type PromptAPIHandlerDetails = Electron.PromptAPIHandlerDetails;
     type Provider = Electron.Provider;
     type PurchaseProductOpts = Electron.PurchaseProductOpts;
     type ReceivedSharedTextureData = Electron.ReceivedSharedTextureData;
@@ -26280,6 +26780,7 @@ declare namespace Electron {
     type ResolveHostOptions = Electron.ResolveHostOptions;
     type ResourceUsage = Electron.ResourceUsage;
     type Response = Electron.Response;
+    type ResponseConstraint = Electron.ResponseConstraint;
     type RestoreOptions = Electron.RestoreOptions;
     type Result = Electron.Result;
     type SaveDialogOptions = Electron.SaveDialogOptions;
@@ -26291,6 +26792,7 @@ declare namespace Electron {
     type SendSharedTextureOptions = Electron.SendSharedTextureOptions;
     type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type ServiceWorkersRunningStatusChangedEventParams = Electron.ServiceWorkersRunningStatusChangedEventParams;
+    type SessionSelectWebauthnAuthenticatorEventParams = Electron.SessionSelectWebauthnAuthenticatorEventParams;
     type Settings = Electron.Settings;
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type SourcesOptions = Electron.SourcesOptions;
@@ -26391,9 +26893,18 @@ declare namespace Electron {
     type JumpListItem = Electron.JumpListItem;
     type KeyboardEvent = Electron.KeyboardEvent;
     type KeyboardInputEvent = Electron.KeyboardInputEvent;
+    type LanguageModelAppendOptions = Electron.LanguageModelAppendOptions;
+    type LanguageModelCloneOptions = Electron.LanguageModelCloneOptions;
+    type LanguageModelCreateCoreOptions = Electron.LanguageModelCreateCoreOptions;
+    type LanguageModelCreateOptions = Electron.LanguageModelCreateOptions;
+    type LanguageModelExpected = Electron.LanguageModelExpected;
+    type LanguageModelMessage = Electron.LanguageModelMessage;
+    type LanguageModelMessageContent = Electron.LanguageModelMessageContent;
+    type LanguageModelPromptOptions = Electron.LanguageModelPromptOptions;
     type MediaAccessPermissionRequest = Electron.MediaAccessPermissionRequest;
     type MemoryInfo = Electron.MemoryInfo;
     type MemoryUsageDetails = Electron.MemoryUsageDetails;
+    type MenuItemBadge = Electron.MenuItemBadge;
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
@@ -26502,6 +27013,9 @@ declare namespace Electron {
     class IpcMainServiceWorker extends Electron.IpcMainServiceWorker {}
     const ipcRenderer: IpcRenderer;
     type IpcRenderer = Electron.IpcRenderer;
+    class LanguageModelUtility extends Electron.LanguageModelUtility {}
+    const localAIHandler: LocalAIHandler;
+    type LocalAIHandler = Electron.LocalAIHandler;
     class Menu extends Electron.Menu {}
     class MenuItem extends Electron.MenuItem {}
     class MessageChannelMain extends Electron.MessageChannelMain {}
@@ -26650,6 +27164,7 @@ declare namespace Electron {
     type ImportCertificateOptions = Electron.ImportCertificateOptions;
     type ImportSharedTextureOptions = Electron.ImportSharedTextureOptions;
     type Info = Electron.Info;
+    type InitialState = Electron.InitialState;
     type Input = Electron.Input;
     type InsertCSSOptions = Electron.InsertCSSOptions;
     type IpcMessageEvent = Electron.IpcMessageEvent;
@@ -26700,6 +27215,7 @@ declare namespace Electron {
     type PreconnectOptions = Electron.PreconnectOptions;
     type Privileges = Electron.Privileges;
     type ProgressBarOptions = Electron.ProgressBarOptions;
+    type PromptAPIHandlerDetails = Electron.PromptAPIHandlerDetails;
     type Provider = Electron.Provider;
     type PurchaseProductOpts = Electron.PurchaseProductOpts;
     type ReceivedSharedTextureData = Electron.ReceivedSharedTextureData;
@@ -26711,6 +27227,7 @@ declare namespace Electron {
     type ResolveHostOptions = Electron.ResolveHostOptions;
     type ResourceUsage = Electron.ResourceUsage;
     type Response = Electron.Response;
+    type ResponseConstraint = Electron.ResponseConstraint;
     type RestoreOptions = Electron.RestoreOptions;
     type Result = Electron.Result;
     type SaveDialogOptions = Electron.SaveDialogOptions;
@@ -26722,6 +27239,7 @@ declare namespace Electron {
     type SendSharedTextureOptions = Electron.SendSharedTextureOptions;
     type SerialPortRevokedDetails = Electron.SerialPortRevokedDetails;
     type ServiceWorkersRunningStatusChangedEventParams = Electron.ServiceWorkersRunningStatusChangedEventParams;
+    type SessionSelectWebauthnAuthenticatorEventParams = Electron.SessionSelectWebauthnAuthenticatorEventParams;
     type Settings = Electron.Settings;
     type SharedDictionaryInfoOptions = Electron.SharedDictionaryInfoOptions;
     type SourcesOptions = Electron.SourcesOptions;
@@ -26822,9 +27340,18 @@ declare namespace Electron {
     type JumpListItem = Electron.JumpListItem;
     type KeyboardEvent = Electron.KeyboardEvent;
     type KeyboardInputEvent = Electron.KeyboardInputEvent;
+    type LanguageModelAppendOptions = Electron.LanguageModelAppendOptions;
+    type LanguageModelCloneOptions = Electron.LanguageModelCloneOptions;
+    type LanguageModelCreateCoreOptions = Electron.LanguageModelCreateCoreOptions;
+    type LanguageModelCreateOptions = Electron.LanguageModelCreateOptions;
+    type LanguageModelExpected = Electron.LanguageModelExpected;
+    type LanguageModelMessage = Electron.LanguageModelMessage;
+    type LanguageModelMessageContent = Electron.LanguageModelMessageContent;
+    type LanguageModelPromptOptions = Electron.LanguageModelPromptOptions;
     type MediaAccessPermissionRequest = Electron.MediaAccessPermissionRequest;
     type MemoryInfo = Electron.MemoryInfo;
     type MemoryUsageDetails = Electron.MemoryUsageDetails;
+    type MenuItemBadge = Electron.MenuItemBadge;
     type MimeTypedBuffer = Electron.MimeTypedBuffer;
     type MouseInputEvent = Electron.MouseInputEvent;
     type MouseWheelInputEvent = Electron.MouseWheelInputEvent;
@@ -26905,6 +27432,7 @@ declare namespace Electron {
   const inAppPurchase: InAppPurchase;
   const ipcMain: IpcMain;
   const ipcRenderer: IpcRenderer;
+  const localAIHandler: LocalAIHandler;
   const nativeImage: typeof NativeImage;
   const nativeTheme: NativeTheme;
   const net: Net;

package/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "electronVersion": "44.0.0-beta.6",
-  "extractedAt": "2026-08-20T23:08:34.987Z"
+  "electronVersion": "45.0.0-alpha.1",
+  "extractedAt": "2026-08-28T07:39:05.308Z"
 }

package/package.json

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