build script updated

If we provide the Version parameter and haven't included the version …

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://donorbox.org/electron-net

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+<!-- Please search existing issues to avoid creating duplicates. -->
+
+<!-- Which version of Electron.NET CLI and API are you using? -->
+<!-- Please always try to use latest version before report. -->
+* **Version**: 
+
+<!-- Which version of .NET Core and Node.js are you using (if applicable)? -->
+
+<!-- What target are you building for? -->
+* **Target**: 
+
+<!-- Enter your issue details below this comment. -->
+<!-- If you want, you can donate to increase issue priority (https://donorbox.org/electron-net) -->
+
+Steps to Reproduce:
+
+1.
+2.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,13 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: Feature
+assignees: ''
+
+---
+
+<!-- Please search existing feature request to avoid creating duplicates. -->
+
+<!-- If you want, you can donate to increase feature request priority (https://donorbox.org/electron-net) -->
+<!-- Describe the feature you'd like. -->

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,13 @@
+---
+name: Question
+about: The issue tracker is not for questions. Please ask questions on https://stackoverflow.com/questions/tagged/electron.net
+  or via chat in https://gitter.im/ElectronNET/community.
+title: ''
+labels: question
+assignees: ''
+
+---
+
+🚨 The issue tracker is not for questions 🚨
+
+The issue tracker is not for questions. Please ask questions on https://stackoverflow.com/questions/tagged/electron.net or via chat in https://gitter.im/ElectronNET/community.

.gitignore

@@ -260,3 +260,6 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
+
+# Mac Only settings file
+.DS_Store

.travis.yml

@@ -1,7 +1,8 @@
 language: csharp
 mono: none
-dotnet: 2.0.0
+dist: xenial
+dotnet: 3.1
 before_script:
-  - npm install electron-packager --global
+  - export PATH="$PATH:/home/travis/.dotnet/tools"
 script:
-  - ./buildAll.sh
+  - ./buildAll.sh

.vscode/tasks.json

@@ -1,16 +1,18 @@
 {
-    "version": "0.1.0",
-    "command": "dotnet",
-    "isShellCommand": true,
-    "args": [],
-    "tasks": [
-        {
-            "taskName": "build",
-            "args": [
-                "${workspaceRoot}/ElectronNET.CLI/ElectronNET.CLI.csproj"
-            ],
-            "isBuildCommand": true,
-            "problemMatcher": "$msCompile"
-        }
-    ]
-}
+  "version": "2.0.0",
+  "command": "dotnet",
+  "args": [],
+  "tasks": [
+    {
+      "label": "build",
+      "type": "shell",
+      "command": "dotnet",
+      "args": ["build", "${workspaceRoot}/ElectronNET.CLI/ElectronNET.CLI.csproj"],
+      "problemMatcher": "$msCompile",
+      "group": {
+        "_id": "build",
+        "isDefault": false
+      }
+    }
+  ]
+}

Changelog.md

@@ -1,4 +1,307 @@
-# not release
+# Not released
+
+# 23.6.2
+
+# Released
+
+# 23.6.1
+
+ElectronNET.CLI:
+
+* New Feature: Upgrade to .NET 6 support
+
+ElectronNET.API:
+
+* New Feature: Native Electron 23.2.0 support, but not all new API features included (we search contributors) 
+* New Feature: Upgrade to .NET 6 support
+* New Feature: Changed Web-Socket .NET Library to [SocketIOClient](https://github.com/doghappy/socket.io-client-csharp)
+* Breaking Changes: We removed deprecated API events/methods from ElectronNET.API [(More Details)](https://www.electronjs.org/docs/latest/breaking-changes)
+
+# 13.5.1
+
+ElectronNET.CLI:
+
+* New Feature: Using exit code instead of seek for the term 'error' (thanks [TSrgy](https://github.com/TSrgy)) [\#562](https://github.com/ElectronNET/Electron.NET/pull/562)  
+* Fixed bug: Allow for property overrides to be passed in (thanks [danatcofo](https://github.com/danatcofo)) [\#531](https://github.com/ElectronNET/Electron.NET/pull/531)  
+Use `/p:propertyName=value` or `/property:propertyName=value` to pass in property overrides. This is equivalent to the `-p:` option documented here: [https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish)  
+* Fixed bug: Add ability to pass an argument for "Version" for both the "dotnet publish" and "electron-builder" commands (thanks [tub5](https://github.com/tub5)) [\#546](https://github.com/ElectronNET/Electron.NET/pull/546)  
+* Fixed bug: Version flag not persisting with the referenced executable (thanks [tub5](https://github.com/tub5)) [\#585](https://github.com/ElectronNET/Electron.NET/pull/585)  
+* Fixed bug: Changes PublishSingleFile default to false for NET5 compatibility (thanks [cristiangiagante](https://github.com/cristiangiagante)) [\#570](https://github.com/ElectronNET/Electron.NET/pull/570)  
+  
+ElectronNET.API:  
+  
+* New Feature: Native Electron 13.1.5 support, but not all new features (we search contributors)   
+* Breaking API Changes (from native Electron 13.1.5): 
+   - `Shell.MoveItemToTrashAsync` renamed with `Shell.TrashItemAsync`  
+   - The deprecated extension APIs have been removed: `BrowserWindow.GetAllExtensionsAsync()`, `BrowserWindow.RemoveExtension()`, `BrowserWindow.AddExtensionAsync()`. Use the session APIs instead: `Session.GetAllExtensionsAsync()`, `Session.RemoveExtension()`, `Session.LoadExtensionAsync()`.  
+* New Feature: singleInstance handle command line arguments [\#520](https://github.com/ElectronNET/Electron.NET/issues/520)  
+* New Feature: Add WebContents [insertCSS](https://www.electronjs.org/docs/api/web-contents#contentsinsertcsscss-options) functionality (thanks [nfichter](https://github.com/nfichter)) [\#559](https://github.com/ElectronNET/Electron.NET/pull/559)  
+* New Feature: Allow IpcMain to send IPC messages to BrowserViews (thanks [nfichter](https://github.com/nfichter)) [\#560](https://github.com/ElectronNET/Electron.NET/pull/560)  
+* New Feature: Add support for proxies that require basic username/password authentication (thanks [nfichter](https://github.com/nfichter)) [\#561](https://github.com/ElectronNET/Electron.NET/pull/561)  
+* New Feature: Add PostData to LoadURLOptions to allow http-posts in LoadURL calls (thanks [Funkrusha](https://github.com/Funkrusha)) [\#547](https://github.com/ElectronNET/Electron.NET/pull/547)  
+* Fixed bug: Fix splash screen interaction causing crashes, ghost dragging, and resizable behavior #540 (thanks [MiniguyBrendan](https://github.com/MiniguyBrendan)) [\#540](https://github.com/ElectronNET/Electron.NET/pull/540)  
+* Fixed bug: Vibrancy serialization fix (thanks [tantumalice](https://github.com/tantumalice)) [\#573](https://github.com/ElectronNET/Electron.NET/pull/573)  
+
+# 11.5.1
+
+ElectronNET.CLI:
+
+* New Feature: Added new build and start commandline options for single exe (thanks [nathanwienand](https://github.com/nathanwienand)) [\#506](https://github.com/ElectronNET/Electron.NET/pull/506)
+* New Feature: Set a description of the app in `electron.manifest.json` (thanks [BurtsevC](https://github.com/BurtsevC)) [\#433](https://github.com/ElectronNET/Electron.NET/pull/433)
+* New Feature: Set a target for the start command (thanks [gabecook](https://github.com/gabecook)) [\#463](https://github.com/ElectronNET/Electron.NET/pull/463)
+* New Feature: `electronize init` support for F# projects (thanks [kojo12228](https://github.com/kojo12228)) [\#457](https://github.com/ElectronNET/Electron.NET/pull/457)
+* New Feature: Linux support for the buildAll.sh (thanks [duncanawoods](https://github.com/duncanawoods)) [\#465](https://github.com/ElectronNET/Electron.NET/pull/465)
+* Fixed bug: ERR_UNKNOWN_URL_SCHEME by intercepting file:// protocol (thanks [duncanawoods](https://github.com/duncanawoods)) [\#467](https://github.com/ElectronNET/Electron.NET/pull/467)
+
+ElectronNET.API:
+
+* New Feature: Native Electron 11.1.1 support, but not all new features (we search contributors)
+* Breaking API Changes (from native Electron 11.0): - Removed: BrowserView.{destroy, fromId, fromWebContents, getAllViews} and id property of BrowserView
+* New Feature: Upgrade to .NET 5 (thanks [scottkuhl](https://github.com/scottkuhl)) [\#509](https://github.com/ElectronNET/Electron.NET/pull/509)
+* New Feature: Extension Method for adding the Electron static class members to the standard MS DI Containers, this is a QOL issue only. `services.AddElectron()` (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: SetMenu completed for the Dock (MacOS) (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+
+Example for the Dock Menu
+
+`Electron.Dock.SetMenu(new [] {
+   new MenuItem {
+      Label = "Dock Menu Item",
+      Click = () => {
+         // do something
+      }
+   },
+});`
+
+Example for consuming the activate event (MacOs only)
+
+`Electron.App.On("activate", obj => {
+   var hasWindows = (bool)obj;
+   // do something
+});`
+
+* New Feature: On and Once implementations for the App and Tray to cover the plethora of events that are not mapped explicitly in those two modules. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: Adding the `EnableRemoteModule` property to the WebPreferences object. As of Electron 10, this property defaulted to false and without it exposed you can't use the remote module within a window. (thanks [danatcofo](https://github.com/danatcofo )) [\#528](https://github.com/ElectronNET/Electron.NET/pull/528)
+* New Feature: Adding a configurable default electron port. (thanks [aarong-av](https://github.com/aarong-av)) [\#505](https://github.com/ElectronNET/Electron.NET/pull/505)
+* New Feature: Added support for launching the application with a file on MacOS (thanks [dlitty](https://github.com/dlitty)) [\#478](https://github.com/ElectronNET/Electron.NET/pull/478)
+* Improved: Avoid Blocking Calls in App and AutoUpdater (thanks [freosc](https://github.com/freosc)) [\#474](https://github.com/ElectronNET/Electron.NET/pull/474)
+* Fixed bug: Maintain references between socket.io connection events (thanks [danatcofo](https://github.com/danatcofo )) [\#468](https://github.com/ElectronNET/Electron.NET/pull/486)
+* Fixed bug: Set default WebPreferences.DefaultFontSize (thanks [duncanawoods](https://github.com/duncanawoods)) [\#468](https://github.com/ElectronNET/Electron.NET/pull/468)
+
+# 9.31.2
+
+* Electron-Builder fixed for Windows builds.
+
+# 9.31.1
+
+ElectronNET.CLI:
+
+* New Feature: Added config parameter (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
+* New Feature: Set the configuration environment with the electron.manifest.json file.
+* Fixed bug: Custom user path removed and replaced by the correct directory with VS macro (When ElectronNET.CLI is the Startup Project, press F5 (Debug) and the ElectronNET.WebApp starts correctly without error!) (thanks [konstantingross](https://github.com/konstantingross)) [\#409](https://github.com/ElectronNET/Electron.NET/pull/409)
+
+ElectronNET.API:
+
+* New Feature: Native Electron 9.0.3 support, but not all new features (we search contributors)
+* New Feature: PowerMonitor API Support (thanks [gustavo-lara-molina](https://github.com/gustavo-lara-molina)) [\#399](https://github.com/ElectronNET/Electron.NET/pull/399) [\#423](https://github.com/ElectronNET/Electron.NET/pull/423)
+* New Feature: NativeTheme API Support (thanks [konstantingross](https://github.com/konstantingross)) [\#402](https://github.com/ElectronNET/Electron.NET/pull/402)
+* New Feature: Cookie API Support (thanks [freosc](https://github.com/freosc)) [\#413](https://github.com/ElectronNET/Electron.NET/pull/413)
+* Changed Feature: Removed dock methods from App API and moved to Dock API (thanks [konstantingross](https://github.com/konstantingross)) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
+* App-Api Enhancement: MenuItems with Submenus need an submenu type workaround [\#412](https://github.com/ElectronNET/Electron.NET/issues/412)
+* App-Api Enhancement: Added UserAgentFallback (thanks [Mandrakia](https://github.com/Mandrakia)) [\#406](https://github.com/ElectronNET/Electron.NET/pull/406)
+* App-Api Enhancement: Summaries rewritten, new App.IsReady / App.HasSingleInstanceLock property, App.Ready event, App.Focus with force parameter method, many parameters changes (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415) [\#422](https://github.com/ElectronNET/Electron.NET/pull/422)
+* App-Api Enhancement: New App.IsReady property and App.Ready event (thanks [konstantingross](https://github.com/konstantingross)) [\#415](https://github.com/ElectronNET/Electron.NET/pull/415)
+* Shell-Api Enhancement: API fixes for Electron 9.0.0 / Added missing parameters / Summaries rewritten (thanks [konstantingross](https://github.com/konstantingross)) [\#417](https://github.com/ElectronNET/Electron.NET/pull/417) [\#418](https://github.com/ElectronNET/Electron.NET/pull/418)
+* Notification-Api Enhancement: Added missing properties in Notifications (thanks [konstantingross](https://github.com/konstantingross)) [\#410](https://github.com/ElectronNET/Electron.NET/pull/410)
+* BrowserWindows-Api Enhancement: Add missing API call for SetProgressBar options (thanks [konstantingross](https://github.com/konstantingross)) [\#416](https://github.com/ElectronNET/Electron.NET/pull/416)
+* BrowserWindow Enhancement: Add BrowserWindow.GetNativeWindowHandle() (thanks [kdlslyv](https://github.com/kdlslyv)) [\#429](https://github.com/ElectronNET/Electron.NET/pull/429)
+* HostHook-Api Enhancement: HostHook.CallAsync should use TaskCompletionSource.SetException instead of throwing exception (thanks [Fre V](https://github.com/freosc)) [\#430](https://github.com/ElectronNET/Electron.NET/pull/430)
+* MacOS Enhancement: Application exit logic (thanks [dafergu2](https://github.com/dafergu2)) [\#405](https://github.com/ElectronNET/Electron.NET/pull/405)
+* Fixed bug: ElectronNET.API.Entities.WebPreferences.ContextIsolation [DefaultValue(true)] [\#411](https://github.com/ElectronNET/Electron.NET/issues/411)
+
+ElectronNET.WebApp (internal use):
+* Improvement debugging and testing new API calls (without install ElectronNET.CLI) (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
+* Fixed bug: Cannot find modules in ElectronHostHook (thanks [konstantingross](https://github.com/konstantingross)) [\#425](https://github.com/ElectronNET/Electron.NET/pull/425)
+
+Thank you for donation [Phil Seeman](https://github.com/mpnow) ❤
+
+# 8.31.2
+
+ElectronNET.CLI:
+* New Feature: Deactivate PublishReadyToRun for build or start [\#395](https://github.com/ElectronNET/Electron.NET/issues/395)
+  
+   `electronize build /target win /PublishReadyToRun false`  
+   `electronize start /PublishReadyToRun false`   
+* Fixed bug: Application window doesn't open after packaging  [\#387](https://github.com/ElectronNET/Electron.NET/issues/387)
+
+ElectronNET.API:
+
+* New Feature: NativeImage Support (thanks [ThrDev](https://github.com/ThrDev)) [\#394](https://github.com/ElectronNET/Electron.NET/pull/394)  
+* New Feature: Update menu items for context menu and system tray on-the-fly. [\#270](https://github.com/ElectronNET/Electron.NET/pull/270)  
+
+
+# 8.31.1
+
+ElectronNET.CLI:
+* New Feature: Set a name and author of the app in `electron.manifest.json` [\#348](https://github.com/ElectronNET/Electron.NET/issues/348#issuecomment-615977950) [\#310](https://github.com/ElectronNET/Electron.NET/issues/310#issuecomment-617361086)
+* New Feature: Live reload (thanks [syedadeel2](https://github.com/syedadeel2)) [\#390](https://github.com/ElectronNET/Electron.NET/pull/390)  
+`electronize start /watch`
+* New Feature: Every new window will created with an clear cache [\#273](https://github.com/ElectronNET/Electron.NET/issues/273)  
+`electronize start /clear-cache`
+
+ElectronNET.API:
+
+* New Feature: Native Electron 8.2.3 support, but not all new features (we search contributors)
+* New Feature: We incease the startup time for ~25-36% [\#356](https://github.com/ElectronNET/Electron.NET/issues/356)
+* New Feature: Added print capability (thanks [x-xx-o](https://github.com/x-xx-o)) [\#355](https://github.com/ElectronNET/Electron.NET/pull/355)
+* New Feature: BrowserView API [\#371](https://github.com/ElectronNET/Electron.NET/issues/371)
+* Changed App.GetNameAsync and App.SetNameAsync to the App.Name Property [\#350](https://github.com/ElectronNET/Electron.NET/issues/350)
+* Fixed bug: Splash Screen disappearing on click [\#357](https://github.com/ElectronNET/Electron.NET/issues/357)
+* Fixed bug: Start MenuRole enum at 1 (thanks [jjuback](https://github.com/jjuback)) [\#369](https://github.com/ElectronNET/Electron.NET/pull/369)
+* Fixed bug: BridgeConnector not connected (spam console) [\#347](https://github.com/ElectronNET/Electron.NET/issues/347)
+* Fixed bug: BrowserWindowOptions is not setting Width and Height properly [\#373](https://github.com/ElectronNET/Electron.NET/issues/373)
+* Fixed bug: IpcMain.Once(string) is not one time use, is not removing listener [\#366](https://github.com/ElectronNET/Electron.NET/issues/366)
+* Fixed bug: IpcMain.RemoveAllListeners(string) is not removing the listeners [\#365](https://github.com/ElectronNET/Electron.NET/issues/365)
+* Fixed bug: GetLoginItemSettingsAsync does not work [\#352](https://github.com/ElectronNET/Electron.NET/issues/352)
+* Fixed bug: Using OnReadyToShow to display the main window in Blazor does not seem to work with Show set to false [\#361](https://github.com/ElectronNET/Electron.NET/issues/361)
+* Fixed bug: Unable to disable WebSecurity along with NodeIntegration enabled [\#389](https://github.com/ElectronNET/Electron.NET/issues/389)
+
+# 7.30.2
+
+ElectronNET.CLI:
+
+* New Feature: Different manifest file support [\#340](https://github.com/ElectronNET/Electron.NET/issues/340)
+  * Create a additional manifest file: `electronize init /manifest test`
+  * Start the app with your additional manifest file: `electronize start /manifest electron.manifest.test.json`
+  * Build the app with your additional manifest file: `electronize build /target win /manifest electron.manifest.test.json`.
+
+* New Feature: Command Line support [\#337](https://github.com/ElectronNET/Electron.NET/issues/337)
+  * You can start the app with: `electronize start /args --dog=woof --test=true`
+  * Or as binary: `myapp.exe /args --dog=woof --test=true`
+* Fixed bug: Start process with listen port 8000 error. [\#308](https://github.com/ElectronNET/Electron.NET/issues/308) (thanks [thecodejedi](https://github.com/thecodejedi))
+* Fixed bug: `electronize build` with no arguments would throw a `KeyNotFoundException`. (thanks [jamiebrynes7](https://github.com/jamiebrynes7))
+
+ElectronNET.API:
+
+* New Feature: Electron 7.1.2 support, but not all new features (we search contributors) [\#341](https://github.com/ElectronNET/Electron.NET/issues/341)
+* New Feature: Electron.App.CommandLine API [\#337](https://github.com/ElectronNET/Electron.NET/issues/337)
+* New Feature: Support of BrowserWindow.AddExtension, BrowserWindow.RemoveExtension, BrowserWindow.GetExtensions (thanks [Daddoon](https://github.com/Daddoon))
+
+Thank you for donation [robertmclaws](https://github.com/robertmclaws) ❤
+
+# 5.30.1
+
+ElectronNET.CLI:
+
+* Move to .NET Core 3.0
+* Use npm npx instead of global installations (thanks [jimbuck](https://github.com/jimbuck))
+
+ElectronNET.API:
+
+* Move to .NET Core 3.0
+* New Feature: Add BrowserWindow.RemoveMenu() (thanks [hack2root](https://github.com/hack2root))
+
+Thanks to [MaherJendoubi](https://github.com/MaherJendoubi), [kant2002](https://github.com/kant2002), [raz-canva](https://github.com/raz-canva) and [Daddoon](https://github.com/Daddoon) to give .NET Core 3.0 feedback!
+# 5.22.14
+
+ElectronNET.CLI:
+
+* Fixed bug: Build fails with latest electron-builder version [\#288](https://github.com/ElectronNET/Electron.NET/issues/288)
+
+ElectronNET.API:
+
+* New Feature: Full support for Auto Updater [(Based on electron-updater - Version 4.0.6)](https://www.electron.build/auto-update)
+* New Feature: Support for set a custom static Port to ASP.NET Backend [\#155](https://github.com/ElectronNET/Electron.NET/issues/155)
+* Fixed bug: Electron tray icon TypeError ([Electron original issue](https://github.com/electron/electron/issues/7657)) (thanks [Tum4ik](https://github.com/Tum4ik))
+* Fixed bug: Wrong tray icon path in the application built via `electronize build` command (thanks [Tum4ik](https://github.com/Tum4ik))
+* Fixed bug: fix async issue where same port is considered open [\#261](https://github.com/ElectronNET/Electron.NET/issues/261) (thanks [netpoetica](https://github.com/netpoetica))
+
+ElectronNET.WebApp:
+
+* Fixed usage of the `Electron.Tray.Show` according fixed bugs in the ElectronNET.CLI (thanks [Tum4ik](https://github.com/Tum4ik))
+
+# 5.22.13
+
+ElectronNET.API:
+
+* Fixed bug: Menu Item visibility [\#257](https://github.com/ElectronNET/Electron.NET/issues/257)
+* Fixed bug: electron.manifest.json - singleInstance not working [\#258](https://github.com/ElectronNET/Electron.NET/issues/258)
+* Fixed security issue: ASP.NET Core process is now bound to 127.0.0.1 instead of the broader localhost [\#258](https://github.com/ElectronNET/Electron.NET/pull/266)  
+
+# 5.22.12
+
+ElectronNET.CLI:
+
+* New Feature: Changed from **electron packager** to [**electron builder**](https://www.electron.build/)
+* New Feature: 'add hosthook' command for add a ElectronHostHook-Directory
+* Fixed bug: 'Unexpected firewall warnings' [\#181](https://github.com/ElectronNET/Electron.NET/issues/181)
+* Fixed bug: 'found 8 vulnerabilities (1 low, 5 moderate, 2 high)' [\#199](https://github.com/ElectronNET/Electron.NET/pull/199)
+* Merged pull request: Call electronize from the Path instead of via dotnet in launchSettings.json [\#243](https://github.com/ElectronNET/Electron.NET/pull/243) (thanks [grbd](https://github.com/grbd))
+
+ElectronNET.API:
+
+* New Feature: Electron 5.0.1 support, but not all new features
+* New Feature: Auto Updater [(Based on electron-updater)](https://www.electron.build/auto-update)
+* New Feature: Splashscreen-Support
+* New Feature: HostHook-API for execute own TypeScript/JavaScript code on native Electron Main-Process
+* New Feature: Session-API functions
+* Fixed bug: Node process running after stopping app [\#96](https://github.com/ElectronNET/Electron.NET/issues/96)
+* Fixed bug: 'X and Y options to not work on Windows 10' [\#193](https://github.com/ElectronNET/Electron.NET/issues/193)
+* Fixed bug: Unable to clear cache [\#66](https://github.com/ElectronNET/Electron.NET/issues/66)
+* Merged pull request: Fix BrowserWindow::SetMenu [\#231](https://github.com/ElectronNET/Electron.NET/pull/231) thanks (thanks [CodeKenpachi](https://github.com/CodeKenpachi))
+* Merged pull request: FIX application hangs after socket reconnect [\#233](https://github.com/ElectronNET/Electron.NET/pull/233) (thanks [pedromrpinto](https://github.com/pedromrpinto))
+* Merged pull request: Reduce chance of detecting false positives when scanning subprocesses for errors. [\#236](https://github.com/ElectronNET/Electron.NET/pull/236) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
+* Merged pull request: Updates the C# API to accept floating point as in JS. [\#240](https://github.com/ElectronNET/Electron.NET/pull/240) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
+* Merged pull request: buildReleaseNuGetPackages should leave you in the same directory you …  [\#241](https://github.com/ElectronNET/Electron.NET/pull/241) (thanks [BorisTheBrave](https://github.com/BorisTheBrave))
+
+ElectronNET.WebApp:
+
+* Implemented a sample for the new HostHook-API
+* Fixed bug: 'Electron.NET API Demo: unable to copy code?' [\#247](https://github.com/ElectronNET/Electron.NET/issues/247)
+
+# 0.0.11
+
+ElectronNET.CLI:
+
+* Invoke 'npm install' without --prod flag to install needed devDependencies as well.
+* Enable SourceLink
+* NuGet Package License Information updated (deprecation of licenseUrl)
+
+ElectronNET.API:
+
+* Documentation added for WebContents.GetUrl()
+* Enable SourceLink
+* NuGet Package License Information updated (deprecation of licenseUrl)
+
+# 0.0.10
+
+ElectronNET.API:
+
+* manifestJsonFilePath fixed (thanks @smack0007)
+* Use Electron release 3.0.0 and updated packages (thanks @deinok)
+* fixes for Socket interaction (thanks @mojinxun)
+* Fixing SingleInstances (thanks @yaofeng)
+* Enhance WebContent.GetUrl (thanks @ru-sh)
+
+ElectronNET.CLI:
+
+* Show Resultcode for better debugging when using Build/Start Command
+* ElectronNET.CLI is now a global dotnet tool
+
+# 0.0.9
+
+ElectronNET.API:
+
+* Better Async handling - thanks @danielmarbach
+
+ElectronNET.CLI:
+
+* More options on the 'build' command, e.g. for a 32bit debug build with electron prune: build /target custom win7-x86;win32 /dotnet-configuration Debug /electron-arch ia32  /electron-params "--prune=true "
+* .NET Core project is now built with Release configuration but can be adjusted with the new params.
+* Be aware: "Breaking" (but because of the alpha status of this project, we won't use SemVer)
+
+# 0.0.8
+
+This version was skipped because we unfortunately  released a pre-version of this on NuGet.
 
 # 0.0.7
 
@@ -11,7 +314,7 @@ ElectronNET.CLI:
 
 ElectronNET.CLI:
 
-* nuget packages are now release bits and have the correct assembly verion
+* nuget packages are now release bits and have the correct assembly version
 * Version command 
 * better devCleanup.cmd
 * Better Platform Support Issue - thanks to @Petermarcu

ElectronNET.API/AutoUpdater.cs

@@ -0,0 +1,621 @@
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Enable apps to automatically update themselves. Based on electron-updater.
+    /// </summary>
+    public sealed class AutoUpdater
+    {
+        /// <summary>
+        /// Whether to automatically download an update when it is found. (Default is true)
+        /// </summary>
+        public bool AutoDownload
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("autoUpdater-autoDownload-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-autoDownload-get-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-autoDownload-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-autoDownload-set", value);
+            }
+        }
+
+        /// <summary>
+        /// Whether to automatically install a downloaded update on app quit (if `QuitAndInstall` was not called before).
+        /// 
+        /// Applicable only on Windows and Linux.
+        /// </summary>
+        public bool AutoInstallOnAppQuit
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-set", value);
+            }
+        }
+
+        /// <summary>
+        /// *GitHub provider only.* Whether to allow update to pre-release versions. 
+        /// Defaults to "true" if application version contains prerelease components (e.g. "0.12.1-alpha.1", here "alpha" is a prerelease component), otherwise "false".
+        /// 
+        /// If "true", downgrade will be allowed("allowDowngrade" will be set to "true").
+        /// </summary>
+        public bool AllowPrerelease
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("autoUpdater-allowPrerelease-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-allowPrerelease-get-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-set", value);
+            }
+        }
+
+        /// <summary>
+        /// *GitHub provider only.* 
+        /// Get all release notes (from current version to latest), not just the latest (Default is false).
+        /// </summary>
+        public bool FullChangelog
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("autoUpdater-fullChangelog-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-fullChangelog-get-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-set", value);
+            }
+        }
+
+        /// <summary>
+        /// Whether to allow version downgrade (when a user from the beta channel wants to go back to the stable channel).
+        /// Taken in account only if channel differs (pre-release version component in terms of semantic versioning).
+        /// Default is false.
+        /// </summary>
+        public bool AllowDowngrade
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("autoUpdater-allowDowngrade-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-allowDowngrade-get-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-set", value);
+            }
+        }
+
+        /// <summary>
+        /// For test only.
+        /// </summary>
+        public string UpdateConfigPath
+        {
+            get
+            {
+                return Task.Run<string>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<string>();
+
+                    BridgeConnector.Socket.On("autoUpdater-updateConfigPath-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-updateConfigPath-get-reply");
+                        taskCompletionSource.SetResult(result.ToString());
+                    });
+
+                    BridgeConnector.Socket.Emit("autoUpdater-updateConfigPath-get");
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+        }
+
+        /// <summary>
+        /// The current application version
+        /// </summary>
+        public Task<SemVer> CurrentVersionAsync
+        {
+            get
+            {
+                return Task.Run<SemVer>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<SemVer>();
+
+                    BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
+                        SemVer version = ((JObject)result).ToObject<SemVer>();
+                        taskCompletionSource.SetResult(version);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
+
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+        /// <summary>
+        /// Get the update channel. Not applicable for GitHub. 
+        /// Doesn’t return channel from the update configuration, only if was previously set.
+        /// </summary>
+        [Obsolete("Use the asynchronous version ChannelAsync instead")]
+        public string Channel
+        {
+            get
+            {
+                return ChannelAsync.Result;
+            }
+        }
+
+        /// <summary>
+        /// Get the update channel. Not applicable for GitHub. 
+        /// Doesn’t return channel from the update configuration, only if was previously set.
+        /// </summary>
+        public Task<string> ChannelAsync
+        {
+            get
+            {
+                return Task.Run<string>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<string>();
+
+                    BridgeConnector.Socket.On("autoUpdater-channel-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
+                        taskCompletionSource.SetResult(result.ToString());
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-channel-get");
+
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Task<Dictionary<string, string>> RequestHeadersAsync
+        {
+            get
+            {
+                return Task.Run(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
+                    BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
+                        Dictionary<string, string> result = ((JObject)headers).ToObject<Dictionary<string, string>>();
+                        taskCompletionSource.SetResult(result);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Dictionary<string, string> RequestHeaders
+        {
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
+            }
+        }
+
+        /// <summary>
+        /// Emitted when there is an error while updating.
+        /// </summary>
+        public event Action<string> OnError
+        {
+            add
+            {
+                if (_error == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-error" + GetHashCode(), (message) =>
+                    {
+                        _error(message.ToString());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-error-event", GetHashCode());
+                }
+                _error += value;
+            }
+            remove
+            {
+                _error -= value;
+
+                if (_error == null)
+                    BridgeConnector.Socket.Off("autoUpdater-error" + GetHashCode());
+            }
+        }
+
+        private event Action<string> _error;
+
+        /// <summary>
+        /// Emitted when checking if an update has started.
+        /// </summary>
+        public event Action OnCheckingForUpdate
+        {
+            add
+            {
+                if (_checkingForUpdate == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-checking-for-update" + GetHashCode(), () =>
+                    {
+                        _checkingForUpdate();
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-checking-for-update-event", GetHashCode());
+                }
+                _checkingForUpdate += value;
+            }
+            remove
+            {
+                _checkingForUpdate -= value;
+
+                if (_checkingForUpdate == null)
+                    BridgeConnector.Socket.Off("autoUpdater-checking-for-update" + GetHashCode());
+            }
+        }
+
+        private event Action _checkingForUpdate;
+
+        /// <summary>
+        /// Emitted when there is an available update. 
+        /// The update is downloaded automatically if AutoDownload is true.
+        /// </summary>
+        public event Action<UpdateInfo> OnUpdateAvailable
+        {
+            add
+            {
+                if (_updateAvailable == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-update-available" + GetHashCode(), (updateInfo) =>
+                    {
+                        _updateAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-update-available-event", GetHashCode());
+                }
+                _updateAvailable += value;
+            }
+            remove
+            {
+                _updateAvailable -= value;
+
+                if (_updateAvailable == null)
+                    BridgeConnector.Socket.Off("autoUpdater-update-available" + GetHashCode());
+            }
+        }
+
+        private event Action<UpdateInfo> _updateAvailable;
+
+        /// <summary>
+        /// Emitted when there is no available update.
+        /// </summary>
+        public event Action<UpdateInfo> OnUpdateNotAvailable
+        {
+            add
+            {
+                if (_updateNotAvailable == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-update-not-available" + GetHashCode(), (updateInfo) =>
+                    {
+                        _updateNotAvailable(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-update-not-available-event", GetHashCode());
+                }
+                _updateNotAvailable += value;
+            }
+            remove
+            {
+                _updateNotAvailable -= value;
+
+                if (_updateNotAvailable == null)
+                    BridgeConnector.Socket.Off("autoUpdater-update-not-available" + GetHashCode());
+            }
+        }
+
+        private event Action<UpdateInfo> _updateNotAvailable;
+
+        /// <summary>
+        /// Emitted on download progress.
+        /// </summary>
+        public event Action<ProgressInfo> OnDownloadProgress
+        {
+            add
+            {
+                if (_downloadProgress == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-download-progress" + GetHashCode(), (progressInfo) =>
+                    {
+                        _downloadProgress(JObject.Parse(progressInfo.ToString()).ToObject<ProgressInfo>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-download-progress-event", GetHashCode());
+                }
+                _downloadProgress += value;
+            }
+            remove
+            {
+                _downloadProgress -= value;
+
+                if (_downloadProgress == null)
+                    BridgeConnector.Socket.Off("autoUpdater-download-progress" + GetHashCode());
+            }
+        }
+
+        private event Action<ProgressInfo> _downloadProgress;
+
+        /// <summary>
+        /// Emitted on download complete.
+        /// </summary>
+        public event Action<UpdateInfo> OnUpdateDownloaded
+        {
+            add
+            {
+                if (_updateDownloaded == null)
+                {
+                    BridgeConnector.Socket.On("autoUpdater-update-downloaded" + GetHashCode(), (updateInfo) =>
+                    {
+                        _updateDownloaded(JObject.Parse(updateInfo.ToString()).ToObject<UpdateInfo>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-autoUpdater-update-downloaded-event", GetHashCode());
+                }
+                _updateDownloaded += value;
+            }
+            remove
+            {
+                _updateDownloaded -= value;
+
+                if (_updateDownloaded == null)
+                    BridgeConnector.Socket.Off("autoUpdater-update-downloaded" + GetHashCode());
+            }
+        }
+
+        private event Action<UpdateInfo> _updateDownloaded;
+
+        private static AutoUpdater _autoUpdater;
+        private static object _syncRoot = new object();
+
+        internal AutoUpdater() { }
+
+        internal static AutoUpdater Instance
+        {
+            get
+            {
+                if (_autoUpdater == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_autoUpdater == null)
+                        {
+                            _autoUpdater = new AutoUpdater();
+                        }
+                    }
+                }
+
+                return _autoUpdater;
+            }
+        }
+
+        /// <summary>
+        /// Asks the server whether there is an update.
+        /// </summary>
+        /// <returns></returns>
+        public Task<UpdateCheckResult> CheckForUpdatesAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                    taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesError" + guid, (error) =>
+            {
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                string message = "An error occurred in CheckForUpdatesAsync";
+                if (error != null && !string.IsNullOrEmpty(error.ToString()))
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
+            });
+
+            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdates", guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Asks the server whether there is an update.
+        /// 
+        /// This will immediately download an update, then install when the app quits.
+        /// </summary>
+        /// <returns></returns>
+        public Task<UpdateCheckResult> CheckForUpdatesAndNotifyAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                    if (updateCheckResult == null)
+                        taskCompletionSource.SetResult(null);
+                    else
+                        taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
+            {
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
+                if (error != null)
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
+            });
+
+            BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        ///  Restarts the app and installs the update after it has been downloaded.
+        ///  It should only be called after `update-downloaded` has been emitted.
+        ///  
+        ///  Note: QuitAndInstall() will close all application windows first and only emit `before-quit` event on `app` after that.
+        ///  This is different from the normal quit event sequence.
+        /// </summary>
+        /// <param name="isSilent">*windows-only* Runs the installer in silent mode. Defaults to `false`.</param>
+        /// <param name="isForceRunAfter">Run the app after finish even on silent install. Not applicable for macOS. Ignored if `isSilent` is set to `false`.</param>
+        public void QuitAndInstall(bool isSilent = false, bool isForceRunAfter = false)
+        {
+            BridgeConnector.Socket.Emit("autoUpdaterQuitAndInstall", isSilent, isForceRunAfter);
+        }
+
+        /// <summary>
+        /// Start downloading update manually. You can use this method if "AutoDownload" option is set to "false".
+        /// </summary>
+        /// <returns>Path to downloaded file.</returns>
+        public Task<string> DownloadUpdateAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("autoUpdaterDownloadUpdateComplete" + guid, (downloadedPath) =>
+            {
+                BridgeConnector.Socket.Off("autoUpdaterDownloadUpdateComplete" + guid);
+                taskCompletionSource.SetResult(downloadedPath.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("autoUpdaterDownloadUpdate", guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Feed URL.
+        /// </summary>
+        /// <returns>Feed URL.</returns>
+        public Task<string> GetFeedURLAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("autoUpdaterGetFeedURLComplete" + guid, (downloadedPath) =>
+            {
+                BridgeConnector.Socket.Off("autoUpdaterGetFeedURLComplete" + guid);
+                taskCompletionSource.SetResult(downloadedPath.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("autoUpdaterGetFeedURL", guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver()
+        };
+    }
+}

ElectronNET.API/BridgeConnector.cs

@@ -1,38 +1,27 @@
-using Quobject.SocketIoClientDotNet.Client;
-using System;
-
-namespace ElectronNET.API
+namespace ElectronNET.API
 {
     internal static class BridgeConnector
     {
-        private static Socket _socket;
-        private static object _syncRoot = new Object();
+        private static SocketIoFacade _socket;
+        private static readonly object SyncRoot = new();
 
-        public static Socket Socket
+        public static SocketIoFacade Socket
         {
             get
             {
-                if(_socket == null && HybridSupport.IsElectronActive)
+                if (_socket == null)
                 {
-                    lock (_syncRoot)
+                    lock (SyncRoot)
                     {
-                        if (_socket == null && HybridSupport.IsElectronActive)
+                        if (_socket == null)
                         {
-                            _socket = IO.Socket("http://localhost:" + BridgeSettings.SocketPort);
-                            _socket.On(Socket.EVENT_CONNECT, () =>
-                            {
-                                Console.WriteLine("BridgeConnector connected!");
-                            });
-                        }
-                    }
-                }
-                else if(_socket == null && !HybridSupport.IsElectronActive)
-                {
-                    lock (_syncRoot)
-                    {
-                        if (_socket == null && !HybridSupport.IsElectronActive)
-                        {
-                            _socket = IO.Socket(new Uri("http://localhost"), new IO.Options { AutoConnect = false });
+
+                            string socketUrl = HybridSupport.IsElectronActive
+                                ? $"http://localhost:{BridgeSettings.SocketPort}"
+                                : "http://localhost";
+
+                            _socket = new SocketIoFacade(socketUrl);
+                            _socket.Connect();
                         }
                     }
                 }
@@ -41,4 +30,4 @@ namespace ElectronNET.API
             }
         }
     }
-}
+}

ElectronNET.API/BrowserView.cs

@@ -0,0 +1,97 @@
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// A BrowserView can be used to embed additional web content into a BrowserWindow. 
+    /// It is like a child window, except that it is positioned relative to its owning window. 
+    /// It is meant to be an alternative to the webview tag.
+    /// </summary>
+    public class BrowserView
+    {
+        /// <summary>
+        /// Gets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        public int Id { get; internal set; }
+
+        /// <summary>
+        /// Render and control web pages.
+        /// </summary>
+        public WebContents WebContents { get; internal set; }
+
+        /// <summary>
+        /// Resizes and moves the view to the supplied bounds relative to the window.
+        /// 
+        /// (experimental)
+        /// </summary>
+        public Rectangle Bounds
+        {
+            get
+            {
+                return Task.Run<Rectangle>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<Rectangle>();
+
+                    BridgeConnector.Socket.On("browserView-getBounds-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("browserView-getBounds-reply");
+                        taskCompletionSource.SetResult((Rectangle)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("browserView-getBounds", Id);
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
+            }
+        }
+
+        /// <summary>
+        /// BrowserView
+        /// </summary>
+        internal BrowserView(int id) 
+        {
+            Id = id;
+
+            // Workaround: increase the Id so as not to conflict with BrowserWindow id
+            // the backend detect about the value an BrowserView
+            WebContents = new WebContents(id + 1000);
+        }
+
+        /// <summary>
+        /// (experimental)
+        /// </summary>
+        /// <param name="options"></param>
+        public void SetAutoResize(AutoResizeOptions options)
+        {
+            BridgeConnector.Socket.Emit("browserView-setAutoResize", Id, JObject.FromObject(options, _jsonSerializer));
+        }
+
+        /// <summary>
+        /// Color in #aarrggbb or #argb form. The alpha channel is optional.
+        /// 
+        /// (experimental)
+        /// </summary>
+        /// <param name="color">Color in #aarrggbb or #argb form. The alpha channel is optional.</param>
+        public void SetBackgroundColor(string color)
+        {
+            BridgeConnector.Socket.Emit("browserView-setBackgroundColor", Id, color);
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Clipboard.cs

@@ -2,7 +2,6 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
-using System;
 using System.Threading.Tasks;
 
 namespace ElectronNET.API
@@ -13,7 +12,7 @@ namespace ElectronNET.API
     public sealed class Clipboard
     {
         private static Clipboard _clipboard;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         internal Clipboard() { }
 
@@ -238,6 +237,40 @@ namespace ElectronNET.API
             BridgeConnector.Socket.Emit("clipboard-write", JObject.FromObject(data, _jsonSerializer), type);
         }
 
+        /// <summary>
+        /// Reads an image from the clipboard.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public Task<NativeImage> ReadImageAsync(string type = "")
+        {
+            var taskCompletionSource = new TaskCompletionSource<NativeImage>();
+
+            BridgeConnector.Socket.On("clipboard-readImage-Completed", (image) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readImage-Completed");
+
+                var nativeImage = ((JObject)image).ToObject<NativeImage>();
+
+                taskCompletionSource.SetResult(nativeImage);
+                
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readImage", type);
+            
+            return taskCompletionSource.Task;
+        }
+        
+        /// <summary>
+        /// Writes an image to the clipboard.
+        /// </summary>
+        /// <param name="image"></param>
+        /// <param name="type"></param>
+        public void WriteImage(NativeImage image, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeImage", JsonConvert.SerializeObject(image), type);
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/CommandLine.cs

@@ -0,0 +1,116 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Manipulate the command line arguments for your app that Chromium reads.
+    /// </summary>
+    public sealed class CommandLine
+    {
+        internal CommandLine() { }
+
+        internal static CommandLine Instance
+        {
+            get
+            {
+                if (_commandLine == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_commandLine == null)
+                        {
+                            _commandLine = new CommandLine();
+                        }
+                    }
+                }
+
+                return _commandLine;
+            }
+        }
+
+        private static CommandLine _commandLine;
+
+        private static object _syncRoot = new object();
+
+        /// <summary>
+        /// Append a switch (with optional value) to Chromium's command line.
+        /// </summary>
+        /// <param name="the_switch">A command-line switch, without the leading --</param>
+        /// <param name="value">(optional) - A value for the given switch</param>
+        /// <remarks>
+        /// Note: This will not affect process.argv. The intended usage of this function is to control Chromium's behavior.
+        /// </remarks>
+        public void AppendSwitch(string the_switch, string value = "")
+        {
+            BridgeConnector.Socket.Emit("appCommandLineAppendSwitch", the_switch, value);
+        }
+
+        /// <summary>
+        /// 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 <code>--switch=value</code>, consider using <code>appendSwitch('switch', 'value')</code> instead.
+        /// </summary>
+        /// <param name="value">The argument to append to the command line</param>
+        /// <remarks>
+        /// Note: This will not affect process.argv. The intended usage of this function is to control Chromium's behavior.
+        /// </remarks>
+        public void AppendArgument(string value)
+        {
+            BridgeConnector.Socket.Emit("appCommandLineAppendArgument", value);
+        }
+
+        /// <summary>
+        /// Whether the command-line switch is present.
+        /// </summary>
+        /// <param name="switchName">A command-line switch</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Whether the command-line switch is present.</returns>
+        public async Task<bool> HasSwitchAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken)) 
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("appCommandLineHasSwitchCompleted", (result) =>
+                {
+                    BridgeConnector.Socket.Off("appCommandLineHasSwitchCompleted");
+                    taskCompletionSource.SetResult((bool)result);
+                });
+
+                BridgeConnector.Socket.Emit("appCommandLineHasSwitch", switchName);
+
+                return await taskCompletionSource.Task.ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// The command-line switch value.
+        /// </summary>
+        /// <param name="switchName">A command-line switch</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The command-line switch value.</returns>
+        /// <remarks>
+        /// Note: When the switch is not present or has no value, it returns empty string.
+        /// </remarks>
+        public async Task<string> GetSwitchValueAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<string>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("appCommandLineGetSwitchValueCompleted", (result) =>
+                {
+                    BridgeConnector.Socket.Off("appCommandLineGetSwitchValueCompleted");
+                    taskCompletionSource.SetResult((string)result);
+                });
+
+                BridgeConnector.Socket.Emit("appCommandLineGetSwitchValue", switchName);
+
+                return await taskCompletionSource.Task.ConfigureAwait(false);
+            }
+        }
+    }
+}

ElectronNET.API/Converter/ModifierTypeListConverter.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace ElectronNET.API.Converter;
+
+/// <summary>
+/// 
+/// </summary>
+public class ModifierTypeListConverter : JsonConverter<List<ModifierType>>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="reader"></param>
+    /// <param name="objectType"></param>
+    /// <param name="existingValue"></param>
+    /// <param name="hasExistingValue"></param>
+    /// <param name="serializer"></param>
+    /// <returns></returns>
+    public override List<ModifierType> ReadJson(JsonReader reader, Type objectType, List<ModifierType> existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        var token = JToken.Load(reader);
+
+        if (token.Type == JTokenType.Null)
+        {
+            return null;
+        }
+
+
+        return token.ToObject<List<string>>().Select(m => (ModifierType)Enum.Parse(typeof(ModifierType), m)).ToList();
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="writer"></param>
+    /// <param name="value"></param>
+    /// <param name="serializer"></param>
+    public override void WriteJson(JsonWriter writer, List<ModifierType> value, JsonSerializer serializer)
+    {
+        writer.WriteStartArray();
+
+        foreach (var modifier in value)
+        {
+            writer.WriteValue(modifier.ToString());
+        }
+
+        writer.WriteEndArray();
+    }
+}

ElectronNET.API/Cookies.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Query and modify a session's cookies.
+    /// </summary>
+    public class Cookies
+    {
+        /// <summary>
+        /// Gets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        public int Id { get; private set; }
+
+        internal Cookies(int id)
+        {
+            Id = id;
+        }
+
+        /// <summary>
+        /// Emitted when a cookie is changed because it was added, edited, removed, or expired.
+        /// </summary>
+        public event Action<Cookie, CookieChangedCause, bool> OnChanged
+        {
+            add
+            {
+                if (_changed == null)
+                {
+                    BridgeConnector.Socket.On("webContents-session-cookies-changed" + Id, (args) =>
+                    {
+                        Cookie cookie = ((JArray)args)[0].ToObject<Cookie>();
+                        CookieChangedCause cause = ((JArray)args)[1].ToObject<CookieChangedCause>();
+                        bool removed = ((JArray)args)[2].ToObject<bool>();
+                        _changed(cookie, cause, removed);
+                    });
+
+                    BridgeConnector.Socket.Emit("register-webContents-session-cookies-changed", Id);
+                }
+                _changed += value;
+            }
+            remove
+            {
+                _changed -= value;
+
+                if (_changed == null)
+                    BridgeConnector.Socket.Off("webContents-session-cookies-changed" + Id);
+            }
+        }
+
+        private event Action<Cookie, CookieChangedCause, bool> _changed;
+
+        /// <summary>
+        /// Sends a request to get all cookies matching filter, and resolves a callack with the response.
+        /// </summary>
+        /// <param name="filter">
+        /// </param>
+        /// <returns>A task which resolves an array of cookie objects.</returns>
+        public Task<Cookie[]> GetAsync(CookieFilter filter)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Cookie[]>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-get-completed" + guid, (cookies) =>
+            {
+                Cookie[] result = ((JArray)cookies).ToObject<Cookie[]>();
+
+                BridgeConnector.Socket.Off("webContents-session-cookies-get-completed" + guid);
+                taskCompletionSource.SetResult(result);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-get", Id, JObject.FromObject(filter, _jsonSerializer), guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="details"></param>
+        /// <returns></returns>
+        public Task SetAsync(CookieDetails details)
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-set-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-set-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-set", Id, JObject.FromObject(details, _jsonSerializer), guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Removes the cookies matching url and name
+        /// </summary>
+        /// <param name="url">The URL associated with the cookie.</param>
+        /// <param name="name">The name of cookie to remove.</param>
+        /// <returns>A task which resolves when the cookie has been removed</returns>
+        public Task RemoveAsync(string url, string name)
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-remove-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-remove-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-remove", Id, url, name, guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes any unwritten cookies data to disk.
+        /// </summary>
+        /// <returns>A task which resolves when the cookie store has been flushed</returns>
+        public Task FlushStoreAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On("webContents-session-cookies-flushStore-completed" + guid, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-cookies-flushStore-completed" + guid);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-cookies-flushStore", Id, guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Dialog.cs

@@ -3,6 +3,7 @@ using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace ElectronNET.API
@@ -13,7 +14,7 @@ namespace ElectronNET.API
     public sealed class Dialog
     {
         private static Dialog _dialog;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         internal Dialog() { }
 
@@ -47,18 +48,25 @@ namespace ElectronNET.API
         public Task<string[]> ShowOpenDialogAsync(BrowserWindow browserWindow, OpenDialogOptions options)
         {
             var taskCompletionSource = new TaskCompletionSource<string[]>();
+            string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showOpenDialogComplete", (filePaths) =>
+            BridgeConnector.Socket.On("showOpenDialogComplete" + guid, (filePaths) =>
             {
-                BridgeConnector.Socket.Off("showOpenDialogComplete");
+                BridgeConnector.Socket.Off("showOpenDialogComplete" + guid);
 
                 var result = ((JArray)filePaths).ToObject<string[]>();
-                taskCompletionSource.SetResult(result);
+                var list = new List<string>();
+                foreach (var item in result)
+                {
+                    list.Add(HttpUtility.UrlDecode(item));
+                }
+                taskCompletionSource.SetResult(list.ToArray());
             });
 
-                BridgeConnector.Socket.Emit("showOpenDialog", 
-                JObject.FromObject(browserWindow, _jsonSerializer), 
-                JObject.FromObject(options, _jsonSerializer));
+
+            BridgeConnector.Socket.Emit("showOpenDialog",
+            JObject.FromObject(browserWindow, _jsonSerializer),
+            JObject.FromObject(options, _jsonSerializer), guid);
 
             return taskCompletionSource.Task;
         }
@@ -72,17 +80,19 @@ namespace ElectronNET.API
         public Task<string> ShowSaveDialogAsync(BrowserWindow browserWindow, SaveDialogOptions options)
         {
             var taskCompletionSource = new TaskCompletionSource<string>();
+            string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showSaveDialogComplete", (filename) =>
+            BridgeConnector.Socket.On("showSaveDialogComplete" + guid, (filename) =>
             {
-                BridgeConnector.Socket.Off("showSaveDialogComplete");
+                BridgeConnector.Socket.Off("showSaveDialogComplete" + guid);
 
                 taskCompletionSource.SetResult(filename.ToString());
             });
 
             BridgeConnector.Socket.Emit("showSaveDialog",
             JObject.FromObject(browserWindow, _jsonSerializer),
-            JObject.FromObject(options, _jsonSerializer));
+            JObject.FromObject(options, _jsonSerializer),
+            guid);
 
             return taskCompletionSource.Task;
         }
@@ -139,10 +149,11 @@ namespace ElectronNET.API
         public Task<MessageBoxResult> ShowMessageBoxAsync(BrowserWindow browserWindow, MessageBoxOptions messageBoxOptions)
         {
             var taskCompletionSource = new TaskCompletionSource<MessageBoxResult>();
+            var guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showMessageBoxComplete", (args) =>
+            BridgeConnector.Socket.On("showMessageBoxComplete" + guid, (args) =>
             {
-                BridgeConnector.Socket.Off("showMessageBoxComplete");
+                BridgeConnector.Socket.Off("showMessageBoxComplete" + guid);
 
                 var result = ((JArray)args);
 
@@ -156,12 +167,13 @@ namespace ElectronNET.API
 
             if (browserWindow == null)
             {
-                BridgeConnector.Socket.Emit("showMessageBox", JObject.FromObject(messageBoxOptions, _jsonSerializer));
+                BridgeConnector.Socket.Emit("showMessageBox", JObject.FromObject(messageBoxOptions, _jsonSerializer), guid);
             } else
             {
                 BridgeConnector.Socket.Emit("showMessageBox", 
                     JObject.FromObject(browserWindow, _jsonSerializer),
-                    JObject.FromObject(messageBoxOptions, _jsonSerializer));
+                    JObject.FromObject(messageBoxOptions, _jsonSerializer),
+                    guid);
             }
 
             return taskCompletionSource.Task;
@@ -205,16 +217,18 @@ namespace ElectronNET.API
         public Task ShowCertificateTrustDialogAsync(BrowserWindow browserWindow, CertificateTrustDialogOptions options)
         {
             var taskCompletionSource = new TaskCompletionSource<object>();
+            string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.On("showCertificateTrustDialogComplete", () =>
+            BridgeConnector.Socket.On("showCertificateTrustDialogComplete" + guid, () =>
             {
-                BridgeConnector.Socket.Off("showCertificateTrustDialogComplete");
+                BridgeConnector.Socket.Off("showCertificateTrustDialogComplete" + guid);
                 taskCompletionSource.SetResult(null);
             });
 
             BridgeConnector.Socket.Emit("showCertificateTrustDialog",
                 JObject.FromObject(browserWindow, _jsonSerializer),
-                JObject.FromObject(options, _jsonSerializer));
+                JObject.FromObject(options, _jsonSerializer),
+                guid);
 
             return taskCompletionSource.Task;
         }

ElectronNET.API/Dock.cs

@@ -0,0 +1,232 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+using ElectronNET.API.Extensions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Control your app in the macOS dock.
+    /// </summary>
+    public sealed class Dock
+    {
+        private static Dock _dock;
+        private static object _syncRoot = new object();
+
+        internal Dock()
+        {
+        }
+
+        internal static Dock Instance
+        {
+            get
+            {
+                if (_dock == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_dock == null)
+                        {
+                            _dock = new Dock();
+                        }
+                    }
+                }
+
+                return _dock;
+            }
+        }
+
+        /// <summary>
+        /// When <see cref="DockBounceType.Critical"/> is passed, the dock icon will bounce until either the application becomes
+        /// active or the request is canceled. When <see cref="DockBounceType.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.
+        /// <para/>
+        /// Note: This method can only be used while the app is not focused; when the app is focused it will return -1.
+        /// </summary>
+        /// <param name="type">Can be critical or informational. The default is informational.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Return an ID representing the request.</returns>
+        public async Task<int> BounceAsync(DockBounceType type, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<int>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-bounce-completed", (id) =>
+                {
+                    BridgeConnector.Socket.Off("dock-bounce-completed");
+                    taskCompletionSource.SetResult((int) id);
+                });
+
+                BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Cancel the bounce of id.
+        /// </summary>
+        /// <param name="id">Id of the request.</param>
+        public void CancelBounce(int id)
+        {
+            BridgeConnector.Socket.Emit("dock-cancelBounce", id);
+        }
+
+        /// <summary>
+        /// Bounces the Downloads stack if the filePath is inside the Downloads folder.
+        /// </summary>
+        /// <param name="filePath"></param>
+        public void DownloadFinished(string filePath)
+        {
+            BridgeConnector.Socket.Emit("dock-downloadFinished", filePath);
+        }
+
+        /// <summary>
+        /// Sets the string to be displayed in the dock’s badging area.
+        /// </summary>
+        /// <param name="text"></param>
+        public void SetBadge(string text)
+        {
+            BridgeConnector.Socket.Emit("dock-setBadge", text);
+        }
+
+        /// <summary>
+        /// Gets the string to be displayed in the dock’s badging area.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The badge string of the dock.</returns>
+        public async Task<string> GetBadgeAsync(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<string>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-getBadge-completed", (text) =>
+                {
+                    BridgeConnector.Socket.Off("dock-getBadge-completed");
+                    taskCompletionSource.SetResult((string) text);
+                });
+
+                BridgeConnector.Socket.Emit("dock-getBadge");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Hides the dock icon.
+        /// </summary>
+        public void Hide()
+        {
+            BridgeConnector.Socket.Emit("dock-hide");
+        }
+
+        /// <summary>
+        /// Shows the dock icon.
+        /// </summary>
+        public void Show()
+        {
+            BridgeConnector.Socket.Emit("dock-show");
+        }
+
+        /// <summary>
+        /// Whether the dock icon is visible. The app.dock.show() call is asynchronous
+        /// so this method might not return true immediately after that call.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the dock icon is visible.</returns>
+        public async Task<bool> IsVisibleAsync(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-isVisible-completed", (isVisible) =>
+                {
+                    BridgeConnector.Socket.Off("dock-isVisible-completed");
+                    taskCompletionSource.SetResult((bool) isVisible);
+                });
+
+                BridgeConnector.Socket.Emit("dock-isVisible");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Gets the dock menu items.
+        /// </summary>
+        /// <value>
+        /// The menu items.
+        /// </value>
+        public IReadOnlyCollection<MenuItem> MenuItems { get { return _items.AsReadOnly(); } }
+        private List<MenuItem> _items = new List<MenuItem>();
+
+        /// <summary>
+        /// Sets the application's dock menu.
+        /// </summary>
+        public void SetMenu(MenuItem[] menuItems)
+        {
+            menuItems.AddMenuItemsId();
+            BridgeConnector.Socket.Emit("dock-setMenu", JArray.FromObject(menuItems, _jsonSerializer));
+            _items.AddRange(menuItems);
+
+            BridgeConnector.Socket.Off("dockMenuItemClicked");
+            BridgeConnector.Socket.On("dockMenuItemClicked", (id) => {
+                MenuItem menuItem = _items.GetMenuItem(id.ToString());
+                menuItem?.Click();
+            });
+           
+        }
+
+        /// <summary>
+        /// TODO: Menu (macOS) still to be implemented
+        /// Gets the application's dock menu.
+        /// </summary>
+        public async Task<Menu> GetMenu(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var taskCompletionSource = new TaskCompletionSource<Menu>();
+            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            {
+                BridgeConnector.Socket.On("dock-getMenu-completed", (menu) =>
+                {
+                    BridgeConnector.Socket.Off("dock-getMenu-completed");
+                    taskCompletionSource.SetResult(((JObject)menu).ToObject<Menu>());
+                });
+
+                BridgeConnector.Socket.Emit("dock-getMenu");
+
+                return await taskCompletionSource.Task
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Sets the image associated with this dock icon.
+        /// </summary>
+        /// <param name="image"></param>
+        public void SetIcon(string image)
+        {
+            BridgeConnector.Socket.Emit("dock-setIcon", image);
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Electron.cs

@@ -15,6 +15,11 @@
         /// </summary>
         public static App App { get { return App.Instance; } }
 
+        /// <summary>
+        /// Enable apps to automatically update themselves. Based on electron-updater.
+        /// </summary>
+        public static AutoUpdater AutoUpdater { get { return AutoUpdater.Instance; } }
+
         /// <summary>
         /// Control your windows.
         /// </summary>
@@ -59,5 +64,29 @@
         /// Perform copy and paste operations on the system clipboard.
         /// </summary>
         public static Clipboard Clipboard { get { return Clipboard.Instance; } }
+
+        /// <summary>
+        /// Allows you to execute native JavaScript/TypeScript code from the host process.
+        /// 
+        /// It is only possible if the Electron.NET CLI has previously added an 
+        /// ElectronHostHook directory:
+        /// <c>electronize add HostHook</c>
+        /// </summary>
+        public static HostHook HostHook { get { return HostHook.Instance; } }
+
+        /// <summary>
+        /// Allows you to execute native Lock and Unlock process.       
+        /// </summary>
+        public static PowerMonitor PowerMonitor { get { return PowerMonitor.Instance; } }
+
+        /// <summary>
+        /// Read and respond to changes in Chromium's native color theme.
+        /// </summary>
+        public static NativeTheme NativeTheme { get { return NativeTheme.Instance; } }
+
+        /// <summary>
+        /// Control your app in the macOS dock.
+        /// </summary>
+        public static Dock Dock { get { return Dock.Instance; } }
     }
-}
+}

ElectronNET.API/ElectronNET.API.csproj

@@ -1,45 +1,48 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageOutputPath>..\artifacts</PackageOutputPath>
     <PackageId>ElectronNET.API</PackageId>
-    <Authors>Gregor Biswanger, Robert Muehsig</Authors>
+    <Authors>Gregor Biswanger, Florian Rappl</Authors>
     <Company />
     <Product>Electron.NET</Product>
-    <PackageLicenseUrl>https://github.com/ElectronNET/Electron.NET/blob/master/LICENSE</PackageLicenseUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/ElectronNET/Electron.NET/</PackageProjectUrl>
-    <Description>Building cross platform electron based desktop apps with .NET Core and ASP.NET NET Core.
+    <Description>Building cross platform electron based desktop apps with .NET Core and ASP.NET Core.
 This package contains the API to access the "native" electron API.</Description>
     <RepositoryUrl>https://github.com/ElectronNET/Electron.NET/</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <PackageTags>electron aspnetcore</PackageTags>
     <PackageReleaseNotes>Changelog: https://github.com/ElectronNET/Electron.NET/blob/master/Changelog.md</PackageReleaseNotes>
-    <PackageIconUrl>https://raw.githubusercontent.com/ElectronNET/Electron.NET/master/assets/images/electron.net-logo-square.png</PackageIconUrl>
+    <PackageIcon>PackageIcon.png</PackageIcon>
+    <Version>99.0.0.0</Version>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DocumentationFile>bin\Debug\netcoreapp2.0\ElectronNET.API.xml</DocumentationFile>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <DocumentationFile>bin\Release\netcoreapp2.0\ElectronNET.API.xml</DocumentationFile>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DocumentationFile>bin\Debug\netcoreapp2.0\ElectronNET.API.xml</DocumentationFile>
-  </PropertyGroup>
-
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Hosting.Abstractions" Version="2.0.0" />
-    <PackageReference Include="SocketIoClientDotNet" Version="1.0.3" />
+    <None Include="PackageIcon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
-
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' == 'Windows_NT'">
     <Exec Command="$(ProjectDir)devCleanup.cmd" IgnoreExitCode="true" />
   </Target>
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(OS)' != 'Windows_NT'">
     <Exec Command="$(ProjectDir)devCleanup.sh" IgnoreExitCode="true" />
   </Target>
-
-</Project>
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="SocketIOClient" Version="3.0.8" />
+    <PackageReference Include="SocketIOClient.Newtonsoft.Json" Version="3.0.7" />
+    <PackageReference Include="System.Drawing.Common" Version="7.0.0" />
+    <PackageReference Include="Microsoft.DotNet.UpgradeAssistant.Extensions.Default.Analyzers" Version="0.4.410601">
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+</Project>

ElectronNET.API/Entities/AboutPanelOptions.cs

@@ -1,7 +1,7 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// About panel options.
     /// </summary>
     public class AboutPanelOptions
     {
@@ -20,14 +20,29 @@
         /// </summary>
         public string Copyright { get; set; }
 
+        /// <summary>
+        /// The app's build version number.
+        /// </summary>
+        public string Version { get; set; }
+
         /// <summary>
         /// Credit information.
         /// </summary>
         public string Credits { get; set; }
 
         /// <summary>
-        /// The app's build version number.
+        /// List of app authors.
         /// </summary>
-        public string Version { get; set; }
+        public string[] Authors { get; set; }
+
+        /// <summary>
+        /// The app's website.
+        /// </summary>
+        public string Website { get; set; }
+
+        /// <summary>
+        /// Path to the app's icon. On Linux, will be shown as 64x64 pixels while retaining aspect ratio.
+        /// </summary>
+        public string IconPath { get; set; }
     }
 }

ElectronNET.API/Entities/AddRepresentationOptions.cs

@@ -0,0 +1,33 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class AddRepresentationOptions
+    {
+        /// <summary>
+        /// Gets or sets the width
+        /// </summary>
+        public int? Width { get; set; }
+
+        /// <summary>
+        /// Gets or sets the height
+        /// </summary>
+        public int? Height { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+
+        /// <summary>
+        /// Gets or sets the buffer
+        /// </summary>
+        public byte[] Buffer { get; set; }
+
+        /// <summary>
+        /// Gets or sets the dataURL
+        /// </summary>
+        public string DataUrl { get; set; } 
+    }
+}

ElectronNET.API/Entities/AutoResizeOptions.cs

@@ -0,0 +1,38 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class AutoResizeOptions
+    {
+        /// <summary>
+        /// If `true`, the view's width will grow and shrink together with the window.
+        /// `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Width { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's height will grow and shrink together with the window.
+        /// `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Height { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's x position and width will grow and shrink proportionally
+        /// with the window. `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Horizontal { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's y position and height will grow and shrink proportionally
+        /// with the window. `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Vertical { get; set; } = false;
+    }
+}

ElectronNET.API/Entities/BitmapOptions.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class BitmapOptions
+    {
+        /// <summary>
+        /// Gets or sets the scale factor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/Blob.cs

@@ -0,0 +1,18 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class Blob : IPostData
+    {
+        /// <summary>
+        /// The object represents a Blob
+        /// </summary>
+        public string Type { get; } = "blob";
+
+        /// <summary>
+        /// The UUID of the Blob being uploaded
+        /// </summary>
+        public string BlobUUID { get; set; }
+    }
+}

ElectronNET.API/Entities/BlockMapDataHolder.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class BlockMapDataHolder
+    {
+        /// <summary>
+        /// The file size. Used to verify downloaded size (save one HTTP request to get length).
+        /// Also used when block map data is embedded into the file(appimage, windows web installer package).
+        /// </summary>
+        public double Size { get; set; }
+
+        /// <summary>
+        /// The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package).
+        /// This information can be obtained from the file itself, but it requires additional HTTP request,
+        /// so, to reduce request count, block map size is specified in the update metadata too.
+        /// </summary>
+        public double BlockMapSize { get; set; }
+
+        /// <summary>
+        /// The file checksum.
+        /// </summary>
+        public string Sha512 { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool IsAdminRightsRequired { get; set; }
+    }
+}

ElectronNET.API/Entities/BrowserViewConstructorOptions.cs

@@ -0,0 +1,25 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class BrowserViewConstructorOptions
+    {
+        /// <summary>
+        /// See BrowserWindow.
+        /// </summary>
+        public WebPreferences WebPreferences { get; set; }
+
+        /// <summary>
+        /// A proxy to set on creation in the format host:port.
+        /// The proxy can be alternatively set using the BrowserView.WebContents.SetProxyAsync function.
+        /// </summary>
+        public string Proxy { get; set; }
+
+        /// <summary>
+        /// The credentials of the Proxy in the format username:password.
+        /// These will only be used if the Proxy field is also set.
+        /// </summary>
+        public string ProxyCredentials { get; set; }
+    }
+}

ElectronNET.API/Entities/BrowserWindowOptions.cs

@@ -12,24 +12,24 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// Window's width in pixels. Default is 800.
         /// </summary>
-        public int Width { get; set; }
+        public int Width { get; set; } = 800;
 
         /// <summary>
         /// Window's height in pixels. Default is 600.
         /// </summary>
-        public int Height { get; set; }
+        public int Height { get; set; } = 600;
 
         /// <summary>
         /// ( if y is used) Window's left offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int X { get; set; }
+        public int X { get; set; } = -1;
 
         /// <summary>
         /// ( if x is used) Window's top offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int Y { get; set; }
+        public int Y { get; set; } = -1;
 
         /// <summary>
         /// The width and height would be used as web page's size, which means the actual
@@ -258,5 +258,17 @@ namespace ElectronNET.API.Entities
         /// Settings of web page's features.
         /// </summary>
         public WebPreferences WebPreferences { get; set; }
+
+        /// <summary>
+        /// A proxy to set on creation in the format host:port.
+        /// The proxy can be alternatively set using the BrowserWindow.WebContents.SetProxyAsync function.
+        /// </summary>
+        public string Proxy { get; set; }
+
+        /// <summary>
+        /// The credentials of the Proxy in the format username:password.
+        /// These will only be used if the Proxy field is also set.
+        /// </summary>
+        public string ProxyCredentials { get; set; }
     }
 }

ElectronNET.API/Entities/CPUUsage.cs

@@ -5,15 +5,15 @@
     /// </summary>
     public class CPUUsage
     {
+        /// <summary>
+        /// Percentage of CPU used since the last call to getCPUUsage. First call returns 0.
+        /// </summary>
+        public int PercentCPUUsage { get; set; }
+
         /// <summary>
         /// The number of average idle cpu wakeups per second since the last call to 
         /// getCPUUsage.First call returns 0.
         /// </summary>
         public int IdleWakeupsPerSecond { get; set; }
-
-        /// <summary>
-        /// Percentage of CPU used since the last call to getCPUUsage. First call returns 0.
-        /// </summary>
-        public int PercentCPUUsage { get; set; }
     }
 }

ElectronNET.API/Entities/ChromeExtensionInfo.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Provide metadata about the current loaded Chrome extension
+    /// </summary>
+    public class ChromeExtensionInfo
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ChromeExtensionInfo"/> class.
+        /// </summary>
+        /// <param name="name">The name of the Chrome extension.</param>
+        /// <param name="version">The version of the Chrome extension.</param>
+        public ChromeExtensionInfo(string name, string version)
+        {
+            Name = name;
+            Version = version;
+        }
+
+        /// <summary>
+        /// Name of the Chrome extension
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Version of the Chrome extension
+        /// </summary>
+        public string Version { get; set; }
+    }
+}

ElectronNET.API/Entities/ClearStorageDataOptions.cs

@@ -0,0 +1,24 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ClearStorageDataOptions
+    {
+        /// <summary>
+        /// Should follow window.location.origin’s representation scheme://host:port.
+        /// </summary>
+        public string Origin { get; set; }
+
+        /// <summary>
+        /// The types of storages to clear, can contain: appcache, cookies, filesystem,
+        /// indexdb, localstorage, shadercache, websql, serviceworkers, cachestorage.
+        /// </summary>
+        public string[] Storages { get; set; }
+
+        /// <summary>
+        /// The types of quotas to clear, can contain: temporary, persistent, syncable.
+        /// </summary>
+        public string[] Quotas { get; set; }
+    }
+}

ElectronNET.API/Entities/Cookie.cs

@@ -0,0 +1,51 @@
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// 
+    /// </summary>
+    public class Cookie {
+        /// <summary>
+        /// The name of the cookie.
+        /// </summary>
+        public string Name { get; set;}
+
+        /// <summary>
+        /// The value of the cookie.
+        /// </summary>
+        public string Value { get; set; }
+
+        /// <summary>
+        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains.
+        /// </summary>
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is a host-only cookie; this will only be true if no domain was passed.
+        /// </summary>
+        public bool HostOnly { get; set; }
+
+        /// <summary>
+        /// (optional) - The path of the cookie.
+        /// </summary>
+        public string Path  { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as secure.
+        /// </summary>
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as HTTP only.
+        /// </summary>
+        public bool HttpOnly  { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is a session cookie or a persistent cookie with an expiration date.
+        /// </summary>
+        public bool Session { get; set; }
+
+        /// <summary>
+        /// (optional) - The expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
+        /// </summary>
+        public long ExpirationDate { get; set; }
+    }
+}

ElectronNET.API/Entities/CookieChangedCause.cs

@@ -0,0 +1,38 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// The cause of the change 
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum CookieChangedCause 
+    {
+        /// <summary>
+        ///The cookie was changed directly by a consumer's action.
+        /// </summary>
+        [JsonProperty("explicit")]
+        @explicit,
+
+        /// <summary>
+        /// The cookie was automatically removed due to an insert operation that overwrote it.
+        /// </summary>
+        overwrite,
+
+        /// <summary>
+        ///  The cookie was automatically removed as it expired.
+        /// </summary>
+        expired,
+
+        /// <summary>
+        ///  The cookie was automatically evicted during garbage collection.
+        /// </summary>
+        evicted,
+
+        /// <summary>
+        ///   The cookie was overwritten with an already-expired expiration date.
+        /// </summary>
+        [JsonProperty("expired_overwrite")]
+        expiredOverwrite
+    }
+}

ElectronNET.API/Entities/CookieDetails.cs

@@ -0,0 +1,56 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities {
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CookieDetails {
+        /// <summary>
+        /// The URL to associate the cookie with. The callback will be rejected if the URL is invalid.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// (optional) - The name of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// (optional) - The value of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")] 
+        public string Value { get; set; }
+
+        /// <summary>
+        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")]
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - The path of the cookie. Empty by default if omitted.
+        /// </summary>
+        [DefaultValue("")] 
+        public string Path { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as secure. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)] 
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Whether the cookie is marked as HTTP only. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool HttpOnly { get; set; }
+
+        /// <summary>
+        /// (optional) - 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.
+        /// </summary>
+        [DefaultValue(0)]
+        public long ExpirationDate { get; set; }
+    }
+}

ElectronNET.API/Entities/CookieFilter.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ElectronNET.API.Entities 
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CookieFilter 
+    {
+        /// <summary>
+        /// (optional) - Retrieves cookies which are associated with url.Empty implies retrieving cookies of all URLs.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters cookies by name.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// (optional) - Retrieves cookies whose domains match or are subdomains of domains.
+        /// </summary>
+        public string Domain { get; set; }
+
+        /// <summary>
+        /// (optional) - Retrieves cookies whose path matches path.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters cookies by their Secure property.
+        /// </summary>
+        public bool Secure { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters out session or persistent cookies.
+        /// </summary>
+        public bool Session { get; set; }
+
+    }
+}

ElectronNET.API/Entities/CreateFromBitmapOptions.cs

@@ -0,0 +1,23 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CreateFromBitmapOptions
+    {
+        /// <summary>
+        /// Gets or sets the width
+        /// </summary>
+        public int? Width { get; set; }
+
+        /// <summary>
+        /// Gets or sets the height
+        /// </summary>
+        public int? Height { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/CreateFromBufferOptions.cs

@@ -0,0 +1,23 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CreateFromBufferOptions
+    {
+        /// <summary>
+        /// Gets or sets the width
+        /// </summary>
+        public int? Width { get; set; }
+
+        /// <summary>
+        /// Gets or sets the height
+        /// </summary>
+        public int? Height { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/CreateInterruptedDownloadOptions.cs

@@ -0,0 +1,67 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CreateInterruptedDownloadOptions
+    {
+        /// <summary>
+        /// Absolute path of the download.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// Complete URL chain for the download.
+        /// </summary>
+        public string[] UrlChain { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string MimeType { get; set; }
+
+        /// <summary>
+        /// Start range for the download.
+        /// </summary>
+        public int Offset { get; set; }
+
+        /// <summary>
+        /// Total length of the download.
+        /// </summary>
+        public int Length { get; set; }
+
+        /// <summary>
+        /// Last-Modified header value.
+        /// </summary>
+        public string LastModified { get; set; }
+
+        /// <summary>
+        /// ETag header value.
+        /// </summary>
+        public string ETag { get; set; }
+
+        /// <summary>
+        /// Time when download was started in number of seconds since UNIX epoch.
+        /// </summary>
+        public int StartTime { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="path">Absolute path of the download.</param>
+        /// <param name="urlChain">Complete URL chain for the download.</param>
+        /// <param name="offset">Start range for the download.</param>
+        /// <param name="length">Total length of the download.</param>
+        /// <param name="lastModified">Last-Modified header value.</param>
+        /// <param name="eTag">ETag header value.</param>
+        public CreateInterruptedDownloadOptions(string path, string[] urlChain, int offset, int length, string lastModified, string eTag)
+        {
+            Path = path;
+            UrlChain = urlChain;
+            Offset = offset;
+            Length = length;
+            LastModified = lastModified;
+            ETag = eTag;
+        }
+    }
+}

ElectronNET.API/Entities/DockBounceType.cs

@@ -1,18 +1,22 @@
-namespace ElectronNET.API
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the DockBounceType enumeration.
     /// </summary>
     public enum DockBounceType
     {
         /// <summary>
-        /// The critical
+        /// Dock icon will bounce until either the application becomes active or the request is canceled.
         /// </summary>
-        critical,
+        [Description("critical")]
+        Critical,
 
         /// <summary>
-        /// The informational
+        /// The dock icon will bounce for one second.
         /// </summary>
-        informational
+        [Description("informational")]
+        Informational
     }
 }

ElectronNET.API/Entities/EnableNetworkEmulationOptions.cs

@@ -0,0 +1,28 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EnableNetworkEmulationOptions
+    {
+        /// <summary>
+        /// Whether to emulate network outage. Defaults to false.
+        /// </summary>
+        public bool Offline { get; set; } = false;
+
+        /// <summary>
+        /// RTT in ms. Defaults to 0 which will disable latency throttling.
+        /// </summary>
+        public int Latency { get; set; }
+
+        /// <summary>
+        /// Download rate in Bps. Defaults to 0 which will disable download throttling.
+        /// </summary>
+        public int DownloadThroughput { get; set; }
+
+        /// <summary>
+        /// Upload rate in Bps. Defaults to 0 which will disable upload throttling.
+        /// </summary>
+        public int UploadThroughput { get; set; }
+    }
+}

ElectronNET.API/Entities/Error.cs

@@ -1,16 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public class Error
-    {
-        /// <summary>
-        /// Gets or sets the stack.
-        /// </summary>
-        /// <value>
-        /// The stack.
-        /// </value>
-        public string Stack { get; set; }
-    }
-}

ElectronNET.API/Entities/Extension.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Docs: https://electronjs.org/docs/api/structures/extension
+    /// </summary>
+    public class Extension
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Copy of the extension's manifest data.
+        /// </summary>
+        public dynamic Manifest { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The extension's file path.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// The extension's `chrome-extension://` URL.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Version { get; set; }
+    }
+}

ElectronNET.API/Entities/FocusOptions.cs

@@ -0,0 +1,15 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Controls the behavior of <see cref="App.Focus(FocusOptions)"/>.
+    /// </summary>
+    public class FocusOptions
+    {
+        /// <summary>
+        /// Make the receiver the active app even if another app is currently active.
+        /// <para/>
+        /// You should seek to use the <see cref="Steal"/> option as sparingly as possible.
+        /// </summary>
+        public bool Steal { get; set; }
+    }
+}

ElectronNET.API/Entities/GPUFeatureStatus.cs

@@ -8,77 +8,77 @@ namespace ElectronNET.API.Entities
     public class GPUFeatureStatus
     {
         /// <summary>
-        /// Canvas
+        /// Canvas.
         /// </summary>
         [JsonProperty("2d_canvas")]
         public string Canvas { get; set; }
 
         /// <summary>
-        /// Flash
+        /// Flash.
         /// </summary>
         [JsonProperty("flash_3d")]
         public string Flash3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D
+        /// Flash Stage3D.
         /// </summary>
         [JsonProperty("flash_stage3d")]
         public string FlashStage3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D Baseline profile
+        /// Flash Stage3D Baseline profile.
         /// </summary>
         [JsonProperty("flash_stage3d_baseline")]
         public string FlashStage3dBaseline { get; set; }
 
         /// <summary>
-        /// Compositing
+        /// Compositing.
         /// </summary>
         [JsonProperty("gpu_compositing")]
         public string GpuCompositing { get; set; }
 
         /// <summary>
-        /// Multiple Raster Threads
+        /// Multiple Raster Threads.
         /// </summary>
         [JsonProperty("multiple_raster_threads")]
         public string MultipleRasterThreads { get; set; }
 
         /// <summary>
-        /// Native GpuMemoryBuffers
+        /// Native GpuMemoryBuffers.
         /// </summary>
         [JsonProperty("native_gpu_memory_buffers")]
         public string NativeGpuMemoryBuffers { get; set; }
 
         /// <summary>
-        /// Rasterization
+        /// Rasterization.
         /// </summary>
         public string Rasterization { get; set; }
 
         /// <summary>
-        /// Video Decode
+        /// Video Decode.
         /// </summary>
         [JsonProperty("video_decode")]
         public string VideoDecode { get; set; }
 
         /// <summary>
-        /// Video Encode
+        /// Video Encode.
         /// </summary>
         [JsonProperty("video_encode")]
         public string VideoEncode { get; set; }
 
         /// <summary>
-        /// VPx Video Decode
+        /// VPx Video Decode.
         /// </summary>
         [JsonProperty("vpx_decode")]
         public string VpxDecode { get; set; }
 
         /// <summary>
-        /// WebGL
+        /// WebGL.
         /// </summary>
         public string Webgl { get; set; }
 
         /// <summary>
-        /// WebGL2
+        /// WebGL2.
         /// </summary>
         public string Webgl2 { get; set; }
     }

ElectronNET.API/Entities/HighlightMode.cs

@@ -1,23 +0,0 @@
-namespace ElectronNET.API.Entities
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    public enum HighlightMode
-    {
-        /// <summary>
-        /// Highlight the tray icon when it is clicked and also when its context menu is open. This is the default.
-        /// </summary>
-        selection,
-
-        /// <summary>
-        /// Always highlight the tray icon.
-        /// </summary>
-        always,
-
-        /// <summary>
-        /// Never highlight the tray icon.
-        /// </summary>
-        never
-    }
-}

ElectronNET.API/Entities/IPostData.cs

@@ -0,0 +1,16 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Interface to use Electrons PostData Object
+    /// </summary>
+    public interface IPostData
+    {
+        /// <summary>
+        /// One of the following:
+        /// rawData - <see cref="UploadRawData"/> The data is available as a Buffer, in the rawData field.
+        /// file - <see cref="UploadFile"/> The object represents a file. The filePath, offset, length and modificationTime fields will be used to describe the file.
+        /// blob - <see cref="Blob"/> The object represents a Blob. The blobUUID field will be used to describe the Blob.
+        /// </summary>
+        public string Type { get; }
+    }
+}

ElectronNET.API/Entities/InputEvent.cs

@@ -0,0 +1,81 @@
+using Newtonsoft.Json.Converters;
+using System.Collections.Generic;
+using ElectronNET.API.Converter;
+using Newtonsoft.Json;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class InputEvent
+    {
+        /// <summary>
+        /// Equivalent to KeyboardEvent.key.
+        /// </summary>
+        public string Key { get; set; } = "";
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.code.
+        /// </summary>
+        public string Code { get; set; } = "";
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.repeat.
+        /// </summary>
+        public bool IsAutoRepeat { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.isComposing.
+        /// </summary>
+        public bool IsComposing { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.shiftKey.
+        /// </summary>
+        public bool Shift { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.controlKey.
+        /// </summary>
+        public bool Control { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.altKey.
+        /// </summary>
+        public bool Alt { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.metaKey.
+        /// </summary>
+        public bool Meta { get; set; } = false;
+
+        /// <summary>
+        /// Equivalent to KeyboardEvent.location.
+        /// </summary>
+        public int Location { get; set; } = 0;
+
+        /// <summary>
+        /// An array of modifiers of the event, can be `shift`, `control`, `ctrl`, `alt`,
+        /// `meta`, `command`, `cmd`, `isKeypad`, `isAutoRepeat`, `leftButtonDown`,
+        /// `middleButtonDown`, `rightButtonDown`, `capsLock`, `numLock`, `left`, `right`
+        /// </summary>
+        [JsonConverter(typeof(ModifierTypeListConverter))]
+        public List<ModifierType> Modifiers { get; set; }
+
+        /// <summary>
+        /// Can be `undefined`, `mouseDown`, `mouseUp`, `mouseMove`, `mouseEnter`,
+        /// `mouseLeave`, `contextMenu`, `mouseWheel`, `rawKeyDown`, `keyDown`, `keyUp`,
+        /// `gestureScrollBegin`, `gestureScrollEnd`, `gestureScrollUpdate`,
+        /// `gestureFlingStart`, `gestureFlingCancel`, `gesturePinchBegin`,
+        /// `gesturePinchEnd`, `gesturePinchUpdate`, `gestureTapDown`, `gestureShowPress`,
+        /// `gestureTap`, `gestureTapCancel`, `gestureShortPress`, `gestureLongPress`,
+        /// `gestureLongTap`, `gestureTwoFingerTap`, `gestureTapUnconfirmed`,
+        /// `gestureDoubleTap`, `touchStart`, `touchMove`, `touchEnd`, `touchCancel`,
+        /// `touchScrollStarted`, `pointerDown`, `pointerUp`, `pointerMove`,
+        /// `pointerRawUpdate`, `pointerCancel` or `pointerCausedUaAction`.
+        /// </summary>
+        [JsonConverter(typeof(StringEnumConverter))]
+        public InputEventType Type { get; set; }
+    }
+}

ElectronNET.API/Entities/InputEventType.cs

@@ -0,0 +1,201 @@
+namespace ElectronNET.API.Entities;
+
+/// <summary>
+/// 
+/// </summary>
+public enum InputEventType
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    undefined,
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseDown,
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseUp,
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseMove,
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseEnter,
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseLeave,
+    /// <summary>
+    /// 
+    /// </summary>
+    contextMenu,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    mouseWheel,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    rawKeyDown,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    keyDown,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    keyUp,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureScrollBegin,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureScrollEnd,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureScrollUpdate,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureFlingStart,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureFlingCancel,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gesturePinchBegin,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gesturePinchEnd,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gesturePinchUpdate,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureTapDown,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureShowPress,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureTap,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureTapCancel,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureShortPress,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureLongPress,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureLongTap,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureTwoFingerTap,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureTapUnconfirmed,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    gestureDoubleTap,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    touchStart,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    touchMove,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    touchEnd,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    touchCancel,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    touchScrollStarted,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerDown,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerUp,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerMove,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerRawUpdate,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerCancel,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    pointerCausedUaAction
+}

ElectronNET.API/Entities/JumpListCategory.cs

@@ -1,8 +1,7 @@
-using ElectronNET.API.Entities;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
@@ -25,4 +24,4 @@ namespace ElectronNET.API
         [JsonConverter(typeof(StringEnumConverter))]
         public JumpListCategoryType Type { get; set; }
     }
-}
+}

ElectronNET.API/Entities/JumpListCategoryType.cs

@@ -1,4 +1,4 @@
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 

ElectronNET.API/Entities/JumpListSettings.cs

@@ -6,13 +6,16 @@
     public class JumpListSettings
     {
         /// <summary>
-        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the MSDN docs).
+        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the
+        /// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd378398(v=vs.85).aspx">MSDN</see> docs).
         /// </summary>
         public int MinItems { get; set; } = 0;
 
         /// <summary>
-        /// 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 next call to app.setJumpList(), Windows will not display any custom category that contains any of the removed items.
+        /// 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 next call to <see cref="App.SetJumpList"/>, Windows will
+        /// not display any custom category that contains any of the removed items.
         /// </summary>
         public JumpListItem[] RemovedItems { get; set; } = new JumpListItem[0];
     }
-}
+}

ElectronNET.API/Entities/LoadURLOptions.cs

@@ -21,5 +21,16 @@
         /// files.
         /// </summary>
         public string BaseURLForDataURL { get; set; }
+
+        /// <summary>
+        /// Extra headers for the request.
+        /// </summary>
+        public string ExtraHeaders { get; set; }
+
+        /// <summary>
+        /// PostData Object for the request.
+        /// Can be <see cref="UploadRawData"/>, <see cref="UploadFile"/> or <see cref="Blob"/>
+        /// </summary>
+        public IPostData[] PostData { get; set; }
     }
 }

ElectronNET.API/Entities/LoginItemSettings.cs

@@ -6,33 +6,33 @@
     public class LoginItemSettings
     {
         /// <summary>
-        /// true if the app is set to open at login.
+        /// <see langword="true"/> if the app is set to open at login.
         /// </summary>
         public bool OpenAtLogin { get; set; }
 
         /// <summary>
-        /// true if the app is set to open as hidden at login. This setting is only 
-        /// supported on macOS.
+        /// <see langword="true"/> if the app is set to open as hidden at login. This setting is not available
+        /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool OpenAsHidden { get; set; }
 
         /// <summary>
-        /// true if the app was opened at login automatically. This setting is only 
-        /// supported on macOS.
+        /// <see langword="true"/> if the app was opened at login automatically. This setting is not available
+        /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool WasOpenedAtLogin { get; set; }
 
         /// <summary>
-        /// 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 only supported on macOS.
+        /// <see langword="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
+        /// <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool WasOpenedAsHidden { get; set; }
 
         /// <summary>
-        /// 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 only supported
-        /// on macOS.
+        /// <see langword="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 <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool RestoreState { get; set; }
     }

ElectronNET.API/Entities/LoginSettings.cs

@@ -6,16 +6,15 @@
     public class LoginSettings
     {
         /// <summary>
-        /// true to open the app at login, false to remove the app as a login item. Defaults
-        /// to false.
+        /// <see langword="true"/> to open the app at login, <see langword="false"/> to remove the app as a login item.
+        /// Defaults to <see langword="false"/>.
         /// </summary>
         public bool OpenAtLogin { get; set; }
 
         /// <summary>
-        /// true to open the app as hidden. Defaults to false. The user can edit this
-        /// setting from the System Preferences so
-        /// app.getLoginItemStatus().wasOpenedAsHidden should be checked when the app is
-        /// opened to know the current value.This setting is only supported on macOS.
+        /// <see langword="true"/> to open the app as hidden. Defaults to <see langword="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 <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
         public bool OpenAsHidden { get; set; }
 

ElectronNET.API/Entities/Margins.cs

@@ -0,0 +1,33 @@
+namespace ElectronNET.API.Entities;
+
+/// <summary>
+/// 
+/// </summary>
+public class Margins
+{
+    /// <summary>
+    /// Can be `default`, `none`, `printableArea`, or `custom`. If `custom` is chosen,
+    /// you will also need to specify `top`, `bottom`, `left`, and `right`.
+    /// </summary>
+    public string MarginType { get; set; }
+
+    /// <summary>
+    /// The top margin of the printed web page, in pixels.
+    /// </summary>
+    public int Top { get; set; }
+
+    /// <summary>
+    /// The bottom margin of the printed web page, in pixels.
+    /// </summary>
+    public int Bottom { get; set; }
+
+    /// <summary>
+    /// The left margin of the printed web page, in pixels.
+    /// </summary>
+    public int Left { get; set; }
+
+    /// <summary>
+    /// The right margin of the printed web page, in pixels.
+    /// </summary>
+    public int Right { get; set; }
+}

ElectronNET.API/Entities/MemoryInfo.cs

@@ -6,31 +6,19 @@
     public class MemoryInfo
     {
         /// <summary>
-        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
-        /// On macOS its value will always be 0.
+        /// The amount of memory currently pinned to actual physical RAM.
         /// </summary>
-        public int PeakWorkingSetSize { get; set; }
+        public int WorkingSetSize { get; set; }
 
         /// <summary>
-        /// Process id of the process.
+        /// The maximum amount of memory that has ever been pinned to actual physical RAM. 
         /// </summary>
-        public int Pid { get; set; }
+        public int PeakWorkingSetSize { get; set; }
 
         /// <summary>
         /// The amount of memory not shared by other processes, such as JS heap or HTML
         /// content.
         /// </summary>
         public int PrivateBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory shared between processes, typically memory consumed by the 
-        /// Electron code itself
-        /// </summary>
-        public int SharedBytes { get; set; }
-
-        /// <summary>
-        /// The amount of memory currently pinned to actual physical RAM.
-        /// </summary>
-        public int WorkingSetSize {get; set; }
     }
-}
+}

ElectronNET.API/Entities/MenuItem.cs

@@ -1,6 +1,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using System;
+using System.ComponentModel;
 
 namespace ElectronNET.API.Entities
 {
@@ -68,12 +69,12 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// If false, the menu item will be greyed out and unclickable.
         /// </summary>
-        public bool Enabled { get; set; }
+        public bool Enabled { get; set; } = true;
 
         /// <summary>
         /// If false, the menu item will be entirely hidden.
         /// </summary>
-        public bool Visible { get; set; }
+        public bool Visible { get; set; } = true;
 
         /// <summary>
         /// Should only be specified for checkbox or radio type menu items.

ElectronNET.API/Entities/MenuRole.cs

@@ -8,7 +8,7 @@
         /// <summary>
         /// The undo
         /// </summary>
-        undo,
+        undo = 1,
 
         /// <summary>
         /// The redo

ElectronNET.API/Entities/ModifierType.cs

@@ -0,0 +1,87 @@
+namespace ElectronNET.API.Entities;
+
+/// <summary>
+/// Specifies the possible modifier keys for a keyboard input.
+/// </summary>
+public enum ModifierType
+{
+    /// <summary>
+    /// The Shift key.
+    /// </summary>
+    shift,
+
+    /// <summary>
+    /// The Control key.
+    /// </summary>
+    control,
+
+    /// <summary>
+    /// The Control key (alias for control).
+    /// </summary>
+    ctrl,
+
+    /// <summary>
+    /// The Alt key.
+    /// </summary>
+    alt,
+
+    /// <summary>
+    /// The Meta key.
+    /// </summary>
+    meta,
+
+    /// <summary>
+    /// The Command key.
+    /// </summary>
+    command,
+
+    /// <summary>
+    /// The Command key (alias for command).
+    /// </summary>
+    cmd,
+
+    /// <summary>
+    /// Indicates whether the keypad modifier key is pressed.
+    /// </summary>
+    isKeypad,
+
+    /// <summary>
+    /// Indicates whether the key is an auto-repeated key.
+    /// </summary>
+    isAutoRepeat,
+
+    /// <summary>
+    /// Indicates whether the left mouse button is pressed.
+    /// </summary>
+    leftButtonDown,
+
+    /// <summary>
+    /// Indicates whether the middle mouse button is pressed.
+    /// </summary>
+    middleButtonDown,
+
+    /// <summary>
+    /// Indicates whether the right mouse button is pressed.
+    /// </summary>
+    rightButtonDown,
+
+    /// <summary>
+    /// The Caps Lock key.
+    /// </summary>
+    capsLock,
+
+    /// <summary>
+    /// The Num Lock key.
+    /// </summary>
+    numlock,
+
+    /// <summary>
+    /// The Left key.
+    /// </summary>
+    left,
+
+    /// <summary>
+    /// The Right key.
+    /// </summary>
+    right
+}

ElectronNET.API/Entities/NativeImage.cs

@@ -1,109 +1,453 @@
-namespace ElectronNET.API.Entities
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+
+namespace ElectronNET.API.Entities
 {
-    // TODO: Need some of real code :)
     /// <summary>
-    /// 
+    /// Native Image handler for Electron.NET
     /// </summary>
+    [JsonConverter(typeof(NativeImageJsonConverter))]
     public class NativeImage
     {
-        //        public static NativeImage CreateEmpty()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        private readonly Dictionary<float, Image> _images = new Dictionary<float, Image>();
+        private bool _isTemplateImage;
 
-        //        public static NativeImage CreateFromBuffer(byte[] buffer)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        private static readonly Dictionary<string, float> ScaleFactorPairs = new Dictionary<string, float>
+        {
+            {"@2x",   2.0f}, {"@3x",     3.0f}, {"@1x",     1.0f}, {"@4x",   4.0f},
+            {"@5x",   5.0f}, {"@1.25x", 1.25f}, {"@1.33x", 1.33f}, {"@1.4x", 1.4f},
+            {"@1.5x", 1.5f}, {"@1.8x",   1.8f}, {"@2.5x",   2.5f}
+        };
 
-        //        public static NativeImage CreateFromBuffer(byte[] buffer, CreateFromBufferOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        private static float? ExtractDpiFromFilePath(string filePath)
+        {
+            var withoutExtension = Path.GetFileNameWithoutExtension(filePath);
+            return ScaleFactorPairs
+                .Where(p => withoutExtension.EndsWith(p.Key))
+                .Select(p => p.Value)
+                .FirstOrDefault();
+        }
+        private static Image BytesToImage(byte[] bytes)
+        {
+            var ms = new MemoryStream(bytes);
+            return Image.FromStream(ms);
+        }
 
-        //        public static NativeImage CreateFromDataURL(string dataURL)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates an empty NativeImage
+        /// </summary>
+        public static NativeImage CreateEmpty()
+        {
+            return new NativeImage();
+        }
 
-        //        public static NativeImage CreateFromPath(string path)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// 
+        /// </summary>
+        public static NativeImage CreateFromBitmap(Bitmap bitmap, CreateFromBitmapOptions options = null)
+        {
+            if (options is null)
+            {
+                options = new CreateFromBitmapOptions();
+            }
 
-        //        public void AddRepresentation(AddRepresentationOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            return new NativeImage(bitmap, options.ScaleFactor);
+        }
 
-        //        public NativeImage Crop(Rectangle rect)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates a NativeImage from a byte array.
+        /// </summary>
+        public static NativeImage CreateFromBuffer(byte[] buffer, CreateFromBufferOptions options = null)
+        {
+            if (options is null)
+            {
+                options = new CreateFromBufferOptions();
+            }
 
-        //        public int GetAspectRatio()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            var ms = new MemoryStream(buffer);
+            var image = Image.FromStream(ms);
 
-        //        public byte[] GetBitmap()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            return new NativeImage(image, options.ScaleFactor);
+        }
 
-        //        public byte[] GetBitmap(BitmapOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates a NativeImage from a base64 encoded data URL.
+        /// </summary>
+        /// <param name="dataUrl">A data URL with a base64 encoded image.</param>
+        public static NativeImage CreateFromDataURL(string dataUrl)
+        {
+            var images = new Dictionary<float,Image>();
+            var parsedDataUrl = Regex.Match(dataUrl, @"data:image/(?<type>.+?),(?<data>.+)");
+            var actualData = parsedDataUrl.Groups["data"].Value;
+            var binData = Convert.FromBase64String(actualData);
 
-        //        public byte[] GetNativeHandle()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            var image = BytesToImage(binData);
 
-        //        public Size GetSize()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            images.Add(1.0f, image);
 
-        //        public bool IsEmpty()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            return new NativeImage(images);
+        }
 
-        //        public bool IsTemplateImage()
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates a NativeImage from an image on the disk.
+        /// </summary>
+        /// <param name="path">The path of the image</param>
+        public static NativeImage CreateFromPath(string path)
+        {
+            var images = new Dictionary<float,Image>();
+            if (Regex.IsMatch(path, "(@.+?x)"))
+            {
+                var dpi = ExtractDpiFromFilePath(path);
+                if (dpi == null)
+                {
+                    throw new Exception($"Invalid scaling factor for '{path}'.");
+                }
 
-        //        public NativeImage Resize(ResizeOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+                images[dpi.Value] = Image.FromFile(path);
+            }
+            else
+            {
+                var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
+                var extension = Path.GetExtension(path);
+                // Load as 1x dpi
+                images[1.0f] = Image.FromFile(path);
 
-        //        public void SetTemplateImage(bool option)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+                foreach (var scale in ScaleFactorPairs)
+                {
+                    var fileName = $"{fileNameWithoutExtension}{scale}.{extension}";
+                    if (File.Exists(fileName))
+                    {
+                        var dpi = ExtractDpiFromFilePath(fileName);
+                        if (dpi != null)
+                        {
+                            images[dpi.Value] = Image.FromFile(fileName);
+                        }
+                    }
+                }
+            }
 
-        //        public byte[] ToBitmap(ToBitmapOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+            return new NativeImage(images);
+        }
 
-        //        public string ToDataURL(ToDataURLOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates an empty NativeImage
+        /// </summary>
+        public NativeImage()
+        {
+        }
 
-        //        public byte[] ToJPEG(int quality)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates a NativeImage from a bitmap and scale factor
+        /// </summary>
+        public NativeImage(Image bitmap, float scaleFactor = 1.0f)
+        {
+            _images.Add(scaleFactor, bitmap);
+        }
 
-        //        public byte[] ToPNG(ToPNGOptions options)
-        //        {
-        //            throw new NotImplementedException();
-        //        }
+        /// <summary>
+        /// Creates a NativeImage from a dictionary of scales and images.
+        /// </summary>
+        public NativeImage(Dictionary<float, Image> imageDictionary)
+        {
+            _images = imageDictionary;
+        }
+
+        /// <summary>
+        /// Crops the image specified by the input rectangle and computes scale factor
+        /// </summary>
+        public NativeImage Crop(Rectangle rect)
+        {
+            var images = new Dictionary<float,Image>();
+            foreach (var image in _images)
+            {
+                images.Add(image.Key, Crop(rect.X, rect.Y, rect.Width, rect.Height, image.Key));
+            }
+
+            return new NativeImage(images);
+        }
+
+        /// <summary>
+        /// Resizes the image and computes scale factor
+        /// </summary>
+        public NativeImage Resize(ResizeOptions options)
+        {
+            var images = new Dictionary<float, Image>();
+            foreach (var image in _images)
+            {
+                images.Add(image.Key, Resize(options.Width, options.Height, image.Key));
+            }
+
+            return new NativeImage(images);
+        }
+
+        /// <summary>
+        /// Add an image representation for a specific scale factor.
+        /// </summary>
+        /// <param name="options"></param>
+        public void AddRepresentation(AddRepresentationOptions options)
+        {
+            if (options.Buffer.Length > 0)
+            {
+                _images[options.ScaleFactor] =
+                    CreateFromBuffer(options.Buffer, new CreateFromBufferOptions {ScaleFactor = options.ScaleFactor})
+                        .GetScale(options.ScaleFactor);
+            }
+            else if (!string.IsNullOrEmpty(options.DataUrl))
+            {
+                _images[options.ScaleFactor] = CreateFromDataURL(options.DataUrl).GetScale(options.ScaleFactor);
+            }
+        }
+
+        /// <summary>
+        /// Gets the aspect ratio for the image based on scale factor
+        /// </summary>
+        /// <param name="scaleFactor">Optional</param>
+        public float GetAspectRatio(float scaleFactor = 1.0f)
+        {
+            var image = GetScale(scaleFactor);
+            if (image != null)
+            {
+                return image.Width / image.Height;
+            }
+
+            return 0f;
+        }
+
+        /// <summary>
+        /// Returns a byte array that contains the image's raw bitmap pixel data.
+        /// </summary>
+        public byte[] GetBitmap(BitmapOptions options)
+        {
+            return ToBitmap(new ToBitmapOptions{ ScaleFactor = options.ScaleFactor });
+        }
+
+        /// <summary>
+        /// Returns a byte array that contains the image's raw bitmap pixel data.
+        /// </summary>
+        public byte[] GetNativeHandle()
+        {
+            return ToBitmap(new ToBitmapOptions());
+        }
+
+        /// <summary>
+        /// Gets the size of the specified image based on scale factor
+        /// </summary>
+        public Size GetSize(float scaleFactor = 1.0f)
+        {
+            if (_images.ContainsKey(scaleFactor))
+            {
+                var image = _images[scaleFactor];
+                return new Size
+                {
+                    Width = image.Width,
+                    Height = image.Height
+                };
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Checks to see if the NativeImage instance is empty.
+        /// </summary>
+        public bool IsEmpty()
+        {
+            return _images.Count <= 0;
+        }
+
+        /// <summary>
+        /// Deprecated. Whether the image is a template image.
+        /// </summary>
+        public bool IsTemplateImage => _isTemplateImage;
+
+        /// <summary>
+        /// Deprecated. Marks the image as a template image.
+        /// </summary>
+        public void SetTemplateImage(bool option)
+        {
+            _isTemplateImage = option;
+        }
+
+        /// <summary>
+        /// Outputs a bitmap based on the scale factor
+        /// </summary>
+        public byte[] ToBitmap(ToBitmapOptions options)
+        {
+            return ImageToBytes(ImageFormat.Bmp, options.ScaleFactor);
+        }
+
+        /// <summary>
+        /// Outputs a data URL based on the scale factor
+        /// </summary>
+        public string ToDataURL(ToDataUrlOptions options)
+        {
+            if (!_images.ContainsKey(options.ScaleFactor))
+            {
+                return null;
+            }
+
+            var image = _images[options.ScaleFactor];
+            var mimeType = ImageCodecInfo.GetImageEncoders().FirstOrDefault(x => x.FormatID == image.RawFormat.Guid)?.MimeType;
+            if (mimeType is null)
+            {
+                mimeType = "image/png";
+            }
+
+            var bytes = ImageToBytes(image.RawFormat, options.ScaleFactor);
+            var base64 = Convert.ToBase64String(bytes);
+
+            return $"data:{mimeType};base64,{base64}";
+        }
+
+        /// <summary>
+        /// Outputs a JPEG for the default scale factor
+        /// </summary>
+        public byte[] ToJPEG(int quality)
+        {
+            return ImageToBytes(ImageFormat.Jpeg, 1.0f, quality);
+        }
+
+        /// <summary>
+        /// Outputs a PNG for the specified scale factor
+        /// </summary>
+        public byte[] ToPNG(ToPNGOptions options)
+        {
+            return ImageToBytes(ImageFormat.Png, options.ScaleFactor);
+        }
+
+        private byte[] ImageToBytes(ImageFormat imageFormat = null, float scaleFactor = 1.0f, int quality = 100)
+        {
+            using var ms = new MemoryStream();
+
+            if (_images.ContainsKey(scaleFactor))
+            {
+                var image = _images[scaleFactor];
+                var encoderCodecInfo = GetEncoder(imageFormat ?? image.RawFormat);
+                var encoder = Encoder.Quality;
+
+                var encoderParameters = new EncoderParameters(1)
+                {
+                    Param = new[]
+                    {
+                        new EncoderParameter(encoder, quality)
+                    }
+                };
+
+                image.Save(ms, encoderCodecInfo, encoderParameters);
+
+                return ms.ToArray();
+            }
+
+            return null;
+        }
+
+        private Image Resize(int? width, int? height, float scaleFactor = 1.0f)
+        {
+            if (!_images.ContainsKey(scaleFactor) || (width is null && height is null))
+            {
+                return null;
+            }
+
+            var image = _images[scaleFactor];
+            using (var g = Graphics.FromImage(image))
+            {
+                g.CompositingQuality = CompositingQuality.HighQuality;
+
+                var aspect = GetAspectRatio(scaleFactor);
+
+                width ??= Convert.ToInt32(image.Width * aspect);
+                height ??= Convert.ToInt32(image.Height * aspect);
+
+                width = Convert.ToInt32(width * scaleFactor);
+                height = Convert.ToInt32(height * scaleFactor);
+
+                var bmp = new Bitmap(width.Value, height.Value);
+                g.DrawImage(bmp,
+                    new System.Drawing.Rectangle(0, 0, image.Width, image.Height),
+                    new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height),
+                    GraphicsUnit.Pixel);
+
+                return bmp;
+            }
+        }
+
+        private Image Crop(int? x, int? y, int? width, int? height, float scaleFactor = 1.0f)
+        {
+            if (!_images.ContainsKey(scaleFactor))
+            {
+                return null;
+            }
+
+            var image = _images[scaleFactor];
+            using (var g = Graphics.FromImage(image))
+            {
+                g.CompositingQuality = CompositingQuality.HighQuality;
+
+                x ??= 0;
+                y ??= 0;
+
+                x = Convert.ToInt32(x * scaleFactor);
+                y = Convert.ToInt32(y * scaleFactor);
+
+                width ??= image.Width;
+                height ??= image.Height;
+
+                width = Convert.ToInt32(width * scaleFactor);
+                height = Convert.ToInt32(height * scaleFactor);
+
+                var bmp = new Bitmap(width.Value, height.Value);
+                g.DrawImage(bmp, new System.Drawing.Rectangle(0, 0, image.Width, image.Height), new System.Drawing.Rectangle(x.Value, y.Value, width.Value, height.Value), GraphicsUnit.Pixel);
+
+                return bmp;
+            }
+        }
+
+        private ImageCodecInfo GetEncoder(ImageFormat format)
+        {
+            var codecs = ImageCodecInfo.GetImageDecoders();
+            foreach (ImageCodecInfo codec in codecs)
+            {
+                if (codec.FormatID == format.Guid)
+                {
+                    return codec;
+                }
+            }
+            return null;
+        }
+
+        internal Dictionary<float,string> GetAllScaledImages()
+        {
+            var dict = new Dictionary<float,string>();
+            try
+            {
+                foreach (var (scale, image) in _images)
+                {
+                    dict.Add(scale, Convert.ToBase64String(ImageToBytes(null, scale)));
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+            }
+            
+            return dict;
+        }
+
+        internal Image GetScale(float scaleFactor)
+        {
+            if (_images.ContainsKey(scaleFactor))
+            {
+                return _images[scaleFactor];
+            }
+
+            return null;
+        }
     }
 }

ElectronNET.API/Entities/NativeImageJsonConverter.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using Newtonsoft.Json;
+
+namespace ElectronNET.API.Entities
+{
+    internal class NativeImageJsonConverter : JsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is NativeImage nativeImage)
+            {
+                var scaledImages = nativeImage.GetAllScaledImages();
+                serializer.Serialize(writer, scaledImages);
+            }
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var dict = serializer.Deserialize<Dictionary<float, string>>(reader);
+            var newDictionary = new Dictionary<float, Image>();
+            foreach (var item in dict)
+            {
+                var bytes = Convert.FromBase64String(item.Value);
+                newDictionary.Add(item.Key, Image.FromStream(new MemoryStream(bytes)));
+            }
+            return new NativeImage(newDictionary);
+        }
+
+        public override bool CanConvert(Type objectType) => objectType == typeof(NativeImage);
+    }
+}

ElectronNET.API/Entities/NotificationOptions.cs

@@ -10,28 +10,28 @@ namespace ElectronNET.API.Entities
     {
         /// <summary>
         /// A title for the notification, which will be shown at the top of the notification
-        /// window when it is shown
+        /// window when it is shown.
         /// </summary>
         public string Title { get; set; }
 
+        /// <summary>
+        /// A subtitle for the notification, which will be displayed below the title.
+        /// </summary>
+        public string SubTitle { get; set; }
+
         /// <summary>
         /// The body text of the notification, which will be displayed below the title or
-        /// subtitle
+        /// subtitle.
         /// </summary>
         public string Body { get; set; }
 
         /// <summary>
-        /// A subtitle for the notification, which will be displayed below the title.
-        /// </summary>
-        public string Subtitle { get; set; }
-
-        /// <summary>
-        /// Whether or not to emit an OS notification noise when showing the notification
+        /// Whether or not to emit an OS notification noise when showing the notification.
         /// </summary>
         public bool Silent { get; set; }
 
         /// <summary>
-        /// An icon to use in the notification
+        /// An icon to use in the notification.
         /// </summary>
         public string Icon { get; set; }
 
@@ -40,6 +40,11 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public bool HasReply { get; set; }
 
+        /// <summary>
+        /// The timeout duration of the notification. Can be 'default' or 'never'.
+        /// </summary>
+        public string TimeoutType { get; set; }
+
         /// <summary>
         /// The placeholder to write in the inline reply input field.
         /// </summary>
@@ -50,16 +55,27 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public string Sound { get; set; }
 
+        /// <summary>
+        /// The urgency level of the notification. Can be 'normal', 'critical', or 'low'.
+        /// </summary>
+        public string Urgency { get; set; }
+
         /// <summary>
         /// Actions to add to the notification. Please read the available actions and
-        /// limitations in the NotificationAction documentation
+        /// limitations in the NotificationAction documentation.
         /// </summary>
         public NotificationAction Actions { get; set; }
 
         /// <summary>
-        /// 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.
+        /// A custom title for the close button of an alert. An empty string will cause the
+        /// default localized text to be used.
+        /// </summary>
+        public string CloseButtonText { get; set; }
+
+        /// <summary>
+        /// 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.
         /// </summary>
         [JsonIgnore]
         public Action OnShow { get; set; }
@@ -148,4 +164,4 @@ namespace ElectronNET.API.Entities
             Body = body;
         }
     }
-}
+}

ElectronNET.API/Entities/OpenExternalOptions.cs

@@ -1,16 +1,22 @@
-using System.ComponentModel;
+using System;
+using System.ComponentModel;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Controls the behavior of OpenExternal.
     /// </summary>
     public class OpenExternalOptions
     {
         /// <summary>
-        /// true to bring the opened application to the foreground. The default is true.
+        /// <see langword="true"/> to bring the opened application to the foreground. The default is <see langword="true"/>.
         /// </summary>
         [DefaultValue(true)]
         public bool Activate { get; set; } = true;
+
+        /// <summary>
+        /// The working directory.
+        /// </summary>
+        public string WorkingDirectory { get; set; }
     }
 }

ElectronNET.API/Entities/PathName.cs

@@ -1,79 +1,95 @@
-namespace ElectronNET.API.Entities
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the PathName enumeration.
     /// </summary>
     public enum PathName
     {
         /// <summary>
         /// User’s home directory.
         /// </summary>
-        home,
+        [Description("home")]
+        Home,
 
         /// <summary>
         /// Per-user application data directory.
         /// </summary>
-        appData,
+        [Description("appData")]
+        AppData,
 
         /// <summary>
         /// The directory for storing your app’s configuration files, 
         /// which by default it is the appData directory appended with your app’s name.
         /// </summary>
-        userData,
+        [Description("userData")]
+        UserData,
 
         /// <summary>
         /// Temporary directory.
         /// </summary>
-        temp,
+        [Description("temp")]
+        Temp,
 
         /// <summary>
         /// The current executable file.
         /// </summary>
-        exe,
+        [Description("exe")]
+        Exe,
 
         /// <summary>
         /// The libchromiumcontent library.
         /// </summary>
-        module,
+        [Description("Module")]
+        Module,
 
         /// <summary>
         /// The current user’s Desktop directory.
         /// </summary>
-        desktop,
+        [Description("desktop")]
+        Desktop,
 
         /// <summary>
         /// Directory for a user’s “My Documents”.
         /// </summary>
-        documents,
+        [Description("documents")]
+        Documents,
 
         /// <summary>
         /// Directory for a user’s downloads.
         /// </summary>
-        downloads,
+        [Description("downloads")]
+        Downloads,
 
         /// <summary>
         /// Directory for a user’s music.
         /// </summary>
-        music,
+        [Description("music")]
+        Music,
 
         /// <summary>
         /// Directory for a user’s pictures.
         /// </summary>
-        pictures,
+        [Description("pictures")]
+        Pictures,
 
         /// <summary>
         /// Directory for a user’s videos.
         /// </summary>
-        videos,
+        [Description("videos")]
+        Videos,
 
         /// <summary>
-        /// The logs
+        /// The logs.
         /// </summary>
-        logs,
+        [Description("logs")]
+        Logs,
 
         /// <summary>
         /// Full path to the system version of the Pepper Flash plugin.
         /// </summary>
-        pepperFlashSystemPlugin
+        [Description("PepperFlashSystemPlugin")]
+        PepperFlashSystemPlugin
     }
 }

ElectronNET.API/Entities/PrintOptions.cs

@@ -0,0 +1,107 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Print dpi
+    /// </summary>
+    public class PrintDpi
+    {
+        /// <summary>
+        /// The horizontal dpi
+        /// </summary>
+        public float Horizontal { get; set; }
+
+        /// <summary>
+        /// The vertical dpi
+        /// </summary>
+        public float Vertical { get; set; }
+    }
+
+    /// <summary>
+    /// The page range to print
+    /// </summary>
+    public class PrintPageRange
+    {
+        /// <summary>
+        /// From
+        /// </summary>
+        public int From { get; set; }
+
+        /// <summary>
+        /// To
+        /// </summary>
+        public int To { get; set; }
+    }
+
+    /// <summary>
+    /// Print options
+    /// </summary>
+    public class PrintOptions
+    {
+        /// <summary>
+        /// Don't ask user for print settings
+        /// </summary>
+        public bool Silent { get; set; }
+
+        /// <summary>
+        /// Prints the background color and image of the web page
+        /// </summary>
+        public bool PrintBackground { get; set; }
+
+        /// <summary>
+        /// Set the printer device name to use
+        /// </summary>
+        public string DeviceName { get; set; }
+
+        /// <summary>
+        /// Set whether the printed web page will be in color or grayscale
+        /// </summary>
+        public bool Color { get; set; }
+
+        /// <summary>
+        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
+        /// margin, and 2 for minimum margin.
+        /// </summary>
+        public int MarginsType { get; set; }
+
+        /// <summary>
+        /// true for landscape, false for portrait.
+        /// </summary>
+        public bool Landscape { get; set; }
+        
+        /// <summary>
+        /// The scale factor of the web page
+        /// </summary>
+        public float ScaleFactor { get; set; }
+
+        /// <summary>
+        /// The number of pages to print per page sheet
+        /// </summary>
+        public int PagesPerSheet { get; set; }
+
+        /// <summary>
+        /// The number of copies of the web page to print
+        /// </summary>
+        public bool Copies { get; set; }
+
+        /// <summary>
+        /// Whether the web page should be collated
+        /// </summary>
+        public bool Collate { get; set; }
+
+        /// <summary>
+        /// The page range to print
+        /// </summary>
+        public PrintPageRange PageRanges { get; set; }
+
+        /// <summary>
+        /// Set the duplex mode of the printed web page. Can be simplex, shortEdge, or longEdge.
+        /// </summary>
+        public string DuplexMode { get; set; }
+
+        /// <summary>
+        /// Dpi
+        /// </summary>
+        public PrintDpi Dpi { get; set; }
+
+    }
+}

ElectronNET.API/Entities/PrintToPDFOptions.cs

@@ -1,35 +1,63 @@
-namespace ElectronNET.API.Entities
+namespace ElectronNET.API.Entities;
+
+/// <summary>
+/// 
+/// </summary>
+public class PrintToPDFOptions
 {
     /// <summary>
-    /// 
+    /// Paper orientation. `true` for landscape, `false` for portrait. Defaults to false.
     /// </summary>
-    public class PrintToPDFOptions
-    {
-        /// <summary>
-        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
-        /// margin, and 2 for minimum margin.
-        /// </summary>
-        public int MarginsType { get; set; }
+    public bool Landscape { get; set; } = false;
 
-        /// <summary>
-        /// Specify page size of the generated PDF. Can be A3, A4, A5, Legal, Letter,
-        /// Tabloid or an Object containing height and width in microns.
-        /// </summary>
-        public string PageSize { get; set; }
+    /// <summary>
+    /// Whether to display header and footer. Defaults to false.
+    /// </summary>
+    public bool DisplayHeaderFooter { get; set; } = false;
 
-        /// <summary>
-        /// Whether to print CSS backgrounds.
-        /// </summary>
-        public bool PrintBackground { get; set; }
+    /// <summary>
+    /// Whether to print background graphics. Defaults to false.
+    /// </summary>
+    public bool PrintBackground { get; set; } = false;
 
-        /// <summary>
-        /// Whether to print selection only.
-        /// </summary>
-        public bool PrintSelectionOnly { get; set; }
+    /// <summary>
+    /// Scale of the webpage rendering. Defaults to 1.
+    /// </summary>
+    public double Scale { get; set; } = 1;
 
-        /// <summary>
-        /// true for landscape, false for portrait.
-        /// </summary>
-        public bool Landscape { get; set; }
-    }
+    /// <summary>
+    /// Specify page size of the generated PDF. Can be `A0`, `A1`, `A2`, `A3`, `A4`,
+    /// `A5`, `A6`, `Legal`, `Letter`, `Tabloid`, `Ledger`, or an Object containing
+    /// `height` and `width` in inches. Defaults to `Letter`.
+    /// </summary>
+    public string PageSize { get; set; } = "Letter";
+
+    /// <summary>
+    /// Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string,
+    /// which means print all pages.
+    /// </summary>
+    public string PageRanges { get; set; } = "";
+
+    /// <summary>
+    /// HTML template for the print header. Should be valid HTML markup with following
+    /// classes used to inject printing values into them: `date` (formatted print date),
+    /// `title` (document title), `url` (document location), `pageNumber` (current page
+    /// number) and `totalPages` (total pages in the document). For example, `<span class="title"></span>`
+    /// would generate span containing the title.
+    /// </summary>
+    public string HeaderTemplate { get; set; }
+
+    /// <summary>
+    /// HTML template for the print footer. Should use the same format as the
+    /// `headerTemplate`.
+    /// </summary>
+    public string FooterTemplate { get; set; }
+
+    /// <summary>
+    /// Whether or not to prefer page size as defined by css. Defaults to false, in
+    /// which case the content will be scaled to fit the paper size.
+    /// </summary>
+    public bool PreferCSSPageSize { get; set; } = false;
+
+    public Margins Margins { get; set; }
 }

ElectronNET.API/Entities/PrinterInfo.cs

@@ -0,0 +1,29 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Printer info
+    /// </summary>
+    public class PrinterInfo
+    {
+        /// <summary>
+        /// Name
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Name
+        /// </summary>
+        public string Description { get; set; }
+        
+        /// <summary>
+        /// Status
+        /// </summary>
+        public int Status { get; set; }
+
+        /// <summary>
+        /// Is default
+        /// </summary>
+        public bool IsDefault { get; set; }
+
+    }
+}

ElectronNET.API/Entities/ProcessMetric.cs

@@ -5,24 +5,42 @@
     /// </summary>
     public class ProcessMetric
     {
-      /// <summary>
-      /// CPU usage of the process.
-      /// </summary>
-      public CPUUsage Cpu { get; set; }
+        /// <summary>
+        /// Process id of the process.
+        /// </summary>
+        public int PId { get; set; }
 
-      /// <summary>
-      /// Memory information for the process.
-      /// </summary>
-      public MemoryInfo Memory {get; set;}
+        /// <summary>
+        /// Process type (Browser or Tab or GPU etc).
+        /// </summary>
+        public string Type { get; set; }
 
-      /// <summary>
-      /// Process id of the process.
-      /// </summary>
-      public int Pid { get; set; }
+        /// <summary>
+        /// CPU usage of the process.
+        /// </summary>
+        public CPUUsage Cpu { get; set; }
 
-      /// <summary>
-      /// Process type (Browser or Tab or GPU etc).
-      /// </summary>
-      public string Type { get; set; }
+        /// <summary>
+        /// Creation time for this process. The time is represented as number of milliseconds since epoch.
+        /// Since the <see cref="PId"/> can be reused after a process dies, it is useful to use both the <see cref="PId"/>
+        /// and the <see cref="CreationTime"/> to uniquely identify a process.
+        /// </summary>
+        public int CreationTime { get; set; }
+
+        /// <summary>
+        /// Memory information for the process.
+        /// </summary>
+        public MemoryInfo Memory { get; set; }
+
+        /// <summary>
+        /// Whether the process is sandboxed on OS level.
+        /// </summary>
+        public bool Sandboxed { get; set; }
+
+        /// <summary>
+        ///  One of the following values:
+        /// untrusted | low | medium | high | unknown
+        /// </summary>
+        public string IntegrityLevel { get; set; }
     }
-}
+}

ElectronNET.API/Entities/ProgressInfo.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ProgressInfo
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Progress { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string BytesPerSecond { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Percent { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Total { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Transferred { get; set; }
+    }
+}

ElectronNET.API/Entities/ProxyConfig.cs

@@ -0,0 +1,36 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ProxyConfig
+    {
+        /// <summary>
+        /// The URL associated with the PAC file.
+        /// </summary>
+        public string PacScript { get; set; }
+
+        /// <summary>
+        /// Rules indicating which proxies to use.
+        /// </summary>
+        public string ProxyRules { get; set; }
+
+        /// <summary>
+        /// Rules indicating which URLs should bypass the proxy settings.
+        /// </summary>
+        public string ProxyBypassRules { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pacScript">The URL associated with the PAC file.</param>
+        /// <param name="proxyRules">Rules indicating which proxies to use.</param>
+        /// <param name="proxyBypassRules">Rules indicating which URLs should bypass the proxy settings.</param>
+        public ProxyConfig(string pacScript, string proxyRules, string proxyBypassRules)
+        {
+            PacScript = pacScript;
+            ProxyRules = proxyRules;
+            ProxyBypassRules = proxyBypassRules;
+        }
+    }
+}

ElectronNET.API/Entities/RelaunchOptions.cs

@@ -1,7 +1,7 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Controls the behavior of <see cref="App.Relaunch(RelaunchOptions)"/>.
     /// </summary>
     public class RelaunchOptions
     {
@@ -21,4 +21,4 @@
         /// </value>
         public string ExecPath { get; set; }
     }
-}
+}

ElectronNET.API/Entities/ReleaseNoteInfo.cs

@@ -0,0 +1,18 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ReleaseNoteInfo
+    {
+        /// <summary>
+        /// The version.
+        /// </summary>
+        public string Version { get; set; }
+
+        /// <summary>
+        /// The note.
+        /// </summary>
+        public string Note { get; set; }
+    }
+}

ElectronNET.API/Entities/RemovePassword.cs

@@ -0,0 +1,53 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class RemovePassword
+    {
+        /// <summary>
+        /// When provided, the authentication info related to the origin will only be
+        /// removed otherwise the entire cache will be cleared.
+        /// </summary>
+        public string Origin { get; set; }
+
+        /// <summary>
+        /// Credentials of the authentication. Must be provided if removing by origin.
+        /// </summary>
+        public string Password { get; set; }
+
+        /// <summary>
+        /// Realm of the authentication. Must be provided if removing by origin.
+        /// </summary>
+        public string Realm { get; set; }
+
+        /// <summary>
+        /// Scheme of the authentication. Can be basic, digest, ntlm, negotiate. 
+        /// Must be provided if removing by origin.
+        /// </summary>
+        [JsonConverter(typeof(StringEnumConverter))]
+        public Scheme Scheme { get; set; }
+
+        /// <summary>
+        /// password.
+        /// </summary>
+        public string Type { get; set; }
+
+        /// <summary>
+        /// Credentials of the authentication. Must be provided if removing by origin.
+        /// </summary>
+        public string Username { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type">password.</param>
+        public RemovePassword(string type)
+        {
+            Type = type;
+        }
+    }
+}

ElectronNET.API/Entities/ResizeOptions.cs

@@ -0,0 +1,23 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ResizeOptions
+    {
+        /// <summary>
+        /// Gets or sets the width
+        /// </summary>
+        public int? Width { get; set; }
+
+        /// <summary>
+        /// Gets or sets the height
+        /// </summary>
+        public int? Height { get; set; }
+
+        /// <summary>
+        /// good, better, or best. Default is "best";
+        /// </summary>
+        public string Quality { get; set; } = "best";
+    }
+}

ElectronNET.API/Entities/Scheme.cs

@@ -0,0 +1,28 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public enum Scheme
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        basic,
+
+        /// <summary>
+        /// 
+        /// </summary>
+        digest,
+
+        /// <summary>
+        /// 
+        /// </summary>
+        ntlm,
+
+        /// <summary>
+        /// 
+        /// </summary>
+        negotiate
+    }
+}

ElectronNET.API/Entities/SemVer.cs

@@ -0,0 +1,59 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class SemVer
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+       public string  Raw { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool Loose { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public SemVerOptions Options { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Major { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Minor { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Patch { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Version { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string[] Build { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public string[] Prerelease { get; set; }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class SemVerOptions {
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool? Loose { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool? IncludePrerelease { get; set; }
+    }
+}

ElectronNET.API/Entities/ShortcutDetails.cs

@@ -1,38 +1,38 @@
-namespace ElectronNET.API
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Structure of a shortcut.
     /// </summary>
     public class ShortcutDetails
     {
         /// <summary>
-        /// The Application User Model ID. Default is empty.
+        /// The Application User Model ID. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string AppUserModelId { get; set; }
 
         /// <summary>
-        /// The arguments to be applied to target when launching from this shortcut. Default is empty.
+        /// The arguments to be applied to <see cref="Target"/> when launching from this shortcut. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Args { get; set; }
 
         /// <summary>
-        /// The working directory. Default is empty.
+        /// The working directory. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Cwd { get; set; }
 
         /// <summary>
-        /// The description of the shortcut. Default is empty.
+        /// The description of the shortcut. Default is <see cref="string.Empty"/>.
         /// </summary>
         public string Description { get; set; }
 
         /// <summary>
-        /// 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.
+        /// The path to the icon, can be a DLL or EXE. <see cref="Icon"/> and <see cref="IconIndex"/> have to be set
+        /// together. Default is <see cref="string.Empty"/>, which uses the target's icon.
         /// </summary>
         public string Icon { get; set; }
 
         /// <summary>
-        /// The resource ID of icon when icon is a DLL or EXE. Default is 0.
+        /// The resource ID of icon when <see cref="Icon"/> is a DLL or EXE. Default is 0.
         /// </summary>
         public int IconIndex { get; set; }
 

ElectronNET.API/Entities/ShortcutLinkOperation.cs

@@ -1,23 +1,28 @@
-namespace ElectronNET.API
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Defines the ShortcutLinkOperation enumeration.
     /// </summary>
     public enum ShortcutLinkOperation
     {
         /// <summary>
         /// Creates a new shortcut, overwriting if necessary.
         /// </summary>
-        create,
+        [Description("create")]
+        Create,
 
         /// <summary>
         /// Updates specified properties only on an existing shortcut.
         /// </summary>
-        update,
+        [Description("update")]
+        Update,
 
         /// <summary>
-        /// Overwrites an existing shortcut, fails if the shortcut doesn’t exist.
+        /// Overwrites an existing shortcut, fails if the shortcut doesn't exist.
         /// </summary>
-        replace
+        [Description("replace")]
+        Replace
     }
-}
+}

ElectronNET.API/Entities/ThemeSourceMode.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Defines the ThemeSourceMode enumeration.
+    /// </summary>
+    public enum ThemeSourceMode
+    {
+        /// <summary>
+        /// Operating system default.
+        /// </summary>
+        [Description("system")]
+        System,
+
+        /// <summary>
+        /// Light theme.
+        /// </summary>
+        [Description("light")]
+        Light,
+
+        /// <summary>
+        /// Dark theme.
+        /// </summary>
+        [Description("dark")]
+        Dark
+    }
+}

ElectronNET.API/Entities/ToBitmapOptions.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ToBitmapOptions
+    {
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/ToDataUrlOptions.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ToDataUrlOptions
+    {
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/ToPNGOptions.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ToPNGOptions
+    {
+        /// <summary>
+        /// Gets or sets the scalefactor
+        /// </summary>
+        public float ScaleFactor { get; set; } = 1.0f;
+    }
+}

ElectronNET.API/Entities/UpdateCancellationToken.cs

@@ -0,0 +1,29 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UpdateCancellationToken
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool Cancelled { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void Cancel()
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void Dispose()
+        {
+
+        }
+    }
+}

ElectronNET.API/Entities/UpdateCheckResult.cs

@@ -0,0 +1,23 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UpdateCheckResult
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public UpdateInfo UpdateInfo { get; set; } = new UpdateInfo();
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string[] Download { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public UpdateCancellationToken CancellationToken { get; set; }
+    }
+}

ElectronNET.API/Entities/UpdateFileInfo.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UpdateFileInfo : BlockMapDataHolder
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Url { get; set; }
+    }
+}

ElectronNET.API/Entities/UpdateInfo.cs

@@ -0,0 +1,38 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UpdateInfo
+    {
+        /// <summary>
+        /// The version.
+        /// </summary>
+        public string Version { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public UpdateFileInfo[] Files { get; set; } = new UpdateFileInfo[0];
+
+        /// <summary>
+        /// The release name.
+        /// </summary>
+        public string ReleaseName { get; set; }
+
+        /// <summary>
+        /// The release notes.
+        /// </summary>
+        public ReleaseNoteInfo[] ReleaseNotes { get; set; } = new ReleaseNoteInfo[0];
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string ReleaseDate { get; set; }
+
+        /// <summary>
+        /// The staged rollout percentage, 0-100.
+        /// </summary>
+        public int StagingPercentage { get; set; }
+    }
+}

ElectronNET.API/Entities/UploadFile.cs

@@ -0,0 +1,34 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UploadFile : IPostData
+    {
+        /// <summary>
+        /// The object represents a file.
+        /// </summary>
+        public string Type { get; } = "file";
+
+        /// <summary>
+        /// The path of the file being uploaded.
+        /// </summary>
+        public string FilePath { get; set; }
+
+        /// <summary>
+        /// The offset from the beginning of the file being uploaded, in bytes. Defaults to 0.
+        /// </summary>
+        public long Offset { get; set; } = 0;
+
+        /// <summary>
+        /// The length of the file being uploaded, <see cref="Offset"/>. Defaults to 0.
+        /// If set to -1, the whole file will be uploaded.
+        /// </summary>
+        public long Length { get; set; } = 0;
+
+        /// <summary>
+        /// The modification time of the file represented by a double, which is the number of seconds since the UNIX Epoch (Jan 1, 1970)
+        /// </summary>
+        public double ModificationTime { get; set; }
+    }
+}

ElectronNET.API/Entities/UploadRawData.cs

@@ -0,0 +1,18 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class UploadRawData : IPostData
+    {
+        /// <summary>
+        /// The data is available as a Buffer, in the rawData field.
+        /// </summary>
+        public string Type { get; } = "rawData";
+        
+        /// <summary>
+        /// The raw bytes of the post data in a Buffer.
+        /// </summary>
+        public byte[] Bytes { get; set; }
+    }
+}

ElectronNET.API/Entities/UserTask.cs

@@ -52,5 +52,10 @@
         /// The title.
         /// </value>
         public string Title { get; set; }
+
+        /// <summary>
+        /// The working directory. Default is <see cref="string.Empty"/>.
+        /// </summary>
+        public string WorkingDirectory { get; set; }
     }
-}
+}

ElectronNET.API/Entities/Vibrancy.cs

@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using System.Runtime.Serialization;
 
 namespace ElectronNET.API.Entities
 {
@@ -10,7 +10,7 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// The appearance based
         /// </summary>
-        [JsonProperty("appearance-based")]
+        [EnumMember(Value = "appearance-based")]
         appearanceBased,
 
         /// <summary>
@@ -51,13 +51,13 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// The medium light
         /// </summary>
-        [JsonProperty("medium-light")]
+        [EnumMember(Value = "medium-light")]
         mediumLight,
 
         /// <summary>
         /// The ultra dark
         /// </summary>
-        [JsonProperty("ultra-dark")]
+        [EnumMember(Value = "ultra-dark")]
         ultraDark
     }
 }

ElectronNET.API/Entities/WebPreferences.cs

@@ -1,4 +1,4 @@
-using System.ComponentModel;
+using System.ComponentModel;
 
 namespace ElectronNET.API.Entities
 {
@@ -15,7 +15,7 @@ namespace ElectronNET.API.Entities
         public bool DevTools { get; set; } = true;
 
         /// <summary>
-        /// Whether node integration is enabled. Default is true.
+        /// Whether node integration is enabled. Required to enable IPC. Default is true.
         /// </summary>
         [DefaultValue(true)]
         public bool NodeIntegration { get; set; } = true;
@@ -126,7 +126,7 @@ namespace ElectronNET.API.Entities
         /// 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.
         /// </summary>
-        public string BlinkFeatures { get; set; }
+        public string EnableBlinkFeatures { get; set; }
 
         /// <summary>
         /// A list of feature strings separated by ,, like CSSVariables,KeyboardEventKey to
@@ -142,7 +142,7 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// Defaults to 16.
         /// </summary>
-        public int DefaultFontSize { get; set; }
+        public int DefaultFontSize { get; set; } = 16;
 
         /// <summary>
         /// Defaults to 13.
@@ -173,7 +173,7 @@ namespace ElectronNET.API.Entities
 
         /// <summary>
         /// 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
+        /// 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
@@ -185,7 +185,8 @@ namespace ElectronNET.API.Entities
         /// Context' entry in the combo box at the top of the Console tab. This option is
         /// currently experimental and may change or be removed in future Electron releases.
         /// </summary>
-        public bool ContextIsolation { get; set; }
+        [DefaultValue(false)]
+        public bool ContextIsolation { get; set; } = false;
 
         /// <summary>
         /// Whether to use native window.open(). Defaults to false. This option is currently experimental.
@@ -203,6 +204,13 @@ namespace ElectronNET.API.Entities
         /// <value>
         ///   <c>true</c> if [webview tag]; otherwise, <c>false</c>.
         /// </value>
-        public bool WebviewTag { get; set; }
+        [DefaultValue(false)]
+        public bool WebviewTag { get; set; } = false;
+
+        /// <summary>
+        /// Whether to enable the remote module. Defaults to false.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool EnableRemoteModule { get; set; } = false;
     }
 }

ElectronNET.API/Events.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Globalization;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Generic Event Consumers for Electron Modules
+    /// </summary>
+    internal class Events
+    {
+        private static Events _events;
+        private static readonly object SyncRoot = new();
+        private readonly TextInfo _textInfo = new CultureInfo("en-US", false).TextInfo;
+        
+        private Events()
+        {}
+
+        public static Events Instance
+        {
+            get
+            {
+                if (_events == null)
+                {
+                    lock (SyncRoot)
+                    {
+                        if (_events == null)
+                        {
+                            _events = new Events();
+                        }
+                    }
+                }
+
+                return _events;
+            }
+        }
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="action">The event handler</param>
+        public void On(string moduleName, string eventName, Action action)
+            => On(moduleName, eventName, action);
+
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="action">The event handler</param>
+        public async Task On<T>(string moduleName, string eventName, Action<T> action)
+        {
+            var listener = $"{moduleName}{_textInfo.ToTitleCase(eventName)}Completed";
+            var subscriber = $"register-{moduleName}-on-event";
+
+            BridgeConnector.Socket.On(listener, action);
+            await BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+        }
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="fn">The event handler</param>
+        public void Once(string moduleName, string eventName, Action action)
+            => Once(moduleName, eventName, action);
+
+
+        /// <summary>
+        /// Subscribe to an unmapped electron event.
+        /// </summary>
+        /// <param name="moduleName">The name of the module, e.g. app, dock, etc...</param>
+        /// <param name="eventName">The name of the event</param>
+        /// <param name="action">The event handler</param>
+        public async Task Once<T>(string moduleName, string eventName, Action<T> action)
+        {
+            var listener = $"{moduleName}{_textInfo.ToTitleCase(eventName)}Completed";
+            var subscriber = $"register-{moduleName}-once-event";
+            BridgeConnector.Socket.Once(listener, action);
+            await BridgeConnector.Socket.Emit(subscriber, eventName, listener);
+        }
+
+    }
+}

ElectronNET.API/Extensions/MenuItemExtensions.cs

@@ -48,5 +48,24 @@ namespace ElectronNET.API.Extensions
 
             return result;
         }
+
+        public static MenuItem[] AddSubmenuTypes(this MenuItem[] menuItems)
+        {
+            for (int index = 0; index < menuItems.Length; index++)
+            {
+                var menuItem = menuItems[index];
+                if (menuItem?.Submenu?.Length > 0)
+                {
+                    if(menuItem.Type == MenuType.normal)
+                    {
+                        menuItem.Type = MenuType.submenu;
+                    }
+
+                    AddSubmenuTypes(menuItem.Submenu);
+                }
+            }
+
+            return menuItems;
+        }
     }
 }

ElectronNET.API/GlobalShortcut.cs

@@ -10,7 +10,7 @@ namespace ElectronNET.API
     public sealed class GlobalShortcut
     {
         private static GlobalShortcut _globalShortcut;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         internal GlobalShortcut() { }
 

ElectronNET.API/GlobalUsings.cs

@@ -0,0 +1,3 @@
+// Global using directives
+
+global using System.Web;

ElectronNET.API/HostHook.cs

@@ -0,0 +1,128 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Allows you to execute native JavaScript/TypeScript code from the host process.
+    /// 
+    /// It is only possible if the Electron.NET CLI has previously added an 
+    /// ElectronHostHook directory:
+    /// <c>electronize add HostHook</c>
+    /// </summary>
+    public sealed class HostHook
+    {
+        private static HostHook _electronHostHook;
+        private static object _syncRoot = new object();
+        string oneCallguid = Guid.NewGuid().ToString();
+
+        internal HostHook() { }
+
+        internal static HostHook Instance
+        {
+            get
+            {
+                if (_electronHostHook == null)
+                {
+                    lock (_syncRoot)
+                    {
+                        if (_electronHostHook == null)
+                        {
+                            _electronHostHook = new HostHook();
+                        }
+                    }
+                }
+
+                return _electronHostHook;
+            }
+        }
+
+        /// <summary>
+        /// Execute native JavaScript/TypeScript code.
+        /// </summary>
+        /// <param name="socketEventName">Socket name registered on the host.</param>
+        /// <param name="arguments">Optional parameters.</param>
+        public void Call(string socketEventName, params dynamic[] arguments)
+        {
+            BridgeConnector.Socket.On(socketEventName + "Error" + oneCallguid, (result) =>
+            {
+                BridgeConnector.Socket.Off(socketEventName + "Error" + oneCallguid);
+                Electron.Dialog.ShowErrorBox("Host Hook Exception", result.ToString());
+            });
+
+            BridgeConnector.Socket.Emit(socketEventName, arguments, oneCallguid);
+        }
+
+        /// <summary>
+        /// Execute native JavaScript/TypeScript code.
+        /// </summary>
+        /// <typeparam name="T">Results from the executed host code.</typeparam>
+        /// <param name="socketEventName">Socket name registered on the host.</param>
+        /// <param name="arguments">Optional parameters.</param>
+        /// <returns></returns>
+        public Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments)
+        {
+            var taskCompletionSource = new TaskCompletionSource<T>();
+            string guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.On(socketEventName + "Error" + guid, (result) =>
+            {
+                BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
+                Electron.Dialog.ShowErrorBox("Host Hook Exception", result.ToString());
+                taskCompletionSource.SetException(new Exception($"Host Hook Exception {result}"));
+            });
+
+            BridgeConnector.Socket.On(socketEventName + "Complete" + guid, (result) =>
+            {
+                BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
+                BridgeConnector.Socket.Off(socketEventName + "Complete" + guid);
+                T data = default;
+
+                try
+                {
+                    if (result.GetType().IsValueType || result is string)
+                    {
+                        data = (T)result;
+                    }
+                    else
+                    {
+                        var token = JToken.Parse(result.ToString());
+                        if (token is JArray)
+                        {
+                            data = token.ToObject<T>();
+                        }
+                        else if (token is JObject)
+                        {
+                            data = token.ToObject<T>();
+                        }
+                        else
+                        {
+                            data = (T)result;
+                        }
+                    }
+                }
+                catch (Exception exception)
+                {
+                    taskCompletionSource.SetException(exception);
+                    //throw new InvalidCastException("Return value does not match with the generic type.", exception);
+                }
+
+                taskCompletionSource.SetResult(data);
+            });
+
+            BridgeConnector.Socket.Emit(socketEventName, arguments, guid);
+
+            return taskCompletionSource.Task;
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/IpcMain.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace ElectronNET.API
 {
@@ -14,7 +15,7 @@ namespace ElectronNET.API
     public sealed class IpcMain
     {
         private static IpcMain _ipcMain;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         internal IpcMain() { }
 
@@ -43,9 +44,10 @@ namespace ElectronNET.API
         /// </summary>
         /// <param name="channel">Channelname.</param>
         /// <param name="listener">Callback Method.</param>
-        public void On(string channel, Action<object> listener)
+        public async Task On(string channel, Action<object> listener)
         {
-            BridgeConnector.Socket.Emit("registerIpcMainChannel", channel);
+            await BridgeConnector.Socket.Emit("registerIpcMainChannel", channel);
+            BridgeConnector.Socket.Off(channel);
             BridgeConnector.Socket.On(channel, (args) => 
             {
                 List<object> objectArray = FormatArguments(args);
@@ -152,7 +154,7 @@ namespace ElectronNET.API
         {
             List<JObject> jobjects = new List<JObject>();
             List<JArray> jarrays = new List<JArray>();
-            List<Object> objects = new List<Object>();
+            List<object> objects = new List<object>();
 
             foreach (var parameterObject in data)
             {
@@ -178,6 +180,45 @@ namespace ElectronNET.API
             }
         }
 
+        /// <summary>
+        /// Send a message to the BrowserView renderer 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 renderer process handles it by
+        /// listening for channel with ipcRenderer module.
+        /// </summary>
+        /// <param name="browserView">BrowserView with channel.</param>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="data">Arguments data.</param>
+        public void Send(BrowserView browserView, string channel, params object[] data)
+        {
+            List<JObject> jobjects = new List<JObject>();
+            List<JArray> jarrays = new List<JArray>();
+            List<object> objects = new List<object>();
+
+            foreach (var parameterObject in data)
+            {
+                if(parameterObject.GetType().IsArray || parameterObject.GetType().IsGenericType && parameterObject is IEnumerable)
+                {
+                    jarrays.Add(JArray.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsClass && !parameterObject.GetType().IsPrimitive && !(parameterObject is string))
+                {
+                    jobjects.Add(JObject.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsPrimitive || (parameterObject is string))
+                {
+                    objects.Add(parameterObject);
+                }
+            }
+
+            if(jobjects.Count > 0 || jarrays.Count > 0)
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
+            }
+            else
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRendererBrowserView", browserView.Id, channel, data);
+            }
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/LifetimeServiceHost.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Base class that reports if ASP.NET Core has fully started.
+    /// </summary>
+    internal class LifetimeServiceHost : IHostedService
+    {
+        public LifetimeServiceHost(IHostApplicationLifetime lifetime)
+        {
+            lifetime.ApplicationStarted.Register(() =>
+            {
+                App.Instance.IsReady = true;
+
+                Console.WriteLine("ASP.NET Core host has fully started.");
+            });
+        }
+
+        /// <summary>
+        /// Triggered when the application host is ready to start the service.
+        /// </summary>
+        /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Triggered when the application host is performing a graceful shutdown.
+        /// </summary>
+        /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+    }
+}

ElectronNET.API/Menu.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using ElectronNET.API.Extensions;
 using System.Linq;
 using System.Collections.ObjectModel;
-using System;
 
 namespace ElectronNET.API
 {
@@ -16,7 +15,7 @@ namespace ElectronNET.API
     public sealed class Menu
     {
         private static Menu _menu;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         internal Menu() { }
 
@@ -57,6 +56,8 @@ namespace ElectronNET.API
             _menuItems.Clear();
 
             menuItems.AddMenuItemsId();
+            menuItems.AddSubmenuTypes();
+
             BridgeConnector.Socket.Emit("menu-setApplicationMenu", JArray.FromObject(menuItems, _jsonSerializer));
             _menuItems.AddRange(menuItems);
 
@@ -83,25 +84,27 @@ namespace ElectronNET.API
         /// <param name="menuItems">The menu items.</param>
         public void SetContextMenu(BrowserWindow browserWindow, MenuItem[] menuItems)
         {
+            menuItems.AddMenuItemsId();
+            menuItems.AddSubmenuTypes();
+
+            BridgeConnector.Socket.Emit("menu-setContextMenu", browserWindow.Id, JArray.FromObject(menuItems, _jsonSerializer));
+
             if (!_contextMenuItems.ContainsKey(browserWindow.Id))
             {
-                menuItems.AddMenuItemsId();
-                BridgeConnector.Socket.Emit("menu-setContextMenu", browserWindow.Id, JArray.FromObject(menuItems, _jsonSerializer));
                 _contextMenuItems.Add(browserWindow.Id, menuItems.ToList());
-
                 var x = _contextMenuItems.ToDictionary(kv => kv.Key, kv => kv.Value.AsReadOnly());
                 ContextMenuItems = new ReadOnlyDictionary<int, ReadOnlyCollection<MenuItem>>(x);
-
-                BridgeConnector.Socket.Off("contextMenuItemClicked");
-                BridgeConnector.Socket.On("contextMenuItemClicked", (results) =>
-                {
-                    var id = ((JArray)results).First.ToString();
-                    var browserWindowId = (int)((JArray)results).Last;
-
-                    MenuItem menuItem = _contextMenuItems[browserWindowId].GetMenuItem(id);
-                    menuItem.Click?.Invoke();
-                });
             }
+
+            BridgeConnector.Socket.Off("contextMenuItemClicked");
+            BridgeConnector.Socket.On("contextMenuItemClicked", (results) =>
+            {
+                var id = ((JArray)results).First.ToString();
+                var browserWindowId = (int)((JArray)results).Last;
+
+                MenuItem menuItem = _contextMenuItems[browserWindowId].GetMenuItem(id);
+                menuItem.Click?.Invoke();
+            });
         }
 
         /// <summary>
@@ -116,8 +119,7 @@ namespace ElectronNET.API
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore,
-            DefaultValueHandling = DefaultValueHandling.Ignore
+            NullValueHandling = NullValueHandling.Ignore
         };
     }
 }