Convert main static references off of Electron into interface implementation and expose the underlying Socket for low level interaction.

ElectronNET.API/App.cs

@@ -7,13 +7,14 @@ using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using ElectronNET.API.Extensions;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Control your application's event lifecycle.
     /// </summary>
-    public sealed class App
+    public sealed class App : IApp
     {
         /// <summary>
         /// Emitted when all windows have been closed.

ElectronNET.API/ApplicationSocket.cs

@@ -0,0 +1,16 @@
+using ElectronNET.API.Interfaces;
+using Quobject.SocketIoClientDotNet.Client;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Wrapper for the underlying Socket connection
+    /// </summary>
+    public class ApplicationSocket : IApplicationSocket
+    {
+        /// <summary>
+        /// Socket used to communicate with main.js
+        /// </summary>
+        public Socket Socket { get; internal set; }
+    }
+}

ElectronNET.API/AutoUpdater.cs

@@ -5,13 +5,14 @@ using Newtonsoft.Json.Serialization;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Enable apps to automatically update themselves. Based on electron-updater.
     /// </summary>
-    public sealed class AutoUpdater
+    public sealed class AutoUpdater : IAutoUpdater
     {
         /// <summary>
         /// Whether to automatically download an update when it is found. (Default is true)

ElectronNET.API/Clipboard.cs

@@ -3,13 +3,14 @@ using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Perform copy and paste operations on the system clipboard.
     /// </summary>
-    public sealed class Clipboard
+    public sealed class Clipboard : IClipboard
     {
         private static Clipboard _clipboard;
         private static object _syncRoot = new object();

ElectronNET.API/Dialog.cs

@@ -6,13 +6,14 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using System.Web;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Display native system dialogs for opening and saving files, alerting, etc.
     /// </summary>
-    public sealed class Dialog
+    public sealed class Dialog : IDialog
     {
         private static Dialog _dialog;
         private static object _syncRoot = new object();

ElectronNET.API/Dock.cs

@@ -3,6 +3,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using ElectronNET.API.Entities;
 using ElectronNET.API.Extensions;
+using ElectronNET.API.Interfaces;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
@@ -12,7 +13,7 @@ namespace ElectronNET.API
     /// <summary>
     /// Control your app in the macOS dock.
     /// </summary>
-    public sealed class Dock
+    public sealed class Dock : IDock
     {
         private static Dock _dock;
         private static object _syncRoot = new object();

ElectronNET.API/GlobalShortcut.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Detect keyboard events when the application does not have keyboard focus.
     /// </summary>
-    public sealed class GlobalShortcut
+    public sealed class GlobalShortcut : IGlobalShortcut
     {
         private static GlobalShortcut _globalShortcut;
         private static object _syncRoot = new object();

ElectronNET.API/HostHook.cs

@@ -3,6 +3,7 @@ using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
@@ -13,7 +14,7 @@ namespace ElectronNET.API
     /// ElectronHostHook directory:
     /// <c>electronize add HostHook</c>
     /// </summary>
-    public sealed class HostHook
+    public sealed class HostHook : IHostHook
     {
         private static HostHook _electronHostHook;
         private static object _syncRoot = new object();

ElectronNET.API/Interfaces/IApp.cs

@@ -0,0 +1,713 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Control your application's event lifecycle.
+    /// </summary>
+    public interface IApp
+    {
+        /// <summary>
+        /// Emitted when all windows have been closed.
+        /// <para/>
+        /// If you do not subscribe to this event and all windows are closed, the default behavior is to quit
+        /// the app; however, if you subscribe, you control whether the app quits or not.If the user pressed
+        /// Cmd + Q, or the developer called <see cref="Quit"/>, Electron will first try to close all the windows
+        /// and then emit the <see cref="WillQuit"/> event, and in this case the <see cref="WindowAllClosed"/> event
+        /// would not be emitted.
+        /// </summary>
+        event Action WindowAllClosed;
+
+        /// <summary>
+        /// Emitted before the application starts closing its windows. 
+        /// <para/>
+        /// Note: If application quit was initiated by <see cref="AutoUpdater.QuitAndInstall"/> then <see cref="BeforeQuit"/>
+        /// is emitted after emitting close event on all windows and closing them.
+        /// <para/>
+        /// Note: On Windows, this event will not be emitted if the app is closed due to a shutdown/restart of the system or a user logout.
+        /// </summary>
+        event Func<QuitEventArgs, Task> BeforeQuit;
+
+        /// <summary>
+        /// Emitted when all windows have been closed and the application will quit.
+        /// <para/>
+        /// See the description of the <see cref="WindowAllClosed"/> event for the differences between the <see cref="WillQuit"/>
+        /// and <see cref="WindowAllClosed"/> events.
+        /// <para/>
+        /// Note: On Windows, this event will not be emitted if the app is closed due to a shutdown/restart of the system or a user logout.
+        /// </summary>
+        event Func<QuitEventArgs, Task> WillQuit;
+
+        /// <summary>
+        /// Emitted when the application is quitting.
+        /// <para/>
+        /// Note: On Windows, this event will not be emitted if the app is closed due to a shutdown/restart of the system or a user logout.
+        /// </summary>
+        event Func<Task> Quitting;
+
+        /// <summary>
+        /// Emitted when a <see cref="BrowserWindow"/> blurred.
+        /// </summary>
+        event Action BrowserWindowBlur;
+
+        /// <summary>
+        /// Emitted when a <see cref="BrowserWindow"/> gets focused.
+        /// </summary>
+        event Action BrowserWindowFocus;
+
+        /// <summary>
+        /// Emitted when a new <see cref="BrowserWindow"/> is created.
+        /// </summary>
+        event Action BrowserWindowCreated;
+
+        /// <summary>
+        /// Emitted when a new <see cref="WebContents"/> is created.
+        /// </summary>
+        event Action WebContentsCreated;
+
+        /// <summary>
+        /// Emitted when Chrome’s accessibility support changes. This event fires when assistive technologies, such as
+        /// screen readers, are enabled or disabled. See https://www.chromium.org/developers/design-documents/accessibility for more details.
+        /// </summary>
+        /// <returns><see langword="true"/> when Chrome's accessibility support is enabled, <see langword="false"/> otherwise.</returns>
+        event Action<bool> AccessibilitySupportChanged;
+
+        /// <summary>
+        /// Emitted when the application has finished basic startup.
+        /// </summary>
+        event Action Ready;
+
+        /// <summary>
+        /// Application host fully started.
+        /// </summary>
+        bool IsReady { get; }
+
+        /// <summary>
+        /// A <see cref="string"/> property that indicates the current application's name, which is the name in the
+        /// application's package.json file.
+        ///
+        /// Usually the name field of package.json is a short lowercase name, according to the npm modules spec. You
+        /// should usually also specify a productName field, which is your application's full capitalized name, and
+        /// which will be preferred over name by Electron.
+        /// </summary>
+        string Name
+        {
+            [Obsolete("Use the asynchronous version NameAsync instead")]
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// A <see cref="string"/> property that indicates the current application's name, which is the name in the
+        /// application's package.json file.
+        ///
+        /// Usually the name field of package.json is a short lowercase name, according to the npm modules spec. You
+        /// should usually also specify a productName field, which is your application's full capitalized name, and
+        /// which will be preferred over name by Electron.
+        /// </summary>
+        Task<string> NameAsync { get; }
+
+        /// <summary>
+        /// A <see cref="CommandLine"/> object that allows you to read and manipulate the command line arguments that Chromium uses.
+        /// </summary>
+        CommandLine CommandLine { get; }
+
+        /// <summary>
+        /// A <see cref="string"/> which is the user agent string Electron will use as a global fallback.
+        /// <para/>
+        /// This is the user agent that will be used when no user agent is set at the webContents or
+        /// session level. It is useful for ensuring that your entire app has the same user agent. Set to a
+        /// custom value as early as possible in your app's initialization to ensure that your overridden value
+        /// is used.
+        /// </summary>
+        string UserAgentFallback
+        {
+            [Obsolete("Use the asynchronous version UserAgentFallbackAsync instead")]
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// A <see cref="string"/> which is the user agent string Electron will use as a global fallback.
+        /// <para/>
+        /// This is the user agent that will be used when no user agent is set at the webContents or
+        /// session level. It is useful for ensuring that your entire app has the same user agent. Set to a
+        /// custom value as early as possible in your app's initialization to ensure that your overridden value
+        /// is used.
+        /// </summary>
+        Task<string> UserAgentFallbackAsync { get; }
+
+        /// <summary>
+        /// Emitted when a MacOS user wants to open a file with the application. The open-file event is usually emitted
+        /// when the application is already open and the OS wants to reuse the application to open the file.
+        /// open-file is also emitted when a file is dropped onto the dock and the application is not yet running.
+        /// <para/>
+        /// On Windows, you have to parse the arguments using App.CommandLine to get the filepath.
+        /// </summary>
+        event Action<string> OpenFile;
+
+        /// <summary>
+        /// Emitted when a MacOS user wants to open a URL with the application. Your application's Info.plist file must
+        /// define the URL scheme within the CFBundleURLTypes key, and set NSPrincipalClass to AtomApplication.
+        /// </summary>
+        event Action<string> OpenUrl;
+
+        /// <summary>
+        /// Try to close all windows. The <see cref="BeforeQuit"/> event will be emitted first. If all windows are successfully
+        /// closed, the <see cref="WillQuit"/> event will be emitted and by default the application will terminate. This method
+        /// guarantees that all beforeunload and unload event handlers are correctly executed. It is possible
+        /// that a window cancels the quitting by returning <see langword="false"/> in the beforeunload event handler.
+        /// </summary>
+        void Quit();
+
+        /// <summary>
+        /// All windows will be closed immediately without asking user and the <see cref="BeforeQuit"/> and <see cref="WillQuit"/>
+        /// events will not be emitted.
+        /// </summary>
+        /// <param name="exitCode">Exits immediately with exitCode. exitCode defaults to 0.</param>
+        void Exit(int exitCode = 0);
+
+        /// <summary>
+        /// Relaunches the app when current instance exits. By default the new instance will use the same working directory
+        /// and command line arguments with current instance.
+        /// <para/>
+        /// Note that this method does not quit the app when executed, you have to call <see cref="Quit"/> or <see cref="Exit"/>
+        /// after calling <see cref="Relaunch()"/> to make the app restart.
+        /// <para/>
+        /// When <see cref="Relaunch()"/> is called for multiple times, multiple instances will be started after current instance
+        /// exited.
+        /// </summary>
+        void Relaunch();
+
+        /// <summary>
+        /// Relaunches the app when current instance exits. By default the new instance will use the same working directory
+        /// and command line arguments with current instance. When <see cref="RelaunchOptions.Args"/> is specified, the
+        /// <see cref="RelaunchOptions.Args"/> will be passed as command line arguments instead. When <see cref="RelaunchOptions.ExecPath"/>
+        /// is specified, the <see cref="RelaunchOptions.ExecPath"/> will be executed for relaunch instead of current app.
+        /// <para/>
+        /// Note that this method does not quit the app when executed, you have to call <see cref="Quit"/> or <see cref="Exit"/>
+        /// after calling <see cref="Relaunch()"/> to make the app restart.
+        /// <para/>
+        /// When <see cref="Relaunch()"/> is called for multiple times, multiple instances will be started after current instance
+        /// exited.
+        /// </summary>
+        /// <param name="relaunchOptions">Options for the relaunch.</param>
+        void Relaunch(RelaunchOptions relaunchOptions);
+
+        /// <summary>
+        /// On Linux, focuses on the first visible window. On macOS, makes the application the active app. On Windows, focuses
+        /// on the application's first window.
+        /// </summary>
+        void Focus();
+
+        /// <summary>
+        /// On Linux, focuses on the first visible window. On macOS, makes the application the active app. On Windows, focuses
+        /// on the application's first window.
+        /// <para/>
+        /// You should seek to use the <see cref="FocusOptions.Steal"/> option as sparingly as possible.
+        /// </summary>
+        void Focus(FocusOptions focusOptions);
+
+        /// <summary>
+        /// Hides all application windows without minimizing them.
+        /// </summary>
+        void Hide();
+
+        /// <summary>
+        /// Shows application windows after they were hidden. Does not automatically focus them.
+        /// </summary>
+        void Show();
+
+        /// <summary>
+        /// The current application directory.
+        /// </summary>
+        Task<string> GetAppPathAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets or creates a directory your app's logs which can then be manipulated with <see cref="GetPathAsync"/>
+        /// or <see cref="SetPath"/>.
+        /// <para/>
+        /// Calling <see cref="SetAppLogsPath"/> without a path parameter will result in this directory being set to
+        /// ~/Library/Logs/YourAppName on macOS, and inside the userData directory on Linux and Windows.
+        /// </summary>
+        /// <param name="path">A custom path for your logs. Must be absolute.</param>
+        void SetAppLogsPath(string path);
+
+        /// <summary>
+        /// The path to a special directory. If <see cref="GetPathAsync"/> is called without called
+        /// <see cref="SetAppLogsPath"/> being called first, a default directory will be created equivalent
+        /// to calling <see cref="SetAppLogsPath"/> without a path parameter.
+        /// </summary>
+        /// <param name="pathName">Special directory.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>A path to a special directory or file associated with name.</returns>
+        Task<string> GetPathAsync(PathName pathName, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Overrides the path to a special directory or file associated with name. If the path specifies a directory
+        /// that does not exist, an Error is thrown. In that case, the directory should be created with fs.mkdirSync or similar.
+        /// <para/>
+        /// You can only override paths of a name defined in <see cref="GetPathAsync"/>.
+        /// <para/>
+        /// By default, web pages' cookies and caches will be stored under the <see cref="PathName.UserData"/> directory. If you
+        /// want to change this location, you have to override the <see cref="PathName.UserData"/> path before the <see cref="Ready"/>
+        /// event of the <see cref="App"/> module is emitted.
+        /// <param name="name">Special directory.</param>
+        /// <param name="path">New path to a special directory.</param>
+        /// </summary>
+        void SetPath(PathName name, string path);
+
+        /// <summary>
+        /// The version of the loaded application. If no version is found in the application’s package.json file, 
+        /// the version of the current bundle or executable is returned.
+        /// </summary>
+        /// <returns>The version of the loaded application.</returns>
+        Task<string> GetVersionAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// The current application locale. Possible return values are documented <see href="https://www.electronjs.org/docs/api/locales">here</see>.
+        /// <para/>
+        /// Note: When distributing your packaged app, you have to also ship the locales folder.
+        /// <para/>
+        /// Note: On Windows, you have to call it after the <see cref="Ready"/> events gets emitted.
+        /// </summary>
+        /// <returns>The current application locale.</returns>
+        Task<string> GetLocaleAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Adds path to the recent documents list. This list is managed by the OS. On Windows you can visit the
+        /// list from the task bar, and on macOS you can visit it from dock menu.
+        /// </summary>
+        /// <param name="path">Path to add.</param>
+        void AddRecentDocument(string path);
+
+        /// <summary>
+        /// Clears the recent documents list.
+        /// </summary>
+        void ClearRecentDocuments();
+
+        /// <summary>
+        /// Sets the current executable as the default handler for a protocol (aka URI scheme). It allows you to
+        /// integrate your app deeper into the operating system. Once registered, all links with your-protocol://
+        /// will be opened with the current executable. The whole link, including protocol, will be passed to your
+        /// application as a parameter.
+        /// <para/>
+        /// Note: On macOS, you can only register protocols that have been added to your app's info.plist, which
+        /// cannot be modified at runtime. However, you can change the file during build time via
+        /// <see href="https://www.electronforge.io/">Electron Forge</see>,
+        /// <see href="https://github.com/electron/electron-packager">Electron Packager</see>, or by editing info.plist
+        /// with a text editor. Please refer to
+        /// <see href="https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/TP40009249-102207-TPXREF115">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// Note: In a Windows Store environment (when packaged as an appx) this API will return true for all calls but
+        /// the registry key it sets won't be accessible by other applications. In order to register your Windows Store
+        /// application as a default protocol handler you <see href="https://docs.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/element-uap-protocol">must declare the protocol in your manifest</see>.
+        /// <para/>
+        /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">
+        /// The name of your protocol, without ://. For example, if you want your app to handle electron:// links,
+        /// call this method with electron as the parameter.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> SetAsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets the current executable as the default handler for a protocol (aka URI scheme). It allows you to
+        /// integrate your app deeper into the operating system. Once registered, all links with your-protocol://
+        /// will be opened with the current executable. The whole link, including protocol, will be passed to your
+        /// application as a parameter.
+        /// <para/>
+        /// Note: On macOS, you can only register protocols that have been added to your app's info.plist, which
+        /// cannot be modified at runtime. However, you can change the file during build time via
+        /// <see href="https://www.electronforge.io/">Electron Forge</see>,
+        /// <see href="https://github.com/electron/electron-packager">Electron Packager</see>, or by editing info.plist
+        /// with a text editor. Please refer to
+        /// <see href="https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/TP40009249-102207-TPXREF115">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// Note: In a Windows Store environment (when packaged as an appx) this API will return true for all calls but
+        /// the registry key it sets won't be accessible by other applications. In order to register your Windows Store
+        /// application as a default protocol handler you <see href="https://docs.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/element-uap-protocol">must declare the protocol in your manifest</see>.
+        /// <para/>
+        /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">
+        /// The name of your protocol, without ://. For example, if you want your app to handle electron:// links,
+        /// call this method with electron as the parameter.</param>
+        /// <param name="path">The path to the Electron executable. Defaults to process.execPath</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets the current executable as the default handler for a protocol (aka URI scheme). It allows you to
+        /// integrate your app deeper into the operating system. Once registered, all links with your-protocol://
+        /// will be opened with the current executable. The whole link, including protocol, will be passed to your
+        /// application as a parameter.
+        /// <para/>
+        /// Note: On macOS, you can only register protocols that have been added to your app's info.plist, which
+        /// cannot be modified at runtime. However, you can change the file during build time via
+        /// <see href="https://www.electronforge.io/">Electron Forge</see>,
+        /// <see href="https://github.com/electron/electron-packager">Electron Packager</see>, or by editing info.plist
+        /// with a text editor. Please refer to
+        /// <see href="https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/TP40009249-102207-TPXREF115">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// Note: In a Windows Store environment (when packaged as an appx) this API will return true for all calls but
+        /// the registry key it sets won't be accessible by other applications. In order to register your Windows Store
+        /// application as a default protocol handler you <see href="https://docs.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/element-uap-protocol">must declare the protocol in your manifest</see>.
+        /// <para/>
+        /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">
+        /// The name of your protocol, without ://. For example, if you want your app to handle electron:// links,
+        /// call this method with electron as the parameter.</param>
+        /// <param name="path">The path to the Electron executable. Defaults to process.execPath</param>
+        /// <param name="args">Arguments passed to the executable. Defaults to an empty array.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> SetAsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable as the default handler for a protocol (aka URI scheme).
+        /// If so, it will remove the app as the default handler.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable as the default handler for a protocol (aka URI scheme).
+        /// If so, it will remove the app as the default handler.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable as the default handler for a protocol (aka URI scheme).
+        /// If so, it will remove the app as the default handler.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="args">Defaults to an empty array.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> RemoveAsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable is the default handler for a protocol (aka URI scheme).
+        /// <para/>
+        /// Note: On macOS, you can use this method to check if the app has been registered as the default protocol
+        /// handler for a protocol. You can also verify this by checking ~/Library/Preferences/com.apple.LaunchServices.plist
+        /// on the macOS machine. Please refer to <see href="https://developer.apple.com/library/mac/documentation/Carbon/Reference/LaunchServicesReference/#//apple_ref/c/func/LSCopyDefaultHandlerForURLScheme">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// The API uses the Windows Registry and LSCopyDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the current executable is the default handler for a protocol (aka URI scheme).</returns>
+        Task<bool> IsDefaultProtocolClientAsync(string protocol, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable is the default handler for a protocol (aka URI scheme).
+        /// <para/>
+        /// Note: On macOS, you can use this method to check if the app has been registered as the default protocol
+        /// handler for a protocol. You can also verify this by checking ~/Library/Preferences/com.apple.LaunchServices.plist
+        /// on the macOS machine. Please refer to <see href="https://developer.apple.com/library/mac/documentation/Carbon/Reference/LaunchServicesReference/#//apple_ref/c/func/LSCopyDefaultHandlerForURLScheme">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// The API uses the Windows Registry and LSCopyDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the current executable is the default handler for a protocol (aka URI scheme).</returns>
+        Task<bool> IsDefaultProtocolClientAsync(string protocol, string path, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// This method checks if the current executable is the default handler for a protocol (aka URI scheme).
+        /// <para/>
+        /// Note: On macOS, you can use this method to check if the app has been registered as the default protocol
+        /// handler for a protocol. You can also verify this by checking ~/Library/Preferences/com.apple.LaunchServices.plist
+        /// on the macOS machine. Please refer to <see href="https://developer.apple.com/library/mac/documentation/Carbon/Reference/LaunchServicesReference/#//apple_ref/c/func/LSCopyDefaultHandlerForURLScheme">Apple's documentation</see>
+        /// for details.
+        /// <para/>
+        /// The API uses the Windows Registry and LSCopyDefaultHandlerForURLScheme internally.
+        /// </summary>
+        /// <param name="protocol">The name of your protocol, without ://.</param>
+        /// <param name="path">Defaults to process.execPath.</param>
+        /// <param name="args">Defaults to an empty array.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the current executable is the default handler for a protocol (aka URI scheme).</returns>
+        Task<bool> IsDefaultProtocolClientAsync(string protocol, string path, string[] args, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Adds tasks to the <see cref="UserTask"/> category of the JumpList on Windows.
+        /// <para/>
+        /// Note: If you'd like to customize the Jump List even more use <see cref="SetJumpList"/> instead.
+        /// </summary>
+        /// <param name="userTasks">Array of <see cref="UserTask"/> objects.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> SetUserTasksAsync(UserTask[] userTasks, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Jump List settings for the application.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Jump List settings.</returns>
+        Task<JumpListSettings> GetJumpListSettingsAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets or removes a custom Jump List for the application. If categories is null the previously set custom
+        /// Jump List (if any) will be replaced by the standard Jump List for the app (managed by Windows).
+        /// <para/>
+        /// Note: If a <see cref="JumpListCategory"/> object has neither the <see cref="JumpListCategory.Type"/> nor
+        /// the <see cref="JumpListCategory.Name"/> property set then its <see cref="JumpListCategory.Type"/> is assumed
+        /// to be <see cref="JumpListCategoryType.tasks"/>. If the <see cref="JumpListCategory.Name"/> property is set but
+        /// the <see cref="JumpListCategory.Type"/> property is omitted then the <see cref="JumpListCategory.Type"/> is
+        /// assumed to be <see cref="JumpListCategoryType.custom"/>.
+        /// <para/>
+        /// Note: Users can remove items from custom categories, and Windows will not allow a removed item to be added
+        /// back into a custom category until after the next successful call to <see cref="SetJumpList"/>. Any attempt
+        /// to re-add a removed item to a custom category earlier than that will result in the entire custom category being
+        /// omitted from the Jump List. The list of removed items can be obtained using <see cref="GetJumpListSettingsAsync"/>.
+        /// </summary>
+        /// <param name="categories">Array of <see cref="JumpListCategory"/> objects.</param>
+        void SetJumpList(JumpListCategory[] categories);
+
+        /// <summary>
+        /// The return value of this method indicates whether or not this instance of your application successfully obtained
+        /// the lock. If it failed to obtain the lock, you can assume that another instance of your application is already
+        /// running with the lock and exit immediately.
+        /// <para/>
+        /// I.e.This method returns <see langword="true"/> if your process is the primary instance of your application and your
+        /// app should continue loading. It returns <see langword="false"/> if your process should immediately quit as it has
+        /// sent its parameters to another instance that has already acquired the lock.
+        /// <para/>
+        /// On macOS, the system enforces single instance automatically when users try to open a second instance of your app
+        /// in Finder, and the open-file and open-url events will be emitted for that.However when users start your app in
+        /// command line, the system's single instance mechanism will be bypassed, and you have to use this method to ensure
+        /// single instance.
+        /// </summary>
+        /// <param name="newInstanceOpened">Lambda with an array of the second instance’s command line arguments.
+        /// The second parameter is the working directory path.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>This method returns false if your process is the primary instance of the application and your app
+        /// should continue loading. And returns true if your process has sent its parameters to another instance, and
+        /// you should immediately quit.
+        /// </returns>
+        Task<bool> RequestSingleInstanceLockAsync(Action<string[], string> newInstanceOpened, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Releases all locks that were created by makeSingleInstance. This will allow
+        /// multiple instances of the application to once again run side by side.
+        /// </summary>
+        void ReleaseSingleInstanceLock();
+
+        /// <summary>
+        /// This method returns whether or not this instance of your app is currently holding the single instance lock.
+        /// You can request the lock with <see cref="RequestSingleInstanceLockAsync"/> and release with
+        /// <see cref="ReleaseSingleInstanceLock"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        Task<bool> HasSingleInstanceLockAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Creates an NSUserActivity and sets it as the current activity. The activity is
+        /// eligible for <see href="https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/Handoff/HandoffFundamentals/HandoffFundamentals.html">Handoff</see>
+        /// to another device afterward.
+        /// </summary>
+        /// <param name="type">Uniquely identifies the activity. Maps to <see href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSUserActivity_Class/index.html#//apple_ref/occ/instp/NSUserActivity/activityType">NSUserActivity.activityType</see>.</param>
+        /// <param name="userInfo">App-specific state to store for use by another device.</param>
+        void SetUserActivity(string type, object userInfo);
+
+        /// <summary>
+        /// Creates an NSUserActivity and sets it as the current activity. The activity is
+        /// eligible for <see href="https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/Handoff/HandoffFundamentals/HandoffFundamentals.html">Handoff</see>
+        /// to another device afterward.
+        /// </summary>
+        /// <param name="type">
+        /// Uniquely identifies the activity. Maps to <see href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSUserActivity_Class/index.html#//apple_ref/occ/instp/NSUserActivity/activityType">NSUserActivity.activityType</see>.
+        /// </param>
+        /// <param name="userInfo">App-specific state to store for use by another device.</param>
+        /// <param name="webpageUrl">
+        /// The webpage to load in a browser if no suitable app is installed on the resuming device. The scheme must be http or https.
+        /// </param>
+        void SetUserActivity(string type, object userInfo, string webpageUrl);
+
+        /// <summary>
+        /// The type of the currently running activity.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        Task<string> GetCurrentActivityTypeAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Invalidates the current <see href="https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/Handoff/HandoffFundamentals/HandoffFundamentals.html">Handoff</see> user activity.
+        /// </summary>
+        void InvalidateCurrentActivity();
+
+        /// <summary>
+        /// Marks the current <see href="https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/Handoff/HandoffFundamentals/HandoffFundamentals.html">Handoff</see> user activity as inactive without invalidating it.
+        /// </summary>
+        void ResignCurrentActivity();
+
+        /// <summary>
+        /// Changes the <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx">Application User Model ID</see> to id.
+        /// </summary>
+        /// <param name="id">Model Id.</param>
+        void SetAppUserModelId(string id);
+
+        /// TODO: Check new parameter which is a function [App.ImportCertificate]
+        /// <summary>
+        /// Imports the certificate in pkcs12 format into the platform certificate store.
+        /// callback is called with the result of import operation, a value of 0 indicates
+        /// success while any other value indicates failure according to chromium net_error_list.
+        /// </summary>
+        /// <param name="options"></param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Result of import. Value of 0 indicates success.</returns>
+        Task<int> ImportCertificateAsync(ImportCertificateOptions options, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Memory and cpu usage statistics of all the processes associated with the app.
+        /// </summary>
+        /// <returns>
+        /// Array of ProcessMetric objects that correspond to memory and cpu usage
+        /// statistics of all the processes associated with the app.
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// </returns>
+        Task<ProcessMetric[]> GetAppMetricsAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// The Graphics Feature Status from chrome://gpu/.
+        /// <para/>
+        /// Note: This information is only usable after the gpu-info-update event is emitted.
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// </summary>
+        Task<GPUFeatureStatus> GetGpuFeatureStatusAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets the counter badge for current app. Setting the count to 0 will hide the badge.
+        /// On macOS it shows on the dock icon. On Linux it only works for Unity launcher.
+        /// <para/>
+        /// Note: Unity launcher requires the existence of a .desktop file to work, for more
+        /// information please read <see href="https://www.electronjs.org/docs/tutorial/desktop-environment-integration#unity-launcher">Desktop Environment Integration</see>.
+        /// </summary>
+        /// <param name="count">Counter badge.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Whether the call succeeded.</returns>
+        Task<bool> SetBadgeCountAsync(int count, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// The current value displayed in the counter badge.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        Task<int> GetBadgeCountAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Whether the current desktop environment is Unity launcher.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        Task<bool> IsUnityRunningAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// If you provided path and args options to <see cref="SetLoginItemSettings"/> then you need to pass the same
+        /// arguments here for <see cref="LoginItemSettings.OpenAtLogin"/> to be set correctly.
+        /// </summary>
+        Task<LoginItemSettings> GetLoginItemSettingsAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// If you provided path and args options to <see cref="SetLoginItemSettings"/> then you need to pass the same
+        /// arguments here for <see cref="LoginItemSettings.OpenAtLogin"/> to be set correctly.
+        /// </summary>
+        /// <param name="options"></param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        Task<LoginItemSettings> GetLoginItemSettingsAsync(LoginItemSettingsOptions options, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Set the app's login item settings.
+        /// To work with Electron's autoUpdater on Windows, which uses <see href="https://github.com/Squirrel/Squirrel.Windows">Squirrel</see>,
+        /// you'll want to set the launch path to Update.exe, and pass arguments that specify your application name.
+        /// </summary>
+        /// <param name="loginSettings"></param>
+        void SetLoginItemSettings(LoginSettings loginSettings);
+
+        /// <summary>
+        /// <see langword="true"/> if Chrome's accessibility support is enabled, <see langword="false"/> otherwise. This API will
+        /// return <see langword="true"/> if the use of assistive technologies, such as screen readers, has been detected.
+        /// See <see href="chromium.org/developers/design-documents/accessibility">Chromium's accessibility docs</see> for more details.
+        /// </summary>
+        /// <returns><see langword="true"/> if Chrome’s accessibility support is enabled, <see langword="false"/> otherwise.</returns>
+        Task<bool> IsAccessibilitySupportEnabledAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Manually enables Chrome's accessibility support, allowing to expose accessibility switch to users in application settings.
+        /// See <see href="chromium.org/developers/design-documents/accessibility">Chromium's accessibility docs</see> for more details.
+        /// Disabled (<see langword="false"/>) by default.
+        /// <para/>
+        /// This API must be called after the <see cref="Ready"/> event is emitted.
+        /// <para/>
+        /// Note: Rendering accessibility tree can significantly affect the performance of your app. It should not be enabled by default.
+        /// </summary>
+        /// <param name="enabled">Enable or disable <see href="https://developers.google.com/web/fundamentals/accessibility/semantics-builtin/the-accessibility-tree">accessibility tree</see> rendering.</param>
+        void SetAccessibilitySupportEnabled(bool enabled);
+
+        /// <summary>
+        /// Show the app's about panel options. These options can be overridden with
+        /// <see cref="SetAboutPanelOptions"/>.
+        /// </summary>
+        void ShowAboutPanel();
+
+        /// <summary>
+        /// Set the about panel options. This will override the values defined in the app's .plist file on macOS. See the
+        /// <see href="https://developer.apple.com/reference/appkit/nsapplication/1428479-orderfrontstandardaboutpanelwith?language=objc">Apple docs</see>
+        /// for more details. On Linux, values must be set in order to be shown; there are no defaults.
+        /// <para/>
+        /// If you do not set credits but still wish to surface them in your app, AppKit will look for a file named "Credits.html",
+        /// "Credits.rtf", and "Credits.rtfd", in that order, in the bundle returned by the NSBundle class method main. The first file
+        /// found is used, and if none is found, the info area is left blank. See Apple
+        /// <see href="https://developer.apple.com/documentation/appkit/nsaboutpaneloptioncredits?language=objc">documentation</see> for more information.
+        /// </summary>
+        /// <param name="options">About panel options.</param>
+        void SetAboutPanelOptions(AboutPanelOptions options);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="App"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void On(string eventName, Action fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="App"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void On(string eventName, Action<object> fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="App"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void Once(string eventName, Action fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="App"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void Once(string eventName, Action<object> fn);
+    }
+}

ElectronNET.API/Interfaces/IApplicationSocket.cs

@@ -0,0 +1,15 @@
+using Quobject.SocketIoClientDotNet.Client;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Wrapper for the underlying Socket connection
+    /// </summary>
+    public interface IApplicationSocket
+    {
+        /// <summary>
+        /// Socket used to communicate with main.js
+        /// </summary>
+        Socket Socket { get; }
+    }
+}

ElectronNET.API/Interfaces/IAutoUpdater.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Enable apps to automatically update themselves. Based on electron-updater.
+    /// </summary>
+    public interface IAutoUpdater
+    {
+        /// <summary>
+        /// Whether to automatically download an update when it is found. (Default is true)
+        /// </summary>
+        bool AutoDownload { get; set; }
+
+        /// <summary>
+        /// Whether to automatically install a downloaded update on app quit (if `QuitAndInstall` was not called before).
+        /// 
+        /// Applicable only on Windows and Linux.
+        /// </summary>
+        bool AutoInstallOnAppQuit { get; set; }
+
+        /// <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>
+        bool AllowPrerelease { get; set; }
+
+        /// <summary>
+        /// *GitHub provider only.* 
+        /// Get all release notes (from current version to latest), not just the latest (Default is false).
+        /// </summary>
+        bool FullChangelog { get; set; }
+
+        /// <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>
+        bool AllowDowngrade { get; set; }
+
+        /// <summary>
+        /// For test only.
+        /// </summary>
+        string UpdateConfigPath { get; }
+
+        /// <summary>
+        /// The current application version
+        /// </summary>
+        Task<SemVer> CurrentVersionAsync { get; }
+
+        /// <summary>
+        /// Get the update channel. Not applicable for GitHub. 
+        /// Doesn’t return channel from the update configuration, only if was previously set.
+        /// </summary>
+        string Channel { get; }
+
+        /// <summary>
+        /// Get the update channel. Not applicable for GitHub. 
+        /// Doesn’t return channel from the update configuration, only if was previously set.
+        /// </summary>
+        Task<string> ChannelAsync { get; }
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        Task<Dictionary<string, string>> RequestHeadersAsync { get; }
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        Dictionary<string, string> RequestHeaders { set; }
+
+        /// <summary>
+        /// Emitted when there is an error while updating.
+        /// </summary>
+        event Action<string> OnError;
+
+        /// <summary>
+        /// Emitted when checking if an update has started.
+        /// </summary>
+        event Action OnCheckingForUpdate;
+
+        /// <summary>
+        /// Emitted when there is an available update. 
+        /// The update is downloaded automatically if AutoDownload is true.
+        /// </summary>
+        event Action<UpdateInfo> OnUpdateAvailable;
+
+        /// <summary>
+        /// Emitted when there is no available update.
+        /// </summary>
+        event Action<UpdateInfo> OnUpdateNotAvailable;
+
+        /// <summary>
+        /// Emitted on download progress.
+        /// </summary>
+        event Action<ProgressInfo> OnDownloadProgress;
+
+        /// <summary>
+        /// Emitted on download complete.
+        /// </summary>
+        event Action<UpdateInfo> OnUpdateDownloaded;
+
+        /// <summary>
+        /// Asks the server whether there is an update.
+        /// </summary>
+        /// <returns></returns>
+        Task<UpdateCheckResult> CheckForUpdatesAsync();
+
+        /// <summary>
+        /// Asks the server whether there is an update.
+        /// 
+        /// This will immediately download an update, then install when the app quits.
+        /// </summary>
+        /// <returns></returns>
+        Task<UpdateCheckResult> CheckForUpdatesAndNotifyAsync();
+
+        /// <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>
+        void QuitAndInstall(bool isSilent = false, bool isForceRunAfter = false);
+
+        /// <summary>
+        /// Start downloading update manually. You can use this method if "AutoDownload" option is set to "false".
+        /// </summary>
+        /// <returns>Path to downloaded file.</returns>
+        Task<string> DownloadUpdateAsync();
+
+        /// <summary>
+        /// Feed URL.
+        /// </summary>
+        /// <returns>Feed URL.</returns>
+        Task<string> GetFeedURLAsync();
+    }
+}

ElectronNET.API/Interfaces/IClipboard.cs

@@ -0,0 +1,122 @@
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Perform copy and paste operations on the system clipboard.
+    /// </summary>
+    public interface IClipboard
+    {
+        /// <summary>
+        /// Read the content in the clipboard as plain text.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns>The content in the clipboard as plain text.</returns>
+        Task<string> ReadTextAsync(string type = "");
+
+        /// <summary>
+        /// Writes the text into the clipboard as plain text.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="type"></param>
+        void WriteText(string text, string type = "");
+
+        /// <summary>
+        /// The content in the clipboard as markup.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        Task<string> ReadHTMLAsync(string type = "");
+
+        /// <summary>
+        /// Writes markup to the clipboard.
+        /// </summary>
+        /// <param name="markup"></param>
+        /// <param name="type"></param>
+        void WriteHTML(string markup, string type = "");
+
+        /// <summary>
+        /// The content in the clipboard as RTF.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        Task<string> ReadRTFAsync(string type = "");
+
+        /// <summary>
+        /// Writes the text into the clipboard in RTF.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="type"></param>
+        void WriteRTF(string text, string type = "");
+
+        /// <summary>
+        /// Returns an Object containing title and url keys representing 
+        /// the bookmark in the clipboard. The title and url values will 
+        /// be empty strings when the bookmark is unavailable.
+        /// </summary>
+        /// <returns></returns>
+        Task<ReadBookmark> ReadBookmarkAsync();
+
+        /// <summary>
+        /// Writes the title and url into the clipboard as a bookmark.
+        /// 
+        /// Note: Most apps on Windows don’t support pasting bookmarks
+        /// into them so you can use clipboard.write to write both a 
+        /// bookmark and fallback text to the clipboard.
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="url"></param>
+        /// <param name="type"></param>
+        void WriteBookmark(string title, string url, string type = "");
+
+        /// <summary>
+        /// macOS: The text on the find pasteboard. This method uses synchronous IPC
+        /// when called from the renderer process. The cached value is reread from the
+        /// find pasteboard whenever the application is activated.
+        /// </summary>
+        /// <returns></returns>
+        Task<string> ReadFindTextAsync();
+
+        /// <summary>
+        /// macOS: Writes the text into the find pasteboard as plain text. This method uses 
+        /// synchronous IPC when called from the renderer process.
+        /// </summary>
+        /// <param name="text"></param>
+        void WriteFindText(string text);
+
+        /// <summary>
+        /// Clears the clipboard content.
+        /// </summary>
+        /// <param name="type"></param>
+        void Clear(string type = "");
+
+        /// <summary>
+        /// An array of supported formats for the clipboard type.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        Task<string[]> AvailableFormatsAsync(string type = "");
+
+        /// <summary>
+        /// Writes data to the clipboard.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="type"></param>
+        void Write(Data data, string type = "");
+
+        /// <summary>
+        /// Reads an image from the clipboard.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        Task<NativeImage> ReadImageAsync(string type = "");
+
+        /// <summary>
+        /// Writes an image to the clipboard.
+        /// </summary>
+        /// <param name="image"></param>
+        /// <param name="type"></param>
+        void WriteImage(NativeImage image, string type = "");
+    }
+}

ElectronNET.API/Interfaces/IDialog.cs

@@ -0,0 +1,102 @@
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Display native system dialogs for opening and saving files, alerting, etc.
+    /// </summary>
+    public interface IDialog
+    {
+        /// <summary>
+        /// Note: On Windows and Linux an open dialog can not be both a file selector 
+        /// and a directory selector, so if you set properties to ['openFile', 'openDirectory'] 
+        /// on these platforms, a directory selector will be shown.
+        /// </summary>
+        /// <param name="browserWindow">The browserWindow argument allows the dialog to attach itself to a parent window, making it modal.</param>
+        /// <param name="options"></param>
+        /// <returns>An array of file paths chosen by the user</returns>
+        Task<string[]> ShowOpenDialogAsync(BrowserWindow browserWindow, OpenDialogOptions options);
+
+        /// <summary>
+        /// Dialog for save files.
+        /// </summary>
+        /// <param name="browserWindow">The browserWindow argument allows the dialog to attach itself to a parent window, making it modal.</param>
+        /// <param name="options"></param>
+        /// <returns>Returns String, the path of the file chosen by the user, if a callback is provided it returns an empty string.</returns>
+        Task<string> ShowSaveDialogAsync(BrowserWindow browserWindow, SaveDialogOptions options);
+
+        /// <summary>
+        /// Shows a message box, it will block the process until the message box is closed.
+        /// It returns the index of the clicked button. The browserWindow argument allows
+        /// the dialog to attach itself to a parent window, making it modal. If a callback
+        /// is passed, the dialog will not block the process.The API call will be
+        /// asynchronous and the result will be passed via callback(response).
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
+        Task<MessageBoxResult> ShowMessageBoxAsync(string message);
+
+        /// <summary>
+        /// Shows a message box, it will block the process until the message box is closed.
+        /// It returns the index of the clicked button. The browserWindow argument allows
+        /// the dialog to attach itself to a parent window, making it modal. If a callback
+        /// is passed, the dialog will not block the process.The API call will be
+        /// asynchronous and the result will be passed via callback(response).
+        /// </summary>
+        /// <param name="messageBoxOptions"></param>
+        /// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
+        Task<MessageBoxResult> ShowMessageBoxAsync(MessageBoxOptions messageBoxOptions);
+
+        /// <summary>
+        /// Shows a message box, it will block the process until the message box is closed.
+        /// It returns the index of the clicked button. If a callback
+        /// is passed, the dialog will not block the process.
+        /// </summary>
+        /// <param name="browserWindow">The browserWindow argument allows the dialog to attach itself to a parent window, making it modal.</param>
+        /// <param name="message"></param>
+        /// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
+        Task<MessageBoxResult> ShowMessageBoxAsync(BrowserWindow browserWindow, string message);
+
+        /// <summary>
+        /// Shows a message box, it will block the process until the message box is closed.
+        /// It returns the index of the clicked button. If a callback
+        /// is passed, the dialog will not block the process.
+        /// </summary>
+        /// <param name="browserWindow">The browserWindow argument allows the dialog to attach itself to a parent window, making it modal.</param>
+        /// <param name="messageBoxOptions"></param>
+        /// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
+        Task<MessageBoxResult> ShowMessageBoxAsync(BrowserWindow browserWindow, MessageBoxOptions messageBoxOptions);
+
+        /// <summary>
+        /// Displays a modal dialog that shows an error message.
+        /// 
+        /// This API can be called safely before the ready event the app module emits, 
+        /// it is usually used to report errors in early stage of startup.If called 
+        /// before the app readyevent on Linux, the message will be emitted to stderr, 
+        /// and no GUI dialog will appear.
+        /// </summary>
+        /// <param name="title">The title to display in the error box.</param>
+        /// <param name="content">The text content to display in the error box.</param>
+        void ShowErrorBox(string title, string content);
+
+        /// <summary>
+        /// On macOS, this displays a modal dialog that shows a message and certificate information,
+        /// and gives the user the option of trusting/importing the certificate. If you provide a 
+        /// browserWindow argument the dialog will be attached to the parent window, making it modal.
+        /// </summary>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        Task ShowCertificateTrustDialogAsync(CertificateTrustDialogOptions options);
+
+        /// <summary>
+        /// On macOS, this displays a modal dialog that shows a message and certificate information,
+        /// and gives the user the option of trusting/importing the certificate. If you provide a 
+        /// browserWindow argument the dialog will be attached to the parent window, making it modal.
+        /// </summary>
+        /// <param name="browserWindow"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        Task ShowCertificateTrustDialogAsync(BrowserWindow browserWindow, CertificateTrustDialogOptions options);
+    }
+}

ElectronNET.API/Interfaces/IDock.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Control your app in the macOS dock.
+    /// </summary>
+    public interface IDock
+    {
+        /// <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>
+        Task<int> BounceAsync(DockBounceType type, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Cancel the bounce of id.
+        /// </summary>
+        /// <param name="id">Id of the request.</param>
+        void CancelBounce(int id);
+
+        /// <summary>
+        /// Bounces the Downloads stack if the filePath is inside the Downloads folder.
+        /// </summary>
+        /// <param name="filePath"></param>
+        void DownloadFinished(string filePath);
+
+        /// <summary>
+        /// Sets the string to be displayed in the dock’s badging area.
+        /// </summary>
+        /// <param name="text"></param>
+        void SetBadge(string 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>
+        Task<string> GetBadgeAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Hides the dock icon.
+        /// </summary>
+        void Hide();
+
+        /// <summary>
+        /// Shows the dock icon.
+        /// </summary>
+        void 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>
+        Task<bool> IsVisibleAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Gets the dock menu items.
+        /// </summary>
+        /// <value>
+        /// The menu items.
+        /// </value>
+        IReadOnlyCollection<MenuItem> MenuItems { get; }
+
+        /// <summary>
+        /// Sets the application's dock menu.
+        /// </summary>
+        void SetMenu(MenuItem[] menuItems);
+
+        /// <summary>
+        /// TODO: Menu (macOS) still to be implemented
+        /// Gets the application's dock menu.
+        /// </summary>
+        Task<Menu> GetMenu(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Sets the image associated with this dock icon.
+        /// </summary>
+        /// <param name="image"></param>
+        void SetIcon(string image);
+    }
+}

ElectronNET.API/Interfaces/IGlobalShortcut.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Detect keyboard events when the application does not have keyboard focus.
+    /// </summary>
+    public interface IGlobalShortcut
+    {
+        /// <summary>
+        /// Registers a global shortcut of accelerator. 
+        /// The callback is called when the registered shortcut is pressed by the user.
+        /// 
+        /// When the accelerator is already taken by other applications, this call will 
+        /// silently fail.This behavior is intended by operating systems, since they don’t
+        /// want applications to fight for global shortcuts.
+        /// </summary>
+        void Register(string accelerator, Action function);
+
+        /// <summary>
+        /// When the accelerator is already taken by other applications, 
+        /// this call will still return false. This behavior is intended by operating systems,
+        /// since they don’t want applications to fight for global shortcuts.
+        /// </summary>
+        /// <returns>Whether this application has registered accelerator.</returns>
+        Task<bool> IsRegisteredAsync(string accelerator);
+
+        /// <summary>
+        /// Unregisters the global shortcut of accelerator.
+        /// </summary>
+        void Unregister(string accelerator);
+
+        /// <summary>
+        /// Unregisters all of the global shortcuts.
+        /// </summary>
+        void UnregisterAll();
+    }
+}

ElectronNET.API/Interfaces/IHostHook.cs

@@ -0,0 +1,30 @@
+using System.Threading.Tasks;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <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 interface IHostHook
+    {
+        /// <summary>
+        /// Execute native JavaScript/TypeScript code.
+        /// </summary>
+        /// <param name="socketEventName">Socket name registered on the host.</param>
+        /// <param name="arguments">Optional parameters.</param>
+        void Call(string socketEventName, params dynamic[] arguments);
+
+        /// <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>
+        Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments);
+    }
+}

ElectronNET.API/Interfaces/IIpcMain.cs

@@ -0,0 +1,65 @@
+using System;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Communicate asynchronously from the main process to renderer processes.
+    /// </summary>
+    public interface IIpcMain
+    {
+        /// <summary>
+        ///  Listens to channel, when a new message arrives listener would be called with 
+        ///  listener(event, args...).
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        void On(string channel, Action<object> listener);
+
+        /// <summary>
+        /// Send a message to the renderer process synchronously via channel, 
+        /// you can also send arbitrary arguments.
+        /// 
+        /// Note: Sending a synchronous message will block the whole renderer process,
+        /// unless you know what you are doing you should never use it.
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="listener"></param>
+        void OnSync(string channel, Func<object, object> listener);
+
+        /// <summary>
+        /// Adds a one time listener method for the event. This listener is invoked only
+        ///  the next time a message is sent to channel, after which it is removed.
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="listener">Callback Method.</param>
+        void Once(string channel, Action<object> listener);
+
+        /// <summary>
+        /// Removes listeners of the specified channel.
+        /// </summary>
+        /// <param name="channel">Channelname.</param>
+        void RemoveAllListeners(string channel);
+
+        /// <summary>
+        /// Send a message to the 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="browserWindow">BrowserWindow with channel.</param>
+        /// <param name="channel">Channelname.</param>
+        /// <param name="data">Arguments data.</param>
+        void Send(BrowserWindow browserWindow, string channel, params object[] data);
+
+        /// <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>
+        void Send(BrowserView browserView, string channel, params object[] data);
+    }
+}

ElectronNET.API/Interfaces/IMenu.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Create native application menus and context menus.
+    /// </summary>
+    public interface IMenu
+    {
+        /// <summary>
+        /// Gets the menu items.
+        /// </summary>
+        /// <value>
+        /// The menu items.
+        /// </value>
+        IReadOnlyCollection<MenuItem> MenuItems { get; }
+
+        /// <summary>
+        /// Gets the context menu items.
+        /// </summary>
+        /// <value>
+        /// The context menu items.
+        /// </value>
+        IReadOnlyDictionary<int, ReadOnlyCollection<MenuItem>> ContextMenuItems { get; }
+
+        /// <summary>
+        /// Sets the application menu.
+        /// </summary>
+        /// <param name="menuItems">The menu items.</param>
+        void SetApplicationMenu(MenuItem[] menuItems);
+
+        /// <summary>
+        /// Sets the context menu.
+        /// </summary>
+        /// <param name="browserWindow">The browser window.</param>
+        /// <param name="menuItems">The menu items.</param>
+        void SetContextMenu(BrowserWindow browserWindow, MenuItem[] menuItems);
+
+        /// <summary>
+        /// Contexts the menu popup.
+        /// </summary>
+        /// <param name="browserWindow">The browser window.</param>
+        void ContextMenuPopup(BrowserWindow browserWindow);
+    }
+}

ElectronNET.API/Interfaces/INativeTheme.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Read and respond to changes in Chromium's native color theme.
+    /// </summary>
+    public interface INativeTheme
+    {
+        /// <summary>
+        /// Setting this property to <see cref="ThemeSourceMode.System"/> will remove the override and everything will be reset to the OS default. By default 'ThemeSource' is <see cref="ThemeSourceMode.System"/>.
+        /// <para/>
+        /// Settings this property to <see cref="ThemeSourceMode.Dark"/> will have the following effects:
+        /// <list type="bullet">
+        /// <item>
+        /// <description><see cref="ShouldUseDarkColorsAsync"/> will be <see langword="true"/> when accessed</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI Electron renders on Linux and Windows including context menus, devtools, etc. will use the dark UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI the OS renders on macOS including menus, window frames, etc. will use the dark UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'prefers-color-scheme' CSS query will match 'dark' mode.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'updated' event will be emitted</description>
+        /// </item> 
+        /// </list>
+        /// <para/>
+        /// Settings this property to <see cref="ThemeSourceMode.Light"/> will have the following effects:
+        /// <list type="bullet">
+        /// <item>
+        /// <description><see cref="ShouldUseDarkColorsAsync"/> will be <see langword="false"/> when accessed</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI Electron renders on Linux and Windows including context menus, devtools, etc. will use the light UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>Any UI the OS renders on macOS including menus, window frames, etc. will use the light UI.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'prefers-color-scheme' CSS query will match 'light' mode.</description>
+        /// </item>
+        /// <item>
+        /// <description>The 'updated' event will be emitted</description>
+        /// </item>
+        /// </list> 
+        /// The usage of this property should align with a classic "dark mode" state machine in your application where the user has three options.
+        /// <para/>
+        /// <list type="bullet">
+        /// <item>
+        /// <description>Follow OS: SetThemeSource(ThemeSourceMode.System);</description>
+        /// </item>
+        /// <item>
+        /// <description>Dark Mode: SetThemeSource(ThemeSourceMode.Dark);</description>
+        /// </item>
+        /// <item>
+        /// <description>Light Mode: SetThemeSource(ThemeSourceMode.Light);</description>
+        /// </item>
+        /// </list>
+        /// Your application should then always use <see cref="ShouldUseDarkColorsAsync"/> to determine what CSS to apply.
+        /// </summary>
+        /// <param name="themeSourceMode">The new ThemeSource.</param>
+        void SetThemeSource(ThemeSourceMode themeSourceMode);
+
+        /// <summary>
+        /// A <see cref="ThemeSourceMode"/> property that can be <see cref="ThemeSourceMode.System"/>, <see cref="ThemeSourceMode.Light"/> or <see cref="ThemeSourceMode.Dark"/>. It is used to override (<seealso cref="SetThemeSource"/>) and
+        /// supercede the value that Chromium has chosen to use internally.
+        /// </summary>
+        Task<ThemeSourceMode> GetThemeSourceAsync();
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has a dark mode enabled or is
+        /// being instructed to show a dark-style UI. If you want to modify this value you
+        /// should use <see cref="SetThemeSource"/>.
+        /// </summary>
+        Task<bool> ShouldUseDarkColorsAsync();
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has high-contrast mode enabled or is
+        /// being instructed to show a high-contrast UI.
+        /// </summary>
+        Task<bool> ShouldUseHighContrastColorsAsync();
+
+        /// <summary>
+        /// A <see cref="bool"/> for if the OS / Chromium currently has an inverted color scheme or is
+        /// being instructed to use an inverted color scheme.
+        /// </summary>
+        Task<bool> ShouldUseInvertedColorSchemeAsync();
+
+        /// <summary>
+        /// Emitted when something in the underlying NativeTheme has changed. This normally means that either the value of <see cref="ShouldUseDarkColorsAsync"/>,
+        /// <see cref="ShouldUseHighContrastColorsAsync"/> or <see cref="ShouldUseInvertedColorSchemeAsync"/> has changed. You will have to check them to determine which one has changed.
+        /// </summary>
+        event Action Updated;
+    }
+}

ElectronNET.API/Interfaces/INotification.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Create OS desktop notifications
+    /// </summary>
+    public interface INotification
+    {
+        /// <summary>
+        /// Create OS desktop notifications
+        /// </summary>
+        /// <param name="notificationOptions"></param>
+        void Show(NotificationOptions notificationOptions);
+
+        /// <summary>
+        /// Whether or not desktop notifications are supported on the current system.
+        /// </summary>
+        /// <returns></returns>
+        Task<bool> IsSupportedAsync();
+    }
+}

ElectronNET.API/Interfaces/IPowerMonitor.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Monitor power state changes..
+    /// </summary>
+    public interface IPowerMonitor
+    {
+        /// <summary>
+        /// Emitted when the system is about to lock the screen. 
+        /// </summary>
+        event Action OnLockScreen;
+
+        /// <summary>
+        /// Emitted when the system is about to unlock the screen. 
+        /// </summary>
+        event Action OnUnLockScreen;
+
+        /// <summary>
+        /// Emitted when the system is suspending.
+        /// </summary>
+        event Action OnSuspend;
+
+        /// <summary>
+        /// Emitted when system is resuming.
+        /// </summary>
+        event Action OnResume;
+
+        /// <summary>
+        /// Emitted when the system changes to AC power.
+        /// </summary>
+        event Action OnAC;
+
+        /// <summary>
+        /// Emitted when system changes to battery power.
+        /// </summary>
+        event Action OnBattery;
+
+        /// <summary>
+        /// Emitted when the system is about to reboot or shut down. If the event handler
+        /// invokes `e.preventDefault()`, Electron will attempt to delay system shutdown in
+        /// order for the app to exit cleanly.If `e.preventDefault()` is called, the app
+        /// should exit as soon as possible by calling something like `app.quit()`.
+        /// </summary>
+        event Action OnShutdown;
+    }
+}

ElectronNET.API/Interfaces/IScreen.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Retrieve information about screen size, displays, cursor position, etc.
+    /// </summary>
+    public interface IScreen
+    {
+        /// <summary>
+        /// Emitted when an new Display has been added.
+        /// </summary>
+        event Action<Display> OnDisplayAdded;
+
+        /// <summary>
+        /// Emitted when oldDisplay has been removed.
+        /// </summary>
+        event Action<Display> OnDisplayRemoved;
+
+        /// <summary>
+        /// Emitted when one or more metrics change in a display. 
+        /// The changedMetrics is an array of strings that describe the changes. 
+        /// Possible changes are bounds, workArea, scaleFactor and rotation.
+        /// </summary>
+        event Action<Display, string[]> OnDisplayMetricsChanged;
+
+        /// <summary>
+        /// The current absolute position of the mouse pointer.
+        /// </summary>
+        /// <returns></returns>
+        Task<Point> GetCursorScreenPointAsync();
+
+        /// <summary>
+        /// macOS: The height of the menu bar in pixels.
+        /// </summary>
+        /// <returns>The height of the menu bar in pixels.</returns>
+        Task<int> GetMenuBarHeightAsync();
+
+        /// <summary>
+        /// The primary display.
+        /// </summary>
+        /// <returns></returns>
+        Task<Display> GetPrimaryDisplayAsync();
+
+        /// <summary>
+        /// An array of displays that are currently available.
+        /// </summary>
+        /// <returns>An array of displays that are currently available.</returns>
+        Task<Display[]> GetAllDisplaysAsync();
+
+        /// <summary>
+        /// The display nearest the specified point.
+        /// </summary>
+        /// <returns>The display nearest the specified point.</returns>
+        Task<Display> GetDisplayNearestPointAsync(Point point);
+
+        /// <summary>
+        /// The display that most closely intersects the provided bounds.
+        /// </summary>
+        /// <param name="rectangle"></param>
+        /// <returns>The display that most closely intersects the provided bounds.</returns>
+        Task<Display> GetDisplayMatchingAsync(Rectangle rectangle);
+    }
+}

ElectronNET.API/Interfaces/IShell.cs

@@ -0,0 +1,70 @@
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Manage files and URLs using their default applications.
+    /// </summary>
+    public interface IShell
+    {
+        /// <summary>
+        /// Show the given file in a file manager. If possible, select the file.
+        /// </summary>
+        /// <param name="fullPath">The full path to the directory / file.</param>
+        Task ShowItemInFolderAsync(string fullPath);
+
+        /// <summary>
+        /// Open the given file in the desktop's default manner.
+        /// </summary>
+        /// <param name="path">The path to the directory / file.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        Task<string> OpenPathAsync(string path);
+
+        /// <summary>
+        /// Open the given external protocol URL in the desktop’s default manner. 
+        /// (For example, mailto: URLs in the user’s default mail agent).
+        /// </summary>
+        /// <param name="url">Max 2081 characters on windows.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        Task<string> OpenExternalAsync(string url);
+
+        /// <summary>
+        /// Open the given external protocol URL in the desktop’s default manner. 
+        /// (For example, mailto: URLs in the user’s default mail agent).
+        /// </summary>
+        /// <param name="url">Max 2081 characters on windows.</param>
+        /// <param name="options">Controls the behavior of OpenExternal.</param>
+        /// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
+        Task<string> OpenExternalAsync(string url, OpenExternalOptions options);
+
+        /// <summary>
+        /// Move the given file to trash and returns a <see cref="bool"/> status for the operation.
+        /// </summary>
+        /// <param name="fullPath">The full path to the directory / file.</param>
+        /// <returns> Whether the item was successfully moved to the trash.</returns>
+        Task<bool> TrashItemAsync(string fullPath);
+
+        /// <summary>
+        /// Play the beep sound.
+        /// </summary>
+        void Beep();
+
+        /// <summary>
+        /// Creates or updates a shortcut link at shortcutPath.
+        /// </summary>
+        /// <param name="shortcutPath">The path to the shortcut.</param>
+        /// <param name="operation">Default is <see cref="ShortcutLinkOperation.Create"/></param>
+        /// <param name="options">Structure of a shortcut.</param>
+        /// <returns>Whether the shortcut was created successfully.</returns>
+        Task<bool> WriteShortcutLinkAsync(string shortcutPath, ShortcutLinkOperation operation, ShortcutDetails options);
+
+        /// <summary>
+        /// Resolves the shortcut link at shortcutPath.
+        /// An exception will be thrown when any error happens.
+        /// </summary>
+        /// <param name="shortcutPath">The path tot the shortcut.</param>
+        /// <returns><see cref="ShortcutDetails"/> of the shortcut.</returns>
+        Task<ShortcutDetails> ReadShortcutLinkAsync(string shortcutPath);
+    }
+}

ElectronNET.API/Interfaces/ITray.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Add icons and context menus to the system's notification area.
+    /// </summary>
+    public interface ITray
+    {
+        /// <summary>
+        /// Emitted when the tray icon is clicked.
+        /// </summary>
+        event Action<TrayClickEventArgs, Rectangle> OnClick;
+
+        /// <summary>
+        /// macOS, Windows: Emitted when the tray icon is right clicked.
+        /// </summary>
+        event Action<TrayClickEventArgs, Rectangle> OnRightClick;
+
+        /// <summary>
+        /// macOS, Windows: Emitted when the tray icon is double clicked.
+        /// </summary>
+        event Action<TrayClickEventArgs, Rectangle> OnDoubleClick;
+
+        /// <summary>
+        /// Windows: Emitted when the tray balloon shows.
+        /// </summary>
+        event Action OnBalloonShow;
+
+        /// <summary>
+        /// Windows: Emitted when the tray balloon is clicked.
+        /// </summary>
+        event Action OnBalloonClick;
+
+        /// <summary>
+        /// Windows: Emitted when the tray balloon is closed 
+        /// because of timeout or user manually closes it.
+        /// </summary>
+        event Action OnBalloonClosed;
+
+        /// <summary>
+        /// Gets the menu items.
+        /// </summary>
+        /// <value>
+        /// The menu items.
+        /// </value>
+        IReadOnlyCollection<MenuItem> MenuItems { get; }
+
+        /// <summary>
+        /// Shows the Traybar.
+        /// </summary>
+        /// <param name="image">The image.</param>
+        /// <param name="menuItem">The menu item.</param>
+        void Show(string image, MenuItem menuItem);
+
+        /// <summary>
+        /// Shows the Traybar.
+        /// </summary>
+        /// <param name="image">The image.</param>
+        /// <param name="menuItems">The menu items.</param>
+        void Show(string image, MenuItem[] menuItems);
+
+        /// <summary>
+        /// Shows the Traybar (empty).
+        /// </summary>
+        /// <param name="image">The image.</param>
+        void Show(string image);
+
+        /// <summary>
+        /// Destroys the tray icon immediately.
+        /// </summary>
+        void Destroy();
+
+        /// <summary>
+        /// Sets the image associated with this tray icon.
+        /// </summary>
+        /// <param name="image"></param>
+        void SetImage(string image);
+
+        /// <summary>
+        /// Sets the image associated with this tray icon when pressed on macOS.
+        /// </summary>
+        /// <param name="image"></param>
+        void SetPressedImage(string image);
+
+        /// <summary>
+        /// Sets the hover text for this tray icon.
+        /// </summary>
+        /// <param name="toolTip"></param>
+        void SetToolTip(string toolTip);
+
+        /// <summary>
+        /// macOS: Sets the title displayed aside of the tray icon in the status bar.
+        /// </summary>
+        /// <param name="title"></param>
+        void SetTitle(string title);
+
+        /// <summary>
+        /// Windows: Displays a tray balloon.
+        /// </summary>
+        /// <param name="options"></param>
+        void DisplayBalloon(DisplayBalloonOptions options);
+
+        /// <summary>
+        /// Whether the tray icon is destroyed.
+        /// </summary>
+        /// <returns></returns>
+        Task<bool> IsDestroyedAsync();
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void On(string eventName, Action fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void On(string eventName, Action<object> fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void Once(string eventName, Action fn);
+
+        /// <summary>
+        /// Subscribe to an unmapped event on the <see cref="Tray"/> module once.
+        /// </summary>
+        /// <param name="eventName">The event name</param>
+        /// <param name="fn">The handler</param>
+        void Once(string eventName, Action<object> fn);
+    }
+}

ElectronNET.API/Interfaces/IWindowManager.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ElectronNET.API.Entities;
+
+namespace ElectronNET.API.Interfaces
+{
+    /// <summary>
+    /// Manage Browser Windows and Views
+    /// </summary>
+    public interface IWindowManager
+    {
+        /// <summary>
+        /// Quit when all windows are closed. (Default is true)
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [quit window all closed]; otherwise, <c>false</c>.
+        /// </value>
+        bool IsQuitOnWindowAllClosed { get; set; }
+
+        /// <summary>
+        /// Gets the browser windows.
+        /// </summary>
+        /// <value>
+        /// The browser windows.
+        /// </value>
+        IReadOnlyCollection<BrowserWindow> BrowserWindows { get; }
+
+        /// <summary>
+        /// Gets the browser views.
+        /// </summary>
+        /// <value>
+        /// The browser view.
+        /// </value>
+        IReadOnlyCollection<BrowserView> BrowserViews { get; }
+
+        /// <summary>
+        /// Creates the window asynchronous.
+        /// </summary>
+        /// <param name="loadUrl">The load URL.</param>
+        /// <returns></returns>
+        Task<BrowserWindow> CreateWindowAsync(string loadUrl = "http://localhost");
+
+        /// <summary>
+        /// Creates the window asynchronous.
+        /// </summary>
+        /// <param name="options">The options.</param>
+        /// <param name="loadUrl">The load URL.</param>
+        /// <returns></returns>
+        Task<BrowserWindow> CreateWindowAsync(BrowserWindowOptions options, string loadUrl = "http://localhost");
+
+        /// <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>
+        /// <returns></returns>
+        Task<BrowserView> CreateBrowserViewAsync();
+
+        /// <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>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        Task<BrowserView> CreateBrowserViewAsync(BrowserViewConstructorOptions options);
+    }
+}

ElectronNET.API/IpcMain.cs

@@ -5,13 +5,14 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Communicate asynchronously from the main process to renderer processes.
     /// </summary>
-    public sealed class IpcMain
+    public sealed class IpcMain : IIpcMain
     {
         private static IpcMain _ipcMain;
         private static object _syncRoot = new object();

ElectronNET.API/Menu.cs

@@ -6,13 +6,14 @@ using System.Collections.Generic;
 using ElectronNET.API.Extensions;
 using System.Linq;
 using System.Collections.ObjectModel;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Create native application menus and context menus.
     /// </summary>
-    public sealed class Menu
+    public sealed class Menu : IMenu
     {
         private static Menu _menu;
         private static object _syncRoot = new object();

ElectronNET.API/NativeTheme.cs

@@ -2,13 +2,14 @@
 using System.Threading.Tasks;
 using ElectronNET.API.Entities;
 using ElectronNET.API.Extensions;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Read and respond to changes in Chromium's native color theme.
     /// </summary>
-    public sealed class NativeTheme
+    public sealed class NativeTheme : INativeTheme
     {
         private static NativeTheme _nativeTheme;
         private static object _syncRoot = new object();

ElectronNET.API/Notification.cs

@@ -6,13 +6,14 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Create OS desktop notifications
     /// </summary>
-    public sealed class Notification
+    public sealed class Notification : INotification
     {
         private static Notification _notification;
         private static object _syncRoot = new object();

ElectronNET.API/PowerMonitor.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Monitor power state changes..
     /// </summary>
-    public sealed class PowerMonitor
+    public sealed class PowerMonitor : IPowerMonitor
     {
         /// <summary>
         /// Emitted when the system is about to lock the screen. 

ElectronNET.API/Screen.cs

@@ -4,13 +4,14 @@ using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Retrieve information about screen size, displays, cursor position, etc.
     /// </summary>
-    public sealed class Screen
+    public sealed class Screen : IScreen
     {
         /// <summary>
         /// Emitted when an new Display has been added.

ElectronNET.API/ServiceCollectionExtensions.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using ElectronNET.API.Interfaces;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace ElectronNET.API
 {
@@ -13,6 +14,7 @@ namespace ElectronNET.API
         public static IServiceCollection AddElectron(this IServiceCollection services)
             => services
                 // adding in this manner to ensure late binding.
+                // this set for backwards compatibility
                 .AddSingleton(provider => IpcMain.Instance)
                 .AddSingleton(provider => App.Instance)
                 .AddSingleton(provider => AutoUpdater.Instance)
@@ -28,6 +30,25 @@ namespace ElectronNET.API
                 .AddSingleton(provider => HostHook.Instance)
                 .AddSingleton(provider => PowerMonitor.Instance)
                 .AddSingleton(provider => NativeTheme.Instance)
-                .AddSingleton(provider => Dock.Instance);
+                .AddSingleton(provider => Dock.Instance)
+                .AddSingleton(provider => new ApplicationSocket { Socket = BridgeConnector.Socket, })
+                // this set for proper dependency injection
+                .AddSingleton<IIpcMain>(provider => IpcMain.Instance)
+                .AddSingleton<IApp>(provider => App.Instance)
+                .AddSingleton<IAutoUpdater>(provider => AutoUpdater.Instance)
+                .AddSingleton<IWindowManager>(provider => WindowManager.Instance)
+                .AddSingleton<IMenu>(provider => Menu.Instance)
+                .AddSingleton<IDialog>(provider => Dialog.Instance)
+                .AddSingleton<INotification>(provider => Notification.Instance)
+                .AddSingleton<ITray>(provider => Tray.Instance)
+                .AddSingleton<IGlobalShortcut>(provider => GlobalShortcut.Instance)
+                .AddSingleton<IShell>(provider => Shell.Instance)
+                .AddSingleton<IScreen>(provider => Screen.Instance)
+                .AddSingleton<IClipboard>(provider => Clipboard.Instance)
+                .AddSingleton<IHostHook>(provider => HostHook.Instance)
+                .AddSingleton<IPowerMonitor>(provider => PowerMonitor.Instance)
+                .AddSingleton<INativeTheme>(provider => NativeTheme.Instance)
+                .AddSingleton<IDock>(provider => Dock.Instance)
+                .AddSingleton<IApplicationSocket>(provider => provider.GetService<ApplicationSocket>());
     }
 }

ElectronNET.API/Shell.cs

@@ -4,13 +4,14 @@ using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System.Threading.Tasks;
 using ElectronNET.API.Extensions;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Manage files and URLs using their default applications.
     /// </summary>
-    public sealed class Shell
+    public sealed class Shell : IShell
     {
         private static Shell _shell;
         private static object _syncRoot = new object();

ElectronNET.API/Tray.cs

@@ -6,13 +6,14 @@ using Newtonsoft.Json.Serialization;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// Add icons and context menus to the system's notification area.
     /// </summary>
-    public sealed class Tray
+    public sealed class Tray : ITray
     {
         /// <summary>
         /// Emitted when the tray icon is clicked.

ElectronNET.API/WindowManager.cs

@@ -7,13 +7,14 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
+using ElectronNET.API.Interfaces;
 
 namespace ElectronNET.API
 {
     /// <summary>
     /// 
     /// </summary>
-    public sealed class WindowManager
+    public sealed class WindowManager : IWindowManager
     {
         private static WindowManager _windowManager;
         private static object _syncRoot = new object();