// Type definitions for Electron 6.1.7 // Project: http://electronjs.org/ // Definitions by: The Electron Team // Definitions: https://github.com/electron/electron-typescript-definitions /// type GlobalEvent = Event; declare namespace Electron { // TODO: Replace this declaration with NodeJS.EventEmitter class EventEmitter { addListener(event: string, listener: Function): this; on(event: string, listener: Function): this; once(event: string, listener: Function): this; removeListener(event: string, listener: Function): this; removeAllListeners(event?: string): this; setMaxListeners(n: number): this; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; prependListener(event: string, listener: Function): this; prependOnceListener(event: string, listener: Function): this; eventNames(): Array<(string | symbol)>; } class Accelerator extends String { } interface CommonInterface { clipboard: Clipboard; crashReporter: CrashReporter; nativeImage: typeof NativeImage; shell: Shell; } interface MainInterface extends CommonInterface { app: App; autoUpdater: AutoUpdater; BrowserView: typeof BrowserView; BrowserWindow: typeof BrowserWindow; ClientRequest: typeof ClientRequest; contentTracing: ContentTracing; Cookies: typeof Cookies; Debugger: typeof Debugger; dialog: Dialog; DownloadItem: typeof DownloadItem; globalShortcut: GlobalShortcut; inAppPurchase: InAppPurchase; IncomingMessage: typeof IncomingMessage; ipcMain: IpcMain; Menu: typeof Menu; MenuItem: typeof MenuItem; net: Net; netLog: NetLog; Notification: typeof Notification; powerMonitor: PowerMonitor; powerSaveBlocker: PowerSaveBlocker; protocol: Protocol; screen: Screen; session: typeof Session; systemPreferences: SystemPreferences; TouchBar: typeof TouchBar; Tray: typeof Tray; webContents: typeof WebContents; WebRequest: typeof WebRequest; } interface RendererInterface extends CommonInterface { BrowserWindowProxy: typeof BrowserWindowProxy; contextBridge: ContextBridge; desktopCapturer: DesktopCapturer; ipcRenderer: IpcRenderer; remote: Remote; webFrame: WebFrame; webviewTag: WebviewTag; } interface AllElectron extends MainInterface, RendererInterface {} const app: App; const autoUpdater: AutoUpdater; const clipboard: Clipboard; const contentTracing: ContentTracing; const contextBridge: ContextBridge; const crashReporter: CrashReporter; const desktopCapturer: DesktopCapturer; const dialog: Dialog; const globalShortcut: GlobalShortcut; const inAppPurchase: InAppPurchase; const ipcMain: IpcMain; const ipcRenderer: IpcRenderer; type nativeImage = NativeImage; const nativeImage: typeof NativeImage; const net: Net; const netLog: NetLog; const powerMonitor: PowerMonitor; const powerSaveBlocker: PowerSaveBlocker; const protocol: Protocol; const remote: Remote; const screen: Screen; type session = Session; const session: typeof Session; const shell: Shell; const systemPreferences: SystemPreferences; type webContents = WebContents; const webContents: typeof WebContents; const webFrame: WebFrame; const webviewTag: WebviewTag; interface App extends EventEmitter { // Docs: http://electronjs.org/docs/api/app /** * Emitted when Chrome's accessibility support changes. This event fires when * assistive technologies, such as screen readers, are enabled or disabled. See * https://www.chromium.org/developers/design-documents/accessibility for more * details. */ on(event: 'accessibility-support-changed', listener: (event: Event, /** * `true` when Chrome's accessibility support is enabled, `false` otherwise. */ accessibilitySupportEnabled: boolean) => void): this; once(event: 'accessibility-support-changed', listener: (event: Event, /** * `true` when Chrome's accessibility support is enabled, `false` otherwise. */ accessibilitySupportEnabled: boolean) => void): this; addListener(event: 'accessibility-support-changed', listener: (event: Event, /** * `true` when Chrome's accessibility support is enabled, `false` otherwise. */ accessibilitySupportEnabled: boolean) => void): this; removeListener(event: 'accessibility-support-changed', listener: (event: Event, /** * `true` when Chrome's accessibility support is enabled, `false` otherwise. */ accessibilitySupportEnabled: boolean) => void): this; /** * Emitted when the application is activated. Various actions can trigger this * event, such as launching the application for the first time, attempting to * re-launch the application when it's already running, or clicking on the * application's dock or taskbar icon. */ on(event: 'activate', listener: (event: Event, hasVisibleWindows: boolean) => void): this; once(event: 'activate', listener: (event: Event, hasVisibleWindows: boolean) => void): this; addListener(event: 'activate', listener: (event: Event, hasVisibleWindows: boolean) => void): this; removeListener(event: 'activate', listener: (event: Event, hasVisibleWindows: boolean) => void): this; /** * Emitted during Handoff after an activity from this device was successfully * resumed on another one. */ on(event: 'activity-was-continued', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; once(event: 'activity-was-continued', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; addListener(event: 'activity-was-continued', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; removeListener(event: 'activity-was-continued', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; /** * Emitted before the application starts closing its windows. Calling * event.preventDefault() will prevent the default behavior, which is terminating * the application. Note: If application quit was initiated by * autoUpdater.quitAndInstall(), then before-quit is emitted after emitting close * event on all windows and closing them. Note: On Windows, this event will not be * emitted if the app is closed due to a shutdown/restart of the system or a user * logout. */ on(event: 'before-quit', listener: (event: Event) => void): this; once(event: 'before-quit', listener: (event: Event) => void): this; addListener(event: 'before-quit', listener: (event: Event) => void): this; removeListener(event: 'before-quit', listener: (event: Event) => void): this; /** * Emitted when a browserWindow gets blurred. */ on(event: 'browser-window-blur', listener: (event: Event, window: BrowserWindow) => void): this; once(event: 'browser-window-blur', listener: (event: Event, window: BrowserWindow) => void): this; addListener(event: 'browser-window-blur', listener: (event: Event, window: BrowserWindow) => void): this; removeListener(event: 'browser-window-blur', listener: (event: Event, window: BrowserWindow) => void): this; /** * Emitted when a new browserWindow is created. */ on(event: 'browser-window-created', listener: (event: Event, window: BrowserWindow) => void): this; once(event: 'browser-window-created', listener: (event: Event, window: BrowserWindow) => void): this; addListener(event: 'browser-window-created', listener: (event: Event, window: BrowserWindow) => void): this; removeListener(event: 'browser-window-created', listener: (event: Event, window: BrowserWindow) => void): this; /** * Emitted when a browserWindow gets focused. */ on(event: 'browser-window-focus', listener: (event: Event, window: BrowserWindow) => void): this; once(event: 'browser-window-focus', listener: (event: Event, window: BrowserWindow) => void): this; addListener(event: 'browser-window-focus', listener: (event: Event, window: BrowserWindow) => void): this; removeListener(event: 'browser-window-focus', listener: (event: Event, window: BrowserWindow) => void): this; /** * Emitted when failed to verify the certificate for url, to trust the certificate * you should prevent the default behavior with event.preventDefault() and call * callback(true). */ on(event: 'certificate-error', listener: (event: Event, webContents: WebContents, url: string, /** * The error code */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; once(event: 'certificate-error', listener: (event: Event, webContents: WebContents, url: string, /** * The error code */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; addListener(event: 'certificate-error', listener: (event: Event, webContents: WebContents, url: string, /** * The error code */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; removeListener(event: 'certificate-error', listener: (event: Event, webContents: WebContents, url: string, /** * The error code */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; /** * Emitted during Handoff when an activity from a different device wants to be * resumed. You should call event.preventDefault() if you want to handle this * event. A user activity can be continued only in an app that has the same * developer Team ID as the activity's source app and that supports the activity's * type. Supported activity types are specified in the app's Info.plist under the * NSUserActivityTypes key. */ on(event: 'continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity on another device. */ userInfo: any) => void): this; once(event: 'continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity on another device. */ userInfo: any) => void): this; addListener(event: 'continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity on another device. */ userInfo: any) => void): this; removeListener(event: 'continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity on another device. */ userInfo: any) => void): this; /** * Emitted during Handoff when an activity from a different device fails to be * resumed. */ on(event: 'continue-activity-error', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * A string with the error's localized description. */ error: string) => void): this; once(event: 'continue-activity-error', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * A string with the error's localized description. */ error: string) => void): this; addListener(event: 'continue-activity-error', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * A string with the error's localized description. */ error: string) => void): this; removeListener(event: 'continue-activity-error', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * A string with the error's localized description. */ error: string) => void): this; /** * Emitted when desktopCapturer.getSources() is called in the renderer process of * webContents. Calling event.preventDefault() will make it return empty sources. */ on(event: 'desktop-capturer-get-sources', listener: (event: Event, webContents: WebContents) => void): this; once(event: 'desktop-capturer-get-sources', listener: (event: Event, webContents: WebContents) => void): this; addListener(event: 'desktop-capturer-get-sources', listener: (event: Event, webContents: WebContents) => void): this; removeListener(event: 'desktop-capturer-get-sources', listener: (event: Event, webContents: WebContents) => void): this; /** * Emitted when the gpu process crashes or is killed. */ on(event: 'gpu-process-crashed', listener: (event: Event, killed: boolean) => void): this; once(event: 'gpu-process-crashed', listener: (event: Event, killed: boolean) => void): this; addListener(event: 'gpu-process-crashed', listener: (event: Event, killed: boolean) => void): this; removeListener(event: 'gpu-process-crashed', listener: (event: Event, killed: boolean) => void): this; /** * Emitted when webContents wants to do basic auth. The default behavior is to * cancel all authentications. To override this you should prevent the default * behavior with event.preventDefault() and call callback(username, password) with * the credentials. */ on(event: 'login', listener: (event: Event, webContents: WebContents, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; once(event: 'login', listener: (event: Event, webContents: WebContents, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; addListener(event: 'login', listener: (event: Event, webContents: WebContents, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; removeListener(event: 'login', listener: (event: Event, webContents: WebContents, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; /** * Emitted when the user clicks the native macOS new tab button. The new tab button * is only visible if the current BrowserWindow has a tabbingIdentifier */ on(event: 'new-window-for-tab', listener: (event: Event) => void): this; once(event: 'new-window-for-tab', listener: (event: Event) => void): this; addListener(event: 'new-window-for-tab', listener: (event: Event) => void): this; removeListener(event: 'new-window-for-tab', listener: (event: Event) => void): this; /** * Emitted when the user wants to open a file with the application. The open-file * event is usually emitted when the application is already open and the OS wants * to reuse the application to open the file. open-file is also emitted when a file * is dropped onto the dock and the application is not yet running. Make sure to * listen for the open-file event very early in your application startup to handle * this case (even before the ready event is emitted). You should call * event.preventDefault() if you want to handle this event. On Windows, you have to * parse process.argv (in the main process) to get the filepath. */ on(event: 'open-file', listener: (event: Event, path: string) => void): this; once(event: 'open-file', listener: (event: Event, path: string) => void): this; addListener(event: 'open-file', listener: (event: Event, path: string) => void): this; removeListener(event: 'open-file', listener: (event: Event, path: string) => void): this; /** * Emitted when the user wants to open a URL with the application. Your * application's Info.plist file must define the url scheme within the * CFBundleURLTypes key, and set NSPrincipalClass to AtomApplication. You should * call event.preventDefault() if you want to handle this event. */ on(event: 'open-url', listener: (event: Event, url: string) => void): this; once(event: 'open-url', listener: (event: Event, url: string) => void): this; addListener(event: 'open-url', listener: (event: Event, url: string) => void): this; removeListener(event: 'open-url', listener: (event: Event, url: string) => void): this; /** * Emitted when the application is quitting. Note: On Windows, this event will not * be emitted if the app is closed due to a shutdown/restart of the system or a * user logout. */ on(event: 'quit', listener: (event: Event, exitCode: number) => void): this; once(event: 'quit', listener: (event: Event, exitCode: number) => void): this; addListener(event: 'quit', listener: (event: Event, exitCode: number) => void): this; removeListener(event: 'quit', listener: (event: Event, exitCode: number) => void): this; /** * Emitted when Electron has finished initializing. On macOS, launchInfo holds the * userInfo of the NSUserNotification that was used to open the application, if it * was launched from Notification Center. You can call app.isReady() to check if * this event has already fired. */ on(event: 'ready', listener: (launchInfo: any) => void): this; once(event: 'ready', listener: (launchInfo: any) => void): this; addListener(event: 'ready', listener: (launchInfo: any) => void): this; removeListener(event: 'ready', listener: (launchInfo: any) => void): this; /** * Emitted when remote.getBuiltin() is called in the renderer process of * webContents. Calling event.preventDefault() will prevent the module from being * returned. Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-builtin', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; once(event: 'remote-get-builtin', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; addListener(event: 'remote-get-builtin', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; removeListener(event: 'remote-get-builtin', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; /** * Emitted when remote.getCurrentWebContents() is called in the renderer process of * webContents. Calling event.preventDefault() will prevent the object from being * returned. Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-current-web-contents', listener: (event: Event, webContents: WebContents) => void): this; once(event: 'remote-get-current-web-contents', listener: (event: Event, webContents: WebContents) => void): this; addListener(event: 'remote-get-current-web-contents', listener: (event: Event, webContents: WebContents) => void): this; removeListener(event: 'remote-get-current-web-contents', listener: (event: Event, webContents: WebContents) => void): this; /** * Emitted when remote.getCurrentWindow() is called in the renderer process of * webContents. Calling event.preventDefault() will prevent the object from being * returned. Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-current-window', listener: (event: Event, webContents: WebContents) => void): this; once(event: 'remote-get-current-window', listener: (event: Event, webContents: WebContents) => void): this; addListener(event: 'remote-get-current-window', listener: (event: Event, webContents: WebContents) => void): this; removeListener(event: 'remote-get-current-window', listener: (event: Event, webContents: WebContents) => void): this; /** * Emitted when remote.getGlobal() is called in the renderer process of * webContents. Calling event.preventDefault() will prevent the global from being * returned. Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-global', listener: (event: Event, webContents: WebContents, globalName: string) => void): this; once(event: 'remote-get-global', listener: (event: Event, webContents: WebContents, globalName: string) => void): this; addListener(event: 'remote-get-global', listener: (event: Event, webContents: WebContents, globalName: string) => void): this; removeListener(event: 'remote-get-global', listener: (event: Event, webContents: WebContents, globalName: string) => void): this; /** * Emitted when .getWebContents() is called in the renderer process of * webContents. Calling event.preventDefault() will prevent the object from being * returned. Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-guest-web-contents', listener: (event: Event, webContents: WebContents, guestWebContents: WebContents) => void): this; once(event: 'remote-get-guest-web-contents', listener: (event: Event, webContents: WebContents, guestWebContents: WebContents) => void): this; addListener(event: 'remote-get-guest-web-contents', listener: (event: Event, webContents: WebContents, guestWebContents: WebContents) => void): this; removeListener(event: 'remote-get-guest-web-contents', listener: (event: Event, webContents: WebContents, guestWebContents: WebContents) => void): this; /** * Emitted when remote.require() is called in the renderer process of webContents. * Calling event.preventDefault() will prevent the module from being returned. * Custom value can be returned by setting event.returnValue. */ on(event: 'remote-require', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; once(event: 'remote-require', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; addListener(event: 'remote-require', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; removeListener(event: 'remote-require', listener: (event: Event, webContents: WebContents, moduleName: string) => void): this; /** * Emitted when the renderer process of webContents crashes or is killed. */ on(event: 'renderer-process-crashed', listener: (event: Event, webContents: WebContents, killed: boolean) => void): this; once(event: 'renderer-process-crashed', listener: (event: Event, webContents: WebContents, killed: boolean) => void): this; addListener(event: 'renderer-process-crashed', listener: (event: Event, webContents: WebContents, killed: boolean) => void): this; removeListener(event: 'renderer-process-crashed', listener: (event: Event, webContents: WebContents, killed: boolean) => void): this; /** * This event will be emitted inside the primary instance of your application when * a second instance has been executed and calls app.requestSingleInstanceLock(). * argv is an Array of the second instance's command line arguments, and * workingDirectory is its current working directory. Usually applications respond * to this by making their primary window focused and non-minimized. This event is * guaranteed to be emitted after the ready event of app gets emitted. Note: Extra * command line arguments might be added by Chromium, such as * --original-process-start-time. */ on(event: 'second-instance', listener: (event: Event, /** * An array of the second instance's command line arguments */ argv: string[], /** * The second instance's working directory */ workingDirectory: string) => void): this; once(event: 'second-instance', listener: (event: Event, /** * An array of the second instance's command line arguments */ argv: string[], /** * The second instance's working directory */ workingDirectory: string) => void): this; addListener(event: 'second-instance', listener: (event: Event, /** * An array of the second instance's command line arguments */ argv: string[], /** * The second instance's working directory */ workingDirectory: string) => void): this; removeListener(event: 'second-instance', listener: (event: Event, /** * An array of the second instance's command line arguments */ argv: string[], /** * The second instance's working directory */ workingDirectory: string) => void): this; /** * Emitted when a client certificate is requested. The url corresponds to the * navigation entry requesting the client certificate and callback can be called * with an entry filtered from the list. Using event.preventDefault() prevents the * application from using the first certificate from the store. */ on(event: 'select-client-certificate', listener: (event: Event, webContents: WebContents, url: string, certificateList: Certificate[], callback: (certificate?: Certificate) => void) => void): this; once(event: 'select-client-certificate', listener: (event: Event, webContents: WebContents, url: string, certificateList: Certificate[], callback: (certificate?: Certificate) => void) => void): this; addListener(event: 'select-client-certificate', listener: (event: Event, webContents: WebContents, url: string, certificateList: Certificate[], callback: (certificate?: Certificate) => void) => void): this; removeListener(event: 'select-client-certificate', listener: (event: Event, webContents: WebContents, url: string, certificateList: Certificate[], callback: (certificate?: Certificate) => void) => void): this; /** * Emitted when Electron has created a new session. */ on(event: 'session-created', listener: (session: Session) => void): this; once(event: 'session-created', listener: (session: Session) => void): this; addListener(event: 'session-created', listener: (session: Session) => void): this; removeListener(event: 'session-created', listener: (session: Session) => void): this; /** * Emitted when Handoff is about to be resumed on another device. If you need to * update the state to be transferred, you should call event.preventDefault() * immediately, construct a new userInfo dictionary and call * app.updateCurrentActiviy() in a timely manner. Otherwise, the operation will * fail and continue-activity-error will be called. */ on(event: 'update-activity-state', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; once(event: 'update-activity-state', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; addListener(event: 'update-activity-state', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; removeListener(event: 'update-activity-state', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string, /** * Contains app-specific state stored by the activity. */ userInfo: any) => void): this; /** * Emitted when a new webContents is created. */ on(event: 'web-contents-created', listener: (event: Event, webContents: WebContents) => void): this; once(event: 'web-contents-created', listener: (event: Event, webContents: WebContents) => void): this; addListener(event: 'web-contents-created', listener: (event: Event, webContents: WebContents) => void): this; removeListener(event: 'web-contents-created', listener: (event: Event, webContents: WebContents) => void): this; /** * Emitted during Handoff before an activity from a different device wants to be * resumed. You should call event.preventDefault() if you want to handle this * event. */ on(event: 'will-continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string) => void): this; once(event: 'will-continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string) => void): this; addListener(event: 'will-continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string) => void): this; removeListener(event: 'will-continue-activity', listener: (event: Event, /** * A string identifying the activity. Maps to . */ type: string) => void): this; /** * Emitted when the application has finished basic startup. On Windows and Linux, * the will-finish-launching event is the same as the ready event; on macOS, this * event represents the applicationWillFinishLaunching notification of * NSApplication. You would usually set up listeners for the open-file and open-url * events here, and start the crash reporter and auto updater. In most cases, you * should do everything in the ready event handler. */ on(event: 'will-finish-launching', listener: Function): this; once(event: 'will-finish-launching', listener: Function): this; addListener(event: 'will-finish-launching', listener: Function): this; removeListener(event: 'will-finish-launching', listener: Function): this; /** * Emitted when all windows have been closed and the application will quit. Calling * event.preventDefault() will prevent the default behaviour, which is terminating * the application. See the description of the window-all-closed event for the * differences between the will-quit and window-all-closed events. Note: On * Windows, this event will not be emitted if the app is closed due to a * shutdown/restart of the system or a user logout. */ on(event: 'will-quit', listener: (event: Event) => void): this; once(event: 'will-quit', listener: (event: Event) => void): this; addListener(event: 'will-quit', listener: (event: Event) => void): this; removeListener(event: 'will-quit', listener: (event: Event) => void): this; /** * Emitted when all windows have been closed. If you do not subscribe to this event * and all windows are closed, the default behavior is to quit the app; however, if * you subscribe, you control whether the app quits or not. If the user pressed Cmd * + Q, or the developer called app.quit(), Electron will first try to close all * the windows and then emit the will-quit event, and in this case the * window-all-closed event would not be emitted. */ on(event: 'window-all-closed', listener: Function): this; once(event: 'window-all-closed', listener: Function): this; addListener(event: 'window-all-closed', listener: Function): this; removeListener(event: 'window-all-closed', listener: Function): this; /** * Adds path to the recent documents list. This list is managed by the OS. On * Windows, you can visit the list from the task bar, and on macOS, you can visit * it from dock menu. */ addRecentDocument(path: string): void; /** * Clears the recent documents list. */ clearRecentDocuments(): void; /** * By default, Chromium disables 3D APIs (e.g. WebGL) until restart on a per domain * basis if the GPU processes crashes too frequently. This function disables that * behaviour. This method can only be called before app is ready. */ disableDomainBlockingFor3DAPIs(): void; /** * Disables hardware acceleration for current app. This method can only be called * before app is ready. */ disableHardwareAcceleration(): void; /** * Enables full sandbox mode on the app. This method can only be called before app * is ready. */ enableSandbox(): void; /** * Exits immediately with exitCode. exitCode defaults to 0. All windows will be * closed immediately without asking the user, and the before-quit and will-quit * events will not be emitted. */ exit(exitCode?: number): void; /** * On Linux, focuses on the first visible window. On macOS, makes the application * the active app. On Windows, focuses on the application's first window. */ focus(): void; getAppMetrics(): ProcessMetric[]; getAppPath(): string; getBadgeCount(): number; getCurrentActivityType(): string; /** * Fetches a path's associated icon. On Windows, there a 2 kinds of icons: On Linux * and macOS, icons depend on the application associated with file mime type. */ getFileIcon(path: string, options?: FileIconOptions): Promise; /** * Fetches a path's associated icon. On Windows, there are 2 kinds of icons: On * Linux and macOS, icons depend on the application associated with file mime type. * Deprecated Soon */ getFileIcon(path: string, options: FileIconOptions, callback: (error: Error, icon: NativeImage) => void): void; /** * Fetches a path's associated icon. On Windows, there are 2 kinds of icons: On * Linux and macOS, icons depend on the application associated with file mime type. * Deprecated Soon */ getFileIcon(path: string, callback: (error: Error, icon: NativeImage) => void): void; getGPUFeatureStatus(): GPUFeatureStatus; /** * For infoType equal to complete: Promise is fulfilled with Object containing all * the GPU Information as in chromium's GPUInfo object. This includes the version * and driver information that's shown on chrome://gpu page. For infoType equal to * basic: Promise is fulfilled with Object containing fewer attributes than when * requested with complete. Here's an example of basic response: Using basic should * be preferred if only basic information like vendorId or driverId is needed. */ getGPUInfo(infoType: string): Promise; getJumpListSettings(): JumpListSettings; /** * To set the locale, you'll want to use a command line switch at app startup, * which may be found here. Note: When distributing your packaged app, you have to * also ship the locales folder. Note: On Windows, you have to call it after the * ready events gets emitted. */ getLocale(): string; /** * Note: When unable to detect locale country code, it returns empty string. */ getLocaleCountryCode(): string; /** * If you provided path and args options to app.setLoginItemSettings, then you need * to pass the same arguments here for openAtLogin to be set correctly. */ getLoginItemSettings(options?: LoginItemSettingsOptions): LoginItemSettings; /** * Usually the name field of package.json is a short lowercased name, according to * the npm modules spec. You should usually also specify a productName field, which * is your application's full capitalized name, and which will be preferred over * name by Electron. */ getName(): string; /** * You can request the following paths by the name: */ getPath(name: string): string; getVersion(): string; /** * This method returns whether or not this instance of your app is currently * holding the single instance lock. You can request the lock with * app.requestSingleInstanceLock() and release with app.releaseSingleInstanceLock() */ hasSingleInstanceLock(): boolean; /** * Hides all application windows without minimizing them. */ hide(): void; /** * Imports the certificate in pkcs12 format into the platform certificate store. * callback is called with the result of import operation, a value of 0 indicates * success while any other value indicates failure according to Chromium * net_error_list. */ importCertificate(options: ImportCertificateOptions, callback: (result: number) => void): void; /** * Invalidates the current Handoff user activity. */ invalidateCurrentActivity(type: string): void; /** * Deprecated Soon */ isAccessibilitySupportEnabled(): boolean; /** * This method checks if the current executable is the default handler for a * protocol (aka URI scheme). If so, it will return true. Otherwise, it will return * false. Note: On macOS, you can use this method to check if the app has been * registered as the default protocol handler for a protocol. You can also verify * this by checking ~/Library/Preferences/com.apple.LaunchServices.plist on the * macOS machine. Please refer to Apple's documentation for details. The API uses * the Windows Registry and LSCopyDefaultHandlerForURLScheme internally. */ isDefaultProtocolClient(protocol: string, path?: string, args?: string[]): boolean; isEmojiPanelSupported(): boolean; isInApplicationsFolder(): boolean; isReady(): boolean; isUnityRunning(): boolean; /** * No confirmation dialog will be presented by default. If you wish to allow the * user to confirm the operation, you may do so using the dialog API. NOTE: This * method throws errors if anything other than the user causes the move to fail. * For instance if the user cancels the authorization dialog, this method returns * false. If we fail to perform the copy, then this method will throw an error. The * message in the error should be informative and tell you exactly what went wrong */ moveToApplicationsFolder(): boolean; /** * Try to close all windows. The before-quit event will be emitted first. If all * windows are successfully closed, the will-quit event will be emitted and by * default the application will terminate. This method guarantees that all * beforeunload and unload event handlers are correctly executed. It is possible * that a window cancels the quitting by returning false in the beforeunload event * handler. */ quit(): void; /** * Relaunches the app when current instance exits. By default, the new instance * will use the same working directory and command line arguments with current * instance. When args is specified, the args will be passed as command line * arguments instead. When execPath is specified, the execPath will be executed for * relaunch instead of current app. Note that this method does not quit the app * when executed, you have to call app.quit or app.exit after calling app.relaunch * to make the app restart. When app.relaunch is called for multiple times, * multiple instances will be started after current instance exited. An example of * restarting current instance immediately and adding a new command line argument * to the new instance: */ relaunch(options?: RelaunchOptions): void; /** * Releases all locks that were created by requestSingleInstanceLock. This will * allow multiple instances of the application to once again run side by side. */ releaseSingleInstanceLock(): void; /** * This method checks if the current executable as the default handler for a * protocol (aka URI scheme). If so, it will remove the app as the default handler. */ removeAsDefaultProtocolClient(protocol: string, path?: string, args?: string[]): boolean; /** * The return value of this method indicates whether or not this instance of your * application successfully obtained the lock. If it failed to obtain the lock, * you can assume that another instance of your application is already running with * the lock and exit immediately. I.e. This method returns true if your process is * the primary instance of your application and your app should continue loading. * It returns false if your process should immediately quit as it has sent its * parameters to another instance that has already acquired the lock. On macOS, the * system enforces single instance automatically when users try to open a second * instance of your app in Finder, and the open-file and open-url events will be * emitted for that. However when users start your app in command line, the * system's single instance mechanism will be bypassed, and you have to use this * method to ensure single instance. An example of activating the window of primary * instance when a second instance starts: */ requestSingleInstanceLock(): boolean; /** * Set the about panel options. This will override the values defined in the app's * .plist file on MacOS. See the Apple docs for more details. On Linux, values must * be set in order to be shown; there are no defaults. */ setAboutPanelOptions(options: AboutPanelOptionsOptions): void; /** * Manually enables Chrome's accessibility support, allowing to expose * accessibility switch to users in application settings. See Chromium's * accessibility docs for more details. Disabled by default. This API must be * called after the ready event is emitted. Note: Rendering accessibility tree can * significantly affect the performance of your app. It should not be enabled by * default. Deprecated Soon */ setAccessibilitySupportEnabled(enabled: boolean): void; /** * Sets or creates a directory your app's logs which can then be manipulated with * app.getPath() or app.setPath(pathName, newPath). Calling app.setAppLogsPath() * without a path parameter will result in this directory being set to * /Library/Logs/YourAppName on macOS, and inside the userData directory on Linux * and Windows. */ setAppLogsPath(path?: string): void; /** * Changes the Application User Model ID to id. */ setAppUserModelId(id: string): void; /** * This method sets the current executable as the default handler for a protocol * (aka URI scheme). It allows you to integrate your app deeper into the operating * system. Once registered, all links with your-protocol:// will be opened with the * current executable. The whole link, including protocol, will be passed to your * application as a parameter. On Windows, you can provide optional parameters * path, the path to your executable, and args, an array of arguments to be passed * to your executable when it launches. Note: On macOS, you can only register * protocols that have been added to your app's info.plist, which can not be * modified at runtime. You can however change the file with a simple text editor * or script during build time. Please refer to Apple's documentation for details. * Note: In a Windows Store environment (when packaged as an appx) this API will * return true for all calls but the registry key it sets won't be accessible by * other applications. In order to register your Windows Store application as a * default protocol handler you must declare the protocol in your manifest. The API * uses the Windows Registry and LSSetDefaultHandlerForURLScheme internally. */ setAsDefaultProtocolClient(protocol: string, path?: string, args?: string[]): boolean; /** * Sets the counter badge for current app. Setting the count to 0 will hide the * badge. On macOS, it shows on the dock icon. On Linux, it only works for Unity * launcher. Note: Unity launcher requires the existence of a .desktop file to * work, for more information please read Desktop Environment Integration. */ setBadgeCount(count: number): boolean; /** * Sets or removes a custom Jump List for the application, and returns one of the * following strings: If categories is null the previously set custom Jump List (if * any) will be replaced by the standard Jump List for the app (managed by * Windows). Note: If a JumpListCategory object has neither the type nor the name * property set then its type is assumed to be tasks. If the name property is set * but the type property is omitted then the type is assumed to be custom. Note: * Users can remove items from custom categories, and Windows will not allow a * removed item to be added back into a custom category until after the next * successful call to app.setJumpList(categories). Any attempt to re-add a removed * item to a custom category earlier than that will result in the entire custom * category being omitted from the Jump List. The list of removed items can be * obtained using app.getJumpListSettings(). Here's a very simple example of * creating a custom Jump List: */ setJumpList(categories: JumpListCategory[]): void; /** * Set the app's login item settings. To work with Electron's autoUpdater on * Windows, which uses Squirrel, you'll want to set the launch path to Update.exe, * and pass arguments that specify your application name. For example: */ setLoginItemSettings(settings: Settings): void; /** * Overrides the current application's name. */ setName(name: string): void; /** * Overrides the path to a special directory or file associated with name. If the * path specifies a directory that does not exist, an Error is thrown. In that * case, the directory should be created with fs.mkdirSync or similar. You can only * override paths of a name defined in app.getPath. By default, web pages' cookies * and caches will be stored under the userData directory. If you want to change * this location, you have to override the userData path before the ready event of * the app module is emitted. */ setPath(name: string, path: string): void; /** * Creates an NSUserActivity and sets it as the current activity. The activity is * eligible for Handoff to another device afterward. */ setUserActivity(type: string, userInfo: any, webpageURL?: string): void; /** * Adds tasks to the Tasks category of the JumpList on Windows. tasks is an array * of Task objects. Note: If you'd like to customize the Jump List even more use * app.setJumpList(categories) instead. */ setUserTasks(tasks: Task[]): boolean; /** * Shows application windows after they were hidden. Does not automatically focus * them. */ show(): void; /** * Show the app's about panel options. These options can be overridden with * app.setAboutPanelOptions(options). */ showAboutPanel(): void; /** * Show the platform's native emoji picker. */ showEmojiPanel(): void; /** * Start accessing a security scoped resource. With this method Electron * applications that are packaged for the Mac App Store may reach outside their * sandbox to access files chosen by the user. See Apple's documentation for a * description of how this system works. */ startAccessingSecurityScopedResource(bookmarkData: string): Function; /** * Updates the current activity if its type matches type, merging the entries from * userInfo into its current userInfo dictionary. */ updateCurrentActivity(type: string, userInfo: any): void; whenReady(): Promise; /** * A Boolean property that's true if Chrome's accessibility support is enabled, * false otherwise. This property will be true if the use of assistive * technologies, such as screen readers, has been detected. Setting this property * to true manually enables Chrome's accessibility support, allowing developers to * expose accessibility switch to users in application settings. See Chromium's * accessibility docs for more details. Disabled by default. This API must be * called after the ready event is emitted. Note: Rendering accessibility tree can * significantly affect the performance of your app. It should not be enabled by * default. */ accessibilitySupportEnabled?: boolean; /** * A Boolean which when true disables the overrides that Electron has in place to * ensure renderer processes are restarted on every navigation. The current * default value for this property is false. The intention is for these overrides * to become disabled by default and then at some point in the future this property * will be removed. This property impacts which native modules you can use in the * renderer process. For more information on the direction Electron is going with * renderer process restarts and usage of native modules in the renderer process * please check out this Tracking Issue. */ allowRendererProcessReuse?: boolean; /** * A Menu property that return Menu if one has been set and null otherwise. Users * can pass a Menu to set this property. */ applicationMenu?: Menu; commandLine: CommandLine; dock: Dock; /** * A Boolean property that returns true if the app is packaged, false otherwise. * For many apps, this property can be used to distinguish development and * production environments. */ isPackaged?: boolean; /** * A String which is the user agent string Electron will use as a global fallback. * This is the user agent that will be used when no user agent is set at the * webContents or session level. Useful for ensuring your entire app has the same * user agent. Set to a custom value as early as possible in your apps * initialization to ensure that your overridden value is used. */ userAgentFallback?: string; } interface AutoUpdater extends EventEmitter { // Docs: http://electronjs.org/docs/api/auto-updater /** * This event is emitted after a user calls quitAndInstall(). When this API is * called, the before-quit event is not emitted before all windows are closed. As a * result you should listen to this event if you wish to perform actions before the * windows are closed while a process is quitting, as well as listening to * before-quit. */ on(event: 'before-quit-for-update', listener: Function): this; once(event: 'before-quit-for-update', listener: Function): this; addListener(event: 'before-quit-for-update', listener: Function): this; removeListener(event: 'before-quit-for-update', listener: Function): this; /** * Emitted when checking if an update has started. */ on(event: 'checking-for-update', listener: Function): this; once(event: 'checking-for-update', listener: Function): this; addListener(event: 'checking-for-update', listener: Function): this; removeListener(event: 'checking-for-update', listener: Function): this; /** * Emitted when there is an error while updating. */ on(event: 'error', listener: (error: Error) => void): this; once(event: 'error', listener: (error: Error) => void): this; addListener(event: 'error', listener: (error: Error) => void): this; removeListener(event: 'error', listener: (error: Error) => void): this; /** * Emitted when there is an available update. The update is downloaded * automatically. */ on(event: 'update-available', listener: Function): this; once(event: 'update-available', listener: Function): this; addListener(event: 'update-available', listener: Function): this; removeListener(event: 'update-available', listener: Function): this; /** * Emitted when an update has been downloaded. On Windows only releaseName is * available. Note: It is not strictly necessary to handle this event. A * successfully downloaded update will still be applied the next time the * application starts. */ on(event: 'update-downloaded', listener: (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void): this; once(event: 'update-downloaded', listener: (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void): this; addListener(event: 'update-downloaded', listener: (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void): this; removeListener(event: 'update-downloaded', listener: (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void): this; /** * Emitted when there is no available update. */ on(event: 'update-not-available', listener: Function): this; once(event: 'update-not-available', listener: Function): this; addListener(event: 'update-not-available', listener: Function): this; removeListener(event: 'update-not-available', listener: Function): this; /** * Asks the server whether there is an update. You must call setFeedURL before * using this API. */ checkForUpdates(): void; getFeedURL(): string; /** * Restarts the app and installs the update after it has been downloaded. It should * only be called after update-downloaded has been emitted. Under the hood calling * autoUpdater.quitAndInstall() will close all application windows first, and * automatically call app.quit() after all windows have been closed. Note: It is * not strictly necessary to call this function to apply an update, as a * successfully downloaded update will always be applied the next time the * application starts. */ quitAndInstall(): void; /** * Sets the url and initialize the auto updater. */ setFeedURL(options: FeedURLOptions): void; } interface BluetoothDevice { // Docs: http://electronjs.org/docs/api/structures/bluetooth-device deviceId: string; deviceName: string; } class BrowserView extends EventEmitter { // Docs: http://electronjs.org/docs/api/browser-view constructor(options?: BrowserViewConstructorOptions); static fromId(id: number): BrowserView; static fromWebContents(webContents: WebContents): (BrowserView) | (null); static getAllViews(): BrowserView[]; /** * Force closing the view, the unload and beforeunload events won't be emitted for * the web page. After you're done with a view, call this function in order to free * memory and other resources as soon as possible. */ destroy(): void; isDestroyed(): boolean; setAutoResize(options: AutoResizeOptions): void; setBackgroundColor(color: string): void; /** * Resizes and moves the view to the supplied bounds relative to the window. */ setBounds(bounds: Rectangle): void; id: number; webContents: WebContents; } class BrowserWindow extends EventEmitter { // Docs: http://electronjs.org/docs/api/browser-window /** * Emitted when the window is set or unset to show always on top of other windows. */ on(event: 'always-on-top-changed', listener: (event: Event, isAlwaysOnTop: boolean) => void): this; once(event: 'always-on-top-changed', listener: (event: Event, isAlwaysOnTop: boolean) => void): this; addListener(event: 'always-on-top-changed', listener: (event: Event, isAlwaysOnTop: boolean) => void): this; removeListener(event: 'always-on-top-changed', listener: (event: Event, isAlwaysOnTop: boolean) => void): this; /** * Emitted when an App Command is invoked. These are typically related to keyboard * media keys or browser commands, as well as the "Back" button built into some * mice on Windows. Commands are lowercased, underscores are replaced with hyphens, * and the APPCOMMAND_ prefix is stripped off. e.g. APPCOMMAND_BROWSER_BACKWARD is * emitted as browser-backward. The following app commands are explictly supported * on Linux: */ on(event: 'app-command', listener: (event: Event, command: string) => void): this; once(event: 'app-command', listener: (event: Event, command: string) => void): this; addListener(event: 'app-command', listener: (event: Event, command: string) => void): this; removeListener(event: 'app-command', listener: (event: Event, command: string) => void): this; /** * Emitted when the window loses focus. */ on(event: 'blur', listener: Function): this; once(event: 'blur', listener: Function): this; addListener(event: 'blur', listener: Function): this; removeListener(event: 'blur', listener: Function): this; /** * Emitted when the window is going to be closed. It's emitted before the * beforeunload and unload event of the DOM. Calling event.preventDefault() will * cancel the close. Usually you would want to use the beforeunload handler to * decide whether the window should be closed, which will also be called when the * window is reloaded. In Electron, returning any value other than undefined would * cancel the close. For example: Note: There is a subtle difference between the * behaviors of window.onbeforeunload = handler and * window.addEventListener('beforeunload', handler). It is recommended to always * set the event.returnValue explicitly, instead of only returning a value, as the * former works more consistently within Electron. */ on(event: 'close', listener: (event: Event) => void): this; once(event: 'close', listener: (event: Event) => void): this; addListener(event: 'close', listener: (event: Event) => void): this; removeListener(event: 'close', listener: (event: Event) => void): this; /** * Emitted when the window is closed. After you have received this event you should * remove the reference to the window and avoid using it any more. */ on(event: 'closed', listener: Function): this; once(event: 'closed', listener: Function): this; addListener(event: 'closed', listener: Function): this; removeListener(event: 'closed', listener: Function): this; /** * Emitted when the window enters a full-screen state. */ on(event: 'enter-full-screen', listener: Function): this; once(event: 'enter-full-screen', listener: Function): this; addListener(event: 'enter-full-screen', listener: Function): this; removeListener(event: 'enter-full-screen', listener: Function): this; /** * Emitted when the window enters a full-screen state triggered by HTML API. */ on(event: 'enter-html-full-screen', listener: Function): this; once(event: 'enter-html-full-screen', listener: Function): this; addListener(event: 'enter-html-full-screen', listener: Function): this; removeListener(event: 'enter-html-full-screen', listener: Function): this; /** * Emitted when the window gains focus. */ on(event: 'focus', listener: Function): this; once(event: 'focus', listener: Function): this; addListener(event: 'focus', listener: Function): this; removeListener(event: 'focus', listener: Function): this; /** * Emitted when the window is hidden. */ on(event: 'hide', listener: Function): this; once(event: 'hide', listener: Function): this; addListener(event: 'hide', listener: Function): this; removeListener(event: 'hide', listener: Function): this; /** * Emitted when the window leaves a full-screen state. */ on(event: 'leave-full-screen', listener: Function): this; once(event: 'leave-full-screen', listener: Function): this; addListener(event: 'leave-full-screen', listener: Function): this; removeListener(event: 'leave-full-screen', listener: Function): this; /** * Emitted when the window leaves a full-screen state triggered by HTML API. */ on(event: 'leave-html-full-screen', listener: Function): this; once(event: 'leave-html-full-screen', listener: Function): this; addListener(event: 'leave-html-full-screen', listener: Function): this; removeListener(event: 'leave-html-full-screen', listener: Function): this; /** * Emitted when window is maximized. */ on(event: 'maximize', listener: Function): this; once(event: 'maximize', listener: Function): this; addListener(event: 'maximize', listener: Function): this; removeListener(event: 'maximize', listener: Function): this; /** * Emitted when the window is minimized. */ on(event: 'minimize', listener: Function): this; once(event: 'minimize', listener: Function): this; addListener(event: 'minimize', listener: Function): this; removeListener(event: 'minimize', listener: Function): this; /** * Emitted when the window is being moved to a new position. Note: On macOS this * event is an alias of moved. */ on(event: 'move', listener: Function): this; once(event: 'move', listener: Function): this; addListener(event: 'move', listener: Function): this; removeListener(event: 'move', listener: Function): this; /** * Emitted once when the window is moved to a new position. */ on(event: 'moved', listener: Function): this; once(event: 'moved', listener: Function): this; addListener(event: 'moved', listener: Function): this; removeListener(event: 'moved', listener: Function): this; /** * Emitted when the native new tab button is clicked. */ on(event: 'new-window-for-tab', listener: Function): this; once(event: 'new-window-for-tab', listener: Function): this; addListener(event: 'new-window-for-tab', listener: Function): this; removeListener(event: 'new-window-for-tab', listener: Function): this; /** * Emitted when the document changed its title, calling event.preventDefault() will * prevent the native window's title from changing. explicitSet is false when title * is synthesized from file url. */ on(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; once(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; addListener(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; removeListener(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; /** * Emitted when the web page has been rendered (while not being shown) and window * can be displayed without a visual flash. */ on(event: 'ready-to-show', listener: Function): this; once(event: 'ready-to-show', listener: Function): this; addListener(event: 'ready-to-show', listener: Function): this; removeListener(event: 'ready-to-show', listener: Function): this; /** * Emitted after the window has been resized. */ on(event: 'resize', listener: Function): this; once(event: 'resize', listener: Function): this; addListener(event: 'resize', listener: Function): this; removeListener(event: 'resize', listener: Function): this; /** * Emitted when the unresponsive web page becomes responsive again. */ on(event: 'responsive', listener: Function): this; once(event: 'responsive', listener: Function): this; addListener(event: 'responsive', listener: Function): this; removeListener(event: 'responsive', listener: Function): this; /** * Emitted when the window is restored from a minimized state. */ on(event: 'restore', listener: Function): this; once(event: 'restore', listener: Function): this; addListener(event: 'restore', listener: Function): this; removeListener(event: 'restore', listener: Function): this; /** * Emitted when scroll wheel event phase has begun. */ on(event: 'scroll-touch-begin', listener: Function): this; once(event: 'scroll-touch-begin', listener: Function): this; addListener(event: 'scroll-touch-begin', listener: Function): this; removeListener(event: 'scroll-touch-begin', listener: Function): this; /** * Emitted when scroll wheel event phase filed upon reaching the edge of element. */ on(event: 'scroll-touch-edge', listener: Function): this; once(event: 'scroll-touch-edge', listener: Function): this; addListener(event: 'scroll-touch-edge', listener: Function): this; removeListener(event: 'scroll-touch-edge', listener: Function): this; /** * Emitted when scroll wheel event phase has ended. */ on(event: 'scroll-touch-end', listener: Function): this; once(event: 'scroll-touch-end', listener: Function): this; addListener(event: 'scroll-touch-end', listener: Function): this; removeListener(event: 'scroll-touch-end', listener: Function): this; /** * Emitted when window session is going to end due to force shutdown or machine * restart or session log off. */ on(event: 'session-end', listener: Function): this; once(event: 'session-end', listener: Function): this; addListener(event: 'session-end', listener: Function): this; removeListener(event: 'session-end', listener: Function): this; /** * Emitted when the window opens a sheet. */ on(event: 'sheet-begin', listener: Function): this; once(event: 'sheet-begin', listener: Function): this; addListener(event: 'sheet-begin', listener: Function): this; removeListener(event: 'sheet-begin', listener: Function): this; /** * Emitted when the window has closed a sheet. */ on(event: 'sheet-end', listener: Function): this; once(event: 'sheet-end', listener: Function): this; addListener(event: 'sheet-end', listener: Function): this; removeListener(event: 'sheet-end', listener: Function): this; /** * Emitted when the window is shown. */ on(event: 'show', listener: Function): this; once(event: 'show', listener: Function): this; addListener(event: 'show', listener: Function): this; removeListener(event: 'show', listener: Function): this; /** * Emitted on 3-finger swipe. Possible directions are up, right, down, left. */ on(event: 'swipe', listener: (event: Event, direction: string) => void): this; once(event: 'swipe', listener: (event: Event, direction: string) => void): this; addListener(event: 'swipe', listener: (event: Event, direction: string) => void): this; removeListener(event: 'swipe', listener: (event: Event, direction: string) => void): this; /** * Emitted when the window exits from a maximized state. */ on(event: 'unmaximize', listener: Function): this; once(event: 'unmaximize', listener: Function): this; addListener(event: 'unmaximize', listener: Function): this; removeListener(event: 'unmaximize', listener: Function): this; /** * Emitted when the web page becomes unresponsive. */ on(event: 'unresponsive', listener: Function): this; once(event: 'unresponsive', listener: Function): this; addListener(event: 'unresponsive', listener: Function): this; removeListener(event: 'unresponsive', listener: Function): this; /** * Emitted before the window is moved. Calling event.preventDefault() will prevent * the window from being moved. Note that this is only emitted when the window is * being resized manually. Resizing the window with setBounds/setSize will not emit * this event. */ on(event: 'will-move', listener: (event: Event, /** * ` Location the window is being moved to. */ newBounds: Rectangle) => void): this; once(event: 'will-move', listener: (event: Event, /** * ` Location the window is being moved to. */ newBounds: Rectangle) => void): this; addListener(event: 'will-move', listener: (event: Event, /** * ` Location the window is being moved to. */ newBounds: Rectangle) => void): this; removeListener(event: 'will-move', listener: (event: Event, /** * ` Location the window is being moved to. */ newBounds: Rectangle) => void): this; /** * Emitted before the window is resized. Calling event.preventDefault() will * prevent the window from being resized. Note that this is only emitted when the * window is being resized manually. Resizing the window with setBounds/setSize * will not emit this event. */ on(event: 'will-resize', listener: (event: Event, /** * ` Size the window is being resized to. */ newBounds: Rectangle) => void): this; once(event: 'will-resize', listener: (event: Event, /** * ` Size the window is being resized to. */ newBounds: Rectangle) => void): this; addListener(event: 'will-resize', listener: (event: Event, /** * ` Size the window is being resized to. */ newBounds: Rectangle) => void): this; removeListener(event: 'will-resize', listener: (event: Event, /** * ` Size the window is being resized to. */ newBounds: Rectangle) => void): this; constructor(options?: BrowserWindowConstructorOptions); /** * Adds DevTools extension located at path, and returns extension's name. The * extension will be remembered so you only need to call this API once, this API is * not for programming use. If you try to add an extension that has already been * loaded, this method will not return and instead log a warning to the console. * The method will also not return if the extension's manifest is missing or * incomplete. Note: This API cannot be called before the ready event of the app * module is emitted. */ static addDevToolsExtension(path: string): void; /** * Adds Chrome extension located at path, and returns extension's name. The method * will also not return if the extension's manifest is missing or incomplete. Note: * This API cannot be called before the ready event of the app module is emitted. */ static addExtension(path: string): void; static fromBrowserView(browserView: BrowserView): (BrowserWindow) | (null); static fromId(id: number): BrowserWindow; static fromWebContents(webContents: WebContents): BrowserWindow; static getAllWindows(): BrowserWindow[]; /** * To check if a DevTools extension is installed you can run the following: Note: * This API cannot be called before the ready event of the app module is emitted. */ static getDevToolsExtensions(): DevToolsExtensions; /** * Note: This API cannot be called before the ready event of the app module is * emitted. */ static getExtensions(): Extensions; static getFocusedWindow(): (BrowserWindow) | (null); /** * Remove a DevTools extension by name. Note: This API cannot be called before the * ready event of the app module is emitted. */ static removeDevToolsExtension(name: string): void; /** * Remove a Chrome extension by name. Note: This API cannot be called before the * ready event of the app module is emitted. */ static removeExtension(name: string): void; /** * Replacement API for setBrowserView supporting work with multi browser views. */ addBrowserView(browserView: BrowserView): void; /** * Adds a window as a tab on this window, after the tab for the window instance. */ addTabbedWindow(browserWindow: BrowserWindow): void; /** * Removes focus from the window. */ blur(): void; blurWebView(): void; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(callback: (image: NativeImage) => void): void; /** * Captures a snapshot of the page within rect. Omitting rect will capture the * whole visible page. */ capturePage(rect?: Rectangle): Promise; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(rect: Rectangle, callback: (image: NativeImage) => void): void; /** * Moves window to the center of the screen. */ center(): void; /** * Try to close the window. This has the same effect as a user manually clicking * the close button of the window. The web page may cancel the close though. See * the close event. */ close(): void; /** * Closes the currently open Quick Look panel. */ closeFilePreview(): void; /** * Force closing the window, the unload and beforeunload event won't be emitted for * the web page, and close event will also not be emitted for this window, but it * guarantees the closed event will be emitted. */ destroy(): void; /** * Starts or stops flashing the window to attract user's attention. */ flashFrame(flag: boolean): void; /** * Focuses on the window. */ focus(): void; focusOnWebView(): void; getBounds(): Rectangle; getBrowserView(): (BrowserView) | (null); /** * Returns array of BrowserView what was an attached with addBrowserView or * setBrowserView. Note: The BrowserView API is currently experimental and may * change or be removed in future Electron releases. */ getBrowserViews(): void; getChildWindows(): BrowserWindow[]; getContentBounds(): Rectangle; getContentSize(): number[]; getMaximumSize(): number[]; getMinimumSize(): number[]; /** * The native type of the handle is HWND on Windows, NSView* on macOS, and Window * (unsigned long) on Linux. */ getNativeWindowHandle(): Buffer; /** * Note: whatever the current state of the window : maximized, minimized or in * fullscreen, this function always returns the position and size of the window in * normal state. In normal state, getBounds and getNormalBounds returns the same * Rectangle. */ getNormalBounds(): Rectangle; getOpacity(): number; getParentWindow(): BrowserWindow; getPosition(): number[]; getRepresentedFilename(): string; getSize(): number[]; /** * Note: The title of the web page can be different from the title of the native * window. */ getTitle(): string; hasShadow(): boolean; /** * Hides the window. */ hide(): void; /** * Hooks a windows message. The callback is called when the message is received in * the WndProc. */ hookWindowMessage(message: number, callback: Function): void; isAlwaysOnTop(): boolean; /** * On Linux always returns true. */ isClosable(): boolean; isDestroyed(): boolean; isDocumentEdited(): boolean; isFocused(): boolean; isFullScreen(): boolean; isFullScreenable(): boolean; isKiosk(): boolean; /** * On Linux always returns true. */ isMaximizable(): boolean; isMaximized(): boolean; isMenuBarAutoHide(): boolean; isMenuBarVisible(): boolean; /** * On Linux always returns true. */ isMinimizable(): boolean; isMinimized(): boolean; isModal(): boolean; /** * On Linux always returns true. */ isMovable(): boolean; isNormal(): boolean; isResizable(): boolean; isSimpleFullScreen(): boolean; isVisible(): boolean; /** * Note: This API always returns false on Windows. */ isVisibleOnAllWorkspaces(): boolean; isWindowMessageHooked(message: number): boolean; /** * Same as webContents.loadFile, filePath should be a path to an HTML file relative * to the root of your application. See the webContents docs for more information. */ loadFile(filePath: string, options?: LoadFileOptions): Promise; /** * Same as webContents.loadURL(url[, options]). The url can be a remote address * (e.g. http://) or a path to a local HTML file using the file:// protocol. To * ensure that file URLs are properly formatted, it is recommended to use Node's * url.format method: You can load a URL using a POST request with URL-encoded data * by doing the following: */ loadURL(url: string, options?: LoadURLOptions): Promise; /** * Maximizes the window. This will also show (but not focus) the window if it isn't * being displayed already. */ maximize(): void; /** * Merges all windows into one window with multiple tabs when native tabs are * enabled and there is more than one open window. */ mergeAllWindows(): void; /** * Minimizes the window. On some platforms the minimized window will be shown in * the Dock. */ minimize(): void; /** * Moves the current tab into a new window if native tabs are enabled and there is * more than one tab in the current window. */ moveTabToNewWindow(): void; /** * Moves window to top(z-order) regardless of focus */ moveTop(): void; /** * Uses Quick Look to preview a file at a given path. */ previewFile(path: string, displayName?: string): void; /** * Same as webContents.reload. */ reload(): void; removeBrowserView(browserView: BrowserView): void; /** * Remove the window's menu bar. */ removeMenu(): void; /** * Restores the window from minimized state to its previous state. */ restore(): void; /** * Selects the next tab when native tabs are enabled and there are other tabs in * the window. */ selectNextTab(): void; /** * Selects the previous tab when native tabs are enabled and there are other tabs * in the window. */ selectPreviousTab(): void; /** * Sets whether the window should show always on top of other windows. After * setting this, the window is still a normal window, not a toolbox window which * can not be focused on. */ setAlwaysOnTop(flag: boolean, level?: 'normal' | 'floating' | 'torn-off-menu' | 'modal-panel' | 'main-menu' | 'status' | 'pop-up-menu' | 'screen-saver', relativeLevel?: number): void; /** * Sets the properties for the window's taskbar button. Note: relaunchCommand and * relaunchDisplayName must always be set together. If one of those properties is * not set, then neither will be used. */ setAppDetails(options: AppDetailsOptions): void; /** * This will make a window maintain an aspect ratio. The extra size allows a * developer to have space, specified in pixels, not included within the aspect * ratio calculations. This API already takes into account the difference between a * window's size and its content size. Consider a normal window with an HD video * player and associated controls. Perhaps there are 15 pixels of controls on the * left edge, 25 pixels of controls on the right edge and 50 pixels of controls * below the player. In order to maintain a 16:9 aspect ratio (standard aspect * ratio for HD @1920x1080) within the player itself we would call this function * with arguments of 16/9 and [ 40, 50 ]. The second argument doesn't care where * the extra width and height are within the content view--only that they exist. * Sum any extra width and height areas you have within the overall content view. * Calling this function with a value of 0 will remove any previously set aspect * ratios. */ setAspectRatio(aspectRatio: number, extraSize: Size): void; /** * Controls whether to hide cursor when typing. */ setAutoHideCursor(autoHide: boolean): void; /** * Sets whether the window menu bar should hide itself automatically. Once set the * menu bar will only show when users press the single Alt key. If the menu bar is * already visible, calling setAutoHideMenuBar(true) won't hide it immediately. */ setAutoHideMenuBar(hide: boolean): void; /** * Sets the background color of the window. See Setting backgroundColor. */ setBackgroundColor(backgroundColor: string): void; /** * Resizes and moves the window to the supplied bounds. Any properties that are not * supplied will default to their current values. */ setBounds(bounds: Rectangle, animate?: boolean): void; setBrowserView(browserView: BrowserView): void; /** * Sets whether the window can be manually closed by user. On Linux does nothing. */ setClosable(closable: boolean): void; /** * Resizes and moves the window's client area (e.g. the web page) to the supplied * bounds. */ setContentBounds(bounds: Rectangle, animate?: boolean): void; /** * Prevents the window contents from being captured by other apps. On macOS it sets * the NSWindow's sharingType to NSWindowSharingNone. On Windows it calls * SetWindowDisplayAffinity with WDA_MONITOR. */ setContentProtection(enable: boolean): void; /** * Resizes the window's client area (e.g. the web page) to width and height. */ setContentSize(width: number, height: number, animate?: boolean): void; /** * Specifies whether the window’s document has been edited, and the icon in title * bar will become gray when set to true. */ setDocumentEdited(edited: boolean): void; /** * Disable or enable the window. */ setEnabled(enable: boolean): void; /** * Changes whether the window can be focused. */ setFocusable(focusable: boolean): void; /** * Sets whether the window should be in fullscreen mode. */ setFullScreen(flag: boolean): void; /** * Sets whether the maximize/zoom window button toggles fullscreen mode or * maximizes the window. */ setFullScreenable(fullscreenable: boolean): void; /** * Sets whether the window should have a shadow. */ setHasShadow(hasShadow: boolean): void; /** * Changes window icon. */ setIcon(icon: NativeImage): void; /** * Makes the window ignore all mouse events. All mouse events happened in this * window will be passed to the window below this window, but if this window has * focus, it will still receive keyboard events. */ setIgnoreMouseEvents(ignore: boolean, options?: IgnoreMouseEventsOptions): void; /** * Enters or leaves the kiosk mode. */ setKiosk(flag: boolean): void; /** * Sets whether the window can be manually maximized by user. On Linux does * nothing. */ setMaximizable(maximizable: boolean): void; /** * Sets the maximum size of window to width and height. */ setMaximumSize(width: number, height: number): void; /** * Sets the menu as the window's menu bar. */ setMenu(menu: (Menu) | (null)): void; /** * Sets whether the menu bar should be visible. If the menu bar is auto-hide, users * can still bring up the menu bar by pressing the single Alt key. */ setMenuBarVisibility(visible: boolean): void; /** * Sets whether the window can be manually minimized by user. On Linux does * nothing. */ setMinimizable(minimizable: boolean): void; /** * Sets the minimum size of window to width and height. */ setMinimumSize(width: number, height: number): void; /** * Sets whether the window can be moved by user. On Linux does nothing. */ setMovable(movable: boolean): void; /** * Sets the opacity of the window. On Linux does nothing. */ setOpacity(opacity: number): void; /** * Sets a 16 x 16 pixel overlay onto the current taskbar icon, usually used to * convey some sort of application status or to passively notify the user. */ setOverlayIcon(overlay: (NativeImage) | (null), description: string): void; /** * Sets parent as current window's parent window, passing null will turn current * window into a top-level window. */ setParentWindow(parent: BrowserWindow): void; /** * Moves window to x and y. */ setPosition(x: number, y: number, animate?: boolean): void; /** * Sets progress value in progress bar. Valid range is [0, 1.0]. Remove progress * bar when progress < 0; Change to indeterminate mode when progress > 1. On Linux * platform, only supports Unity desktop environment, you need to specify the * *.desktop file name to desktopName field in package.json. By default, it will * assume app.getName().desktop. On Windows, a mode can be passed. Accepted values * are none, normal, indeterminate, error, and paused. If you call setProgressBar * without a mode set (but with a value within the valid range), normal will be * assumed. */ setProgressBar(progress: number, options?: ProgressBarOptions): void; /** * Sets the pathname of the file the window represents, and the icon of the file * will show in window's title bar. */ setRepresentedFilename(filename: string): void; /** * Sets whether the window can be manually resized by user. */ setResizable(resizable: boolean): void; /** * Setting a window shape determines the area within the window where the system * permits drawing and user interaction. Outside of the given region, no pixels * will be drawn and no mouse events will be registered. Mouse events outside of * the region will not be received by that window, but will fall through to * whatever is behind the window. */ setShape(rects: Rectangle[]): void; /** * Changes the attachment point for sheets on macOS. By default, sheets are * attached just below the window frame, but you may want to display them beneath a * HTML-rendered toolbar. For example: */ setSheetOffset(offsetY: number, offsetX?: number): void; /** * Enters or leaves simple fullscreen mode. Simple fullscreen mode emulates the * native fullscreen behavior found in versions of Mac OS X prior to Lion (10.7). */ setSimpleFullScreen(flag: boolean): void; /** * Resizes the window to width and height. If width or height are below any set * minimum size constraints the window will snap to its minimum size. */ setSize(width: number, height: number, animate?: boolean): void; /** * Makes the window not show in the taskbar. */ setSkipTaskbar(skip: boolean): void; /** * Add a thumbnail toolbar with a specified set of buttons to the thumbnail image * of a window in a taskbar button layout. Returns a Boolean object indicates * whether the thumbnail has been added successfully. The number of buttons in * thumbnail toolbar should be no greater than 7 due to the limited room. Once you * setup the thumbnail toolbar, the toolbar cannot be removed due to the platform's * limitation. But you can call the API with an empty array to clean the buttons. * The buttons is an array of Button objects: The flags is an array that can * include following Strings: */ setThumbarButtons(buttons: ThumbarButton[]): boolean; /** * Sets the region of the window to show as the thumbnail image displayed when * hovering over the window in the taskbar. You can reset the thumbnail to be the * entire window by specifying an empty region: { x: 0, y: 0, width: 0, height: 0 * }. */ setThumbnailClip(region: Rectangle): void; /** * Sets the toolTip that is displayed when hovering over the window thumbnail in * the taskbar. */ setThumbnailToolTip(toolTip: string): void; /** * Changes the title of native window to title. */ setTitle(title: string): void; /** * Sets the touchBar layout for the current window. Specifying null or undefined * clears the touch bar. This method only has an effect if the machine has a touch * bar and is running on macOS 10.12.1+. Note: The TouchBar API is currently * experimental and may change or be removed in future Electron releases. */ setTouchBar(touchBar: TouchBar): void; /** * Adds a vibrancy effect to the browser window. Passing null or an empty string * will remove the vibrancy effect on the window. */ setVibrancy(type: 'appearance-based' | 'light' | 'dark' | 'titlebar' | 'selection' | 'menu' | 'popover' | 'sidebar' | 'medium-light' | 'ultra-dark'): void; /** * Sets whether the window should be visible on all workspaces. Note: This API does * nothing on Windows. */ setVisibleOnAllWorkspaces(visible: boolean, options?: VisibleOnAllWorkspacesOptions): void; /** * Sets whether the window traffic light buttons should be visible. This cannot be * called when titleBarStyle is set to customButtonsOnHover. */ setWindowButtonVisibility(visible: boolean): void; /** * Shows and gives focus to the window. */ show(): void; /** * Same as webContents.showDefinitionForSelection(). */ showDefinitionForSelection(): void; /** * Shows the window but doesn't focus on it. */ showInactive(): void; /** * Toggles the visibility of the tab bar if native tabs are enabled and there is * only one tab in the current window. */ toggleTabBar(): void; /** * Unhooks all of the window messages. */ unhookAllWindowMessages(): void; /** * Unhook the window message. */ unhookWindowMessage(message: number): void; /** * Unmaximizes the window. */ unmaximize(): void; id: number; webContents: WebContents; } class BrowserWindowProxy extends EventEmitter { // Docs: http://electronjs.org/docs/api/browser-window-proxy /** * Removes focus from the child window. */ blur(): void; /** * Forcefully closes the child window without calling its unload event. */ close(): void; /** * Evaluates the code in the child window. */ eval(code: string): void; /** * Focuses the child window (brings the window to front). */ focus(): void; /** * Sends a message to the child window with the specified origin or * for no origin * preference. In addition to these methods, the child window implements * window.opener object with no properties and a single method. */ postMessage(message: string, targetOrigin: string): void; /** * Invokes the print dialog on the child window. */ print(): void; closed: boolean; } interface Certificate { // Docs: http://electronjs.org/docs/api/structures/certificate /** * PEM encoded data */ data: string; /** * Fingerprint of the certificate */ fingerprint: string; /** * Issuer principal */ issuer: CertificatePrincipal; /** * Issuer certificate (if not self-signed) */ issuerCert: Certificate; /** * Issuer's Common Name */ issuerName: string; /** * Hex value represented string */ serialNumber: string; /** * Subject principal */ subject: CertificatePrincipal; /** * Subject's Common Name */ subjectName: string; /** * End date of the certificate being valid in seconds */ validExpiry: number; /** * Start date of the certificate being valid in seconds */ validStart: number; } interface CertificatePrincipal { // Docs: http://electronjs.org/docs/api/structures/certificate-principal /** * Common Name. */ commonName: string; /** * Country or region. */ country: string; /** * Locality. */ locality: string; /** * Organization names. */ organizations: string[]; /** * Organization Unit names. */ organizationUnits: string[]; /** * State or province. */ state: string; } class ClientRequest extends EventEmitter { // Docs: http://electronjs.org/docs/api/client-request /** * Emitted when the request is aborted. The abort event will not be fired if the * request is already closed. */ on(event: 'abort', listener: Function): this; once(event: 'abort', listener: Function): this; addListener(event: 'abort', listener: Function): this; removeListener(event: 'abort', listener: Function): this; /** * Emitted as the last event in the HTTP request-response transaction. The close * event indicates that no more events will be emitted on either the request or * response objects. */ on(event: 'close', listener: Function): this; once(event: 'close', listener: Function): this; addListener(event: 'close', listener: Function): this; removeListener(event: 'close', listener: Function): this; /** * Emitted when the net module fails to issue a network request. Typically when the * request object emits an error event, a close event will subsequently follow and * no response object will be provided. */ on(event: 'error', listener: ( /** * an error object providing some information about the failure. */ error: Error) => void): this; once(event: 'error', listener: ( /** * an error object providing some information about the failure. */ error: Error) => void): this; addListener(event: 'error', listener: ( /** * an error object providing some information about the failure. */ error: Error) => void): this; removeListener(event: 'error', listener: ( /** * an error object providing some information about the failure. */ error: Error) => void): this; /** * Emitted just after the last chunk of the request's data has been written into * the request object. */ on(event: 'finish', listener: Function): this; once(event: 'finish', listener: Function): this; addListener(event: 'finish', listener: Function): this; removeListener(event: 'finish', listener: Function): this; /** * Emitted when an authenticating proxy is asking for user credentials. The * callback function is expected to be called back with user credentials: Providing * empty credentials will cancel the request and report an authentication error on * the response object: */ on(event: 'login', listener: (authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; once(event: 'login', listener: (authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; addListener(event: 'login', listener: (authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; removeListener(event: 'login', listener: (authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; /** * Emitted when there is redirection and the mode is manual. Calling * request.followRedirect will continue with the redirection. */ on(event: 'redirect', listener: (statusCode: number, method: string, redirectUrl: string, responseHeaders: any) => void): this; once(event: 'redirect', listener: (statusCode: number, method: string, redirectUrl: string, responseHeaders: any) => void): this; addListener(event: 'redirect', listener: (statusCode: number, method: string, redirectUrl: string, responseHeaders: any) => void): this; removeListener(event: 'redirect', listener: (statusCode: number, method: string, redirectUrl: string, responseHeaders: any) => void): this; on(event: 'response', listener: ( /** * An object representing the HTTP response message. */ response: IncomingMessage) => void): this; once(event: 'response', listener: ( /** * An object representing the HTTP response message. */ response: IncomingMessage) => void): this; addListener(event: 'response', listener: ( /** * An object representing the HTTP response message. */ response: IncomingMessage) => void): this; removeListener(event: 'response', listener: ( /** * An object representing the HTTP response message. */ response: IncomingMessage) => void): this; constructor(options: 'method' | 'url' | 'session' | 'partition' | 'protocol' | 'host' | 'hostname' | 'port' | 'path' | 'redirect'); /** * Cancels an ongoing HTTP transaction. If the request has already emitted the * close event, the abort operation will have no effect. Otherwise an ongoing event * will emit abort and close events. Additionally, if there is an ongoing response * object,it will emit the aborted event. */ abort(): void; /** * Sends the last chunk of the request data. Subsequent write or end operations * will not be allowed. The finish event is emitted just after the end operation. */ end(chunk?: (string) | (Buffer), encoding?: string, callback?: Function): void; /** * Continues any deferred redirection request when the redirection mode is manual. */ followRedirect(): void; getHeader(name: string): Header; /** * You can use this method in conjunction with POST requests to get the progress of * a file upload or other data transfer. */ getUploadProgress(): UploadProgress; /** * Removes a previously set extra header name. This method can be called only * before first write. Trying to call it after the first write will throw an error. */ removeHeader(name: string): void; /** * Adds an extra HTTP header. The header name will issued as it is without * lowercasing. It can be called only before first write. Calling this method after * the first write will throw an error. If the passed value is not a String, its * toString() method will be called to obtain the final value. */ setHeader(name: string, value: any): void; /** * callback is essentially a dummy function introduced in the purpose of keeping * similarity with the Node.js API. It is called asynchronously in the next tick * after chunk content have been delivered to the Chromium networking layer. * Contrary to the Node.js implementation, it is not guaranteed that chunk content * have been flushed on the wire before callback is called. Adds a chunk of data to * the request body. The first write operation may cause the request headers to be * issued on the wire. After the first write operation, it is not allowed to add or * remove a custom header. */ write(chunk: (string) | (Buffer), encoding?: string, callback?: Function): void; chunkedEncoding: boolean; } interface Clipboard extends EventEmitter { // Docs: http://electronjs.org/docs/api/clipboard availableFormats(type?: 'selection' | 'clipboard'): string[]; /** * Clears the clipboard content. */ clear(type?: 'selection' | 'clipboard'): void; has(format: string, type?: 'selection' | 'clipboard'): boolean; read(format: string): string; /** * Returns an Object containing title and url keys representing the bookmark in the * clipboard. The title and url values will be empty strings when the bookmark is * unavailable. */ readBookmark(): ReadBookmark; readBuffer(format: string): Buffer; /** * This method uses synchronous IPC when called from the renderer process. The * cached value is reread from the find pasteboard whenever the application is * activated. */ readFindText(): string; readHTML(type?: 'selection' | 'clipboard'): string; readImage(type?: 'selection' | 'clipboard'): NativeImage; readRTF(type?: 'selection' | 'clipboard'): string; readText(type?: 'selection' | 'clipboard'): string; /** * Writes data to the clipboard. */ write(data: Data, type?: 'selection' | 'clipboard'): void; /** * Writes the title and url into the clipboard as a bookmark. Note: Most apps on * Windows don't support pasting bookmarks into them so you can use clipboard.write * to write both a bookmark and fallback text to the clipboard. */ writeBookmark(title: string, url: string, type?: 'selection' | 'clipboard'): void; /** * Writes the buffer into the clipboard as format. */ writeBuffer(format: string, buffer: Buffer, type?: 'selection' | 'clipboard'): void; /** * Writes the text into the find pasteboard (the pasteboard that holds information * about the current state of the active application’s find panel) as plain text. * This method uses synchronous IPC when called from the renderer process. */ writeFindText(text: string): void; /** * Writes markup to the clipboard. */ writeHTML(markup: string, type?: 'selection' | 'clipboard'): void; /** * Writes image to the clipboard. */ writeImage(image: NativeImage, type?: 'selection' | 'clipboard'): void; /** * Writes the text into the clipboard in RTF. */ writeRTF(text: string, type?: 'selection' | 'clipboard'): void; /** * Writes the text into the clipboard as plain text. */ writeText(text: string, type?: 'selection' | 'clipboard'): void; } interface ContentTracing extends EventEmitter { // Docs: http://electronjs.org/docs/api/content-tracing /** * Get a set of category groups. The category groups can change as new code paths * are reached. Once all child processes have acknowledged the getCategories * request the callback is invoked with an array of category groups. Deprecated * Soon */ getCategories(callback: (categories: string[]) => void): void; /** * Get a set of category groups. The category groups can change as new code paths * are reached. */ getCategories(): Promise; /** * Get the maximum usage across processes of trace buffer as a percentage of the * full state. When the TraceBufferUsage value is determined the callback is * called. Deprecated Soon */ getTraceBufferUsage(callback: (value: number) => void): void; /** * Get the maximum usage across processes of trace buffer as a percentage of the * full state. */ getTraceBufferUsage(): Promise; /** * Start recording on all processes. Recording begins immediately locally and * asynchronously on child processes as soon as they receive the EnableRecording * request. The callback will be called once all child processes have acknowledged * the startRecording request. Deprecated Soon */ startRecording(options: (TraceCategoriesAndOptions) | (TraceConfig), callback: Function): void; /** * Start recording on all processes. Recording begins immediately locally and * asynchronously on child processes as soon as they receive the EnableRecording * request. */ startRecording(options: (TraceCategoriesAndOptions) | (TraceConfig)): Promise; /** * Stop recording on all processes. Child processes typically cache trace data and * only rarely flush and send trace data back to the main process. This helps to * minimize the runtime overhead of tracing since sending trace data over IPC can * be an expensive operation. So, to end tracing, we must asynchronously ask all * child processes to flush any pending trace data. Once all child processes have * acknowledged the stopRecording request, callback will be called with a file that * contains the traced data. Trace data will be written into resultFilePath if it * is not empty or into a temporary file. The actual file path will be passed to * callback if it's not null. Deprecated Soon */ stopRecording(resultFilePath: string, callback: (resultFilePath: string) => void): void; /** * Stop recording on all processes. Child processes typically cache trace data and * only rarely flush and send trace data back to the main process. This helps to * minimize the runtime overhead of tracing since sending trace data over IPC can * be an expensive operation. So, to end tracing, we must asynchronously ask all * child processes to flush any pending trace data. Trace data will be written into * resultFilePath if it is not empty or into a temporary file. */ stopRecording(resultFilePath: string): Promise; } interface ContextBridge extends EventEmitter { // Docs: http://electronjs.org/docs/api/context-bridge exposeInMainWorld(apiKey: string, api: Record): void; } interface Cookie { // Docs: http://electronjs.org/docs/api/structures/cookie /** * The domain of the cookie; this will be normalized with a preceding dot so that * it's also valid for subdomains. */ domain?: string; /** * The expiration date of the cookie as the number of seconds since the UNIX epoch. * Not provided for session cookies. */ expirationDate?: number; /** * Whether the cookie is a host-only cookie; this will only be true if no domain * was passed. */ hostOnly?: boolean; /** * Whether the cookie is marked as HTTP only. */ httpOnly?: boolean; /** * The name of the cookie. */ name: string; /** * The path of the cookie. */ path?: string; /** * Whether the cookie is marked as secure. */ secure?: boolean; /** * Whether the cookie is a session cookie or a persistent cookie with an expiration * date. */ session?: boolean; /** * The value of the cookie. */ value: string; } class Cookies extends EventEmitter { // Docs: http://electronjs.org/docs/api/cookies /** * Emitted when a cookie is changed because it was added, edited, removed, or * expired. */ on(event: 'changed', listener: (event: Event, /** * The cookie that was changed. */ cookie: Cookie, /** * The cause of the change with one of the following values: */ cause: ('explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite'), /** * `true` if the cookie was removed, `false` otherwise. */ removed: boolean) => void): this; once(event: 'changed', listener: (event: Event, /** * The cookie that was changed. */ cookie: Cookie, /** * The cause of the change with one of the following values: */ cause: ('explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite'), /** * `true` if the cookie was removed, `false` otherwise. */ removed: boolean) => void): this; addListener(event: 'changed', listener: (event: Event, /** * The cookie that was changed. */ cookie: Cookie, /** * The cause of the change with one of the following values: */ cause: ('explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite'), /** * `true` if the cookie was removed, `false` otherwise. */ removed: boolean) => void): this; removeListener(event: 'changed', listener: (event: Event, /** * The cookie that was changed. */ cookie: Cookie, /** * The cause of the change with one of the following values: */ cause: ('explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite'), /** * `true` if the cookie was removed, `false` otherwise. */ removed: boolean) => void): this; /** * Writes any unwritten cookies data to disk. */ flushStore(): Promise; /** * Writes any unwritten cookies data to disk. Deprecated Soon */ flushStore(callback: Function): void; /** * Sends a request to get all cookies matching filter, and resolves a promise with * the response. */ get(filter: Filter): Promise; /** * Sends a request to get all cookies matching filter, callback will be called with * callback(error, cookies) on complete. Deprecated Soon */ get(filter: Filter, callback: (error: Error, cookies: Cookie[]) => void): void; /** * Removes the cookies matching url and name */ remove(url: string, name: string): Promise; /** * Removes the cookies matching url and name, callback will called with callback() * on complete. Deprecated Soon */ remove(url: string, name: string, callback: Function): void; /** * Sets a cookie with details. */ set(details: Details): Promise; /** * Sets a cookie with details, callback will be called with callback(error) on * complete. Deprecated Soon */ set(details: Details, callback: (error: Error) => void): void; } interface CPUUsage { // Docs: http://electronjs.org/docs/api/structures/cpu-usage /** * The number of average idle cpu wakeups per second since the last call to * getCPUUsage. First call returns 0. Will always return 0 on Windows. */ idleWakeupsPerSecond: number; /** * Percentage of CPU used since the last call to getCPUUsage. First call returns 0. */ percentCPUUsage: number; } interface CrashReport { // Docs: http://electronjs.org/docs/api/structures/crash-report date: Date; id: string; } interface CrashReporter { // Docs: http://electronjs.org/docs/api/crash-reporter /** * Set an extra parameter to be sent with the crash report. The values specified * here will be sent in addition to any values set via the extra option when start * was called. This API is only available on macOS and windows, if you need to * add/update extra parameters on Linux after your first call to start you can call * start again with the updated extra options. */ addExtraParameter(key: string, value: string): void; /** * Returns the date and ID of the last crash report. Only crash reports that have * been uploaded will be returned; even if a crash report is present on disk it * will not be returned until it is uploaded. In the case that there are no * uploaded reports, null is returned. */ getLastCrashReport(): CrashReport; /** * See all of the current parameters being passed to the crash reporter. */ getParameters(): void; /** * Returns all uploaded crash reports. Each report contains the date and uploaded * ID. */ getUploadedReports(): CrashReport[]; /** * Note: This API can only be called from the main process. */ getUploadToServer(): boolean; /** * Remove a extra parameter from the current set of parameters so that it will not * be sent with the crash report. */ removeExtraParameter(key: string): void; /** * This would normally be controlled by user preferences. This has no effect if * called before start is called. Note: This API can only be called from the main * process. */ setUploadToServer(uploadToServer: boolean): void; /** * You are required to call this method before using any other crashReporter APIs * and in each process (main/renderer) from which you want to collect crash * reports. You can pass different options to crashReporter.start when calling from * different processes. Note Child processes created via the child_process module * will not have access to the Electron modules. Therefore, to collect crash * reports from them, use process.crashReporter.start instead. Pass the same * options as above along with an additional one called crashesDirectory that * should point to a directory to store the crash reports temporarily. You can test * this out by calling process.crash() to crash the child process. Note: If you * need send additional/updated extra parameters after your first call start you * can call addExtraParameter on macOS or call start again with the new/updated * extra parameters on Linux and Windows. Note: On macOS and windows, Electron uses * a new crashpad client for crash collection and reporting. If you want to enable * crash reporting, initializing crashpad from the main process using * crashReporter.start is required regardless of which process you want to collect * crashes from. Once initialized this way, the crashpad handler collects crashes * from all processes. You still have to call crashReporter.start from the renderer * or child process, otherwise crashes from them will get reported without * companyName, productName or any of the extra information. */ start(options: CrashReporterStartOptions): void; } interface CustomScheme { // Docs: http://electronjs.org/docs/api/structures/custom-scheme privileges?: Privileges; /** * Custom schemes to be registered with options. */ scheme: string; } class Debugger extends EventEmitter { // Docs: http://electronjs.org/docs/api/debugger /** * Emitted when debugging session is terminated. This happens either when * webContents is closed or devtools is invoked for the attached webContents. */ on(event: 'detach', listener: (event: Event, /** * Reason for detaching debugger. */ reason: string) => void): this; once(event: 'detach', listener: (event: Event, /** * Reason for detaching debugger. */ reason: string) => void): this; addListener(event: 'detach', listener: (event: Event, /** * Reason for detaching debugger. */ reason: string) => void): this; removeListener(event: 'detach', listener: (event: Event, /** * Reason for detaching debugger. */ reason: string) => void): this; /** * Emitted whenever debugging target issues instrumentation event. */ on(event: 'message', listener: (event: Event, /** * Method name. */ method: string, /** * Event parameters defined by the 'parameters' attribute in the remote debugging * protocol. */ params: any) => void): this; once(event: 'message', listener: (event: Event, /** * Method name. */ method: string, /** * Event parameters defined by the 'parameters' attribute in the remote debugging * protocol. */ params: any) => void): this; addListener(event: 'message', listener: (event: Event, /** * Method name. */ method: string, /** * Event parameters defined by the 'parameters' attribute in the remote debugging * protocol. */ params: any) => void): this; removeListener(event: 'message', listener: (event: Event, /** * Method name. */ method: string, /** * Event parameters defined by the 'parameters' attribute in the remote debugging * protocol. */ params: any) => void): this; /** * Attaches the debugger to the webContents. */ attach(protocolVersion?: string): void; /** * Detaches the debugger from the webContents. */ detach(): void; isAttached(): boolean; /** * Send given command to the debugging target. Deprecated Soon */ sendCommand(method: string, commandParams?: any, callback?: (error: any, result: any) => void): void; /** * Send given command to the debugging target. */ sendCommand(method: string, commandParams?: any): Promise; } interface DesktopCapturer extends EventEmitter { // Docs: http://electronjs.org/docs/api/desktop-capturer /** * Starts gathering information about all available desktop media sources, and * calls callback(error, sources) when finished. sources is an array of * DesktopCapturerSource objects, each DesktopCapturerSource represents a screen or * an individual window that can be captured. Deprecated Soon */ getSources(options: SourcesOptions, callback: (error: Error, sources: DesktopCapturerSource[]) => void): void; getSources(options: SourcesOptions): Promise; } interface DesktopCapturerSource { // Docs: http://electronjs.org/docs/api/structures/desktop-capturer-source /** * An icon image of the application that owns the window or null if the source has * a type screen. The size of the icon is not known in advance and depends on what * the the application provides. */ appIcon: NativeImage; /** * A unique identifier that will correspond to the id of the matching returned by * the . On some platforms, this is equivalent to the XX portion of the id field * above and on others it will differ. It will be an empty string if not available. */ display_id: string; /** * The identifier of a window or screen that can be used as a chromeMediaSourceId * constraint when calling [navigator.webkitGetUserMedia]. The format of the * identifier will be window:XX or screen:XX, where XX is a random generated * number. */ id: string; /** * A screen source will be named either Entire Screen or Screen , while the name of * a window source will match the window title. */ name: string; /** * A thumbnail image. There is no guarantee that the size of the thumbnail is the * same as the thumbnailSize specified in the options passed to * desktopCapturer.getSources. The actual size depends on the scale of the screen * or window. */ thumbnail: NativeImage; } interface Dialog extends EventEmitter { // Docs: http://electronjs.org/docs/api/dialog /** * On macOS, this displays a modal dialog that shows a message and certificate * information, and gives the user the option of trusting/importing the * certificate. If you provide a browserWindow argument the dialog will be attached * to the parent window, making it modal. On Windows the options are more limited, * due to the Win32 APIs used: Deprecated Soon */ showCertificateTrustDialog(browserWindow: BrowserWindow, options: CertificateTrustDialogOptions, callback: Function): void; /** * On macOS, this displays a modal dialog that shows a message and certificate * information, and gives the user the option of trusting/importing the * certificate. If you provide a browserWindow argument the dialog will be attached * to the parent window, making it modal. On Windows the options are more limited, * due to the Win32 APIs used: */ showCertificateTrustDialog(options: CertificateTrustDialogOptions): Promise; /** * On macOS, this displays a modal dialog that shows a message and certificate * information, and gives the user the option of trusting/importing the * certificate. If you provide a browserWindow argument the dialog will be attached * to the parent window, making it modal. On Windows the options are more limited, * due to the Win32 APIs used: Deprecated Soon */ showCertificateTrustDialog(options: CertificateTrustDialogOptions, callback: Function): void; /** * On macOS, this displays a modal dialog that shows a message and certificate * information, and gives the user the option of trusting/importing the * certificate. If you provide a browserWindow argument the dialog will be attached * to the parent window, making it modal. On Windows the options are more limited, * due to the Win32 APIs used: */ showCertificateTrustDialog(browserWindow: BrowserWindow, options: CertificateTrustDialogOptions): Promise; /** * On macOS, this displays a modal dialog that shows a message and certificate * information, and gives the user the option of trusting/importing the * certificate. If you provide a browserWindow argument the dialog will be attached * to the parent window, making it modal. On Windows the options are more limited, * due to the Win32 APIs used: Deprecated Soon */ showCertificateTrustDialog(browserWindow: BrowserWindow, options: CertificateTrustDialogOptions, callback: Function): void; /** * Displays a modal dialog that shows an error message. This API can be called * safely before the ready event the app module emits, it is usually used to report * errors in early stage of startup. If called before the app readyevent on Linux, * the message will be emitted to stderr, and no GUI dialog will appear. */ showErrorBox(title: string, content: string): void; /** * Shows a message box, it will block the process until the message box is closed. * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. */ showMessageBox(browserWindow: BrowserWindow, options: MessageBoxOptions): Promise; /** * Shows a message box, it will block the process until the message box is closed. * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. */ showMessageBox(options: MessageBoxOptions): Promise; /** * Shows a message box, it will block the process until the message box is closed. * It returns the index of the clicked button. The browserWindow argument allows * the dialog to attach itself to a parent window, making it modal. */ showMessageBoxSync(browserWindow: BrowserWindow, options: MessageBoxSyncOptions): number; /** * Shows a message box, it will block the process until the message box is closed. * It returns the index of the clicked button. The browserWindow argument allows * the dialog to attach itself to a parent window, making it modal. */ showMessageBoxSync(options: MessageBoxSyncOptions): number; /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed or selected when you want to limit the user to a specific type. For * example: The extensions array should contain extensions without wildcards or * dots (e.g. 'png' is good but '.png' and '*.png' are bad). To show all files, use * the '*' wildcard (no other wildcard is supported). Note: On Windows and Linux an * open dialog can not be both a file selector and a directory selector, so if you * set properties to ['openFile', 'openDirectory'] on these platforms, a directory * selector will be shown. */ showOpenDialog(browserWindow: BrowserWindow, options: OpenDialogOptions, callback?: Function): Promise; /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed or selected when you want to limit the user to a specific type. For * example: The extensions array should contain extensions without wildcards or * dots (e.g. 'png' is good but '.png' and '*.png' are bad). To show all files, use * the '*' wildcard (no other wildcard is supported). Note: On Windows and Linux an * open dialog can not be both a file selector and a directory selector, so if you * set properties to ['openFile', 'openDirectory'] on these platforms, a directory * selector will be shown. */ showOpenDialog(options: OpenDialogOptions, callback?: Function): Promise; /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed or selected when you want to limit the user to a specific type. For * example: The extensions array should contain extensions without wildcards or * dots (e.g. 'png' is good but '.png' and '*.png' are bad). To show all files, use * the '*' wildcard (no other wildcard is supported). Note: On Windows and Linux an * open dialog can not be both a file selector and a directory selector, so if you * set properties to ['openFile', 'openDirectory'] on these platforms, a directory * selector will be shown. */ showOpenDialogSync(browserWindow: BrowserWindow, options: OpenDialogSyncOptions): (string[]) | (undefined); /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed or selected when you want to limit the user to a specific type. For * example: The extensions array should contain extensions without wildcards or * dots (e.g. 'png' is good but '.png' and '*.png' are bad). To show all files, use * the '*' wildcard (no other wildcard is supported). Note: On Windows and Linux an * open dialog can not be both a file selector and a directory selector, so if you * set properties to ['openFile', 'openDirectory'] on these platforms, a directory * selector will be shown. */ showOpenDialogSync(options: OpenDialogSyncOptions): (string[]) | (undefined); /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed, see dialog.showOpenDialog for an example. Note: On macOS, using * the asynchronous version is recommended to avoid issues when expanding and * collapsing the dialog. */ showSaveDialog(options: SaveDialogOptions): Promise; /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed, see dialog.showOpenDialog for an example. Note: On macOS, using * the asynchronous version is recommended to avoid issues when expanding and * collapsing the dialog. */ showSaveDialog(browserWindow: BrowserWindow, options: SaveDialogOptions): Promise; /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed, see dialog.showOpenDialog for an example. */ showSaveDialogSync(options: SaveDialogSyncOptions): (string) | (undefined); /** * The browserWindow argument allows the dialog to attach itself to a parent * window, making it modal. The filters specifies an array of file types that can * be displayed, see dialog.showOpenDialog for an example. */ showSaveDialogSync(browserWindow: BrowserWindow, options: SaveDialogSyncOptions): (string) | (undefined); } interface Display { // Docs: http://electronjs.org/docs/api/structures/display /** * Can be available, unavailable, unknown. */ accelerometerSupport: ('available' | 'unavailable' | 'unknown'); bounds: Rectangle; /** * The number of bits per pixel. */ colorDepth: number; /** * represent a color space (three-dimensional object which contains all realizable * color combinations) for the purpose of color conversions */ colorSpace: string; /** * The number of bits per color component. */ depthPerComponent: number; /** * Unique identifier associated with the display. */ id: number; /** * true for an internal display and false for an external display */ internal: boolean; /** * Whether or not the display is a monochrome display. */ monochrome: boolean; /** * Can be 0, 90, 180, 270, represents screen rotation in clock-wise degrees. */ rotation: number; /** * Output device's pixel scale factor. */ scaleFactor: number; size: Size; /** * Can be available, unavailable, unknown. */ touchSupport: ('available' | 'unavailable' | 'unknown'); workArea: Rectangle; workAreaSize: Size; } class DownloadItem extends EventEmitter { // Docs: http://electronjs.org/docs/api/download-item /** * Emitted when the download is in a terminal state. This includes a completed * download, a cancelled download (via downloadItem.cancel()), and interrupted * download that can't be resumed. The state can be one of following: */ on(event: 'done', listener: (event: Event, /** * Can be `completed`, `cancelled` or `interrupted`. */ state: ('completed' | 'cancelled' | 'interrupted')) => void): this; once(event: 'done', listener: (event: Event, /** * Can be `completed`, `cancelled` or `interrupted`. */ state: ('completed' | 'cancelled' | 'interrupted')) => void): this; addListener(event: 'done', listener: (event: Event, /** * Can be `completed`, `cancelled` or `interrupted`. */ state: ('completed' | 'cancelled' | 'interrupted')) => void): this; removeListener(event: 'done', listener: (event: Event, /** * Can be `completed`, `cancelled` or `interrupted`. */ state: ('completed' | 'cancelled' | 'interrupted')) => void): this; /** * Emitted when the download has been updated and is not done. The state can be one * of following: */ on(event: 'updated', listener: (event: Event, /** * Can be `progressing` or `interrupted`. */ state: ('progressing' | 'interrupted')) => void): this; once(event: 'updated', listener: (event: Event, /** * Can be `progressing` or `interrupted`. */ state: ('progressing' | 'interrupted')) => void): this; addListener(event: 'updated', listener: (event: Event, /** * Can be `progressing` or `interrupted`. */ state: ('progressing' | 'interrupted')) => void): this; removeListener(event: 'updated', listener: (event: Event, /** * Can be `progressing` or `interrupted`. */ state: ('progressing' | 'interrupted')) => void): this; /** * Cancels the download operation. */ cancel(): void; canResume(): boolean; getContentDisposition(): string; getETag(): string; /** * Note: The file name is not always the same as the actual one saved in local * disk. If user changes the file name in a prompted download saving dialog, the * actual name of saved file will be different. */ getFilename(): string; getLastModifiedTime(): string; getMimeType(): string; getReceivedBytes(): number; getSaveDialogOptions(): SaveDialogOptions; getSavePath(): string; getStartTime(): number; /** * Note: The following methods are useful specifically to resume a cancelled item * when session is restarted. */ getState(): ('progressing' | 'completed' | 'cancelled' | 'interrupted'); /** * If the size is unknown, it returns 0. */ getTotalBytes(): number; getURL(): string; getURLChain(): string[]; hasUserGesture(): boolean; isPaused(): boolean; /** * Pauses the download. */ pause(): void; /** * Resumes the download that has been paused. Note: To enable resumable downloads * the server you are downloading from must support range requests and provide both * Last-Modified and ETag header values. Otherwise resume() will dismiss previously * received bytes and restart the download from the beginning. */ resume(): void; /** * This API allows the user to set custom options for the save dialog that opens * for the download item by default. The API is only available in session's * will-download callback function. */ setSaveDialogOptions(options: SaveDialogOptions): void; /** * The API is only available in session's will-download callback function. If user * doesn't set the save path via the API, Electron will use the original routine to * determine the save path(Usually prompts a save dialog). */ setSavePath(path: string): void; } interface Event extends GlobalEvent { // Docs: http://electronjs.org/docs/api/structures/event preventDefault: (() => void); } interface FileFilter { // Docs: http://electronjs.org/docs/api/structures/file-filter extensions: string[]; name: string; } interface GlobalShortcut extends EventEmitter { // Docs: http://electronjs.org/docs/api/global-shortcut /** * When the accelerator is already taken by other applications, this call will * still return false. This behavior is intended by operating systems, since they * don't want applications to fight for global shortcuts. */ isRegistered(accelerator: Accelerator): boolean; /** * Registers a global shortcut of accelerator. The callback is called when the * registered shortcut is pressed by the user. When the accelerator is already * taken by other applications, this call will silently fail. This behavior is * intended by operating systems, since they don't want applications to fight for * global shortcuts. The following accelerators will not be registered successfully * on macOS 10.14 Mojave unless the app has been authorized as a trusted * accessibility client: */ register(accelerator: Accelerator, callback: Function): boolean; /** * Registers a global shortcut of all accelerator items in accelerators. The * callback is called when any of the registered shortcuts are pressed by the user. * When a given accelerator is already taken by other applications, this call will * silently fail. This behavior is intended by operating systems, since they don't * want applications to fight for global shortcuts. The following accelerators will * not be registered successfully on macOS 10.14 Mojave unless the app has been * authorized as a trusted accessibility client: */ registerAll(accelerators: string[], callback: Function): void; /** * Unregisters the global shortcut of accelerator. */ unregister(accelerator: Accelerator): void; /** * Unregisters all of the global shortcuts. */ unregisterAll(): void; } interface GPUFeatureStatus { // Docs: http://electronjs.org/docs/api/structures/gpu-feature-status /** * Canvas. */ '2d_canvas': string; /** * Flash. */ flash_3d: string; /** * Flash Stage3D. */ flash_stage3d: string; /** * Flash Stage3D Baseline profile. */ flash_stage3d_baseline: string; /** * Compositing. */ gpu_compositing: string; /** * Multiple Raster Threads. */ multiple_raster_threads: string; /** * Native GpuMemoryBuffers. */ native_gpu_memory_buffers: string; /** * Rasterization. */ rasterization: string; /** * Video Decode. */ video_decode: string; /** * Video Encode. */ video_encode: string; /** * VPx Video Decode. */ vpx_decode: string; /** * WebGL. */ webgl: string; /** * WebGL2. */ webgl2: string; } interface InAppPurchase extends EventEmitter { // Docs: http://electronjs.org/docs/api/in-app-purchase /** * Emitted when one or more transactions have been updated. */ on(event: 'transactions-updated', listener: (event: Event, /** * Array of objects. */ transactions: Transaction[]) => void): this; once(event: 'transactions-updated', listener: (event: Event, /** * Array of objects. */ transactions: Transaction[]) => void): this; addListener(event: 'transactions-updated', listener: (event: Event, /** * Array of objects. */ transactions: Transaction[]) => void): this; removeListener(event: 'transactions-updated', listener: (event: Event, /** * Array of objects. */ transactions: Transaction[]) => void): this; canMakePayments(): boolean; /** * Completes all pending transactions. */ finishAllTransactions(): void; /** * Completes the pending transactions corresponding to the date. */ finishTransactionByDate(date: string): void; /** * Retrieves the product descriptions. Deprecated Soon */ getProducts(productIDs: string[], callback: (products: Product[]) => void): void; /** * Retrieves the product descriptions. */ getProducts(productIDs: string[]): Promise; getReceiptURL(): string; /** * You should listen for the transactions-updated event as soon as possible and * certainly before you call purchaseProduct. Deprecated Soon */ purchaseProduct(productID: string, quantity?: number, callback?: (isProductValid: boolean) => void): void; /** * You should listen for the transactions-updated event as soon as possible and * certainly before you call purchaseProduct. */ purchaseProduct(productID: string, quantity?: number): Promise; } class IncomingMessage extends EventEmitter { // Docs: http://electronjs.org/docs/api/incoming-message /** * Emitted when a request has been canceled during an ongoing HTTP transaction. */ on(event: 'aborted', listener: Function): this; once(event: 'aborted', listener: Function): this; addListener(event: 'aborted', listener: Function): this; removeListener(event: 'aborted', listener: Function): this; /** * The data event is the usual method of transferring response data into * applicative code. */ on(event: 'data', listener: ( /** * A chunk of response body's data. */ chunk: Buffer) => void): this; once(event: 'data', listener: ( /** * A chunk of response body's data. */ chunk: Buffer) => void): this; addListener(event: 'data', listener: ( /** * A chunk of response body's data. */ chunk: Buffer) => void): this; removeListener(event: 'data', listener: ( /** * A chunk of response body's data. */ chunk: Buffer) => void): this; /** * Indicates that response body has ended. */ on(event: 'end', listener: Function): this; once(event: 'end', listener: Function): this; addListener(event: 'end', listener: Function): this; removeListener(event: 'end', listener: Function): this; /** * error Error - Typically holds an error string identifying failure root cause. * Emitted when an error was encountered while streaming response data events. For * instance, if the server closes the underlying while the response is still * streaming, an error event will be emitted on the response object and a close * event will subsequently follow on the request object. */ on(event: 'error', listener: Function): this; once(event: 'error', listener: Function): this; addListener(event: 'error', listener: Function): this; removeListener(event: 'error', listener: Function): this; headers: any; httpVersion: string; httpVersionMajor: number; httpVersionMinor: number; statusCode: number; statusMessage: string; } interface IOCounters { // Docs: http://electronjs.org/docs/api/structures/io-counters /** * Then number of I/O other operations. */ otherOperationCount: number; /** * Then number of I/O other transfers. */ otherTransferCount: number; /** * The number of I/O read operations. */ readOperationCount: number; /** * The number of I/O read transfers. */ readTransferCount: number; /** * The number of I/O write operations. */ writeOperationCount: number; /** * The number of I/O write transfers. */ writeTransferCount: number; } interface IpcMain extends EventEmitter { // Docs: http://electronjs.org/docs/api/ipc-main /** * Listens to channel, when a new message arrives listener would be called with * listener(event, args...). */ on(channel: string, listener: (event: IpcMainEvent, ...args: any[]) => void): this; /** * Adds a one time listener function for the event. This listener is invoked only * the next time a message is sent to channel, after which it is removed. */ once(channel: string, listener: (event: IpcMainEvent, ...args: any[]) => void): this; /** * Removes listeners of the specified channel. */ removeAllListeners(channel: string): this; /** * Removes the specified listener from the listener array for the specified * channel. */ removeListener(channel: string, listener: Function): this; } interface IpcMainEvent extends Event { // Docs: http://electronjs.org/docs/api/structures/ipc-main-event /** * The ID of the renderer frame that sent this message */ frameId: number; /** * A function that will send an IPC message to the renderer frame that sent the * original message that you are currently handling. You should use this method to * "reply" to the sent message in order to guaruntee the reply will go to the * correct process and frame. */ reply: Function; /** * Set this to the value to be returned in a syncronous message */ returnValue: any; /** * Returns the webContents that sent the message */ sender: WebContents; } interface IpcRenderer extends EventEmitter { // Docs: http://electronjs.org/docs/api/ipc-renderer /** * Listens to channel, when a new message arrives listener would be called with * listener(event, args...). */ on(channel: string, listener: (event: IpcRendererEvent, ...args: any[]) => void): this; /** * Adds a one time listener function for the event. This listener is invoked only * the next time a message is sent to channel, after which it is removed. */ once(channel: string, listener: (event: IpcRendererEvent, ...args: any[]) => void): this; /** * Removes all listeners, or those of the specified channel. */ removeAllListeners(channel: string): this; /** * Removes the specified listener from the listener array for the specified * channel. */ removeListener(channel: string, listener: Function): this; /** * Send a message to the main process asynchronously via channel, you can also send * arbitrary arguments. Arguments will be serialized in JSON internally and hence * no functions or prototype chain will be included. The main process handles it by * listening for channel with ipcMain module. */ send(channel: string, ...args: any[]): void; /** * Send a message to the main process synchronously via channel, you can also send * arbitrary arguments. Arguments will be serialized in JSON internally and hence * no functions or prototype chain will be included. The main process handles it by * listening for channel with ipcMain module, and replies by setting * event.returnValue. Note: Sending a synchronous message will block the whole * renderer process, unless you know what you are doing you should never use it. */ sendSync(channel: string, ...args: any[]): any; /** * Sends a message to a window with webContentsId via channel. */ sendTo(webContentsId: number, channel: string, ...args: any[]): void; /** * Like ipcRenderer.send but the event will be sent to the element in the * host page instead of the main process. */ sendToHost(channel: string, ...args: any[]): void; } interface IpcRendererEvent extends Event { // Docs: http://electronjs.org/docs/api/structures/ipc-renderer-event /** * The IpcRenderer instance that emitted the event originally */ sender: IpcRenderer; /** * The webContents.id that sent the message, you can call * event.sender.sendTo(event.senderId, ...) to reply to the message, see for more * information. This only applies to messages sent from a different renderer. * Messages sent directly from the main process set event.senderId to 0. */ senderId: number; } interface JumpListCategory { // Docs: http://electronjs.org/docs/api/structures/jump-list-category /** * Array of objects if type is tasks or custom, otherwise it should be omitted. */ items?: JumpListItem[]; /** * Must be set if type is custom, otherwise it should be omitted. */ name?: string; /** * One of the following: */ type?: ('tasks' | 'frequent' | 'recent' | 'custom'); } interface JumpListItem { // Docs: http://electronjs.org/docs/api/structures/jump-list-item /** * The command line arguments when program is executed. Should only be set if type * is task. */ args?: string; /** * Description of the task (displayed in a tooltip). Should only be set if type is * task. */ description?: string; /** * The index of the icon in the resource file. If a resource file contains multiple * icons this value can be used to specify the zero-based index of the icon that * should be displayed for this task. If a resource file contains only one icon, * this property should be set to zero. */ iconIndex?: number; /** * The absolute path to an icon to be displayed in a Jump List, which can be an * arbitrary resource file that contains an icon (e.g. .ico, .exe, .dll). You can * usually specify process.execPath to show the program icon. */ iconPath?: string; /** * Path of the file to open, should only be set if type is file. */ path?: string; /** * Path of the program to execute, usually you should specify process.execPath * which opens the current program. Should only be set if type is task. */ program?: string; /** * The text to be displayed for the item in the Jump List. Should only be set if * type is task. */ title?: string; /** * One of the following: */ type?: ('task' | 'separator' | 'file'); /** * The working directory. Default is empty. */ workingDirectory?: string; } interface KeyboardEvent extends Event { // Docs: http://electronjs.org/docs/api/structures/keyboard-event /** * whether an Alt key was used in an accelerator to trigger the Event */ altKey?: boolean; /** * whether the Control key was used in an accelerator to trigger the Event */ ctrlKey?: boolean; /** * whether a meta key was used in an accelerator to trigger the Event */ metaKey?: boolean; /** * whether a Shift key was used in an accelerator to trigger the Event */ shiftKey?: boolean; /** * whether an accelerator was used to trigger the event as opposed to another user * gesture like mouse click */ triggeredByAccelerator?: boolean; } interface MemoryUsageDetails { // Docs: http://electronjs.org/docs/api/structures/memory-usage-details count: number; liveSize: number; size: number; } class Menu { // Docs: http://electronjs.org/docs/api/menu /** * Emitted when a popup is closed either manually or with menu.closePopup(). */ on(event: 'menu-will-close', listener: (event: Event) => void): this; once(event: 'menu-will-close', listener: (event: Event) => void): this; addListener(event: 'menu-will-close', listener: (event: Event) => void): this; removeListener(event: 'menu-will-close', listener: (event: Event) => void): this; /** * Emitted when menu.popup() is called. */ on(event: 'menu-will-show', listener: (event: Event) => void): this; once(event: 'menu-will-show', listener: (event: Event) => void): this; addListener(event: 'menu-will-show', listener: (event: Event) => void): this; removeListener(event: 'menu-will-show', listener: (event: Event) => void): this; constructor(); /** * Generally, the template is an array of options for constructing a MenuItem. The * usage can be referenced above. You can also attach other fields to the element * of the template and they will become properties of the constructed menu items. */ static buildFromTemplate(template: Array<(MenuItemConstructorOptions) | (MenuItem)>): Menu; /** * Note: The returned Menu instance doesn't support dynamic addition or removal of * menu items. Instance properties can still be dynamically modified. */ static getApplicationMenu(): (Menu) | (null); /** * Sends the action to the first responder of application. This is used for * emulating default macOS menu behaviors. Usually you would use the role property * of a MenuItem. See the macOS Cocoa Event Handling Guide for more information on * macOS' native actions. */ static sendActionToFirstResponder(action: string): void; /** * Sets menu as the application menu on macOS. On Windows and Linux, the menu will * be set as each window's top menu. Also on Windows and Linux, you can use a & in * the top-level item name to indicate which letter should get a generated * accelerator. For example, using &File for the file menu would result in a * generated Alt-F accelerator that opens the associated menu. The indicated * character in the button label gets an underline. The & character is not * displayed on the button label. Passing null will suppress the default menu. On * Windows and Linux, this has the additional effect of removing the menu bar from * the window. Note: The default menu will be created automatically if the app does * not set one. It contains standard items such as File, Edit, View, Window and * Help. */ static setApplicationMenu(menu: (Menu) | (null)): void; /** * Appends the menuItem to the menu. */ append(menuItem: MenuItem): void; /** * Closes the context menu in the browserWindow. */ closePopup(browserWindow?: BrowserWindow): void; getMenuItemById(id: string): MenuItem; /** * Inserts the menuItem to the pos position of the menu. */ insert(pos: number, menuItem: MenuItem): void; /** * Pops up this menu as a context menu in the BrowserWindow. */ popup(options?: PopupOptions): void; items: MenuItem[]; } class MenuItem { // Docs: http://electronjs.org/docs/api/menu-item constructor(options: MenuItemConstructorOptions); accelerator: string; checked: boolean; click: Function; commandId: number; enabled: boolean; icon: NativeImage; id: string; label: string; menu: Menu; registerAccelerator: boolean; role: string; sublabel: string; submenu: Menu; type: string; visible: boolean; } interface MimeTypedBuffer { // Docs: http://electronjs.org/docs/api/structures/mime-typed-buffer /** * The actual Buffer content. */ data: Buffer; /** * The mimeType of the Buffer that you are sending. */ mimeType: string; } class NativeImage { // Docs: http://electronjs.org/docs/api/native-image /** * Creates an empty NativeImage instance. */ static createEmpty(): NativeImage; /** * Creates a new NativeImage instance from buffer that contains the raw bitmap * pixel data returned by toBitmap(). The specific format is platform-dependent. */ static createFromBitmap(buffer: Buffer, options: CreateFromBitmapOptions): NativeImage; /** * Creates a new NativeImage instance from buffer. Tries to decode as PNG or JPEG * first. */ static createFromBuffer(buffer: Buffer, options?: CreateFromBufferOptions): NativeImage; /** * Creates a new NativeImage instance from dataURL. */ static createFromDataURL(dataURL: string): NativeImage; /** * Creates a new NativeImage instance from the NSImage that maps to the given image * name. See NSImageName for a list of possible values. The hslShift is applied to * the image with the following rules This means that [-1, 0, 1] will make the * image completely white and [-1, 1, 0] will make the image completely black. In * some cases, the NSImageName doesn't match its string representation; one example * of this is NSFolderImageName, whose string representation would actually be * NSFolder. Therefore, you'll need to determine the correct string representation * for your image before passing it in. This can be done with the following: echo * -e '#import \nint main() { NSLog(@"%@", SYSTEM_IMAGE_NAME); }' | * clang -otest -x objective-c -framework Cocoa - && ./test where SYSTEM_IMAGE_NAME * should be replaced with any value from this list. */ static createFromNamedImage(imageName: string, hslShift: number[]): NativeImage; /** * Creates a new NativeImage instance from a file located at path. This method * returns an empty image if the path does not exist, cannot be read, or is not a * valid image. */ static createFromPath(path: string): NativeImage; /** * Add an image representation for a specific scale factor. This can be used to * explicitly add different scale factor representations to an image. This can be * called on empty images. */ addRepresentation(options: AddRepresentationOptions): void; crop(rect: Rectangle): NativeImage; getAspectRatio(): number; /** * The difference between getBitmap() and toBitmap() is, getBitmap() does not copy * the bitmap data, so you have to use the returned Buffer immediately in current * event loop tick, otherwise the data might be changed or destroyed. */ getBitmap(options?: BitmapOptions): Buffer; /** * Notice that the returned pointer is a weak pointer to the underlying native * image instead of a copy, so you must ensure that the associated nativeImage * instance is kept around. */ getNativeHandle(): Buffer; getSize(): Size; isEmpty(): boolean; isTemplateImage(): boolean; /** * If only the height or the width are specified then the current aspect ratio will * be preserved in the resized image. */ resize(options: ResizeOptions): NativeImage; /** * Marks the image as a template image. */ setTemplateImage(option: boolean): void; toBitmap(options?: ToBitmapOptions): Buffer; toDataURL(options?: ToDataURLOptions): string; toJPEG(quality: number): Buffer; toPNG(options?: ToPNGOptions): Buffer; } interface Net extends EventEmitter { // Docs: http://electronjs.org/docs/api/net /** * Creates a ClientRequest instance using the provided options which are directly * forwarded to the ClientRequest constructor. The net.request method would be used * to issue both secure and insecure HTTP requests according to the specified * protocol scheme in the options object. */ request(options: (any) | (string)): ClientRequest; } interface NetLog extends EventEmitter { // Docs: http://electronjs.org/docs/api/net-log /** * Starts recording network events to path. */ startLogging(path: string): void; /** * Stops recording network events. If not called, net logging will automatically * end when app quits. Deprecated Soon */ stopLogging(callback?: (path: string) => void): void; /** * Stops recording network events. If not called, net logging will automatically * end when app quits. */ stopLogging(): Promise; /** * A Boolean property that indicates whether network logs are recorded. */ currentlyLogging?: boolean; /** * A String property that returns the path to the current log file. */ currentlyLoggingPath?: string; } class Notification extends EventEmitter { // Docs: http://electronjs.org/docs/api/notification on(event: 'action', listener: (event: Event, /** * The index of the action that was activated. */ index: number) => void): this; once(event: 'action', listener: (event: Event, /** * The index of the action that was activated. */ index: number) => void): this; addListener(event: 'action', listener: (event: Event, /** * The index of the action that was activated. */ index: number) => void): this; removeListener(event: 'action', listener: (event: Event, /** * The index of the action that was activated. */ index: number) => void): this; /** * Emitted when the notification is clicked by the user. */ on(event: 'click', listener: (event: Event) => void): this; once(event: 'click', listener: (event: Event) => void): this; addListener(event: 'click', listener: (event: Event) => void): this; removeListener(event: 'click', listener: (event: Event) => void): this; /** * Emitted when the notification is closed by manual intervention from the user. * This event is not guaranteed to be emitted in all cases where the notification * is closed. */ on(event: 'close', listener: (event: Event) => void): this; once(event: 'close', listener: (event: Event) => void): this; addListener(event: 'close', listener: (event: Event) => void): this; removeListener(event: 'close', listener: (event: Event) => void): this; /** * Emitted when the user clicks the "Reply" button on a notification with hasReply: * true. */ on(event: 'reply', listener: (event: Event, /** * The string the user entered into the inline reply field. */ reply: string) => void): this; once(event: 'reply', listener: (event: Event, /** * The string the user entered into the inline reply field. */ reply: string) => void): this; addListener(event: 'reply', listener: (event: Event, /** * The string the user entered into the inline reply field. */ reply: string) => void): this; removeListener(event: 'reply', listener: (event: Event, /** * The string the user entered into the inline reply field. */ reply: string) => void): this; /** * Emitted when the notification is shown to the user, note this could be fired * multiple times as a notification can be shown multiple times through the show() * method. */ on(event: 'show', listener: (event: Event) => void): this; once(event: 'show', listener: (event: Event) => void): this; addListener(event: 'show', listener: (event: Event) => void): this; removeListener(event: 'show', listener: (event: Event) => void): this; constructor(options: NotificationConstructorOptions); static isSupported(): boolean; /** * Dismisses the notification. */ close(): void; /** * Immediately shows the notification to the user, please note this means unlike * the HTML5 Notification implementation, instantiating a new Notification does not * immediately show it to the user, you need to call this method before the OS will * display it. If the notification has been shown before, this method will dismiss * the previously shown notification and create a new one with identical * properties. */ show(): void; } interface NotificationAction { // Docs: http://electronjs.org/docs/api/structures/notification-action /** * The label for the given action. */ text?: string; /** * The type of action, can be button. */ type: ('button'); } interface Point { // Docs: http://electronjs.org/docs/api/structures/point x: number; y: number; } interface PowerMonitor extends EventEmitter { // Docs: http://electronjs.org/docs/api/power-monitor /** * Emitted when the system is about to lock the screen. */ on(event: 'lock-screen', listener: Function): this; once(event: 'lock-screen', listener: Function): this; addListener(event: 'lock-screen', listener: Function): this; removeListener(event: 'lock-screen', listener: Function): this; /** * Emitted when the system changes to AC power. */ on(event: 'on-ac', listener: Function): this; once(event: 'on-ac', listener: Function): this; addListener(event: 'on-ac', listener: Function): this; removeListener(event: 'on-ac', listener: Function): this; /** * Emitted when system changes to battery power. */ on(event: 'on-battery', listener: Function): this; once(event: 'on-battery', listener: Function): this; addListener(event: 'on-battery', listener: Function): this; removeListener(event: 'on-battery', listener: Function): this; /** * Emitted when system is resuming. */ on(event: 'resume', listener: Function): this; once(event: 'resume', listener: Function): this; addListener(event: 'resume', listener: Function): this; removeListener(event: 'resume', listener: Function): this; /** * Emitted when the system is about to reboot or shut down. If the event handler * invokes e.preventDefault(), Electron will attempt to delay system shutdown in * order for the app to exit cleanly. If e.preventDefault() is called, the app * should exit as soon as possible by calling something like app.quit(). */ on(event: 'shutdown', listener: Function): this; once(event: 'shutdown', listener: Function): this; addListener(event: 'shutdown', listener: Function): this; removeListener(event: 'shutdown', listener: Function): this; /** * Emitted when the system is suspending. */ on(event: 'suspend', listener: Function): this; once(event: 'suspend', listener: Function): this; addListener(event: 'suspend', listener: Function): this; removeListener(event: 'suspend', listener: Function): this; /** * Emitted as soon as the systems screen is unlocked. */ on(event: 'unlock-screen', listener: Function): this; once(event: 'unlock-screen', listener: Function): this; addListener(event: 'unlock-screen', listener: Function): this; removeListener(event: 'unlock-screen', listener: Function): this; /** * Calculate the system idle state. idleThreshold is the amount of time (in * seconds) before considered idle. locked is available on supported systems only. */ getSystemIdleState(idleThreshold: number): ('active' | 'idle' | 'locked' | 'unknown'); /** * Calculate system idle time in seconds. */ getSystemIdleTime(): number; /** * Calculate the system idle state. idleThreshold is the amount of time (in * seconds) before considered idle. callback will be called synchronously on some * systems and with an idleState argument that describes the system's state. locked * is available on supported systems only. */ querySystemIdleState(idleThreshold: number, callback: (idleState: 'active' | 'idle' | 'locked' | 'unknown') => void): void; /** * Calculate system idle time in seconds. */ querySystemIdleTime(callback: (idleTime: number) => void): void; } interface PowerSaveBlocker extends EventEmitter { // Docs: http://electronjs.org/docs/api/power-save-blocker isStarted(id: number): boolean; /** * Starts preventing the system from entering lower-power mode. Returns an integer * identifying the power save blocker. Note: prevent-display-sleep has higher * precedence over prevent-app-suspension. Only the highest precedence type takes * effect. In other words, prevent-display-sleep always takes precedence over * prevent-app-suspension. For example, an API calling A requests for * prevent-app-suspension, and another calling B requests for * prevent-display-sleep. prevent-display-sleep will be used until B stops its * request. After that, prevent-app-suspension is used. */ start(type: 'prevent-app-suspension' | 'prevent-display-sleep'): number; /** * Stops the specified power save blocker. */ stop(id: number): void; } interface PrinterInfo { // Docs: http://electronjs.org/docs/api/structures/printer-info description: string; isDefault: boolean; name: string; status: number; } interface ProcessMemoryInfo { // Docs: http://electronjs.org/docs/api/structures/process-memory-info /** * The amount of memory not shared by other processes, such as JS heap or HTML * content in Kilobytes. */ private: number; /** * and The amount of memory currently pinned to actual physical RAM in Kilobytes. */ residentSet: number; /** * The amount of memory shared between processes, typically memory consumed by the * Electron code itself in Kilobytes. */ shared: number; } interface ProcessMetric { // Docs: http://electronjs.org/docs/api/structures/process-metric /** * CPU usage of the process. */ cpu: CPUUsage; /** * Process id of the process. */ pid: number; /** * Process type. One of the following values: */ type: ('Browser' | 'Tab' | 'Utility' | 'Zygote' | 'GPU' | 'Unknown'); } interface Product { // Docs: http://electronjs.org/docs/api/structures/product /** * The total size of the content, in bytes. */ contentLengths: number[]; /** * A string that identifies the version of the content. */ contentVersion: string; /** * The locale formatted price of the product. */ formattedPrice: string; /** * A Boolean value that indicates whether the App Store has downloadable content * for this product. true if at least one file has been associated with the * product. */ isDownloadable: boolean; /** * A description of the product. */ localizedDescription: string; /** * The name of the product. */ localizedTitle: string; /** * The cost of the product in the local currency. */ price: number; /** * The string that identifies the product to the Apple App Store. */ productIdentifier: string; } interface Protocol extends EventEmitter { // Docs: http://electronjs.org/docs/api/protocol /** * Intercepts scheme protocol and uses handler as the protocol's new handler which * sends a Buffer as a response. */ interceptBufferProtocol(scheme: string, handler: (request: InterceptBufferProtocolRequest, callback: (buffer?: Buffer) => void) => void, completion?: (error: Error) => void): void; /** * Intercepts scheme protocol and uses handler as the protocol's new handler which * sends a file as a response. */ interceptFileProtocol(scheme: string, handler: (request: InterceptFileProtocolRequest, callback: (filePath: string) => void) => void, completion?: (error: Error) => void): void; /** * Intercepts scheme protocol and uses handler as the protocol's new handler which * sends a new HTTP request as a response. */ interceptHttpProtocol(scheme: string, handler: (request: InterceptHttpProtocolRequest, callback: (redirectRequest: RedirectRequest) => void) => void, completion?: (error: Error) => void): void; /** * Same as protocol.registerStreamProtocol, except that it replaces an existing * protocol handler. */ interceptStreamProtocol(scheme: string, handler: (request: InterceptStreamProtocolRequest, callback: (stream?: (NodeJS.ReadableStream) | (StreamProtocolResponse)) => void) => void, completion?: (error: Error) => void): void; /** * Intercepts scheme protocol and uses handler as the protocol's new handler which * sends a String as a response. */ interceptStringProtocol(scheme: string, handler: (request: InterceptStringProtocolRequest, callback: (data?: string) => void) => void, completion?: (error: Error) => void): void; /** * The callback will be called with a boolean that indicates whether there is * already a handler for scheme. Deprecated Soon */ isProtocolHandled(scheme: string, callback: (handled: boolean) => void): void; isProtocolHandled(scheme: string): Promise; /** * Registers a protocol of scheme that will send a Buffer as a response. The usage * is the same with registerFileProtocol, except that the callback should be called * with either a Buffer object or an object that has the data, mimeType, and * charset properties. Example: */ registerBufferProtocol(scheme: string, handler: (request: RegisterBufferProtocolRequest, callback: (buffer?: (Buffer) | (MimeTypedBuffer)) => void) => void, completion?: (error: Error) => void): void; /** * Registers a protocol of scheme that will send the file as a response. The * handler will be called with handler(request, callback) when a request is going * to be created with scheme. completion will be called with completion(null) when * scheme is successfully registered or completion(error) when failed. To handle * the request, the callback should be called with either the file's path or an * object that has a path property, e.g. callback(filePath) or callback({ path: * filePath }). The object may also have a headers property which gives a map of * headers to values for the response headers, e.g. callback({ path: filePath, * headers: {"Content-Security-Policy": "default-src 'none'"]}). When callback is * called with nothing, a number, or an object that has an error property, the * request will fail with the error number you specified. For the available error * numbers you can use, please see the net error list. By default the scheme is * treated like http:, which is parsed differently than protocols that follow the * "generic URI syntax" like file:. */ registerFileProtocol(scheme: string, handler: (request: RegisterFileProtocolRequest, callback: (filePath?: string) => void) => void, completion?: (error: Error) => void): void; /** * Registers a protocol of scheme that will send an HTTP request as a response. The * usage is the same with registerFileProtocol, except that the callback should be * called with a redirectRequest object that has the url, method, referrer, * uploadData and session properties. By default the HTTP request will reuse the * current session. If you want the request to have a different session you should * set session to null. For POST requests the uploadData object must be provided. */ registerHttpProtocol(scheme: string, handler: (request: RegisterHttpProtocolRequest, callback: (redirectRequest: RedirectRequest) => void) => void, completion?: (error: Error) => void): void; /** * Note: This method can only be used before the ready event of the app module gets * emitted and can be called only once. Registers the scheme as standard, secure, * bypasses content security policy for resources, allows registering ServiceWorker * and supports fetch API. Specify a privilege with the value of true to enable the * capability. An example of registering a privileged scheme, with bypassing * Content Security Policy: A standard scheme adheres to what RFC 3986 calls * generic URI syntax. For example http and https are standard schemes, while file * is not. Registering a scheme as standard, will allow relative and absolute * resources to be resolved correctly when served. Otherwise the scheme will behave * like the file protocol, but without the ability to resolve relative URLs. For * example when you load following page with custom protocol without registering it * as standard scheme, the image will not be loaded because non-standard schemes * can not recognize relative URLs: Registering a scheme as standard will allow * access to files through the FileSystem API. Otherwise the renderer will throw a * security error for the scheme. By default web storage apis (localStorage, * sessionStorage, webSQL, indexedDB, cookies) are disabled for non standard * schemes. So in general if you want to register a custom protocol to replace the * http protocol, you have to register it as a standard scheme. * protocol.registerSchemesAsPrivileged can be used to replicate the functionality * of the previous protocol.registerStandardSchemes, webFrame.registerURLSchemeAs* * and protocol.registerServiceWorkerSchemes functions that existed prior to * Electron 5.0.0, for example: before (<= v4.x) after (>= v5.x) */ registerSchemesAsPrivileged(customSchemes: CustomScheme[]): void; /** * Registers a protocol of scheme that will send a Readable as a response. The * usage is similar to the other register{Any}Protocol, except that the callback * should be called with either a Readable object or an object that has the data, * statusCode, and headers properties. Example: It is possible to pass any object * that implements the readable stream API (emits data/end/error events). For * example, here's how a file could be returned: */ registerStreamProtocol(scheme: string, handler: (request: RegisterStreamProtocolRequest, callback: (stream?: (NodeJS.ReadableStream) | (StreamProtocolResponse)) => void) => void, completion?: (error: Error) => void): void; /** * Registers a protocol of scheme that will send a String as a response. The usage * is the same with registerFileProtocol, except that the callback should be called * with either a String or an object that has the data, mimeType, and charset * properties. */ registerStringProtocol(scheme: string, handler: (request: RegisterStringProtocolRequest, callback: (data?: string) => void) => void, completion?: (error: Error) => void): void; /** * Remove the interceptor installed for scheme and restore its original handler. */ uninterceptProtocol(scheme: string, completion?: (error: Error) => void): void; /** * Unregisters the custom protocol of scheme. */ unregisterProtocol(scheme: string, completion?: (error: Error) => void): void; } interface Rectangle { // Docs: http://electronjs.org/docs/api/structures/rectangle /** * The height of the rectangle (must be an integer). */ height: number; /** * The width of the rectangle (must be an integer). */ width: number; /** * The x coordinate of the origin of the rectangle (must be an integer). */ x: number; /** * The y coordinate of the origin of the rectangle (must be an integer). */ y: number; } interface Referrer { // Docs: http://electronjs.org/docs/api/structures/referrer /** * Can be default, unsafe-url, no-referrer-when-downgrade, no-referrer, origin, * strict-origin-when-cross-origin, same-origin or strict-origin. See the for more * details on the meaning of these values. */ policy: ('default' | 'unsafe-url' | 'no-referrer-when-downgrade' | 'no-referrer' | 'origin' | 'strict-origin-when-cross-origin' | 'same-origin' | 'strict-origin'); /** * HTTP Referrer URL. */ url: string; } interface Remote extends MainInterface { // Docs: http://electronjs.org/docs/api/remote getCurrentWebContents(): WebContents; /** * Note: Do not use removeAllListeners on BrowserWindow. Use of this can remove all * blur listeners, disable click events on touch bar buttons, and other unintended * consequences. */ getCurrentWindow(): BrowserWindow; getGlobal(name: string): any; /** * e.g. */ require(module: string): any; /** * The process object in the main process. This is the same as * remote.getGlobal('process') but is cached. */ process?: any; } interface RemoveClientCertificate { // Docs: http://electronjs.org/docs/api/structures/remove-client-certificate /** * Origin of the server whose associated client certificate must be removed from * the cache. */ origin: string; /** * clientCertificate. */ type: string; } interface RemovePassword { // Docs: http://electronjs.org/docs/api/structures/remove-password /** * When provided, the authentication info related to the origin will only be * removed otherwise the entire cache will be cleared. */ origin?: string; /** * Credentials of the authentication. Must be provided if removing by origin. */ password?: string; /** * Realm of the authentication. Must be provided if removing by origin. */ realm?: string; /** * Scheme of the authentication. Can be basic, digest, ntlm, negotiate. Must be * provided if removing by origin. */ scheme?: ('basic' | 'digest' | 'ntlm' | 'negotiate'); /** * password. */ type: string; /** * Credentials of the authentication. Must be provided if removing by origin. */ username?: string; } interface Screen extends EventEmitter { // Docs: http://electronjs.org/docs/api/screen /** * Emitted when newDisplay has been added. */ on(event: 'display-added', listener: (event: Event, newDisplay: Display) => void): this; once(event: 'display-added', listener: (event: Event, newDisplay: Display) => void): this; addListener(event: 'display-added', listener: (event: Event, newDisplay: Display) => void): this; removeListener(event: 'display-added', listener: (event: Event, newDisplay: Display) => void): this; /** * Emitted when one or more metrics change in a display. The changedMetrics is an * array of strings that describe the changes. Possible changes are bounds, * workArea, scaleFactor and rotation. */ on(event: 'display-metrics-changed', listener: (event: Event, display: Display, changedMetrics: string[]) => void): this; once(event: 'display-metrics-changed', listener: (event: Event, display: Display, changedMetrics: string[]) => void): this; addListener(event: 'display-metrics-changed', listener: (event: Event, display: Display, changedMetrics: string[]) => void): this; removeListener(event: 'display-metrics-changed', listener: (event: Event, display: Display, changedMetrics: string[]) => void): this; /** * Emitted when oldDisplay has been removed. */ on(event: 'display-removed', listener: (event: Event, oldDisplay: Display) => void): this; once(event: 'display-removed', listener: (event: Event, oldDisplay: Display) => void): this; addListener(event: 'display-removed', listener: (event: Event, oldDisplay: Display) => void): this; removeListener(event: 'display-removed', listener: (event: Event, oldDisplay: Display) => void): this; /** * Converts a screen DIP point to a screen physical point. The DPI scale is * performed relative to the display containing the DIP point. */ dipToScreenPoint(point: Point): Point; /** * Converts a screen DIP rect to a screen physical rect. The DPI scale is performed * relative to the display nearest to window. If window is null, scaling will be * performed to the display nearest to rect. */ dipToScreenRect(window: (BrowserWindow) | (null), rect: Rectangle): Rectangle; getAllDisplays(): Display[]; /** * The current absolute position of the mouse pointer. */ getCursorScreenPoint(): Point; getDisplayMatching(rect: Rectangle): Display; getDisplayNearestPoint(point: Point): Display; getPrimaryDisplay(): Display; /** * Converts a screen physical point to a screen DIP point. The DPI scale is * performed relative to the display containing the physical point. */ screenToDipPoint(point: Point): Point; /** * Converts a screen physical rect to a screen DIP rect. The DPI scale is performed * relative to the display nearest to window. If window is null, scaling will be * performed to the display nearest to rect. */ screenToDipRect(window: (BrowserWindow) | (null), rect: Rectangle): Rectangle; } interface ScrubberItem { // Docs: http://electronjs.org/docs/api/structures/scrubber-item /** * The image to appear in this item. */ icon?: NativeImage; /** * The text to appear in this item. */ label?: string; } interface SegmentedControlSegment { // Docs: http://electronjs.org/docs/api/structures/segmented-control-segment /** * Whether this segment is selectable. Default: true. */ enabled?: boolean; /** * The image to appear in this segment. */ icon?: NativeImage; /** * The text to appear in this segment. */ label?: string; } class Session extends EventEmitter { // Docs: http://electronjs.org/docs/api/session /** * If partition starts with persist:, the page will use a persistent session * available to all pages in the app with the same partition. if there is no * persist: prefix, the page will use an in-memory session. If the partition is * empty then default session of the app will be returned. To create a Session with * options, you have to ensure the Session with the partition has never been used * before. There is no way to change the options of an existing Session object. */ static fromPartition(partition: string, options?: FromPartitionOptions): Session; /** * A Session object, the default session object of the app. */ static defaultSession?: Session; /** * Emitted when Electron is about to download item in webContents. Calling * event.preventDefault() will cancel the download and item will not be available * from next tick of the process. */ on(event: 'will-download', listener: (event: Event, item: DownloadItem, webContents: WebContents) => void): this; once(event: 'will-download', listener: (event: Event, item: DownloadItem, webContents: WebContents) => void): this; addListener(event: 'will-download', listener: (event: Event, item: DownloadItem, webContents: WebContents) => void): this; removeListener(event: 'will-download', listener: (event: Event, item: DownloadItem, webContents: WebContents) => void): this; /** * Dynamically sets whether to always send credentials for HTTP NTLM or Negotiate * authentication. */ allowNTLMCredentialsForDomains(domains: string): void; clearAuthCache(): Promise; clearAuthCache(options: (RemovePassword) | (RemoveClientCertificate)): Promise; /** * Clears the session’s HTTP authentication cache. Deprecated Soon */ clearAuthCache(options: (RemovePassword) | (RemoveClientCertificate), callback: Function): void; /** * Clears the session’s HTTP cache. */ clearCache(): Promise; /** * Clears the session’s HTTP cache. Deprecated Soon */ clearCache(callback: (error: number) => void): void; /** * Clears the host resolver cache. */ clearHostResolverCache(): Promise; /** * Clears the host resolver cache. Deprecated Soon */ clearHostResolverCache(callback?: Function): void; /** * Clears the storage data for the current session. Deprecated Soon */ clearStorageData(options?: ClearStorageDataOptions, callback?: Function): void; clearStorageData(options?: ClearStorageDataOptions): Promise; /** * Allows resuming cancelled or interrupted downloads from previous Session. The * API will generate a DownloadItem that can be accessed with the will-download * event. The DownloadItem will not have any WebContents associated with it and the * initial state will be interrupted. The download will start only when the resume * API is called on the DownloadItem. */ createInterruptedDownload(options: CreateInterruptedDownloadOptions): void; /** * Disables any network emulation already active for the session. Resets to the * original network configuration. */ disableNetworkEmulation(): void; /** * Emulates network with the given configuration for the session. */ enableNetworkEmulation(options: EnableNetworkEmulationOptions): void; /** * Writes any unwritten DOMStorage data to disk. */ flushStorageData(): void; /** * Deprecated Soon */ getBlobData(identifier: string, callback: (result: Buffer) => void): void; getBlobData(identifier: string): Promise; getCacheSize(): Promise; /** * Callback is invoked with the session's current cache size. Deprecated Soon */ getCacheSize(callback: (size: number, error: number) => void): void; getPreloads(): string[]; getUserAgent(): string; resolveProxy(url: string): Promise; /** * Resolves the proxy information for url. The callback will be called with * callback(proxy) when the request is performed. Deprecated Soon */ resolveProxy(url: string, callback: (proxy: string) => void): void; /** * Sets the certificate verify proc for session, the proc will be called with * proc(request, callback) whenever a server certificate verification is requested. * Calling callback(0) accepts the certificate, calling callback(-2) rejects it. * Calling setCertificateVerifyProc(null) will revert back to default certificate * verify proc. */ setCertificateVerifyProc(proc: (request: CertificateVerifyProcRequest, callback: (verificationResult: number) => void) => void): void; /** * Sets download saving directory. By default, the download directory will be the * Downloads under the respective app folder. */ setDownloadPath(path: string): void; /** * Sets the handler which can be used to respond to permission checks for the * session. Returning true will allow the permission and false will reject it. To * clear the handler, call setPermissionCheckHandler(null). */ setPermissionCheckHandler(handler: ((webContents: WebContents, permission: string, requestingOrigin: string, details: PermissionCheckHandlerDetails) => 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 callback(false) * will reject it. To clear the handler, call setPermissionRequestHandler(null). */ setPermissionRequestHandler(handler: ((webContents: WebContents, permission: string, callback: (permissionGranted: boolean) => void, details: PermissionRequestHandlerDetails) => 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. */ setPreloads(preloads: string[]): void; /** * Sets the proxy settings. When pacScript and proxyRules are provided together, * the proxyRules option is ignored and pacScript configuration is applied. The * proxyRules has to follow the rules below: For example: The proxyBypassRules is a * comma separated list of rules described below: */ setProxy(config: Config): Promise; /** * Sets the proxy settings. When pacScript and proxyRules are provided together, * the proxyRules option is ignored and pacScript configuration is applied. The * proxyRules has to follow the rules below: For example: The proxyBypassRules is a * comma separated list of rules described below: Deprecated Soon */ setProxy(config: Config, callback: Function): void; /** * Overrides the userAgent and acceptLanguages for this session. The * acceptLanguages must a comma separated ordered list of language codes, for * example "en-US,fr,de,ko,zh-CN,ja". This doesn't affect existing WebContents, and * each WebContents can use webContents.setUserAgent to override the session-wide * user agent. */ setUserAgent(userAgent: string, acceptLanguages?: string): void; cookies: Cookies; netLog: NetLog; protocol: Protocol; webRequest: WebRequest; } interface Shell { // Docs: http://electronjs.org/docs/api/shell /** * Play the beep sound. */ beep(): void; /** * Move the given file to trash and returns a boolean status for the operation. */ moveItemToTrash(fullPath: string): boolean; /** * Open the given external protocol URL in the desktop's default manner. (For * example, mailto: URLs in the user's default mail agent). */ openExternal(url: string, options?: OpenExternalOptions): Promise; /** * Open the given external protocol URL in the desktop's default manner. (For * example, mailto: URLs in the user's default mail agent). Deprecated */ openExternalSync(url: string, options?: OpenExternalSyncOptions): boolean; /** * Open the given file in the desktop's default manner. */ openItem(fullPath: string): boolean; /** * Resolves the shortcut link at shortcutPath. An exception will be thrown when any * error happens. */ readShortcutLink(shortcutPath: string): ShortcutDetails; /** * Show the given file in a file manager. If possible, select the file. */ showItemInFolder(fullPath: string): void; /** * Creates or updates a shortcut link at shortcutPath. */ writeShortcutLink(shortcutPath: string, operation: 'create' | 'update' | 'replace', options: ShortcutDetails): boolean; /** * Creates or updates a shortcut link at shortcutPath. */ writeShortcutLink(shortcutPath: string, options: ShortcutDetails): boolean; } interface ShortcutDetails { // Docs: http://electronjs.org/docs/api/structures/shortcut-details /** * The Application User Model ID. Default is empty. */ appUserModelId?: string; /** * The arguments to be applied to target when launching from this shortcut. Default * is empty. */ args?: string; /** * The working directory. Default is empty. */ cwd?: string; /** * The description of the shortcut. Default is empty. */ description?: string; /** * The path to the icon, can be a DLL or EXE. icon and iconIndex have to be set * together. Default is empty, which uses the target's icon. */ icon?: string; /** * The resource ID of icon when icon is a DLL or EXE. Default is 0. */ iconIndex?: number; /** * The target to launch from this shortcut. */ target: string; } interface Size { // Docs: http://electronjs.org/docs/api/structures/size height: number; width: number; } interface StreamProtocolResponse { // Docs: http://electronjs.org/docs/api/structures/stream-protocol-response /** * A Node.js readable stream representing the response body. */ data: NodeJS.ReadableStream; /** * An object containing the response headers. */ headers: Headers; /** * The HTTP response code. */ statusCode: number; } interface SystemPreferences extends EventEmitter { // Docs: http://electronjs.org/docs/api/system-preferences on(event: 'accent-color-changed', listener: (event: Event, /** * The new RGBA color the user assigned to be their system accent color. */ newColor: string) => void): this; once(event: 'accent-color-changed', listener: (event: Event, /** * The new RGBA color the user assigned to be their system accent color. */ newColor: string) => void): this; addListener(event: 'accent-color-changed', listener: (event: Event, /** * The new RGBA color the user assigned to be their system accent color. */ newColor: string) => void): this; removeListener(event: 'accent-color-changed', listener: (event: Event, /** * The new RGBA color the user assigned to be their system accent color. */ newColor: string) => void): this; on(event: 'color-changed', listener: (event: Event) => void): this; once(event: 'color-changed', listener: (event: Event) => void): this; addListener(event: 'color-changed', listener: (event: Event) => void): this; removeListener(event: 'color-changed', listener: (event: Event) => void): this; on(event: 'high-contrast-color-scheme-changed', listener: (event: Event, /** * `true` if a high contrast theme is being used, `false` otherwise. */ highContrastColorScheme: boolean) => void): this; once(event: 'high-contrast-color-scheme-changed', listener: (event: Event, /** * `true` if a high contrast theme is being used, `false` otherwise. */ highContrastColorScheme: boolean) => void): this; addListener(event: 'high-contrast-color-scheme-changed', listener: (event: Event, /** * `true` if a high contrast theme is being used, `false` otherwise. */ highContrastColorScheme: boolean) => void): this; removeListener(event: 'high-contrast-color-scheme-changed', listener: (event: Event, /** * `true` if a high contrast theme is being used, `false` otherwise. */ highContrastColorScheme: boolean) => void): this; on(event: 'inverted-color-scheme-changed', listener: (event: Event, /** * `true` if an inverted color scheme (a high contrast color scheme with light text * and dark backgrounds) is being used, `false` otherwise. */ invertedColorScheme: boolean) => void): this; once(event: 'inverted-color-scheme-changed', listener: (event: Event, /** * `true` if an inverted color scheme (a high contrast color scheme with light text * and dark backgrounds) is being used, `false` otherwise. */ invertedColorScheme: boolean) => void): this; addListener(event: 'inverted-color-scheme-changed', listener: (event: Event, /** * `true` if an inverted color scheme (a high contrast color scheme with light text * and dark backgrounds) is being used, `false` otherwise. */ invertedColorScheme: boolean) => void): this; removeListener(event: 'inverted-color-scheme-changed', listener: (event: Event, /** * `true` if an inverted color scheme (a high contrast color scheme with light text * and dark backgrounds) is being used, `false` otherwise. */ invertedColorScheme: boolean) => void): this; /** * Important: In order to properly leverage this API, you must set the * NSMicrophoneUsageDescription and NSCameraUsageDescription strings in your app's * Info.plist file. The values for these keys will be used to populate the * permission dialogs so that the user will be properly informed as to the purpose * of the permission request. See Electron Application Distribution for more * information about how to set these in the context of Electron. This user consent * was not required until macOS 10.14 Mojave, so this method will always return * true if your system is running 10.13 High Sierra or lower. */ askForMediaAccess(mediaType: 'microphone' | 'camera'): Promise; /** * NOTE: This API will return false on macOS systems older than Sierra 10.12.2. */ canPromptTouchID(): boolean; /** * This API is only available on macOS 10.14 Mojave or newer. */ getAccentColor(): string; /** * Returns an object with system animation settings. */ getAnimationSettings(): AnimationSettings; /** * Gets the macOS appearance setting that you have declared you want for your * application, maps to NSApplication.appearance. You can use the * setAppLevelAppearance API to set this value. */ getAppLevelAppearance(): ('dark' | 'light' | 'unknown'); getColor(color: '3d-dark-shadow' | '3d-dark-shadow' | '3d-face' | '3d-highlight' | '3d-light' | '3d-shadow' | 'active-border' | 'active-caption' | 'active-caption-gradient' | 'app-workspace' | 'button-text' | 'caption-text' | 'desktop' | 'disabled-text' | 'highlight' | 'highlight-text' | 'hotlight' | 'inactive-border' | 'inactive-caption' | 'inactive-caption-gradient' | 'inactive-caption-text' | 'info-background' | 'info-text' | 'menu' | 'menu-highlight' | 'menubar' | 'menu-text' | 'scrollbar' | 'window' | 'window-frame' | 'window-text' | 'alternate-selected-control-text' | 'alternate-selected-control-text' | 'control-background' | 'control' | 'control-text' | 'disabled-control-text' | 'find-highlight' | 'grid' | 'header-text' | 'highlight' | 'keyboard-focus-indicator' | 'label' | 'link' | 'placeholder-text' | 'quaternary-label' | 'scrubber-textured-background' | 'secondary-label' | 'selected-content-background' | 'selected-control' | 'selected-control-text' | 'selected-menu-item' | 'selected-text-background' | 'selected-text' | 'separator' | 'shadow' | 'tertiary-label' | 'text-background' | 'text' | 'under-page-background' | 'unemphasized-selected-content-background' | 'unemphasized-selected-text-background' | 'unemphasized-selected-text' | 'window-background' | 'window-frame-text'): string; /** * Gets the macOS appearance setting that is currently applied to your application, * maps to NSApplication.effectiveAppearance Please note that until Electron is * built targeting the 10.14 SDK, your application's effectiveAppearance will * default to 'light' and won't inherit the OS preference. In the interim in order * for your application to inherit the OS preference you must set the * NSRequiresAquaSystemAppearance key in your apps Info.plist to false. If you are * using electron-packager or electron-forge just set the enableDarwinDarkMode * packager option to true. See the Electron Packager API for more details. */ getEffectiveAppearance(): ('dark' | 'light' | 'unknown'); /** * This user consent was not required until macOS 10.14 Mojave, so this method will * always return granted if your system is running 10.13 High Sierra or lower. */ getMediaAccessStatus(mediaType: string): ('not-determined' | 'granted' | 'denied' | 'restricted' | 'unknown'); /** * Returns one of several standard system colors that automatically adapt to * vibrancy and changes in accessibility settings like 'Increase contrast' and * 'Reduce transparency'. See Apple Documentation for more details. */ getSystemColor(color: 'blue' | 'brown' | 'gray' | 'green' | 'orange' | 'pink' | 'purple' | 'red' | 'yellow'): void; /** * Some popular key and types are: */ getUserDefault(key: string, type: 'string' | 'boolean' | 'integer' | 'float' | 'double' | 'url' | 'array' | 'dictionary'): any; /** * An example of using it to determine if you should create a transparent window or * not (transparent windows won't work correctly when DWM composition is disabled): */ isAeroGlassEnabled(): boolean; isDarkMode(): boolean; isHighContrastColorScheme(): boolean; isInvertedColorScheme(): boolean; isSwipeTrackingFromScrollEventsEnabled(): boolean; isTrustedAccessibilityClient(prompt: boolean): boolean; /** * Posts event as native notifications of macOS. The userInfo is an Object that * contains the user information dictionary sent along with the notification. */ postLocalNotification(event: string, userInfo: any): void; /** * Posts event as native notifications of macOS. The userInfo is an Object that * contains the user information dictionary sent along with the notification. */ postNotification(event: string, userInfo: any, deliverImmediately?: boolean): void; /** * Posts event as native notifications of macOS. The userInfo is an Object that * contains the user information dictionary sent along with the notification. */ postWorkspaceNotification(event: string, userInfo: any): void; /** * This API itself will not protect your user data; rather, it is a mechanism to * allow you to do so. Native apps will need to set Access Control Constants like * kSecAccessControlUserPresence on the their keychain entry so that reading it * would auto-prompt for Touch ID biometric consent. This could be done with * node-keytar, such that one would store an encryption key with node-keytar and * only fetch it if promptTouchID() resolves. NOTE: This API will return a rejected * Promise on macOS systems older than Sierra 10.12.2. */ promptTouchID(reason: string): Promise; /** * Add the specified defaults to your application's NSUserDefaults. */ registerDefaults(defaults: any): void; /** * Removes the key in NSUserDefaults. This can be used to restore the default or * global value of a key previously set with setUserDefault. */ removeUserDefault(key: string): void; /** * Sets the appearance setting for your application, this should override the * system default and override the value of getEffectiveAppearance. */ setAppLevelAppearance(appearance: 'dark' | 'light'): void; /** * Set the value of key in NSUserDefaults. Note that type should match actual type * of value. An exception is thrown if they don't. Some popular key and types are: */ setUserDefault(key: string, type: string, value: string): void; /** * Same as subscribeNotification, but uses NSNotificationCenter for local defaults. * This is necessary for events such as NSUserDefaultsDidChangeNotification. */ subscribeLocalNotification(event: string, callback: (event: string, userInfo: any) => void): number; /** * Subscribes to native notifications of macOS, callback will be called with * callback(event, userInfo) when the corresponding event happens. The userInfo is * an Object that contains the user information dictionary sent along with the * notification. The id of the subscriber is returned, which can be used to * unsubscribe the event. Under the hood this API subscribes to * NSDistributedNotificationCenter, example values of event are: */ subscribeNotification(event: string, callback: (event: string, userInfo: any) => void): number; /** * Same as subscribeNotification, but uses * NSWorkspace.sharedWorkspace.notificationCenter. This is necessary for events * such as NSWorkspaceDidActivateApplicationNotification. */ subscribeWorkspaceNotification(event: string, callback: (event: string, userInfo: any) => void): void; /** * Same as unsubscribeNotification, but removes the subscriber from * NSNotificationCenter. */ unsubscribeLocalNotification(id: number): void; /** * Removes the subscriber with id. */ unsubscribeNotification(id: number): void; /** * Same as unsubscribeNotification, but removes the subscriber from * NSWorkspace.sharedWorkspace.notificationCenter. */ unsubscribeWorkspaceNotification(id: number): void; } interface Task { // Docs: http://electronjs.org/docs/api/structures/task /** * The command line arguments when program is executed. */ arguments: string; /** * Description of this task. */ description: string; /** * The icon index in the icon file. If an icon file consists of two or more icons, * set this value to identify the icon. If an icon file consists of one icon, this * value is 0. */ iconIndex: number; /** * The absolute path to an icon to be displayed in a JumpList, which can be an * arbitrary resource file that contains an icon. You can usually specify * process.execPath to show the icon of the program. */ iconPath: string; /** * Path of the program to execute, usually you should specify process.execPath * which opens the current program. */ program: string; /** * The string to be displayed in a JumpList. */ title: string; /** * The working directory. Default is empty. */ workingDirectory?: string; } interface ThumbarButton { // Docs: http://electronjs.org/docs/api/structures/thumbar-button click: Function; /** * Control specific states and behaviors of the button. By default, it is * ['enabled']. */ flags?: string[]; /** * The icon showing in thumbnail toolbar. */ icon: NativeImage; /** * The text of the button's tooltip. */ tooltip?: string; } class TouchBarButton extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-button constructor(options: TouchBarButtonConstructorOptions); backgroundColor: string; icon: NativeImage; label: string; } class TouchBarColorPicker extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-color-picker constructor(options: TouchBarColorPickerConstructorOptions); availableColors: string[]; selectedColor: string; } class TouchBarGroup extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-group constructor(options: TouchBarGroupConstructorOptions); } class TouchBarLabel extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-label constructor(options: TouchBarLabelConstructorOptions); label: string; textColor: string; } class TouchBarPopover extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-popover constructor(options: TouchBarPopoverConstructorOptions); icon: NativeImage; label: string; } class TouchBarScrubber extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-scrubber constructor(options: TouchBarScrubberConstructorOptions); continuous: boolean; items: ScrubberItem[]; mode: string; overlayStyle: string; selectedStyle: string; showArrowButtons: boolean; } class TouchBarSegmentedControl extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-segmented-control constructor(options: TouchBarSegmentedControlConstructorOptions); segments: SegmentedControlSegment[]; segmentStyle: string; selectedIndex: number; } class TouchBarSlider extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-slider constructor(options: TouchBarSliderConstructorOptions); label: string; maxValue: number; minValue: number; value: number; } class TouchBarSpacer extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar-spacer constructor(options: TouchBarSpacerConstructorOptions); } class TouchBar extends EventEmitter { // Docs: http://electronjs.org/docs/api/touch-bar constructor(options: TouchBarConstructorOptions); escapeItem: (TouchBarButton | TouchBarColorPicker | TouchBarGroup | TouchBarLabel | TouchBarPopover | TouchBarScrubber | TouchBarSegmentedControl | TouchBarSlider | TouchBarSpacer | null); static TouchBarButton: typeof TouchBarButton; static TouchBarColorPicker: typeof TouchBarColorPicker; static TouchBarGroup: typeof TouchBarGroup; static TouchBarLabel: typeof TouchBarLabel; static TouchBarPopover: typeof TouchBarPopover; static TouchBarScrubber: typeof TouchBarScrubber; static TouchBarSegmentedControl: typeof TouchBarSegmentedControl; static TouchBarSlider: typeof TouchBarSlider; static TouchBarSpacer: typeof TouchBarSpacer; } interface TraceCategoriesAndOptions { // Docs: http://electronjs.org/docs/api/structures/trace-categories-and-options /** * – is a filter to control what category groups should be traced. A filter can * have an optional prefix to exclude category groups that contain a matching * category. Having both included and excluded category patterns in the same list * is not supported. Examples: test_MyTest*, test_MyTest*,test_OtherStuff, * -excluded_category1,-excluded_category2. */ categoryFilter: string; /** * Controls what kind of tracing is enabled, it is a comma-delimited sequence of * the following strings: record-until-full, record-continuously, trace-to-console, * enable-sampling, enable-systrace, e.g. 'record-until-full,enable-sampling'. The * first 3 options are trace recording modes and hence mutually exclusive. If more * than one trace recording modes appear in the traceOptions string, the last one * takes precedence. If none of the trace recording modes are specified, recording * mode is record-until-full. The trace option will first be reset to the default * option (record_mode set to record-until-full, enable_sampling and * enable_systrace set to false) before options parsed from traceOptions are * applied on it. */ traceOptions: string; } interface TraceConfig { // Docs: http://electronjs.org/docs/api/structures/trace-config excluded_categories?: string[]; included_categories?: string[]; memory_dump_config?: MemoryDumpConfig; } interface Transaction { // Docs: http://electronjs.org/docs/api/structures/transaction /** * The error code if an error occurred while processing the transaction. */ errorCode: number; /** * The error message if an error occurred while processing the transaction. */ errorMessage: string; /** * The identifier of the restored transaction by the App Store. */ originalTransactionIdentifier: string; payment: Payment; /** * The date the transaction was added to the App Store’s payment queue. */ transactionDate: string; /** * A string that uniquely identifies a successful payment transaction. */ transactionIdentifier: string; /** * The transaction state, can be purchasing, purchased, failed, restored or * deferred. */ transactionState: ('purchasing' | 'purchased' | 'failed' | 'restored' | 'deferred'); } class Tray extends EventEmitter { // Docs: http://electronjs.org/docs/api/tray /** * Emitted when the tray balloon is clicked. */ on(event: 'balloon-click', listener: Function): this; once(event: 'balloon-click', listener: Function): this; addListener(event: 'balloon-click', listener: Function): this; removeListener(event: 'balloon-click', listener: Function): this; /** * Emitted when the tray balloon is closed because of timeout or user manually * closes it. */ on(event: 'balloon-closed', listener: Function): this; once(event: 'balloon-closed', listener: Function): this; addListener(event: 'balloon-closed', listener: Function): this; removeListener(event: 'balloon-closed', listener: Function): this; /** * Emitted when the tray balloon shows. */ on(event: 'balloon-show', listener: Function): this; once(event: 'balloon-show', listener: Function): this; addListener(event: 'balloon-show', listener: Function): this; removeListener(event: 'balloon-show', listener: Function): this; /** * Emitted when the tray icon is clicked. */ on(event: 'click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle, /** * The position of the event. */ position: Point) => void): this; once(event: 'click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle, /** * The position of the event. */ position: Point) => void): this; addListener(event: 'click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle, /** * The position of the event. */ position: Point) => void): this; removeListener(event: 'click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle, /** * The position of the event. */ position: Point) => void): this; /** * Emitted when the tray icon is double clicked. */ on(event: 'double-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; once(event: 'double-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; addListener(event: 'double-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; removeListener(event: 'double-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; /** * Emitted when a drag operation ends on the tray or ends at another location. */ on(event: 'drag-end', listener: Function): this; once(event: 'drag-end', listener: Function): this; addListener(event: 'drag-end', listener: Function): this; removeListener(event: 'drag-end', listener: Function): this; /** * Emitted when a drag operation enters the tray icon. */ on(event: 'drag-enter', listener: Function): this; once(event: 'drag-enter', listener: Function): this; addListener(event: 'drag-enter', listener: Function): this; removeListener(event: 'drag-enter', listener: Function): this; /** * Emitted when a drag operation exits the tray icon. */ on(event: 'drag-leave', listener: Function): this; once(event: 'drag-leave', listener: Function): this; addListener(event: 'drag-leave', listener: Function): this; removeListener(event: 'drag-leave', listener: Function): this; /** * Emitted when any dragged items are dropped on the tray icon. */ on(event: 'drop', listener: Function): this; once(event: 'drop', listener: Function): this; addListener(event: 'drop', listener: Function): this; removeListener(event: 'drop', listener: Function): this; /** * Emitted when dragged files are dropped in the tray icon. */ on(event: 'drop-files', listener: (event: Event, /** * The paths of the dropped files. */ files: string[]) => void): this; once(event: 'drop-files', listener: (event: Event, /** * The paths of the dropped files. */ files: string[]) => void): this; addListener(event: 'drop-files', listener: (event: Event, /** * The paths of the dropped files. */ files: string[]) => void): this; removeListener(event: 'drop-files', listener: (event: Event, /** * The paths of the dropped files. */ files: string[]) => void): this; /** * Emitted when dragged text is dropped in the tray icon. */ on(event: 'drop-text', listener: (event: Event, /** * the dropped text string. */ text: string) => void): this; once(event: 'drop-text', listener: (event: Event, /** * the dropped text string. */ text: string) => void): this; addListener(event: 'drop-text', listener: (event: Event, /** * the dropped text string. */ text: string) => void): this; removeListener(event: 'drop-text', listener: (event: Event, /** * the dropped text string. */ text: string) => void): this; /** * Emitted when the mouse enters the tray icon. */ on(event: 'mouse-enter', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; once(event: 'mouse-enter', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; addListener(event: 'mouse-enter', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; removeListener(event: 'mouse-enter', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; /** * Emitted when the mouse exits the tray icon. */ on(event: 'mouse-leave', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; once(event: 'mouse-leave', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; addListener(event: 'mouse-leave', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; removeListener(event: 'mouse-leave', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; /** * Emitted when the mouse moves in the tray icon. */ on(event: 'mouse-move', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; once(event: 'mouse-move', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; addListener(event: 'mouse-move', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; removeListener(event: 'mouse-move', listener: (event: KeyboardEvent, /** * The position of the event. */ position: Point) => void): this; /** * Emitted when the tray icon is right clicked. */ on(event: 'right-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; once(event: 'right-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; addListener(event: 'right-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; removeListener(event: 'right-click', listener: (event: KeyboardEvent, /** * The bounds of tray icon. */ bounds: Rectangle) => void): this; constructor(image: (NativeImage) | (string)); /** * Destroys the tray icon immediately. */ destroy(): void; /** * Displays a tray balloon. */ displayBalloon(options: DisplayBalloonOptions): void; /** * The bounds of this tray icon as Object. */ getBounds(): Rectangle; getIgnoreDoubleClickEvents(): boolean; getTitle(title: string): string; isDestroyed(): boolean; /** * Pops up the context menu of the tray icon. When menu is passed, the menu will be * shown instead of the tray icon's context menu. The position is only available on * Windows, and it is (0, 0) by default. */ popUpContextMenu(menu?: Menu, position?: Point): void; /** * Sets the context menu for this icon. */ setContextMenu(menu: (Menu) | (null)): void; /** * Sets when the tray's icon background becomes highlighted (in blue). Deprecated * Note: You can use highlightMode with a BrowserWindow by toggling between 'never' * and 'always' modes when the window visibility changes. */ setHighlightMode(mode: 'selection' | 'always' | 'never'): void; /** * Sets the option to ignore double click events. Ignoring these events allows you * to detect every individual click of the tray icon. This value is set to false by * default. */ setIgnoreDoubleClickEvents(ignore: boolean): void; /** * Sets the image associated with this tray icon. */ setImage(image: (NativeImage) | (string)): void; /** * Sets the image associated with this tray icon when pressed on macOS. */ setPressedImage(image: (NativeImage) | (string)): void; /** * Sets the title displayed next to the tray icon in the status bar (Support ANSI * colors). */ setTitle(title: string): void; /** * Sets the hover text for this tray icon. */ setToolTip(toolTip: string): void; } interface UploadBlob { // Docs: http://electronjs.org/docs/api/structures/upload-blob /** * UUID of blob data to upload. */ blobUUID: string; /** * blob. */ type: string; } interface UploadData { // Docs: http://electronjs.org/docs/api/structures/upload-data /** * UUID of blob data. Use method to retrieve the data. */ blobUUID: string; /** * Content being sent. */ bytes: Buffer; /** * Path of file being uploaded. */ file: string; } interface UploadFile { // Docs: http://electronjs.org/docs/api/structures/upload-file /** * Path of file to be uploaded. */ filePath: string; /** * Number of bytes to read from offset. Defaults to 0. */ length: number; /** * Last Modification time in number of seconds since the UNIX epoch. */ modificationTime: number; /** * Defaults to 0. */ offset: number; /** * file. */ type: string; } interface UploadRawData { // Docs: http://electronjs.org/docs/api/structures/upload-raw-data /** * Data to be uploaded. */ bytes: Buffer; /** * rawData. */ type: string; } class WebContents extends EventEmitter { // Docs: http://electronjs.org/docs/api/web-contents static fromId(id: number): WebContents; static getAllWebContents(): WebContents[]; static getFocusedWebContents(): WebContents; /** * Emitted before dispatching the keydown and keyup events in the page. Calling * event.preventDefault will prevent the page keydown/keyup events and the menu * shortcuts. To only prevent the menu shortcuts, use setIgnoreMenuShortcuts: */ on(event: 'before-input-event', listener: (event: Event, /** * Input properties. */ input: Input) => void): this; once(event: 'before-input-event', listener: (event: Event, /** * Input properties. */ input: Input) => void): this; addListener(event: 'before-input-event', listener: (event: Event, /** * Input properties. */ input: Input) => void): this; removeListener(event: 'before-input-event', listener: (event: Event, /** * Input properties. */ input: Input) => void): this; /** * Emitted when failed to verify the certificate for url. The usage is the same * with the certificate-error event of app. */ on(event: 'certificate-error', listener: (event: Event, url: string, /** * The error code. */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; once(event: 'certificate-error', listener: (event: Event, url: string, /** * The error code. */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; addListener(event: 'certificate-error', listener: (event: Event, url: string, /** * The error code. */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; removeListener(event: 'certificate-error', listener: (event: Event, url: string, /** * The error code. */ error: string, certificate: Certificate, callback: (isTrusted: boolean) => void) => void): this; /** * Emitted when the associated window logs a console message. Will not be emitted * for windows with offscreen rendering enabled. */ on(event: 'console-message', listener: (event: Event, level: number, message: string, line: number, sourceId: string) => void): this; once(event: 'console-message', listener: (event: Event, level: number, message: string, line: number, sourceId: string) => void): this; addListener(event: 'console-message', listener: (event: Event, level: number, message: string, line: number, sourceId: string) => void): this; removeListener(event: 'console-message', listener: (event: Event, level: number, message: string, line: number, sourceId: string) => void): this; /** * Emitted when there is a new context menu that needs to be handled. */ on(event: 'context-menu', listener: (event: Event, params: ContextMenuParams) => void): this; once(event: 'context-menu', listener: (event: Event, params: ContextMenuParams) => void): this; addListener(event: 'context-menu', listener: (event: Event, params: ContextMenuParams) => void): this; removeListener(event: 'context-menu', listener: (event: Event, params: ContextMenuParams) => void): this; /** * Emitted when the renderer process crashes or is killed. */ on(event: 'crashed', listener: (event: Event, killed: boolean) => void): this; once(event: 'crashed', listener: (event: Event, killed: boolean) => void): this; addListener(event: 'crashed', listener: (event: Event, killed: boolean) => void): this; removeListener(event: 'crashed', listener: (event: Event, killed: boolean) => void): this; /** * Emitted when the cursor's type changes. The type parameter can be default, * crosshair, pointer, text, wait, help, e-resize, n-resize, ne-resize, nw-resize, * s-resize, se-resize, sw-resize, w-resize, ns-resize, ew-resize, nesw-resize, * nwse-resize, col-resize, row-resize, m-panning, e-panning, n-panning, * ne-panning, nw-panning, s-panning, se-panning, sw-panning, w-panning, move, * vertical-text, cell, context-menu, alias, progress, nodrop, copy, none, * not-allowed, zoom-in, zoom-out, grab, grabbing or custom. If the type parameter * is custom, the image parameter will hold the custom cursor image in a * NativeImage, and scale, size and hotspot will hold additional information about * the custom cursor. */ on(event: 'cursor-changed', listener: (event: Event, type: string, image?: NativeImage, /** * scaling factor for the custom cursor. */ scale?: number, /** * the size of the `image`. */ size?: Size, /** * coordinates of the custom cursor's hotspot. */ hotspot?: Point) => void): this; once(event: 'cursor-changed', listener: (event: Event, type: string, image?: NativeImage, /** * scaling factor for the custom cursor. */ scale?: number, /** * the size of the `image`. */ size?: Size, /** * coordinates of the custom cursor's hotspot. */ hotspot?: Point) => void): this; addListener(event: 'cursor-changed', listener: (event: Event, type: string, image?: NativeImage, /** * scaling factor for the custom cursor. */ scale?: number, /** * the size of the `image`. */ size?: Size, /** * coordinates of the custom cursor's hotspot. */ hotspot?: Point) => void): this; removeListener(event: 'cursor-changed', listener: (event: Event, type: string, image?: NativeImage, /** * scaling factor for the custom cursor. */ scale?: number, /** * the size of the `image`. */ size?: Size, /** * coordinates of the custom cursor's hotspot. */ hotspot?: Point) => void): this; /** * Emitted when desktopCapturer.getSources() is called in the renderer process. * Calling event.preventDefault() will make it return empty sources. */ on(event: 'desktop-capturer-get-sources', listener: (event: Event) => void): this; once(event: 'desktop-capturer-get-sources', listener: (event: Event) => void): this; addListener(event: 'desktop-capturer-get-sources', listener: (event: Event) => void): this; removeListener(event: 'desktop-capturer-get-sources', listener: (event: Event) => void): this; /** * Emitted when webContents is destroyed. */ on(event: 'destroyed', listener: Function): this; once(event: 'destroyed', listener: Function): this; addListener(event: 'destroyed', listener: Function): this; removeListener(event: 'destroyed', listener: Function): this; /** * Emitted when DevTools is closed. */ on(event: 'devtools-closed', listener: Function): this; once(event: 'devtools-closed', listener: Function): this; addListener(event: 'devtools-closed', listener: Function): this; removeListener(event: 'devtools-closed', listener: Function): this; /** * Emitted when DevTools is focused / opened. */ on(event: 'devtools-focused', listener: Function): this; once(event: 'devtools-focused', listener: Function): this; addListener(event: 'devtools-focused', listener: Function): this; removeListener(event: 'devtools-focused', listener: Function): this; /** * Emitted when DevTools is opened. */ on(event: 'devtools-opened', listener: Function): this; once(event: 'devtools-opened', listener: Function): this; addListener(event: 'devtools-opened', listener: Function): this; removeListener(event: 'devtools-opened', listener: Function): this; /** * Emitted when the devtools window instructs the webContents to reload */ on(event: 'devtools-reload-page', listener: Function): this; once(event: 'devtools-reload-page', listener: Function): this; addListener(event: 'devtools-reload-page', listener: Function): this; removeListener(event: 'devtools-reload-page', listener: Function): this; /** * Emitted when a has been attached to this web contents. */ on(event: 'did-attach-webview', listener: (event: Event, /** * The guest web contents that is used by the ` */ webContents: WebContents) => void): this; once(event: 'did-attach-webview', listener: (event: Event, /** * The guest web contents that is used by the ` */ webContents: WebContents) => void): this; addListener(event: 'did-attach-webview', listener: (event: Event, /** * The guest web contents that is used by the ` */ webContents: WebContents) => void): this; removeListener(event: 'did-attach-webview', listener: (event: Event, /** * The guest web contents that is used by the ` */ webContents: WebContents) => void): this; /** * Emitted when a page's theme color changes. This is usually due to encountering a * meta tag: */ on(event: 'did-change-theme-color', listener: (event: Event, /** * Theme color is in format of '#rrggbb'. It is `null` when no theme color is set. */ color: (string) | (null)) => void): this; once(event: 'did-change-theme-color', listener: (event: Event, /** * Theme color is in format of '#rrggbb'. It is `null` when no theme color is set. */ color: (string) | (null)) => void): this; addListener(event: 'did-change-theme-color', listener: (event: Event, /** * Theme color is in format of '#rrggbb'. It is `null` when no theme color is set. */ color: (string) | (null)) => void): this; removeListener(event: 'did-change-theme-color', listener: (event: Event, /** * Theme color is in format of '#rrggbb'. It is `null` when no theme color is set. */ color: (string) | (null)) => void): this; /** * This event is like did-finish-load but emitted when the load failed or was * cancelled, e.g. window.stop() is invoked. The full list of error codes and their * meaning is available here. */ on(event: 'did-fail-load', listener: (event: Event, errorCode: number, errorDescription: string, validatedURL: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-fail-load', listener: (event: Event, errorCode: number, errorDescription: string, validatedURL: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-fail-load', listener: (event: Event, errorCode: number, errorDescription: string, validatedURL: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-fail-load', listener: (event: Event, errorCode: number, errorDescription: string, validatedURL: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Emitted when the navigation is done, i.e. the spinner of the tab has stopped * spinning, and the onload event was dispatched. */ on(event: 'did-finish-load', listener: Function): this; once(event: 'did-finish-load', listener: Function): this; addListener(event: 'did-finish-load', listener: Function): this; removeListener(event: 'did-finish-load', listener: Function): this; /** * Emitted when a frame has done navigation. */ on(event: 'did-frame-finish-load', listener: (event: Event, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-frame-finish-load', listener: (event: Event, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-frame-finish-load', listener: (event: Event, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-frame-finish-load', listener: (event: Event, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Emitted when any frame navigation is done. This event is not emitted for in-page * navigations, such as clicking anchor links or updating the window.location.hash. * Use did-navigate-in-page event for this purpose. */ on(event: 'did-frame-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations, */ httpStatusText: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-frame-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations, */ httpStatusText: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-frame-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations, */ httpStatusText: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-frame-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations, */ httpStatusText: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Emitted when a main frame navigation is done. This event is not emitted for * in-page navigations, such as clicking anchor links or updating the * window.location.hash. Use did-navigate-in-page event for this purpose. */ on(event: 'did-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations */ httpStatusText: string) => void): this; once(event: 'did-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations */ httpStatusText: string) => void): this; addListener(event: 'did-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations */ httpStatusText: string) => void): this; removeListener(event: 'did-navigate', listener: (event: Event, url: string, /** * -1 for non HTTP navigations */ httpResponseCode: number, /** * empty for non HTTP navigations */ httpStatusText: string) => void): this; /** * Emitted when an in-page navigation happened in any frame. When in-page * navigation happens, the page URL changes but does not cause navigation outside * of the page. Examples of this occurring are when anchor links are clicked or * when the DOM hashchange event is triggered. */ on(event: 'did-navigate-in-page', listener: (event: Event, url: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-navigate-in-page', listener: (event: Event, url: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-navigate-in-page', listener: (event: Event, url: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-navigate-in-page', listener: (event: Event, url: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Emitted after a server side redirect occurs during navigation. For example a * 302 redirect. This event can not be prevented, if you want to prevent redirects * you should checkout out the will-redirect event above. */ on(event: 'did-redirect-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-redirect-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-redirect-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-redirect-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Corresponds to the points in time when the spinner of the tab started spinning. */ on(event: 'did-start-loading', listener: Function): this; once(event: 'did-start-loading', listener: Function): this; addListener(event: 'did-start-loading', listener: Function): this; removeListener(event: 'did-start-loading', listener: Function): this; /** * Emitted when any frame (including main) starts navigating. isInplace will be * true for in-page navigations. */ on(event: 'did-start-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'did-start-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'did-start-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'did-start-navigation', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Corresponds to the points in time when the spinner of the tab stopped spinning. */ on(event: 'did-stop-loading', listener: Function): this; once(event: 'did-stop-loading', listener: Function): this; addListener(event: 'did-stop-loading', listener: Function): this; removeListener(event: 'did-stop-loading', listener: Function): this; /** * Emitted when the document in the given frame is loaded. */ on(event: 'dom-ready', listener: (event: Event) => void): this; once(event: 'dom-ready', listener: (event: Event) => void): this; addListener(event: 'dom-ready', listener: (event: Event) => void): this; removeListener(event: 'dom-ready', listener: (event: Event) => void): this; /** * Emitted when the window enters a full-screen state triggered by HTML API. */ on(event: 'enter-html-full-screen', listener: Function): this; once(event: 'enter-html-full-screen', listener: Function): this; addListener(event: 'enter-html-full-screen', listener: Function): this; removeListener(event: 'enter-html-full-screen', listener: Function): this; /** * Emitted when a result is available for [webContents.findInPage] request. */ on(event: 'found-in-page', listener: (event: Event, result: Result) => void): this; once(event: 'found-in-page', listener: (event: Event, result: Result) => void): this; addListener(event: 'found-in-page', listener: (event: Event, result: Result) => void): this; removeListener(event: 'found-in-page', listener: (event: Event, result: Result) => void): this; /** * Emitted when the renderer process sends an asynchronous message via * ipcRenderer.send(). */ on(event: 'ipc-message', listener: (event: Event, channel: string, ...args: any[]) => void): this; once(event: 'ipc-message', listener: (event: Event, channel: string, ...args: any[]) => void): this; addListener(event: 'ipc-message', listener: (event: Event, channel: string, ...args: any[]) => void): this; removeListener(event: 'ipc-message', listener: (event: Event, channel: string, ...args: any[]) => void): this; /** * Emitted when the renderer process sends a synchronous message via * ipcRenderer.sendSync(). */ on(event: 'ipc-message-sync', listener: (event: Event, channel: string, ...args: any[]) => void): this; once(event: 'ipc-message-sync', listener: (event: Event, channel: string, ...args: any[]) => void): this; addListener(event: 'ipc-message-sync', listener: (event: Event, channel: string, ...args: any[]) => void): this; removeListener(event: 'ipc-message-sync', listener: (event: Event, channel: string, ...args: any[]) => void): this; /** * Emitted when the window leaves a full-screen state triggered by HTML API. */ on(event: 'leave-html-full-screen', listener: Function): this; once(event: 'leave-html-full-screen', listener: Function): this; addListener(event: 'leave-html-full-screen', listener: Function): this; removeListener(event: 'leave-html-full-screen', listener: Function): this; /** * Emitted when webContents wants to do basic auth. The usage is the same with the * login event of app. */ on(event: 'login', listener: (event: Event, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; once(event: 'login', listener: (event: Event, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; addListener(event: 'login', listener: (event: Event, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; removeListener(event: 'login', listener: (event: Event, request: Request, authInfo: AuthInfo, callback: (username: string, password: string) => void) => void): this; /** * Emitted when media is paused or done playing. */ on(event: 'media-paused', listener: Function): this; once(event: 'media-paused', listener: Function): this; addListener(event: 'media-paused', listener: Function): this; removeListener(event: 'media-paused', listener: Function): this; /** * Emitted when media starts playing. */ on(event: 'media-started-playing', listener: Function): this; once(event: 'media-started-playing', listener: Function): this; addListener(event: 'media-started-playing', listener: Function): this; removeListener(event: 'media-started-playing', listener: Function): this; /** * Emitted when the page requests to open a new window for a url. It could be * requested by window.open or an external link like . By * default a new BrowserWindow will be created for the url. Calling * event.preventDefault() will prevent Electron from automatically creating a new * BrowserWindow. If you call event.preventDefault() and manually create a new * BrowserWindow then you must set event.newGuest to reference the new * BrowserWindow instance, failing to do so may result in unexpected behavior. For * example: */ on(event: 'new-window', listener: (event: Event, url: string, frameName: string, /** * Can be `default`, `foreground-tab`, `background-tab`, `new-window`, * `save-to-disk` and `other`. */ disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'), /** * The options which will be used for creating the new . */ options: any, /** * The non-standard features (features not handled by Chromium or Electron) given * to `window.open()`. */ additionalFeatures: string[], /** * The referrer that will be passed to the new window. May or may not result in the * `Referer` header being sent, depending on the referrer policy. */ referrer: Referrer) => void): this; once(event: 'new-window', listener: (event: Event, url: string, frameName: string, /** * Can be `default`, `foreground-tab`, `background-tab`, `new-window`, * `save-to-disk` and `other`. */ disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'), /** * The options which will be used for creating the new . */ options: any, /** * The non-standard features (features not handled by Chromium or Electron) given * to `window.open()`. */ additionalFeatures: string[], /** * The referrer that will be passed to the new window. May or may not result in the * `Referer` header being sent, depending on the referrer policy. */ referrer: Referrer) => void): this; addListener(event: 'new-window', listener: (event: Event, url: string, frameName: string, /** * Can be `default`, `foreground-tab`, `background-tab`, `new-window`, * `save-to-disk` and `other`. */ disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'), /** * The options which will be used for creating the new . */ options: any, /** * The non-standard features (features not handled by Chromium or Electron) given * to `window.open()`. */ additionalFeatures: string[], /** * The referrer that will be passed to the new window. May or may not result in the * `Referer` header being sent, depending on the referrer policy. */ referrer: Referrer) => void): this; removeListener(event: 'new-window', listener: (event: Event, url: string, frameName: string, /** * Can be `default`, `foreground-tab`, `background-tab`, `new-window`, * `save-to-disk` and `other`. */ disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'), /** * The options which will be used for creating the new . */ options: any, /** * The non-standard features (features not handled by Chromium or Electron) given * to `window.open()`. */ additionalFeatures: string[], /** * The referrer that will be passed to the new window. May or may not result in the * `Referer` header being sent, depending on the referrer policy. */ referrer: Referrer) => void): this; /** * Emitted when page receives favicon urls. */ on(event: 'page-favicon-updated', listener: (event: Event, /** * Array of URLs. */ favicons: string[]) => void): this; once(event: 'page-favicon-updated', listener: (event: Event, /** * Array of URLs. */ favicons: string[]) => void): this; addListener(event: 'page-favicon-updated', listener: (event: Event, /** * Array of URLs. */ favicons: string[]) => void): this; removeListener(event: 'page-favicon-updated', listener: (event: Event, /** * Array of URLs. */ favicons: string[]) => void): this; /** * Fired when page title is set during navigation. explicitSet is false when title * is synthesized from file url. */ on(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; once(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; addListener(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; removeListener(event: 'page-title-updated', listener: (event: Event, title: string, explicitSet: boolean) => void): this; /** * Emitted when a new frame is generated. Only the dirty area is passed in the * buffer. */ on(event: 'paint', listener: (event: Event, dirtyRect: Rectangle, /** * The image data of the whole frame. */ image: NativeImage) => void): this; once(event: 'paint', listener: (event: Event, dirtyRect: Rectangle, /** * The image data of the whole frame. */ image: NativeImage) => void): this; addListener(event: 'paint', listener: (event: Event, dirtyRect: Rectangle, /** * The image data of the whole frame. */ image: NativeImage) => void): this; removeListener(event: 'paint', listener: (event: Event, dirtyRect: Rectangle, /** * The image data of the whole frame. */ image: NativeImage) => void): this; /** * Emitted when a plugin process has crashed. */ on(event: 'plugin-crashed', listener: (event: Event, name: string, version: string) => void): this; once(event: 'plugin-crashed', listener: (event: Event, name: string, version: string) => void): this; addListener(event: 'plugin-crashed', listener: (event: Event, name: string, version: string) => void): this; removeListener(event: 'plugin-crashed', listener: (event: Event, name: string, version: string) => void): this; /** * Emitted when the preload script preloadPath throws an unhandled exception error. */ on(event: 'preload-error', listener: (event: Event, preloadPath: string, error: Error) => void): this; once(event: 'preload-error', listener: (event: Event, preloadPath: string, error: Error) => void): this; addListener(event: 'preload-error', listener: (event: Event, preloadPath: string, error: Error) => void): this; removeListener(event: 'preload-error', listener: (event: Event, preloadPath: string, error: Error) => void): this; /** * Emitted when remote.getBuiltin() is called in the renderer process. Calling * event.preventDefault() will prevent the module from being returned. Custom value * can be returned by setting event.returnValue. */ on(event: 'remote-get-builtin', listener: (event: Event, moduleName: string) => void): this; once(event: 'remote-get-builtin', listener: (event: Event, moduleName: string) => void): this; addListener(event: 'remote-get-builtin', listener: (event: Event, moduleName: string) => void): this; removeListener(event: 'remote-get-builtin', listener: (event: Event, moduleName: string) => void): this; /** * Emitted when remote.getCurrentWebContents() is called in the renderer process. * Calling event.preventDefault() will prevent the object from being returned. * Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-current-web-contents', listener: (event: Event) => void): this; once(event: 'remote-get-current-web-contents', listener: (event: Event) => void): this; addListener(event: 'remote-get-current-web-contents', listener: (event: Event) => void): this; removeListener(event: 'remote-get-current-web-contents', listener: (event: Event) => void): this; /** * Emitted when remote.getCurrentWindow() is called in the renderer process. * Calling event.preventDefault() will prevent the object from being returned. * Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-current-window', listener: (event: Event) => void): this; once(event: 'remote-get-current-window', listener: (event: Event) => void): this; addListener(event: 'remote-get-current-window', listener: (event: Event) => void): this; removeListener(event: 'remote-get-current-window', listener: (event: Event) => void): this; /** * Emitted when remote.getGlobal() is called in the renderer process. Calling * event.preventDefault() will prevent the global from being returned. Custom value * can be returned by setting event.returnValue. */ on(event: 'remote-get-global', listener: (event: Event, globalName: string) => void): this; once(event: 'remote-get-global', listener: (event: Event, globalName: string) => void): this; addListener(event: 'remote-get-global', listener: (event: Event, globalName: string) => void): this; removeListener(event: 'remote-get-global', listener: (event: Event, globalName: string) => void): this; /** * Emitted when .getWebContents() is called in the renderer process. * Calling event.preventDefault() will prevent the object from being returned. * Custom value can be returned by setting event.returnValue. */ on(event: 'remote-get-guest-web-contents', listener: (event: Event, guestWebContents: WebContents) => void): this; once(event: 'remote-get-guest-web-contents', listener: (event: Event, guestWebContents: WebContents) => void): this; addListener(event: 'remote-get-guest-web-contents', listener: (event: Event, guestWebContents: WebContents) => void): this; removeListener(event: 'remote-get-guest-web-contents', listener: (event: Event, guestWebContents: WebContents) => void): this; /** * Emitted when remote.require() is called in the renderer process. Calling * event.preventDefault() will prevent the module from being returned. Custom value * can be returned by setting event.returnValue. */ on(event: 'remote-require', listener: (event: Event, moduleName: string) => void): this; once(event: 'remote-require', listener: (event: Event, moduleName: string) => void): this; addListener(event: 'remote-require', listener: (event: Event, moduleName: string) => void): this; removeListener(event: 'remote-require', listener: (event: Event, moduleName: string) => void): this; /** * Emitted when the unresponsive web page becomes responsive again. */ on(event: 'responsive', listener: Function): this; once(event: 'responsive', listener: Function): this; addListener(event: 'responsive', listener: Function): this; removeListener(event: 'responsive', listener: Function): this; /** * Emitted when bluetooth device needs to be selected on call to * navigator.bluetooth.requestDevice. To use navigator.bluetooth api webBluetooth * should be enabled. If event.preventDefault is not called, first available device * will be selected. callback should be called with deviceId to be selected, * passing empty string to callback will cancel the request. */ on(event: 'select-bluetooth-device', listener: (event: Event, devices: BluetoothDevice[], callback: (deviceId: string) => void) => void): this; once(event: 'select-bluetooth-device', listener: (event: Event, devices: BluetoothDevice[], callback: (deviceId: string) => void) => void): this; addListener(event: 'select-bluetooth-device', listener: (event: Event, devices: BluetoothDevice[], callback: (deviceId: string) => void) => void): this; removeListener(event: 'select-bluetooth-device', listener: (event: Event, devices: BluetoothDevice[], callback: (deviceId: string) => void) => void): this; /** * Emitted when a client certificate is requested. The usage is the same with the * select-client-certificate event of app. */ on(event: 'select-client-certificate', listener: (event: Event, url: string, certificateList: Certificate[], callback: (certificate: Certificate) => void) => void): this; once(event: 'select-client-certificate', listener: (event: Event, url: string, certificateList: Certificate[], callback: (certificate: Certificate) => void) => void): this; addListener(event: 'select-client-certificate', listener: (event: Event, url: string, certificateList: Certificate[], callback: (certificate: Certificate) => void) => void): this; removeListener(event: 'select-client-certificate', listener: (event: Event, url: string, certificateList: Certificate[], callback: (certificate: Certificate) => void) => void): this; /** * Emitted when the web page becomes unresponsive. */ on(event: 'unresponsive', listener: Function): this; once(event: 'unresponsive', listener: Function): this; addListener(event: 'unresponsive', listener: Function): this; removeListener(event: 'unresponsive', listener: Function): this; /** * Emitted when mouse moves over a link or the keyboard moves the focus to a link. */ on(event: 'update-target-url', listener: (event: Event, url: string) => void): this; once(event: 'update-target-url', listener: (event: Event, url: string) => void): this; addListener(event: 'update-target-url', listener: (event: Event, url: string) => void): this; removeListener(event: 'update-target-url', listener: (event: Event, url: string) => void): this; /** * Emitted when a 's web contents is being attached to this web contents. * Calling event.preventDefault() will destroy the guest page. This event can be * used to configure webPreferences for the webContents of a before it's * loaded, and provides the ability to set settings that can't be set via * attributes. Note: The specified preload script option will be appear as * preloadURL (not preload) in the webPreferences object emitted with this event. */ on(event: 'will-attach-webview', listener: (event: Event, /** * The web preferences that will be used by the guest page. This object can be * modified to adjust the preferences for the guest page. */ webPreferences: any, /** * The other ` */ params: any) => void): this; once(event: 'will-attach-webview', listener: (event: Event, /** * The web preferences that will be used by the guest page. This object can be * modified to adjust the preferences for the guest page. */ webPreferences: any, /** * The other ` */ params: any) => void): this; addListener(event: 'will-attach-webview', listener: (event: Event, /** * The web preferences that will be used by the guest page. This object can be * modified to adjust the preferences for the guest page. */ webPreferences: any, /** * The other ` */ params: any) => void): this; removeListener(event: 'will-attach-webview', listener: (event: Event, /** * The web preferences that will be used by the guest page. This object can be * modified to adjust the preferences for the guest page. */ webPreferences: any, /** * The other ` */ params: any) => void): this; /** * Emitted when a user or the page wants to start navigation. It can happen when * the window.location object is changed or a user clicks a link in the page. This * event will not emit when the navigation is started programmatically with APIs * like webContents.loadURL and webContents.back. It is also not emitted for * in-page navigations, such as clicking anchor links or updating the * window.location.hash. Use did-navigate-in-page event for this purpose. Calling * event.preventDefault() will prevent the navigation. */ on(event: 'will-navigate', listener: (event: Event, url: string) => void): this; once(event: 'will-navigate', listener: (event: Event, url: string) => void): this; addListener(event: 'will-navigate', listener: (event: Event, url: string) => void): this; removeListener(event: 'will-navigate', listener: (event: Event, url: string) => void): this; /** * Emitted when a beforeunload event handler is attempting to cancel a page unload. * Calling event.preventDefault() will ignore the beforeunload event handler and * allow the page to be unloaded. */ on(event: 'will-prevent-unload', listener: (event: Event) => void): this; once(event: 'will-prevent-unload', listener: (event: Event) => void): this; addListener(event: 'will-prevent-unload', listener: (event: Event) => void): this; removeListener(event: 'will-prevent-unload', listener: (event: Event) => void): this; /** * Emitted as a server side redirect occurs during navigation. For example a 302 * redirect. This event will be emitted after did-start-navigation and always * before the did-redirect-navigation event for the same navigation. Calling * event.preventDefault() will prevent the navigation (not just the redirect). */ on(event: 'will-redirect', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; once(event: 'will-redirect', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; addListener(event: 'will-redirect', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; removeListener(event: 'will-redirect', listener: (event: Event, url: string, isInPlace: boolean, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void): this; /** * Adds the specified path to DevTools workspace. Must be used after DevTools * creation: */ addWorkSpace(path: string): void; /** * Begin subscribing for presentation events and captured frames, the callback 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 * 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, image will only * contain the repainted area. onlyDirty defaults to false. */ beginFrameSubscription(callback: (image: NativeImage, dirtyRect: Rectangle) => void): void; /** * Begin subscribing for presentation events and captured frames, the callback 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 * 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, image will only * contain the repainted area. onlyDirty defaults to false. */ beginFrameSubscription(onlyDirty: boolean, callback: (image: NativeImage, dirtyRect: Rectangle) => void): void; canGoBack(): boolean; canGoForward(): boolean; canGoToOffset(offset: number): boolean; /** * Captures a snapshot of the page within rect. Omitting rect will capture the * whole visible page. */ capturePage(rect?: Rectangle): Promise; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(rect: Rectangle, callback: (image: NativeImage) => void): void; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(callback: (image: NativeImage) => void): void; /** * Clears the navigation history. */ clearHistory(): void; /** * Closes the devtools. */ closeDevTools(): void; /** * Executes the editing command copy in web page. */ copy(): void; /** * Copy the image at the given position to the clipboard. */ copyImageAt(x: number, y: number): void; /** * Executes the editing command cut in web page. */ cut(): void; /** * Executes the editing command delete in web page. */ delete(): void; /** * Disable device emulation enabled by webContents.enableDeviceEmulation. */ disableDeviceEmulation(): void; /** * Initiates a download of the resource at url without navigating. The * will-download event of session will be triggered. */ downloadURL(url: string): void; /** * Enable device emulation with the given parameters. */ enableDeviceEmulation(parameters: Parameters): void; /** * End subscribing for frame presentation events. */ endFrameSubscription(): void; /** * Evaluates code in page. In the browser window some HTML APIs like * requestFullScreen can only be invoked by a gesture from the user. Setting * userGesture to true will remove this limitation. Deprecated Soon */ executeJavaScript(code: string, userGesture?: boolean, callback?: (result: any) => void): Promise; /** * Evaluates code in page. In the browser window some HTML APIs like * requestFullScreen can only be invoked by a gesture from the user. Setting * userGesture to true will remove this limitation. */ executeJavaScript(code: string, userGesture?: boolean): Promise; /** * Starts a request to find all matches for the text in the web page. The result of * the request can be obtained by subscribing to found-in-page event. */ findInPage(text: string, options?: FindInPageOptions): number; /** * Focuses the web page. */ focus(): void; getFrameRate(): number; getOSProcessId(): number; /** * Get the system printer list. */ getPrinters(): PrinterInfo[]; getProcessId(): number; getTitle(): string; getType(): ('backgroundPage' | 'window' | 'browserView' | 'remote' | 'webview' | 'offscreen'); getURL(): string; getUserAgent(): string; getWebRTCIPHandlingPolicy(): string; getZoomFactor(): number; getZoomLevel(): number; /** * Makes the browser go back a web page. */ goBack(): void; /** * Makes the browser go forward a web page. */ goForward(): void; /** * Navigates browser to the specified absolute web page index. */ goToIndex(index: number): void; /** * Navigates to the specified offset from the "current entry". */ goToOffset(offset: number): void; /** * Injects CSS into the current web page. */ insertCSS(css: string): void; /** * Inserts text to the focused element. */ insertText(text: string): void; /** * Starts inspecting element at position (x, y). */ inspectElement(x: number, y: number): void; /** * Opens the developer tools for the service worker context. */ inspectServiceWorker(): void; /** * Opens the developer tools for the shared worker context. */ inspectSharedWorker(): void; /** * Schedules a full repaint of the window this web contents is in. If offscreen * rendering is enabled invalidates the frame and generates a new one through the * 'paint' event. */ invalidate(): void; isAudioMuted(): boolean; isCrashed(): boolean; isCurrentlyAudible(): boolean; isDestroyed(): boolean; isDevToolsFocused(): boolean; isDevToolsOpened(): boolean; isFocused(): boolean; isLoading(): boolean; isLoadingMainFrame(): boolean; isOffscreen(): boolean; isPainting(): boolean; isWaitingForResponse(): boolean; /** * Loads the given file in the window, filePath should be a path to an HTML file * relative to the root of your application. For instance an app structure like * this: Would require code like this */ loadFile(filePath: string, options?: LoadFileOptions): Promise; /** * Loads the url in the window. The url must contain the protocol prefix, e.g. the * http:// or file://. If the load should bypass http cache then use the pragma * header to achieve it. */ loadURL(url: string, options?: LoadURLOptions): Promise; /** * Opens the devtools. When contents is a tag, the mode would be detach * by default, explicitly passing an empty mode can force using last used dock * state. */ openDevTools(options?: OpenDevToolsOptions): void; /** * Executes the editing command paste in web page. */ paste(): void; /** * Executes the editing command pasteAndMatchStyle in web page. */ pasteAndMatchStyle(): void; /** * Prints window's web page. When silent is set to true, Electron will pick the * system's default printer if deviceName is empty and the default settings for * printing. Calling window.print() in web page is equivalent to calling * webContents.print({ silent: false, printBackground: false, deviceName: '' }). * Use page-break-before: always; CSS style to force to print to a new page. */ print(options?: PrintOptions, callback?: (success: boolean) => void): void; /** * Prints window's web page as PDF with Chromium's preview printing custom * settings. The landscape will be ignored if @page CSS at-rule is used in the web * page. By default, an empty options will be regarded as: Use page-break-before: * always; CSS style to force to print to a new page. An example of * webContents.printToPDF: */ printToPDF(options: PrintToPDFOptions): Promise; /** * Prints window's web page as PDF with Chromium's preview printing custom * settings. The callback will be called with callback(error, data) on completion. * The data is a Buffer that contains the generated PDF data. Deprecated Soon */ printToPDF(options: PrintToPDFOptions, callback: (error: Error, data: Buffer) => void): void; /** * Executes the editing command redo in web page. */ redo(): void; /** * Reloads the current web page. */ reload(): void; /** * Reloads current page and ignores cache. */ reloadIgnoringCache(): void; /** * Removes the specified path from DevTools workspace. */ removeWorkSpace(path: string): void; /** * Executes the editing command replace in web page. */ replace(text: string): void; /** * Executes the editing command replaceMisspelling in web page. */ replaceMisspelling(text: string): void; savePage(fullPath: string, saveType: 'HTMLOnly' | 'HTMLComplete' | 'MHTML'): Promise; /** * Executes the editing command selectAll in web page. */ selectAll(): void; /** * Send an asynchronous message to renderer process via channel, you can also send * arbitrary arguments. Arguments will be serialized in JSON internally and hence * no functions or prototype chain will be included. The renderer process can * handle the message by listening to channel with the ipcRenderer module. An * example of sending messages from the main process to the renderer process: */ send(channel: string, ...args: any[]): void; /** * Sends an input event to the page. Note: The BrowserWindow containing the * contents needs to be focused for sendInputEvent() to work. For keyboard events, * the event object also have following properties: For mouse events, the event * object also have following properties: For the mouseWheel event, the event * object also have following properties: */ sendInputEvent(event: Event): void; /** * Send an asynchronous message to a specific frame in a renderer process via * channel. Arguments will be serialized as JSON internally and as such no * functions or prototype chains will be included. The renderer process can handle * the message by listening to channel with the ipcRenderer module. If you want to * get the frameId of a given renderer context you should use the * webFrame.routingId value. E.g. You can also read frameId from all incoming IPC * messages in the main process. */ sendToFrame(frameId: number, channel: string, ...args: any[]): void; /** * Mute the audio on the current web page. */ setAudioMuted(muted: boolean): void; /** * Controls whether or not this WebContents will throttle animations and timers * when the page becomes backgrounded. This also affects the Page Visibility API. */ setBackgroundThrottling(allowed: boolean): void; /** * Uses the devToolsWebContents as the target WebContents to show devtools. The * devToolsWebContents must not have done any navigation, and it should not be used * for other purposes after the call. By default Electron manages the devtools by * creating an internal WebContents with native view, which developers have very * limited control of. With the setDevToolsWebContents method, developers can use * any WebContents to show the devtools in it, including BrowserWindow, BrowserView * and tag. Note that closing the devtools does not destroy the * devToolsWebContents, it is caller's responsibility to destroy * devToolsWebContents. An example of showing devtools in a tag: An * example of showing devtools in a BrowserWindow: */ setDevToolsWebContents(devToolsWebContents: WebContents): void; /** * If offscreen rendering is enabled sets the frame rate to the specified number. * Only values between 1 and 60 are accepted. */ setFrameRate(fps: number): void; /** * Ignore application menu shortcuts while this web contents is focused. */ setIgnoreMenuShortcuts(ignore: boolean): void; /** * Sets the maximum and minimum layout-based (i.e. non-visual) zoom level. */ setLayoutZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Overrides the user agent for this web page. */ setUserAgent(userAgent: string): void; /** * Sets the maximum and minimum pinch-to-zoom level. */ setVisualZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Setting the WebRTC IP handling policy allows you to control which IPs are * exposed via WebRTC. See BrowserLeaks for more details. */ setWebRTCIPHandlingPolicy(policy: 'default' | 'default_public_interface_only' | 'default_public_and_private_interfaces' | 'disable_non_proxied_udp'): void; /** * Changes the zoom factor to the specified factor. Zoom factor is zoom percent * divided by 100, so 300% = 3.0. */ setZoomFactor(factor: number): void; /** * Changes the zoom level to the specified level. The original size is 0 and each * increment above or below represents zooming 20% larger or smaller to default * limits of 300% and 50% of original size, respectively. The formula for this is * scale := 1.2 ^ level. */ setZoomLevel(level: number): void; /** * Shows pop-up dictionary that searches the selected word on the page. */ showDefinitionForSelection(): void; /** * Sets the item as dragging item for current drag-drop operation, file is the * absolute path of the file to be dragged, and icon is the image showing under the * cursor when dragging. */ startDrag(item: Item): void; /** * If offscreen rendering is enabled and not painting, start painting. */ startPainting(): void; /** * Stops any pending navigation. */ stop(): void; /** * Stops any findInPage request for the webContents with the provided action. */ stopFindInPage(action: 'clearSelection' | 'keepSelection' | 'activateSelection'): void; /** * If offscreen rendering is enabled and painting, stop painting. */ stopPainting(): void; /** * Takes a V8 heap snapshot and saves it to filePath. */ takeHeapSnapshot(filePath: string): Promise; /** * Toggles the developer tools. */ toggleDevTools(): void; /** * Executes the editing command undo in web page. */ undo(): void; /** * Executes the editing command unselect in web page. */ unselect(): void; debugger: Debugger; devToolsWebContents: WebContents; hostWebContents: WebContents; id: number; session: Session; } interface WebFrame extends EventEmitter { // Docs: http://electronjs.org/docs/api/web-frame /** * Attempts to free memory that is no longer being used (like images from a * previous navigation). Note that blindly calling this method probably makes * Electron slower since it will have to refill these emptied caches, you should * only call it if an event in your app has occurred that makes you think your page * is actually using less memory (i.e. you have navigated from a super heavy page * to a mostly empty one, and intend to stay there). */ clearCache(): void; /** * Evaluates code in page. In the browser window some HTML APIs like * requestFullScreen can only be invoked by a gesture from the user. Setting * userGesture to true will remove this limitation. */ executeJavaScript(code: string, userGesture?: boolean): Promise; /** * Evaluates code in page. In the browser window some HTML APIs like * requestFullScreen can only be invoked by a gesture from the user. Setting * userGesture to true will remove this limitation. Deprecated Soon */ executeJavaScript(code: string, userGesture?: boolean, callback?: (result: any) => void): Promise; /** * Works like executeJavaScript but evaluates scripts in an isolated context. * Deprecated Soon */ executeJavaScriptInIsolatedWorld(worldId: number, scripts: WebSource[], userGesture?: boolean, callback?: (result: any) => void): Promise; /** * Works like executeJavaScript but evaluates scripts in an isolated context. */ executeJavaScriptInIsolatedWorld(worldId: number, scripts: WebSource[], userGesture?: boolean): Promise; findFrameByName(name: string): WebFrame; findFrameByRoutingId(routingId: number): WebFrame; getFrameForSelector(selector: string): WebFrame; /** * Returns an object describing usage information of Blink's internal memory * caches. This will generate: */ getResourceUsage(): ResourceUsage; getZoomFactor(): number; getZoomLevel(): number; /** * Inserts css as a style sheet in the document. */ insertCSS(css: string): void; /** * Inserts text to the focused element. */ insertText(text: string): void; /** * Set the content security policy of the isolated world. */ setIsolatedWorldContentSecurityPolicy(worldId: number, csp: string): void; /** * Set the name of the isolated world. Useful in devtools. */ setIsolatedWorldHumanReadableName(worldId: number, name: string): void; /** * Set the security origin, content security policy and name of the isolated world. * Note: If the csp is specified, then the securityOrigin also has to be specified. */ setIsolatedWorldInfo(worldId: number, info: Info): void; /** * Set the security origin of the isolated world. */ setIsolatedWorldSecurityOrigin(worldId: number, securityOrigin: string): void; /** * Sets the maximum and minimum layout-based (i.e. non-visual) zoom level. */ setLayoutZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Sets a provider for spell checking in input fields and text areas. The provider * must be an object that has a spellCheck method that accepts an array of * individual words for spellchecking. The spellCheck function runs asynchronously * and calls the callback function with an array of misspelt words when complete. * An example of using node-spellchecker as provider: */ setSpellCheckProvider(language: string, provider: Provider): void; /** * Sets the maximum and minimum pinch-to-zoom level. */ setVisualZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Changes the zoom factor to the specified factor. Zoom factor is zoom percent * divided by 100, so 300% = 3.0. */ setZoomFactor(factor: number): void; /** * Changes the zoom level to the specified level. The original size is 0 and each * increment above or below represents zooming 20% larger or smaller to default * limits of 300% and 50% of original size, respectively. */ setZoomLevel(level: number): void; /** * A WebFrame representing the first child frame of webFrame, the property would be * null if webFrame has no children or if first child is not in the current * renderer process. */ firstChild?: WebFrame; /** * A WebFrame representing next sibling frame, the property would be null if * webFrame is the last frame in its parent or if the next sibling is not in the * current renderer process. */ nextSibling?: WebFrame; /** * A WebFrame representing the frame which opened webFrame, the property would be * null if there's no opener or opener is not in the current renderer process. */ opener?: WebFrame; /** * A WebFrame representing parent frame of webFrame, the property would be null if * webFrame is top or parent is not in the current renderer process. */ parent?: WebFrame; /** * An Integer representing the unique frame id in the current renderer process. * Distinct WebFrame instances that refer to the same underlying frame will have * the same routingId. */ routingId?: number; /** * A WebFrame representing top frame in frame hierarchy to which webFrame belongs, * the property would be null if top frame is not in the current renderer process. */ top?: WebFrame; } class WebRequest extends EventEmitter { // Docs: http://electronjs.org/docs/api/web-request /** * The listener will be called with listener(details) when a server initiated * redirect is about to occur. */ onBeforeRedirect(listener: ((details: OnBeforeRedirectDetails) => void) | (null)): void; /** * The listener will be called with listener(details) when a server initiated * redirect is about to occur. */ onBeforeRedirect(filter: OnBeforeRedirectFilter, listener: ((details: OnBeforeRedirectDetails) => void) | (null)): void; /** * The listener will be called with listener(details, callback) when a request is * about to occur. The uploadData is an array of UploadData objects. The callback * has to be called with an response object. Some examples of valid urls: */ onBeforeRequest(listener: ((details: OnBeforeRequestDetails, callback: (response: Response) => void) => void) | (null)): void; /** * The listener will be called with listener(details, callback) when a request is * about to occur. The uploadData is an array of UploadData objects. The callback * has to be called with an response object. Some examples of valid urls: */ onBeforeRequest(filter: OnBeforeRequestFilter, listener: ((details: OnBeforeRequestDetails, callback: (response: Response) => void) => void) | (null)): void; /** * The listener will be called with listener(details, callback) before sending an * HTTP request, once the request headers are available. This may occur after a TCP * connection is made to the server, but before any http data is sent. The callback * has to be called with an response object. */ onBeforeSendHeaders(filter: OnBeforeSendHeadersFilter, listener: ((details: OnBeforeSendHeadersDetails, callback: (response: OnBeforeSendHeadersResponse) => void) => void) | (null)): void; /** * The listener will be called with listener(details, callback) before sending an * HTTP request, once the request headers are available. This may occur after a TCP * connection is made to the server, but before any http data is sent. The callback * has to be called with an response object. */ onBeforeSendHeaders(listener: ((details: OnBeforeSendHeadersDetails, callback: (response: OnBeforeSendHeadersResponse) => void) => void) | (null)): void; /** * The listener will be called with listener(details) when a request is completed. */ onCompleted(filter: OnCompletedFilter, listener: ((details: OnCompletedDetails) => void) | (null)): void; /** * The listener will be called with listener(details) when a request is completed. */ onCompleted(listener: ((details: OnCompletedDetails) => void) | (null)): void; /** * The listener will be called with listener(details) when an error occurs. */ onErrorOccurred(listener: ((details: OnErrorOccurredDetails) => void) | (null)): void; /** * The listener will be called with listener(details) when an error occurs. */ onErrorOccurred(filter: OnErrorOccurredFilter, listener: ((details: OnErrorOccurredDetails) => void) | (null)): void; /** * The listener will be called with listener(details, callback) when HTTP response * headers of a request have been received. The callback has to be called with an * response object. */ onHeadersReceived(filter: OnHeadersReceivedFilter, listener: ((details: OnHeadersReceivedDetails, callback: (response: OnHeadersReceivedResponse) => void) => void) | (null)): void; /** * The listener will be called with listener(details, callback) when HTTP response * headers of a request have been received. The callback has to be called with an * response object. */ onHeadersReceived(listener: ((details: OnHeadersReceivedDetails, callback: (response: OnHeadersReceivedResponse) => void) => void) | (null)): void; /** * The listener will be called with listener(details) when first byte of the * response body is received. For HTTP requests, this means that the status line * and response headers are available. */ onResponseStarted(listener: ((details: OnResponseStartedDetails) => void) | (null)): void; /** * The listener will be called with listener(details) when first byte of the * response body is received. For HTTP requests, this means that the status line * and response headers are available. */ onResponseStarted(filter: OnResponseStartedFilter, listener: ((details: OnResponseStartedDetails) => void) | (null)): void; /** * The listener will be called with listener(details) just before a request is * going to be sent to the server, modifications of previous onBeforeSendHeaders * response are visible by the time this listener is fired. */ onSendHeaders(filter: OnSendHeadersFilter, listener: ((details: OnSendHeadersDetails) => void) | (null)): void; /** * The listener will be called with listener(details) just before a request is * going to be sent to the server, modifications of previous onBeforeSendHeaders * response are visible by the time this listener is fired. */ onSendHeaders(listener: ((details: OnSendHeadersDetails) => void) | (null)): void; } interface WebSource { // Docs: http://electronjs.org/docs/api/structures/web-source code: string; /** * Default is 1. */ startLine?: number; url?: string; } interface WebviewTag extends HTMLElement { // Docs: http://electronjs.org/docs/api/webview-tag /** * Fired when a load has committed. This includes navigation within the current * document as well as subframe document-level loads, but does not include * asynchronous resource loads. */ addEventListener(event: 'load-commit', listener: (event: LoadCommitEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'load-commit', listener: (event: LoadCommitEvent) => void): this; /** * Fired when the navigation is done, i.e. the spinner of the tab will stop * spinning, and the onload event is dispatched. */ addEventListener(event: 'did-finish-load', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'did-finish-load', listener: (event: Event) => void): this; /** * This event is like did-finish-load, but fired when the load failed or was * cancelled, e.g. window.stop() is invoked. */ addEventListener(event: 'did-fail-load', listener: (event: DidFailLoadEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'did-fail-load', listener: (event: DidFailLoadEvent) => void): this; /** * Fired when a frame has done navigation. */ addEventListener(event: 'did-frame-finish-load', listener: (event: DidFrameFinishLoadEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'did-frame-finish-load', listener: (event: DidFrameFinishLoadEvent) => void): this; /** * Corresponds to the points in time when the spinner of the tab starts spinning. */ addEventListener(event: 'did-start-loading', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'did-start-loading', listener: (event: Event) => void): this; /** * Corresponds to the points in time when the spinner of the tab stops spinning. */ addEventListener(event: 'did-stop-loading', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'did-stop-loading', listener: (event: Event) => void): this; /** * Fired when document in the given frame is loaded. */ addEventListener(event: 'dom-ready', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'dom-ready', listener: (event: Event) => void): this; /** * Fired when page title is set during navigation. explicitSet is false when title * is synthesized from file url. */ addEventListener(event: 'page-title-updated', listener: (event: PageTitleUpdatedEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'page-title-updated', listener: (event: PageTitleUpdatedEvent) => void): this; /** * Fired when page receives favicon urls. */ addEventListener(event: 'page-favicon-updated', listener: (event: PageFaviconUpdatedEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'page-favicon-updated', listener: (event: PageFaviconUpdatedEvent) => void): this; /** * Fired when page enters fullscreen triggered by HTML API. */ addEventListener(event: 'enter-html-full-screen', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'enter-html-full-screen', listener: (event: Event) => void): this; /** * Fired when page leaves fullscreen triggered by HTML API. */ addEventListener(event: 'leave-html-full-screen', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'leave-html-full-screen', listener: (event: Event) => void): this; /** * Fired when the guest window logs a console message. The following example code * forwards all log messages to the embedder's console without regard for log level * or other properties. */ addEventListener(event: 'console-message', listener: (event: ConsoleMessageEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'console-message', listener: (event: ConsoleMessageEvent) => void): this; /** * Fired when a result is available for webview.findInPage request. */ addEventListener(event: 'found-in-page', listener: (event: FoundInPageEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'found-in-page', listener: (event: FoundInPageEvent) => void): this; /** * Fired when the guest page attempts to open a new browser window. The following * example code opens the new url in system's default browser. */ addEventListener(event: 'new-window', listener: (event: NewWindowEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'new-window', listener: (event: NewWindowEvent) => void): this; /** * Emitted when a user or the page wants to start navigation. It can happen when * the window.location object is changed or a user clicks a link in the page. This * event will not emit when the navigation is started programmatically with APIs * like .loadURL and .back. It is also not emitted during in-page * navigation, such as clicking anchor links or updating the window.location.hash. * Use did-navigate-in-page event for this purpose. Calling event.preventDefault() * does NOT have any effect. */ addEventListener(event: 'will-navigate', listener: (event: WillNavigateEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'will-navigate', listener: (event: WillNavigateEvent) => void): this; /** * Emitted when a navigation is done. This event is not emitted for in-page * navigations, such as clicking anchor links or updating the window.location.hash. * Use did-navigate-in-page event for this purpose. */ addEventListener(event: 'did-navigate', listener: (event: DidNavigateEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'did-navigate', listener: (event: DidNavigateEvent) => void): this; /** * Emitted when an in-page navigation happened. When in-page navigation happens, * the page URL changes but does not cause navigation outside of the page. Examples * of this occurring are when anchor links are clicked or when the DOM hashchange * event is triggered. */ addEventListener(event: 'did-navigate-in-page', listener: (event: DidNavigateInPageEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'did-navigate-in-page', listener: (event: DidNavigateInPageEvent) => void): this; /** * Fired when the guest page attempts to close itself. The following example code * navigates the webview to about:blank when the guest attempts to close itself. */ addEventListener(event: 'close', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'close', listener: (event: Event) => void): this; /** * Fired when the guest page has sent an asynchronous message to embedder page. * With sendToHost method and ipc-message event you can communicate between guest * page and embedder page: */ addEventListener(event: 'ipc-message', listener: (event: IpcMessageEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'ipc-message', listener: (event: IpcMessageEvent) => void): this; /** * Fired when the renderer process is crashed. */ addEventListener(event: 'crashed', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'crashed', listener: (event: Event) => void): this; /** * Fired when a plugin process is crashed. */ addEventListener(event: 'plugin-crashed', listener: (event: PluginCrashedEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'plugin-crashed', listener: (event: PluginCrashedEvent) => void): this; /** * Fired when the WebContents is destroyed. */ addEventListener(event: 'destroyed', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'destroyed', listener: (event: Event) => void): this; /** * Emitted when media starts playing. */ addEventListener(event: 'media-started-playing', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'media-started-playing', listener: (event: Event) => void): this; /** * Emitted when media is paused or done playing. */ addEventListener(event: 'media-paused', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'media-paused', listener: (event: Event) => void): this; /** * Emitted when a page's theme color changes. This is usually due to encountering a * meta tag: */ addEventListener(event: 'did-change-theme-color', listener: (event: DidChangeThemeColorEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'did-change-theme-color', listener: (event: DidChangeThemeColorEvent) => void): this; /** * Emitted when mouse moves over a link or the keyboard moves the focus to a link. */ addEventListener(event: 'update-target-url', listener: (event: UpdateTargetUrlEvent) => void, useCapture?: boolean): this; removeEventListener(event: 'update-target-url', listener: (event: UpdateTargetUrlEvent) => void): this; /** * Emitted when DevTools is opened. */ addEventListener(event: 'devtools-opened', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'devtools-opened', listener: (event: Event) => void): this; /** * Emitted when DevTools is closed. */ addEventListener(event: 'devtools-closed', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'devtools-closed', listener: (event: Event) => void): this; /** * Emitted when DevTools is focused / opened. */ addEventListener(event: 'devtools-focused', listener: (event: Event) => void, useCapture?: boolean): this; removeEventListener(event: 'devtools-focused', listener: (event: Event) => void): this; addEventListener(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; removeEventListener(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, useCapture?: boolean): void; removeEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; canGoBack(): boolean; canGoForward(): boolean; canGoToOffset(offset: number): boolean; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(callback: (image: NativeImage) => void): void; /** * Captures a snapshot of the page within rect. Upon completion callback will be * called with callback(image). The image is an instance of NativeImage that stores * data of the snapshot. Omitting rect will capture the whole visible page. * Deprecated Soon */ capturePage(rect: Rectangle, callback: (image: NativeImage) => void): void; /** * Captures a snapshot of the page within rect. Omitting rect will capture the * whole visible page. */ capturePage(rect?: Rectangle): Promise; /** * Clears the navigation history. */ clearHistory(): void; /** * Closes the DevTools window of guest page. */ closeDevTools(): void; /** * Executes editing command copy in page. */ copy(): void; /** * Executes editing command cut in page. */ cut(): void; /** * Executes editing command delete in page. */ delete(): void; /** * Initiates a download of the resource at url without navigating. */ downloadURL(url: string): void; /** * Evaluates code in page. If userGesture is set, it will create the user gesture * context in the page. HTML APIs like requestFullScreen, which require user * action, can take advantage of this option for automation. Deprecated Soon */ executeJavaScript(code: string, userGesture?: boolean, callback?: (result: any) => void): Promise; /** * Evaluates code in page. If userGesture is set, it will create the user gesture * context in the page. HTML APIs like requestFullScreen, which require user * action, can take advantage of this option for automation. */ executeJavaScript(code: string, userGesture?: boolean): Promise; /** * Starts a request to find all matches for the text in the web page. The result of * the request can be obtained by subscribing to found-in-page event. */ findInPage(text: string, options?: FindInPageOptions): number; getTitle(): string; getURL(): string; getUserAgent(): string; /** * It depends on the remote module, it is therefore not available when this module * is disabled. */ getWebContents(): WebContents; getWebContentsId(): number; getZoomFactor(): number; getZoomLevel(): number; /** * Makes the guest page go back. */ goBack(): void; /** * Makes the guest page go forward. */ goForward(): void; /** * Navigates to the specified absolute index. */ goToIndex(index: number): void; /** * Navigates to the specified offset from the "current entry". */ goToOffset(offset: number): void; /** * Injects CSS into the guest page. */ insertCSS(css: string): void; /** * Inserts text to the focused element. */ insertText(text: string): void; /** * Starts inspecting element at position (x, y) of guest page. */ inspectElement(x: number, y: number): void; /** * Opens the DevTools for the service worker context present in the guest page. */ inspectServiceWorker(): void; /** * Opens the DevTools for the shared worker context present in the guest page. */ inspectSharedWorker(): void; isAudioMuted(): boolean; isCrashed(): boolean; isCurrentlyAudible(): boolean; isDevToolsFocused(): boolean; isDevToolsOpened(): boolean; isLoading(): boolean; isLoadingMainFrame(): boolean; isWaitingForResponse(): boolean; /** * Loads the url in the webview, the url must contain the protocol prefix, e.g. the * http:// or file://. */ loadURL(url: string, options?: LoadURLOptions): Promise; /** * Opens a DevTools window for guest page. */ openDevTools(): void; /** * Executes editing command paste in page. */ paste(): void; /** * Executes editing command pasteAndMatchStyle in page. */ pasteAndMatchStyle(): void; /** * Prints webview's web page. Same as webContents.print([options]). */ print(options?: PrintOptions): void; /** * Prints webview's web page as PDF, Same as webContents.printToPDF(options, * callback). Deprecated Soon */ printToPDF(options: PrintToPDFOptions, callback: (error: Error, data: Buffer) => void): void; /** * Prints webview's web page as PDF, Same as webContents.printToPDF(options). */ printToPDF(options: PrintToPDFOptions): Promise; /** * Executes editing command redo in page. */ redo(): void; /** * Reloads the guest page. */ reload(): void; /** * Reloads the guest page and ignores cache. */ reloadIgnoringCache(): void; /** * Executes editing command replace in page. */ replace(text: string): void; /** * Executes editing command replaceMisspelling in page. */ replaceMisspelling(text: string): void; /** * Executes editing command selectAll in page. */ selectAll(): void; /** * Send an asynchronous message to renderer process via channel, you can also send * arbitrary arguments. The renderer process can handle the message by listening to * the channel event with the ipcRenderer module. See webContents.send for * examples. */ send(channel: string, ...args: any[]): void; /** * Sends an input event to the page. See webContents.sendInputEvent for detailed * description of event object. */ sendInputEvent(event: any): void; /** * Set guest page muted. */ setAudioMuted(muted: boolean): void; /** * Sets the maximum and minimum layout-based (i.e. non-visual) zoom level. */ setLayoutZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Overrides the user agent for the guest page. */ setUserAgent(userAgent: string): void; /** * Sets the maximum and minimum pinch-to-zoom level. */ setVisualZoomLevelLimits(minimumLevel: number, maximumLevel: number): void; /** * Changes the zoom factor to the specified factor. Zoom factor is zoom percent * divided by 100, so 300% = 3.0. */ setZoomFactor(factor: number): void; /** * Changes the zoom level to the specified level. The original size is 0 and each * increment above or below represents zooming 20% larger or smaller to default * limits of 300% and 50% of original size, respectively. The formula for this is * scale := 1.2 ^ level. */ setZoomLevel(level: number): void; /** * Shows pop-up dictionary that searches the selected word on the page. */ showDefinitionForSelection(): void; /** * Stops any pending navigation. */ stop(): void; /** * Stops any findInPage request for the webview with the provided action. */ stopFindInPage(action: 'clearSelection' | 'keepSelection' | 'activateSelection'): void; /** * Executes editing command undo in page. */ undo(): void; /** * Executes editing command unselect in page. */ unselect(): void; /** * When this attribute is present the guest page will be allowed to open new * windows. Popups are disabled by default. */ allowpopups?: string; /** * A list of strings which specifies the blink features to be disabled separated by * ,. The full list of supported feature strings can be found in the * RuntimeEnabledFeatures.json5 file. */ disableblinkfeatures?: string; /** * When this attribute is present the guest page will have web security disabled. * Web security is enabled by default. */ disablewebsecurity?: string; /** * A list of strings which specifies the blink features to be enabled separated by * ,. The full list of supported feature strings can be found in the * RuntimeEnabledFeatures.json5 file. */ enableblinkfeatures?: string; /** * When this attribute is false the guest page in webview will not have access to * the remote module. The remote module is available by default. */ enableremotemodule?: string; /** * Sets the referrer URL for the guest page. */ httpreferrer?: string; /** * When this attribute is present the guest page in webview will have node * integration and can use node APIs like require and process to access low level * system resources. Node integration is disabled by default in the guest page. */ nodeintegration?: string; /** * Experimental option for enabling NodeJS 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. */ nodeintegrationinsubframes?: string; /** * Sets the session used by the page. If partition starts with persist:, the page * will use a persistent session available to all pages in the app with the same * partition. if there is no persist: prefix, the page will use an in-memory * session. By assigning the same partition, multiple pages can share the same * session. If the partition is unset then default session of the app will be used. * This value can only be modified before the first navigation, since the session * of an active renderer process cannot change. Subsequent attempts to modify the * value will fail with a DOM exception. */ partition?: string; /** * When this attribute is present the guest page in webview will be able to use * browser plugins. Plugins are disabled by default. */ plugins?: string; /** * Specifies a script that will be loaded before other scripts run in the guest * page. The protocol of script's URL must be either file: or asar:, because it * will be loaded by require in guest page under the hood. When the guest page * doesn't have node integration this script will still have access to all Node * APIs, but global objects injected by Node will be deleted after this script has * finished executing. Note: This option will be appear as preloadURL (not preload) * in the webPreferences specified to the will-attach-webview event. */ preload?: string; /** * Returns the visible URL. Writing to this attribute initiates top-level * navigation. Assigning src its own value will reload the current page. The src * attribute can also accept data URLs, such as data:text/plain,Hello, world!. */ src?: string; /** * Sets the user agent for the guest page before the page is navigated to. Once the * page is loaded, use the setUserAgent method to change the user agent. */ useragent?: string; /** * A list of strings which specifies the web preferences to be set on the webview, * separated by ,. The full list of supported preference strings can be found in * BrowserWindow. The string follows the same format as the features string in * window.open. A name by itself is given a true boolean value. A preference can be * set to another value by including an =, followed by the value. Special values * yes and 1 are interpreted as true, while no and 0 are interpreted as false. */ webpreferences?: string; } interface AboutPanelOptionsOptions { /** * The app's name. */ applicationName?: string; /** * The app's version. */ applicationVersion?: string; /** * Copyright information. */ copyright?: string; /** * The app's build version number. */ version?: string; /** * Credit information. */ credits?: string; /** * The app's website. */ website?: string; /** * Path to the app's icon. Will be shown as 64x64 pixels while retaining aspect * ratio. */ iconPath?: string; } interface AddRepresentationOptions { /** * The scale factor to add the image representation for. */ scaleFactor: number; /** * Defaults to 0. Required if a bitmap buffer is specified as buffer. */ width?: number; /** * Defaults to 0. Required if a bitmap buffer is specified as buffer. */ height?: number; /** * The buffer containing the raw image data. */ buffer?: Buffer; /** * The data URL containing either a base 64 encoded PNG or JPEG image. */ dataURL?: string; } interface AnimationSettings { /** * Returns true if rich animations should be rendered. Looks at session type (e.g. * remote desktop) and accessibility settings to give guidance for heavy * animations. */ shouldRenderRichAnimation: boolean; /** * Determines on a per-platform basis whether scroll animations (e.g. produced by * home/end key) should be enabled. */ scrollAnimationsEnabledBySystem: boolean; /** * Determines whether the user desires reduced motion based on platform APIs. */ prefersReducedMotion: boolean; } interface AppDetailsOptions { /** * Window's . It has to be set, otherwise the other options will have no effect. */ appId?: string; /** * Window's . */ appIconPath?: string; /** * Index of the icon in appIconPath. Ignored when appIconPath is not set. Default * is 0. */ appIconIndex?: number; /** * Window's . */ relaunchCommand?: string; /** * Window's . */ relaunchDisplayName?: string; } interface AuthInfo { isProxy: boolean; scheme: string; host: string; port: number; realm: string; } interface AutoResizeOptions { /** * If true, the view's width will grow and shrink together with the window. false * by default. */ width: boolean; /** * If true, the view's height will grow and shrink together with the window. false * by default. */ height: boolean; /** * If true, the view's x position and width will grow and shrink proportionly with * the window. false by default. */ horizontal: boolean; /** * If true, the view's y position and height will grow and shrink proportinaly with * the window. false by default. */ vertical: boolean; } interface BitmapOptions { /** * Defaults to 1.0. */ scaleFactor?: number; } interface BrowserViewConstructorOptions { /** * See . */ webPreferences?: WebPreferences; } interface BrowserWindowConstructorOptions { /** * Window's width in pixels. Default is 800. */ width?: number; /** * Window's height in pixels. Default is 600. */ height?: number; /** * ( if y is used) Window's left offset from screen. Default is to center the * window. */ x?: number; /** * ( if x is used) Window's top offset from screen. Default is to center the * window. */ y?: number; /** * The width and height would be used as web page's size, which means the actual * window's size will include window frame's size and be slightly larger. Default * is false. */ useContentSize?: boolean; /** * Show window in the center of the screen. */ center?: boolean; /** * Window's minimum width. Default is 0. */ minWidth?: number; /** * Window's minimum height. Default is 0. */ minHeight?: number; /** * Window's maximum width. Default is no limit. */ maxWidth?: number; /** * Window's maximum height. Default is no limit. */ maxHeight?: number; /** * Whether window is resizable. Default is true. */ resizable?: boolean; /** * Whether window is movable. This is not implemented on Linux. Default is true. */ movable?: boolean; /** * Whether window is minimizable. This is not implemented on Linux. Default is * true. */ minimizable?: boolean; /** * Whether window is maximizable. This is not implemented on Linux. Default is * true. */ maximizable?: boolean; /** * Whether window is closable. This is not implemented on Linux. Default is true. */ closable?: boolean; /** * Whether the window can be focused. Default is true. On Windows setting * focusable: false also implies setting skipTaskbar: true. On Linux setting * focusable: false makes the window stop interacting with wm, so the window will * always stay on top in all workspaces. */ focusable?: boolean; /** * Whether the window should always stay on top of other windows. Default is false. */ alwaysOnTop?: boolean; /** * Whether the window should show in fullscreen. When explicitly set to false the * fullscreen button will be hidden or disabled on macOS. Default is false. */ fullscreen?: boolean; /** * Whether the window can be put into fullscreen mode. On macOS, also whether the * maximize/zoom button should toggle full screen mode or maximize window. Default * is true. */ fullscreenable?: boolean; /** * Use pre-Lion fullscreen on macOS. Default is false. */ simpleFullscreen?: boolean; /** * Whether to show the window in taskbar. Default is false. */ skipTaskbar?: boolean; /** * The kiosk mode. Default is false. */ kiosk?: boolean; /** * Default window title. Default is "Electron". If the HTML tag is defined * in the HTML file loaded by loadURL(), this property will be * ignored. */ title?: string; /** * The window icon. On Windows it is recommended to use ICO icons to get best * visual effects, you can also leave it undefined so the executable's icon will be * used. */ icon?: (NativeImage) | (string); /** * Whether window should be shown when created. Default is true. */ show?: boolean; /** * Specify false to create a . Default is true. */ frame?: boolean; /** * Specify parent window. Default is null. */ parent?: BrowserWindow; /** * Whether this is a modal window. This only works when the window is a child * window. Default is false. */ modal?: boolean; /** * Whether the web view accepts a single mouse-down event that simultaneously * activates the window. Default is false. */ acceptFirstMouse?: boolean; /** * Whether to hide cursor when typing. Default is false. */ disableAutoHideCursor?: boolean; /** * Auto hide the menu bar unless the Alt key is pressed. Default is false. */ autoHideMenuBar?: boolean; /** * Enable the window to be resized larger than screen. Default is false. */ enableLargerThanScreen?: boolean; /** * Window's background color as a hexadecimal value, like #66CD00 or #FFF or * #80FFFFFF (alpha in #AARRGGBB format is supported if transparent is set to * true). Default is #FFF (white). */ backgroundColor?: string; /** * Whether window should have a shadow. This is only implemented on macOS. Default * is true. */ hasShadow?: boolean; /** * Set the initial opacity of the window, between 0.0 (fully transparent) and 1.0 * (fully opaque). This is only implemented on Windows and macOS. */ opacity?: number; /** * Forces using dark theme for the window, only works on some GTK+3 desktop * environments. Default is false. */ darkTheme?: boolean; /** * Makes the window . Default is false. */ transparent?: boolean; /** * The type of window, default is normal window. See more about this below. */ type?: string; /** * The style of window title bar. Default is default. Possible values are: */ titleBarStyle?: ('default' | 'hidden' | 'hiddenInset' | 'customButtonsOnHover'); /** * Shows the title in the title bar in full screen mode on macOS for all * titleBarStyle options. Default is false. */ fullscreenWindowTitle?: boolean; /** * Use WS_THICKFRAME style for frameless windows on Windows, which adds standard * window frame. Setting it to false will remove window shadow and window * animations. Default is true. */ thickFrame?: boolean; /** * Add a type of vibrancy effect to the window, only on macOS. Can be * appearance-based, light, dark, titlebar, selection, menu, popover, sidebar, * medium-light or ultra-dark. Please note that using frame: false in combination * with a vibrancy value requires that you use a non-default titleBarStyle as well. */ vibrancy?: ('appearance-based' | 'light' | 'dark' | 'titlebar' | 'selection' | 'menu' | 'popover' | 'sidebar' | 'medium-light' | 'ultra-dark'); /** * Controls the behavior on macOS when option-clicking the green stoplight button * on the toolbar or by clicking the Window > Zoom menu item. If true, the window * will grow to the preferred width of the web page when zoomed, false will cause * it to zoom to the width of the screen. This will also affect the behavior when * calling maximize() directly. Default is false. */ zoomToPageWidth?: boolean; /** * Tab group name, allows opening the window as a native tab on macOS 10.12+. * Windows with the same tabbing identifier will be grouped together. This also * adds a native new tab button to your window's tab bar and allows your app and * window to receive the new-window-for-tab event. */ tabbingIdentifier?: string; /** * Settings of web page's features. */ webPreferences?: WebPreferences; } interface CertificateTrustDialogOptions { /** * The certificate to trust/import. */ certificate: Certificate; /** * The message to display to the user. */ message: string; } interface CertificateVerifyProcRequest { hostname: string; certificate: Certificate; /** * Verification result from chromium. */ verificationResult: string; /** * Error code. */ errorCode: number; } interface ClearStorageDataOptions { /** * Should follow window.location.origin’s representation scheme://host:port. */ origin?: string; /** * The types of storages to clear, can contain: appcache, cookies, filesystem, * indexdb, localstorage, shadercache, websql, serviceworkers, cachestorage. */ storages?: string[]; /** * The types of quotas to clear, can contain: temporary, persistent, syncable. */ quotas?: string[]; } interface CommandLine { /** * Append a switch (with optional value) to Chromium's command line. Note: This * will not affect process.argv. The intended usage of this function is to control * Chromium's behavior. */ appendSwitch: (the_switch: string, value?: string) => void; /** * Append an argument to Chromium's command line. The argument will be quoted * correctly. Switches will precede arguments regardless of appending order. If * you're appending an argument like --switch=value, consider using * appendSwitch('switch', 'value') instead. Note: This will not affect * process.argv. The intended usage of this function is to control Chromium's * behavior. */ appendArgument: (value: string) => void; hasSwitch: (the_switch: string) => boolean; /** * Note: When the switch is not present or has no value, it returns empty string. */ getSwitchValue: (the_switch: string) => string; } interface Config { /** * The URL associated with the PAC file. */ pacScript: string; /** * Rules indicating which proxies to use. */ proxyRules: string; /** * Rules indicating which URLs should bypass the proxy settings. */ proxyBypassRules: string; } interface ConsoleMessageEvent extends Event { level: number; message: string; line: number; sourceId: string; } interface ContextMenuParams { /** * x coordinate. */ x: number; /** * y coordinate. */ y: number; /** * URL of the link that encloses the node the context menu was invoked on. */ linkURL: string; /** * Text associated with the link. May be an empty string if the contents of the * link are an image. */ linkText: string; /** * URL of the top level page that the context menu was invoked on. */ pageURL: string; /** * URL of the subframe that the context menu was invoked on. */ frameURL: string; /** * Source URL for the element that the context menu was invoked on. Elements with * source URLs are images, audio and video. */ srcURL: string; /** * Type of the node the context menu was invoked on. Can be none, image, audio, * video, canvas, file or plugin. */ mediaType: ('none' | 'image' | 'audio' | 'video' | 'canvas' | 'file' | 'plugin'); /** * Whether the context menu was invoked on an image which has non-empty contents. */ hasImageContents: boolean; /** * Whether the context is editable. */ isEditable: boolean; /** * Text of the selection that the context menu was invoked on. */ selectionText: string; /** * Title or alt text of the selection that the context was invoked on. */ titleText: string; /** * The misspelled word under the cursor, if any. */ misspelledWord: string; /** * The character encoding of the frame on which the menu was invoked. */ frameCharset: string; /** * If the context menu was invoked on an input field, the type of that field. * Possible values are none, plainText, password, other. */ inputFieldType: string; /** * Input source that invoked the context menu. Can be none, mouse, keyboard, touch * or touchMenu. */ menuSourceType: ('none' | 'mouse' | 'keyboard' | 'touch' | 'touchMenu'); /** * The flags for the media element the context menu was invoked on. */ mediaFlags: MediaFlags; /** * These flags indicate whether the renderer believes it is able to perform the * corresponding action. */ editFlags: EditFlags; } interface CrashReporterStartOptions { companyName: string; /** * URL that crash reports will be sent to as POST. */ submitURL: string; /** * Defaults to app.getName(). */ productName?: string; /** * Whether crash reports should be sent to the server Default is true. */ uploadToServer?: boolean; /** * Default is false. */ ignoreSystemCrashHandler?: boolean; /** * An object you can define that will be sent along with the report. Only string * properties are sent correctly. Nested objects are not supported and the property * names and values must be less than 64 characters long. */ extra?: Extra; /** * Directory to store the crashreports temporarily (only used when the crash * reporter is started via process.crashReporter.start). */ crashesDirectory?: string; } interface CreateFromBitmapOptions { width: number; height: number; /** * Defaults to 1.0. */ scaleFactor?: number; } interface CreateFromBufferOptions { /** * Required for bitmap buffers. */ width?: number; /** * Required for bitmap buffers. */ height?: number; /** * Defaults to 1.0. */ scaleFactor?: number; } interface CreateInterruptedDownloadOptions { /** * Absolute path of the download. */ path: string; /** * Complete URL chain for the download. */ urlChain: string[]; mimeType?: string; /** * Start range for the download. */ offset: number; /** * Total length of the download. */ length: number; /** * Last-Modified header value. */ lastModified: string; /** * ETag header value. */ eTag: string; /** * Time when download was started in number of seconds since UNIX epoch. */ startTime?: number; } interface Data { text?: string; html?: string; image?: NativeImage; rtf?: string; /** * The title of the URL at text. */ bookmark?: string; } interface Details { /** * The url to associate the cookie with. */ url: string; /** * The name of the cookie. Empty by default if omitted. */ name?: string; /** * The value of the cookie. Empty by default if omitted. */ value?: string; /** * The domain of the cookie. Empty by default if omitted. */ domain?: string; /** * The path of the cookie. Empty by default if omitted. */ path?: string; /** * Whether the cookie should be marked as Secure. Defaults to false. */ secure?: boolean; /** * Whether the cookie should be marked as HTTP only. Defaults to false. */ httpOnly?: boolean; /** * The expiration date of the cookie as the number of seconds since the UNIX epoch. * If omitted then the cookie becomes a session cookie and will not be retained * between sessions. */ expirationDate?: number; } interface DevToolsExtensions { } interface DidChangeThemeColorEvent extends Event { themeColor: string; } interface DidFailLoadEvent extends Event { errorCode: number; errorDescription: string; validatedURL: string; isMainFrame: boolean; } interface DidFrameFinishLoadEvent extends Event { isMainFrame: boolean; } interface DidNavigateEvent extends Event { url: string; } interface DidNavigateInPageEvent extends Event { isMainFrame: boolean; url: string; } interface DisplayBalloonOptions { /** * - */ icon?: (NativeImage) | (string); title: string; content: string; } interface Dock { /** * When critical is passed, the dock icon will bounce until either the application * becomes active or the request is canceled. When informational is passed, the * dock icon will bounce for one second. However, the request remains active until * either the application becomes active or the request is canceled. Nota Bene: * This method can only be used while the app is not focused; when the app is * focused it will return -1. */ bounce: (type?: 'critical' | 'informational') => number; /** * Cancel the bounce of id. */ cancelBounce: (id: number) => void; /** * Bounces the Downloads stack if the filePath is inside the Downloads folder. */ downloadFinished: (filePath: string) => void; /** * Sets the string to be displayed in the dock’s badging area. */ setBadge: (text: string) => void; getBadge: () => string; /** * Hides the dock icon. */ hide: () => void; show: () => Promise; isVisible: () => boolean; /** * Sets the application's dock menu. */ setMenu: (menu: Menu) => void; getMenu: () => (Menu) | (null); /** * Sets the image associated with this dock icon. */ setIcon: (image: (NativeImage) | (string)) => void; } interface EnableNetworkEmulationOptions { /** * Whether to emulate network outage. Defaults to false. */ offline?: boolean; /** * RTT in ms. Defaults to 0 which will disable latency throttling. */ latency?: number; /** * Download rate in Bps. Defaults to 0 which will disable download throttling. */ downloadThroughput?: number; /** * Upload rate in Bps. Defaults to 0 which will disable upload throttling. */ uploadThroughput?: number; } interface Extensions { } interface FeedURLOptions { url: string; /** * HTTP request headers. */ headers?: Headers; /** * Either json or default, see the README for more information. */ serverType?: string; } interface FileIconOptions { size: ('small' | 'normal' | 'large'); } interface Filter { /** * Retrieves cookies which are associated with url. Empty implies retrieving * cookies of all urls. */ url?: string; /** * Filters cookies by name. */ name?: string; /** * Retrieves cookies whose domains match or are subdomains of domains. */ domain?: string; /** * Retrieves cookies whose path matches path. */ path?: string; /** * Filters cookies by their Secure property. */ secure?: boolean; /** * Filters out session or persistent cookies. */ session?: boolean; } interface FindInPageOptions { /** * Whether to search forward or backward, defaults to true. */ forward?: boolean; /** * Whether the operation is first request or a follow up, defaults to false. */ findNext?: boolean; /** * Whether search should be case-sensitive, defaults to false. */ matchCase?: boolean; /** * Whether to look only at the start of words. defaults to false. */ wordStart?: boolean; /** * When combined with wordStart, accepts a match in the middle of a word if the * match begins with an uppercase letter followed by a lowercase or non-letter. * Accepts several other intra-word matches, defaults to false. */ medialCapitalAsWordStart?: boolean; } interface FoundInPageEvent extends Event { result: FoundInPageResult; } interface FromPartitionOptions { /** * Whether to enable cache. */ cache: boolean; } interface Header { /** * Specify an extra header name. */ name: string; } interface Headers { } interface HeapStatistics { totalHeapSize: number; totalHeapSizeExecutable: number; totalPhysicalSize: number; totalAvailableSize: number; usedHeapSize: number; heapSizeLimit: number; mallocedMemory: number; peakMallocedMemory: number; doesZapGarbage: boolean; } interface IgnoreMouseEventsOptions { /** * If true, forwards mouse move messages to Chromium, enabling mouse related events * such as mouseleave. Only used when ignore is true. If ignore is false, * forwarding is always disabled regardless of this value. */ forward?: boolean; } interface ImportCertificateOptions { /** * Path for the pkcs12 file. */ certificate: string; /** * Passphrase for the certificate. */ password: string; } interface Info { /** * Security origin for the isolated world. */ securityOrigin?: string; /** * Content Security Policy for the isolated world. */ csp?: string; /** * Name for isolated world. Useful in devtools. */ name?: string; } interface Input { /** * Either keyUp or keyDown. */ type: string; /** * Equivalent to . */ key: string; /** * Equivalent to . */ code: string; /** * Equivalent to . */ isAutoRepeat: boolean; /** * Equivalent to . */ shift: boolean; /** * Equivalent to . */ control: boolean; /** * Equivalent to . */ alt: boolean; /** * Equivalent to . */ meta: boolean; } interface InterceptBufferProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface InterceptFileProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface InterceptHttpProtocolRequest { url: string; headers: Headers; referrer: string; method: string; uploadData: UploadData[]; } interface InterceptStreamProtocolRequest { url: string; headers: Headers; referrer: string; method: string; uploadData: UploadData[]; } interface InterceptStringProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface IpcMessageEvent extends Event { channel: string; args: any[]; } interface Item { /** * or files Array The path(s) to the file(s) being dragged. */ file: string; /** * The image must be non-empty on macOS. */ icon: NativeImage; } interface JumpListSettings { /** * The minimum number of items that will be shown in the Jump List (for a more * detailed description of this value see the ). */ minItems: number; /** * Array of JumpListItem objects that correspond to items that the user has * explicitly removed from custom categories in the Jump List. These items must not * be re-added to the Jump List in the call to app.setJumpList(), Windows will not * display any custom category that contains any of the removed items. */ removedItems: JumpListItem[]; } interface LoadCommitEvent extends Event { url: string; isMainFrame: boolean; } interface LoadFileOptions { /** * Passed to url.format(). */ query?: Query; /** * Passed to url.format(). */ search?: string; /** * Passed to url.format(). */ hash?: string; } interface LoadURLOptions { /** * An HTTP Referrer url. */ httpReferrer?: (string) | (Referrer); /** * A user agent originating the request. */ userAgent?: string; /** * Extra headers separated by "\n" */ extraHeaders?: string; postData?: (UploadRawData[]) | (UploadFile[]) | (UploadBlob[]); /** * Base url (with trailing path separator) for files to be loaded by the data url. * This is needed only if the specified url is a data url and needs to load other * files. */ baseURLForDataURL?: string; } interface LoginItemSettings { options?: Options; /** * true if the app is set to open at login. */ openAtLogin: boolean; /** * true if the app is set to open as hidden at login. This setting is not available * on . */ openAsHidden: boolean; /** * true if the app was opened at login automatically. This setting is not available * on . */ wasOpenedAtLogin: boolean; /** * true if the app was opened as a hidden login item. This indicates that the app * should not open any windows at startup. This setting is not available on . */ wasOpenedAsHidden: boolean; /** * true if the app was opened as a login item that should restore the state from * the previous session. This indicates that the app should restore the windows * that were open the last time the app was closed. This setting is not available * on . */ restoreState: boolean; } interface LoginItemSettingsOptions { /** * The executable path to compare against. Defaults to process.execPath. */ path?: string; /** * The command-line arguments to compare against. Defaults to an empty array. */ args?: string[]; } interface MemoryDumpConfig { } interface MenuItemConstructorOptions { /** * Will be called with click(menuItem, browserWindow, event) when the menu item is * clicked. */ click?: (menuItem: MenuItem, browserWindow: BrowserWindow, event: KeyboardEvent) => void; /** * Can be undo, redo, cut, copy, paste, pasteAndMatchStyle, delete, selectAll, * reload, forceReload, toggleDevTools, resetZoom, zoomIn, zoomOut, * togglefullscreen, window, minimize, close, help, about, services, hide, * hideOthers, unhide, quit, startSpeaking, stopSpeaking, close, minimize, zoom, * front, appMenu, fileMenu, editMenu, viewMenu, recentDocuments, toggleTabBar, * selectNextTab, selectPreviousTab, mergeAllWindows, clearRecentDocuments, * moveTabToNewWindow or windowMenu Define the action of the menu item, when * specified the click property will be ignored. See . */ role?: ('undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'pasteAndMatchStyle' | 'delete' | 'selectAll' | 'reload' | 'forceReload' | 'toggleDevTools' | 'resetZoom' | 'zoomIn' | 'zoomOut' | 'togglefullscreen' | 'window' | 'minimize' | 'close' | 'help' | 'about' | 'services' | 'hide' | 'hideOthers' | 'unhide' | 'quit' | 'startSpeaking' | 'stopSpeaking' | 'close' | 'minimize' | 'zoom' | 'front' | 'appMenu' | 'fileMenu' | 'editMenu' | 'viewMenu' | 'recentDocuments' | 'toggleTabBar' | 'selectNextTab' | 'selectPreviousTab' | 'mergeAllWindows' | 'clearRecentDocuments' | 'moveTabToNewWindow' | 'windowMenu'); /** * Can be normal, separator, submenu, checkbox or radio. */ type?: ('normal' | 'separator' | 'submenu' | 'checkbox' | 'radio'); label?: string; sublabel?: string; accelerator?: Accelerator; icon?: (NativeImage) | (string); /** * If false, the menu item will be greyed out and unclickable. */ enabled?: boolean; /** * default is true, and when false will prevent the accelerator from triggering the * item if the item is not visible`. */ acceleratorWorksWhenHidden?: boolean; /** * If false, the menu item will be entirely hidden. */ visible?: boolean; /** * Should only be specified for checkbox or radio type menu items. */ checked?: boolean; /** * If false, the accelerator won't be registered with the system, but it will still * be displayed. Defaults to true. */ registerAccelerator?: boolean; /** * Should be specified for submenu type menu items. If submenu is specified, the * type: 'submenu' can be omitted. If the value is not a then it will be * automatically converted to one using Menu.buildFromTemplate. */ submenu?: (MenuItemConstructorOptions[]) | (Menu); /** * Unique within a single menu. If defined then it can be used as a reference to * this item by the position attribute. */ id?: string; /** * Inserts this item before the item with the specified label. If the referenced * item doesn't exist the item will be inserted at the end of the menu. Also * implies that the menu item in question should be placed in the same “group” as * the item. */ before?: string[]; /** * Inserts this item after the item with the specified label. If the referenced * item doesn't exist the item will be inserted at the end of the menu. */ after?: string[]; /** * Provides a means for a single context menu to declare the placement of their * containing group before the containing group of the item with the specified * label. */ beforeGroupContaining?: string[]; /** * Provides a means for a single context menu to declare the placement of their * containing group after the containing group of the item with the specified * label. */ afterGroupContaining?: string[]; } interface MessageBoxOptions { /** * Can be "none", "info", "error", "question" or "warning". On Windows, "question" * displays the same icon as "info", unless you set an icon using the "icon" * option. On macOS, both "warning" and "error" display the same warning icon. */ type?: string; /** * Array of texts for buttons. On Windows, an empty array will result in one button * labeled "OK". */ buttons?: string[]; /** * Index of the button in the buttons array which will be selected by default when * the message box opens. */ defaultId?: number; /** * Title of the message box, some platforms will not show it. */ title?: string; /** * Content of the message box. */ message: string; /** * Extra information of the message. */ detail?: string; /** * If provided, the message box will include a checkbox with the given label. The * checkbox state can be inspected only when using callback. */ checkboxLabel?: string; /** * Initial checked state of the checkbox. false by default. */ checkboxChecked?: boolean; icon?: NativeImage; /** * The index of the button to be used to cancel the dialog, via the Esc key. By * default this is assigned to the first button with "cancel" or "no" as the label. * If no such labeled buttons exist and this option is not set, 0 will be used as * the return value or callback response. */ cancelId?: number; /** * On Windows Electron will try to figure out which one of the buttons are common * buttons (like "Cancel" or "Yes"), and show the others as command links in the * dialog. This can make the dialog appear in the style of modern Windows apps. If * you don't like this behavior, you can set noLink to true. */ noLink?: boolean; /** * Normalize the keyboard access keys across platforms. Default is false. Enabling * this assumes & is used in the button labels for the placement of the keyboard * shortcut access key and labels will be converted so they work correctly on each * platform, & characters are removed on macOS, converted to _ on Linux, and left * untouched on Windows. For example, a button label of Vie&w will be converted to * Vie_w on Linux and View on macOS and can be selected via Alt-W on Windows and * Linux. */ normalizeAccessKeys?: boolean; } interface MessageBoxReturnValue { /** * The index of the clicked button. */ response: number; /** * The checked state of the checkbox if checkboxLabel was set. Otherwise false. */ checkboxChecked: boolean; } interface MessageBoxSyncOptions { /** * Can be "none", "info", "error", "question" or "warning". On Windows, "question" * displays the same icon as "info", unless you set an icon using the "icon" * option. On macOS, both "warning" and "error" display the same warning icon. */ type?: string; /** * Array of texts for buttons. On Windows, an empty array will result in one button * labeled "OK". */ buttons?: string[]; /** * Index of the button in the buttons array which will be selected by default when * the message box opens. */ defaultId?: number; /** * Title of the message box, some platforms will not show it. */ title?: string; /** * Content of the message box. */ message: string; /** * Extra information of the message. */ detail?: string; /** * If provided, the message box will include a checkbox with the given label. The * checkbox state can be inspected only when using callback. */ checkboxLabel?: string; /** * Initial checked state of the checkbox. false by default. */ checkboxChecked?: boolean; icon?: (NativeImage) | (string); /** * The index of the button to be used to cancel the dialog, via the Esc key. By * default this is assigned to the first button with "cancel" or "no" as the label. * If no such labeled buttons exist and this option is not set, 0 will be used as * the return value or callback response. */ cancelId?: number; /** * On Windows Electron will try to figure out which one of the buttons are common * buttons (like "Cancel" or "Yes"), and show the others as command links in the * dialog. This can make the dialog appear in the style of modern Windows apps. If * you don't like this behavior, you can set noLink to true. */ noLink?: boolean; /** * Normalize the keyboard access keys across platforms. Default is false. Enabling * this assumes & is used in the button labels for the placement of the keyboard * shortcut access key and labels will be converted so they work correctly on each * platform, & characters are removed on macOS, converted to _ on Linux, and left * untouched on Windows. For example, a button label of Vie&w will be converted to * Vie_w on Linux and View on macOS and can be selected via Alt-W on Windows and * Linux. */ normalizeAccessKeys?: boolean; } interface NewWindowEvent extends Event { url: string; frameName: string; /** * Can be `default`, `foreground-tab`, `background-tab`, `new-window`, * `save-to-disk` and `other`. */ disposition: ('default' | 'foreground-tab' | 'background-tab' | 'new-window' | 'save-to-disk' | 'other'); /** * The options which should be used for creating the new . */ options: Options; } interface NotificationConstructorOptions { /** * A title for the notification, which will be shown at the top of the notification * window when it is shown. */ title: string; /** * A subtitle for the notification, which will be displayed below the title. */ subtitle?: string; /** * The body text of the notification, which will be displayed below the title or * subtitle. */ body: string; /** * Whether or not to emit an OS notification noise when showing the notification. */ silent?: boolean; /** * An icon to use in the notification. */ icon?: (string) | (NativeImage); /** * Whether or not to add an inline reply option to the notification. */ hasReply?: boolean; /** * The placeholder to write in the inline reply input field. */ replyPlaceholder?: string; /** * The name of the sound file to play when the notification is shown. */ sound?: string; /** * Actions to add to the notification. Please read the available actions and * limitations in the NotificationAction documentation. */ actions?: NotificationAction[]; /** * A custom title for the close button of an alert. An empty string will cause the * default localized text to be used. */ closeButtonText?: string; } interface OnBeforeRedirectDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; redirectURL: string; statusCode: number; /** * The server IP address that the request was actually sent to. */ ip?: string; fromCache: boolean; responseHeaders: ResponseHeaders; } interface OnBeforeRedirectFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnBeforeRequestDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; uploadData: UploadData[]; } interface OnBeforeRequestFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnBeforeSendHeadersDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; requestHeaders: RequestHeaders; } interface OnBeforeSendHeadersFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnBeforeSendHeadersResponse { cancel?: boolean; /** * When provided, request will be made with these headers. */ requestHeaders?: RequestHeaders; } interface OnCompletedDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; responseHeaders: ResponseHeaders; fromCache: boolean; statusCode: number; statusLine: string; } interface OnCompletedFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnErrorOccurredDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; fromCache: boolean; /** * The error description. */ error: string; } interface OnErrorOccurredFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnHeadersReceivedDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; statusLine: string; statusCode: number; responseHeaders: ResponseHeaders; } interface OnHeadersReceivedFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnHeadersReceivedResponse { cancel?: boolean; /** * When provided, the server is assumed to have responded with these headers. */ responseHeaders?: ResponseHeaders; /** * Should be provided when overriding responseHeaders to change header status * otherwise original response header's status will be used. */ statusLine?: string; } interface OnResponseStartedDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; responseHeaders: ResponseHeaders; /** * Indicates whether the response was fetched from disk cache. */ fromCache: boolean; statusCode: number; statusLine: string; } interface OnResponseStartedFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OnSendHeadersDetails { id: number; url: string; method: string; webContentsId?: number; resourceType: string; referrer: string; timestamp: number; requestHeaders: RequestHeaders; } interface OnSendHeadersFilter { /** * Array of URL patterns that will be used to filter out the requests that do not * match the URL patterns. */ urls: string[]; } interface OpenDevToolsOptions { /** * Opens the devtools with specified dock state, can be right, bottom, undocked, * detach. Defaults to last used dock state. In undocked mode it's possible to dock * back. In detach mode it's not. */ mode: ('right' | 'bottom' | 'undocked' | 'detach'); /** * Whether to bring the opened devtools window to the foreground. The default is * true. */ activate?: boolean; } interface OpenDialogOptions { title?: string; defaultPath?: string; /** * Custom label for the confirmation button, when left empty the default label will * be used. */ buttonLabel?: string; filters?: FileFilter[]; /** * Contains which features the dialog should use. The following values are * supported: */ properties?: Array<'openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles' | 'createDirectory' | 'promptToCreate' | 'noResolveAliases' | 'treatPackageAsDirectory'>; /** * Message to display above input boxes. */ message?: string; /** * Create when packaged for the Mac App Store. */ securityScopedBookmarks?: boolean; } interface OpenDialogReturnValue { /** * whether or not the dialog was canceled. */ canceled: boolean; /** * An array of file paths chosen by the user. If the dialog is cancelled this will * be an empty array. */ filePaths?: string[]; /** * An array matching the filePaths array of base64 encoded strings which contains * security scoped bookmark data. securityScopedBookmarks must be enabled for this * to be populated. */ bookmarks?: string[]; } interface OpenDialogSyncOptions { title?: string; defaultPath?: string; /** * Custom label for the confirmation button, when left empty the default label will * be used. */ buttonLabel?: string; filters?: FileFilter[]; /** * Contains which features the dialog should use. The following values are * supported: */ properties?: Array<'openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles' | 'createDirectory' | 'promptToCreate' | 'noResolveAliases' | 'treatPackageAsDirectory'>; /** * Message to display above input boxes. */ message?: string; /** * Create when packaged for the Mac App Store. */ securityScopedBookmarks?: boolean; } interface OpenExternalOptions { /** * true to bring the opened application to the foreground. The default is true. */ activate?: boolean; /** * The working directory. */ workingDirectory?: string; } interface OpenExternalSyncOptions { /** * true to bring the opened application to the foreground. The default is true. */ activate?: boolean; /** * The working directory. */ workingDirectory?: string; } interface PageFaviconUpdatedEvent extends Event { /** * Array of URLs. */ favicons: string[]; } interface PageTitleUpdatedEvent extends Event { title: string; explicitSet: boolean; } interface Parameters { /** * Specify the screen type to emulate (default: desktop): */ screenPosition: ('desktop' | 'mobile'); /** * Set the emulated screen size (screenPosition == mobile). */ screenSize: Size; /** * Position the view on the screen (screenPosition == mobile) (default: { x: 0, y: * 0 }). */ viewPosition: Point; /** * Set the device scale factor (if zero defaults to original device scale factor) * (default: 0). */ deviceScaleFactor: number; /** * Set the emulated view size (empty means no override) */ viewSize: Size; /** * Scale of emulated view inside available space (not in fit to view mode) * (default: 1). */ scale: number; } interface Payment { /** * The identifier of the purchased product. */ productIdentifier: string; /** * The quantity purchased. */ quantity: number; } interface PermissionCheckHandlerDetails { /** * The security orign of the media check. */ securityOrigin: string; /** * The type of media access being requested, can be video, audio or unknown */ mediaType: ('video' | 'audio' | 'unknown'); /** * The last URL the requesting frame loaded */ requestingUrl: string; /** * Whether the frame making the request is the main frame */ isMainFrame: boolean; } interface PermissionRequestHandlerDetails { /** * The url of the openExternal request. */ externalURL?: string; /** * The types of media access being requested, elements can be video or audio */ mediaTypes?: Array<'video' | 'audio'>; /** * The last URL the requesting frame loaded */ requestingUrl: string; /** * Whether the frame making the request is the main frame */ isMainFrame: boolean; } interface PluginCrashedEvent extends Event { name: string; version: string; } interface PopupOptions { /** * Default is the focused window. */ window?: BrowserWindow; /** * Default is the current mouse cursor position. Must be declared if y is declared. */ x?: number; /** * Default is the current mouse cursor position. Must be declared if x is declared. */ y?: number; /** * The index of the menu item to be positioned under the mouse cursor at the * specified coordinates. Default is -1. */ positioningItem?: number; /** * Called when menu is closed. */ callback?: () => void; } interface PrintOptions { /** * Don't ask user for print settings. Default is false. */ silent?: boolean; /** * Also prints the background color and image of the web page. Default is false. */ printBackground?: boolean; /** * Set the printer device name to use. Default is ''. */ deviceName?: string; } interface PrintToPDFOptions { /** * Specifies the type of margins to use. Uses 0 for default margin, 1 for no * margin, and 2 for minimum margin. */ marginsType?: number; /** * Specify page size of the generated PDF. Can be A3, A4, A5, Legal, Letter, * Tabloid or an Object containing height and width in microns. */ pageSize?: (string) | (Size); /** * Whether to print CSS backgrounds. */ printBackground?: boolean; /** * Whether to print selection only. */ printSelectionOnly?: boolean; /** * true for landscape, false for portrait. */ landscape?: boolean; } interface Privileges { /** * Default false. */ standard?: boolean; /** * Default false. */ secure?: boolean; /** * Default false. */ bypassCSP?: boolean; /** * Default false. */ allowServiceWorkers?: boolean; /** * Default false. */ supportFetchAPI?: boolean; /** * Default false. */ corsEnabled?: boolean; } interface ProgressBarOptions { /** * Mode for the progress bar. Can be none, normal, indeterminate, error or paused. */ mode: ('none' | 'normal' | 'indeterminate' | 'error' | 'paused'); } interface Provider { /** * . */ spellCheck: (words: string[], callback: (misspeltWords: string[]) => void) => void; } interface ReadBookmark { title: string; url: string; } interface RedirectRequest { url: string; method: string; session?: Session; uploadData?: UploadData; } interface RegisterBufferProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface RegisterFileProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface RegisterHttpProtocolRequest { url: string; headers: Headers; referrer: string; method: string; uploadData: UploadData[]; } interface RegisterStreamProtocolRequest { url: string; headers: Headers; referrer: string; method: string; uploadData: UploadData[]; } interface RegisterStringProtocolRequest { url: string; referrer: string; method: string; uploadData: UploadData[]; } interface RelaunchOptions { args?: string[]; execPath?: string; } interface Request { method: string; url: string; referrer: string; } interface ResizeOptions { /** * Defaults to the image's width. */ width?: number; /** * Defaults to the image's height. */ height?: number; /** * The desired quality of the resize image. Possible values are good, better or * best. The default is best. These values express a desired quality/speed * tradeoff. They are translated into an algorithm-specific method that depends on * the capabilities (CPU, GPU) of the underlying platform. It is possible for all * three methods to be mapped to the same algorithm on a given platform. */ quality?: string; } interface ResourceUsage { images: MemoryUsageDetails; scripts: MemoryUsageDetails; cssStyleSheets: MemoryUsageDetails; xslStyleSheets: MemoryUsageDetails; fonts: MemoryUsageDetails; other: MemoryUsageDetails; } interface Response { cancel?: boolean; /** * The original request is prevented from being sent or completed and is instead * redirected to the given URL. */ redirectURL?: string; } interface Result { requestId: number; /** * Position of the active match. */ activeMatchOrdinal: number; /** * Number of Matches. */ matches: number; /** * Coordinates of first match region. */ selectionArea: SelectionArea; finalUpdate: boolean; } interface SaveDialogOptions { title?: string; /** * Absolute directory path, absolute file path, or file name to use by default. */ defaultPath?: string; /** * Custom label for the confirmation button, when left empty the default label will * be used. */ buttonLabel?: string; filters?: FileFilter[]; /** * Message to display above text fields. */ message?: string; /** * Custom label for the text displayed in front of the filename text field. */ nameFieldLabel?: string; /** * Show the tags input box, defaults to true. */ showsTagField?: boolean; /** * Create a when packaged for the Mac App Store. If this option is enabled and the * file doesn't already exist a blank file will be created at the chosen path. */ securityScopedBookmarks?: boolean; } interface SaveDialogReturnValue { /** * whether or not the dialog was canceled. */ canceled: boolean; /** * If the dialog is canceled this will be undefined. */ filePath?: string; /** * Base64 encoded string which contains the security scoped bookmark data for the * saved file. securityScopedBookmarks must be enabled for this to be present. */ bookmark?: string; } interface SaveDialogSyncOptions { title?: string; /** * Absolute directory path, absolute file path, or file name to use by default. */ defaultPath?: string; /** * Custom label for the confirmation button, when left empty the default label will * be used. */ buttonLabel?: string; filters?: FileFilter[]; /** * Message to display above text fields. */ message?: string; /** * Custom label for the text displayed in front of the filename text field. */ nameFieldLabel?: string; /** * Show the tags input box, defaults to true. */ showsTagField?: boolean; /** * Create a when packaged for the Mac App Store. If this option is enabled and the * file doesn't already exist a blank file will be created at the chosen path. */ securityScopedBookmarks?: boolean; } interface Settings { /** * true to open the app at login, false to remove the app as a login item. Defaults * to false. */ openAtLogin?: boolean; /** * true to open the app as hidden. Defaults to false. The user can edit this * setting from the System Preferences so * app.getLoginItemSettings().wasOpenedAsHidden should be checked when the app is * opened to know the current value. This setting is not available on . */ openAsHidden?: boolean; /** * The executable to launch at login. Defaults to process.execPath. */ path?: string; /** * The command-line arguments to pass to the executable. Defaults to an empty * array. Take care to wrap paths in quotes. */ args?: string[]; } interface SourcesOptions { /** * An array of Strings that lists the types of desktop sources to be captured, * available types are screen and window. */ types: string[]; /** * The size that the media source thumbnail should be scaled to. Default is 150 x * 150. Set width or height to 0 when you do not need the thumbnails. This will * save the processing time required for capturing the content of each window and * screen. */ thumbnailSize?: Size; /** * Set to true to enable fetching window icons. The default value is false. When * false the appIcon property of the sources return null. Same if a source has the * type screen. */ fetchWindowIcons?: boolean; } interface SystemMemoryInfo { /** * The total amount of physical memory in Kilobytes available to the system. */ total: number; /** * The total amount of memory not being used by applications or disk cache. */ free: number; /** * The total amount of swap memory in Kilobytes available to the system. */ swapTotal: number; /** * The free amount of swap memory in Kilobytes available to the system. */ swapFree: number; } interface ToBitmapOptions { /** * Defaults to 1.0. */ scaleFactor?: number; } interface ToDataURLOptions { /** * Defaults to 1.0. */ scaleFactor?: number; } interface ToPNGOptions { /** * Defaults to 1.0. */ scaleFactor?: number; } interface TouchBarButtonConstructorOptions { /** * Button text. */ label?: string; /** * Button background color in hex format, i.e #ABCDEF. */ backgroundColor?: string; /** * Button icon. */ icon?: NativeImage; /** * Can be left, right or overlay. */ iconPosition?: ('left' | 'right' | 'overlay'); /** * Function to call when the button is clicked. */ click?: () => void; } interface TouchBarColorPickerConstructorOptions { /** * Array of hex color strings to appear as possible colors to select. */ availableColors?: string[]; /** * The selected hex color in the picker, i.e #ABCDEF. */ selectedColor?: string; /** * Function to call when a color is selected. */ change?: (color: string) => void; } interface TouchBarConstructorOptions { items: Array<(TouchBarButton) | (TouchBarColorPicker) | (TouchBarGroup) | (TouchBarLabel) | (TouchBarPopover) | (TouchBarScrubber) | (TouchBarSegmentedControl) | (TouchBarSlider) | (TouchBarSpacer)>; escapeItem?: (TouchBarButton) | (TouchBarColorPicker) | (TouchBarGroup) | (TouchBarLabel) | (TouchBarPopover) | (TouchBarScrubber) | (TouchBarSegmentedControl) | (TouchBarSlider) | (TouchBarSpacer) | (null); } interface TouchBarGroupConstructorOptions { /** * Items to display as a group. */ items: TouchBar; } interface TouchBarLabelConstructorOptions { /** * Text to display. */ label?: string; /** * Hex color of text, i.e #ABCDEF. */ textColor?: string; } interface TouchBarPopoverConstructorOptions { /** * Popover button text. */ label?: string; /** * Popover button icon. */ icon?: NativeImage; /** * Items to display in the popover. */ items?: TouchBar; /** * true to display a close button on the left of the popover, false to not show it. * Default is true. */ showCloseButton?: boolean; } interface TouchBarScrubberConstructorOptions { /** * An array of items to place in this scrubber. */ items: ScrubberItem[]; /** * Called when the user taps an item that was not the last tapped item. */ select: (selectedIndex: number) => void; /** * Called when the user taps any item. */ highlight: (highlightedIndex: number) => void; /** * Selected item style. Defaults to null. */ selectedStyle: string; /** * Selected overlay item style. Defaults to null. */ overlayStyle: string; /** * Defaults to false. */ showArrowButtons: boolean; /** * Defaults to free. */ mode: string; /** * Defaults to true. */ continuous: boolean; } interface TouchBarSegmentedControlConstructorOptions { /** * Style of the segments: */ segmentStyle?: ('automatic' | 'rounded' | 'textured-rounded' | 'round-rect' | 'textured-square' | 'capsule' | 'small-square' | 'separated'); /** * The selection mode of the control: */ mode?: ('single' | 'multiple' | 'buttons'); /** * An array of segments to place in this control. */ segments: SegmentedControlSegment[]; /** * The index of the currently selected segment, will update automatically with user * interaction. When the mode is multiple it will be the last selected item. */ selectedIndex?: number; /** * Called when the user selects a new segment. */ change: (selectedIndex: number, isSelected: boolean) => void; } interface TouchBarSliderConstructorOptions { /** * Label text. */ label?: string; /** * Selected value. */ value?: number; /** * Minimum value. */ minValue?: number; /** * Maximum value. */ maxValue?: number; /** * Function to call when the slider is changed. */ change?: (newValue: number) => void; } interface TouchBarSpacerConstructorOptions { /** * Size of spacer, possible values are: */ size?: ('small' | 'large' | 'flexible'); } interface UpdateTargetUrlEvent extends Event { url: string; } interface UploadProgress { /** * Whether the request is currently active. If this is false no other properties * will be set */ active: boolean; /** * Whether the upload has started. If this is false both current and total will be * set to 0. */ started: boolean; /** * The number of bytes that have been uploaded so far */ current: number; /** * The number of bytes that will be uploaded this request */ total: number; } interface Versions { /** * A String representing Chrome's version string. */ chrome?: string; /** * A String representing Electron's version string. */ electron?: string; } interface VisibleOnAllWorkspacesOptions { /** * Sets whether the window should be visible above fullscreen windows */ visibleOnFullScreen?: boolean; } interface WillNavigateEvent extends Event { url: string; } interface EditFlags { /** * Whether the renderer believes it can undo. */ canUndo: boolean; /** * Whether the renderer believes it can redo. */ canRedo: boolean; /** * Whether the renderer believes it can cut. */ canCut: boolean; /** * Whether the renderer believes it can copy */ canCopy: boolean; /** * Whether the renderer believes it can paste. */ canPaste: boolean; /** * Whether the renderer believes it can delete. */ canDelete: boolean; /** * Whether the renderer believes it can select all. */ canSelectAll: boolean; } interface Extra { } interface FoundInPageResult { requestId: number; /** * Position of the active match. */ activeMatchOrdinal: number; /** * Number of Matches. */ matches: number; /** * Coordinates of first match region. */ selectionArea: SelectionArea; finalUpdate: boolean; } interface MediaFlags { /** * Whether the media element has crashed. */ inError: boolean; /** * Whether the media element is paused. */ isPaused: boolean; /** * Whether the media element is muted. */ isMuted: boolean; /** * Whether the media element has audio. */ hasAudio: boolean; /** * Whether the media element is looping. */ isLooping: boolean; /** * Whether the media element's controls are visible. */ isControlsVisible: boolean; /** * Whether the media element's controls are toggleable. */ canToggleControls: boolean; /** * Whether the media element can be rotated. */ canRotate: boolean; } interface Options { } interface Query { } interface RequestHeaders { } interface ResponseHeaders { } interface SelectionArea { } interface WebPreferences { /** * Whether to enable DevTools. If it is set to false, can not use * BrowserWindow.webContents.openDevTools() to open DevTools. Default is true. */ devTools?: boolean; /** * Whether node integration is enabled. Default is false. */ nodeIntegration?: boolean; /** * Whether node integration is enabled in web workers. Default is false. More about * this can be found in . */ nodeIntegrationInWorker?: boolean; /** * Experimental option for enabling Node.js support in sub-frames such as iframes * and child windows. All your preloads will load for every iframe, you can use * process.isMainFrame to determine if you are in the main frame or not. */ nodeIntegrationInSubFrames?: boolean; /** * Specifies a script that will be loaded before other scripts run in the page. * This script will always have access to node APIs no matter whether node * integration is turned on or off. The value should be the absolute file path to * the script. When node integration is turned off, the preload script can * reintroduce Node global symbols back to the global scope. See example . */ preload?: string; /** * If set, this will sandbox the renderer associated with the window, making it * compatible with the Chromium OS-level sandbox and disabling the Node.js engine. * This is not the same as the nodeIntegration option and the APIs available to the * preload script are more limited. Read more about the option . This option is * currently experimental and may change or be removed in future Electron releases. */ sandbox?: boolean; /** * Whether to enable the module. Default is true. */ enableRemoteModule?: boolean; /** * Sets the session used by the page. Instead of passing the Session object * directly, you can also choose to use the partition option instead, which accepts * a partition string. When both session and partition are provided, session will * be preferred. Default is the default session. */ session?: Session; /** * Sets the session used by the page according to the session's partition string. * If partition starts with persist:, the page will use a persistent session * available to all pages in the app with the same partition. If there is no * persist: prefix, the page will use an in-memory session. By assigning the same * partition, multiple pages can share the same session. Default is the default * session. */ partition?: string; /** * When specified, web pages with the same affinity will run in the same renderer * process. Note that due to reusing the renderer process, certain webPreferences * options will also be shared between the web pages even when you specified * different values for them, including but not limited to preload, sandbox and * nodeIntegration. So it is suggested to use exact same webPreferences for web * pages with the same affinity. */ affinity?: string; /** * The default zoom factor of the page, 3.0 represents 300%. Default is 1.0. */ zoomFactor?: number; /** * Enables JavaScript support. Default is true. */ javascript?: boolean; /** * When false, it will disable the same-origin policy (usually using testing * websites by people), and set allowRunningInsecureContent to true if this options * has not been set by user. Default is true. */ webSecurity?: boolean; /** * Allow an https page to run JavaScript, CSS or plugins from http URLs. Default is * false. */ allowRunningInsecureContent?: boolean; /** * Enables image support. Default is true. */ images?: boolean; /** * Make TextArea elements resizable. Default is true. */ textAreasAreResizable?: boolean; /** * Enables WebGL support. Default is true. */ webgl?: boolean; /** * Whether plugins should be enabled. Default is false. */ plugins?: boolean; /** * Enables Chromium's experimental features. Default is false. */ experimentalFeatures?: boolean; /** * Enables scroll bounce (rubber banding) effect on macOS. Default is false. */ scrollBounce?: 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 file. */ enableBlinkFeatures?: string; /** * A list of feature strings separated by ,, like CSSVariables,KeyboardEventKey to * disable. The full list of supported feature strings can be found in the file. */ disableBlinkFeatures?: string; /** * Sets the default font for the font-family. */ defaultFontFamily?: DefaultFontFamily; /** * Defaults to 16. */ defaultFontSize?: number; /** * Defaults to 13. */ defaultMonospaceFontSize?: number; /** * Defaults to 0. */ minimumFontSize?: number; /** * Defaults to ISO-8859-1. */ defaultEncoding?: string; /** * Whether to throttle animations and timers when the page becomes background. This * also affects the . Defaults to true. */ backgroundThrottling?: boolean; /** * Whether to enable offscreen rendering for the browser window. Defaults to false. * See the for more details. */ offscreen?: boolean; /** * Whether to run Electron APIs and the specified preload script in a separate * JavaScript context. Defaults to false. The context that the preload script runs * in will still have full access to the document and window globals but it will * use its own set of JavaScript builtins (Array, Object, JSON, etc.) and will be * isolated from any changes made to the global environment by the loaded page. The * Electron API will only be available in the preload script and not the loaded * page. This option should be used when loading potentially untrusted remote * content to ensure the loaded content cannot tamper with the preload script and * any Electron APIs being used. This option uses the same technique used by . You * can access this context in the dev tools by selecting the 'Electron Isolated * Context' entry in the combo box at the top of the Console tab. */ contextIsolation?: boolean; /** * Whether to use native window.open(). Defaults to false. Child windows will * always have node integration disabled unless nodeIntegrationInSubFrames is true. * This option is currently experimental. */ nativeWindowOpen?: boolean; /** * Whether to enable the . Defaults to false. The preload script configured for the * will have node integration enabled when it is executed so you should ensure * remote/untrusted content is not able to create a tag with a possibly malicious * preload script. You can use the will-attach-webview event on to strip away the * preload script and to validate or alter the 's initial settings. */ webviewTag?: boolean; /** * A list of strings that will be appended to process.argv in the renderer process * of this app. Useful for passing small bits of data down to renderer process * preload scripts. */ additionalArguments?: string[]; /** * Whether to enable browser style consecutive dialog protection. Default is false. */ safeDialogs?: boolean; /** * The message to display when consecutive dialog protection is triggered. If not * defined the default message would be used, note that currently the default * message is in English and not localized. */ safeDialogsMessage?: string; /** * Whether dragging and dropping a file or link onto the page causes a navigation. * Default is false. */ navigateOnDragDrop?: boolean; /** * Autoplay policy to apply to content in the window, can be * no-user-gesture-required, user-gesture-required, * document-user-activation-required. Defaults to no-user-gesture-required. */ autoplayPolicy?: ('no-user-gesture-required' | 'user-gesture-required' | 'document-user-activation-required'); /** * Whether to prevent the window from resizing when entering HTML Fullscreen. * Default is false. */ disableHtmlFullscreenWindowResize?: boolean; } interface DefaultFontFamily { /** * Defaults to Times New Roman. */ standard?: string; /** * Defaults to Times New Roman. */ serif?: string; /** * Defaults to Arial. */ sansSerif?: string; /** * Defaults to Courier New. */ monospace?: string; /** * Defaults to Script. */ cursive?: string; /** * Defaults to Impact. */ fantasy?: string; } } declare module 'electron' { export = Electron; } interface NodeRequireFunction { (moduleName: 'electron'): typeof Electron; } interface File { /** * The real path to the file on the users filesystem */ path: string; } declare module 'original-fs' { import * as fs from 'fs'; export = fs; } interface Document { createElement(tagName: 'webview'): Electron.WebviewTag; } declare namespace NodeJS { interface Process extends EventEmitter { // Docs: http://electronjs.org/docs/api/process /** * Emitted when Electron has loaded its internal initialization script and is * beginning to load the web page or the main script. It can be used by the preload * script to add removed Node global symbols back to the global scope when node * integration is turned off: */ on(event: 'loaded', listener: Function): this; once(event: 'loaded', listener: Function): this; addListener(event: 'loaded', listener: Function): this; removeListener(event: 'loaded', listener: Function): this; /** * Causes the main thread of the current process crash. */ crash(): void; getCPUUsage(): Electron.CPUUsage; /** * Indicates the creation time of the application. The time is represented as * number of milliseconds since epoch. It returns null if it is unable to get the * process creation time. */ getCreationTime(): (number) | (null); /** * Returns an object with V8 heap statistics. Note that all statistics are reported * in Kilobytes. */ getHeapStatistics(): Electron.HeapStatistics; getIOCounters(): Electron.IOCounters; /** * Returns an object giving memory usage statistics about the current process. Note * that all statistics are reported in Kilobytes. This api should be called after * app ready. Chromium does not provide residentSet value for macOS. This is * because macOS performs in-memory compression of pages that haven't been recently * used. As a result the resident set size value is not what one would expect. * private memory is more representative of the actual pre-compression memory usage * of the process on macOS. */ getProcessMemoryInfo(): Promise; /** * Returns an object giving memory usage statistics about the entire system. Note * that all statistics are reported in Kilobytes. */ getSystemMemoryInfo(): Electron.SystemMemoryInfo; /** * Examples: Note: It returns the actual operating system version instead of kernel * version on macOS unlike os.release(). */ getSystemVersion(): string; /** * Causes the main thread of the current process hang. */ hang(): void; /** * Sets the file descriptor soft limit to maxDescriptors or the OS hard limit, * whichever is lower for the current process. */ setFdLimit(maxDescriptors: number): void; /** * Takes a V8 heap snapshot and saves it to filePath. */ takeHeapSnapshot(filePath: string): boolean; /** * A Boolean. When app is started by being passed as parameter to the default app, * this property is true in the main process, otherwise it is undefined. */ defaultApp?: boolean; /** * A Boolean that controls whether or not deprecation warnings are printed to * stderr when formerly callback-based APIs converted to Promises are invoked using * callbacks. Setting this to true will enable deprecation warnings. */ enablePromiseAPIs?: boolean; /** * A Boolean, true when the current renderer context is the "main" renderer frame. * If you want the ID of the current frame you should use webFrame.routingId. */ isMainFrame?: boolean; /** * A Boolean. For Mac App Store build, this property is true, for other builds it * is undefined. */ mas?: boolean; /** * A Boolean that controls ASAR support inside your application. Setting this to * true will disable the support for asar archives in Node's built-in modules. */ noAsar?: boolean; /** * A Boolean that controls whether or not deprecation warnings are printed to * stderr. Setting this to true will silence deprecation warnings. This property is * used instead of the --no-deprecation command line flag. */ noDeprecation?: boolean; /** * A String representing the path to the resources directory. */ resourcesPath?: string; /** * A Boolean. When the renderer process is sandboxed, this property is true, * otherwise it is undefined. */ sandboxed?: boolean; /** * A Boolean that controls whether or not deprecation warnings will be thrown as * exceptions. Setting this to true will throw errors for deprecations. This * property is used instead of the --throw-deprecation command line flag. */ throwDeprecation?: boolean; /** * A Boolean that controls whether or not deprecations printed to stderr include * their stack trace. Setting this to true will print stack traces for * deprecations. This property is instead of the --trace-deprecation command line * flag. */ traceDeprecation?: boolean; /** * A Boolean that controls whether or not process warnings printed to stderr * include their stack trace. Setting this to true will print stack traces for * process warnings (including deprecations). This property is instead of the * --trace-warnings command line flag. */ traceProcessWarnings?: boolean; /** * A String representing the current process's type, can be "browser" (i.e. main * process), "renderer", or "worker" (i.e. web worker). */ type?: string; /** * A Boolean. If the app is running as a Windows Store app (appx), this property is * true, for otherwise it is undefined. */ windowsStore?: boolean; } interface ProcessVersions { electron: string; chrome: string; } }