diff --git a/src/WebExtensions.Net/Extensions/Events/Event.cs b/src/WebExtensions.Net/Extensions/Events/Event.cs
index a03371e..7de113d 100644
--- a/src/WebExtensions.Net/Extensions/Events/Event.cs
+++ b/src/WebExtensions.Net/Extensions/Events/Event.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using JsBind.Net;
 
 namespace WebExtensions.Net.Events
 {
@@ -7,6 +8,7 @@ public partial class Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Called when an event occurs. The parameters of this function depend on the type of event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Delegate callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -15,6 +17,7 @@ public virtual ValueTask AddListener(Delegate callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Delegate callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -22,6 +25,7 @@ public virtual ValueTask<bool> HasListener(Delegate callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Delegate callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Extensions/Menus/IContextMenusApi.cs b/src/WebExtensions.Net/Extensions/Menus/IContextMenusApi.cs
index 420c0ff..7434a87 100644
--- a/src/WebExtensions.Net/Extensions/Menus/IContextMenusApi.cs
+++ b/src/WebExtensions.Net/Extensions/Menus/IContextMenusApi.cs
@@ -1,6 +1,9 @@
-namespace WebExtensions.Net.Menus
+using JsBind.Net;
+
+namespace WebExtensions.Net.Menus
 {
     /// <inheritdoc />
+    [JsAccessPath("contextMenus")]
     public partial interface IContextMenusApi : IMenusApi
     {
     }
diff --git a/src/WebExtensions.Net/Extensions/Menus/IWebExtensionsApi.cs b/src/WebExtensions.Net/Extensions/Menus/IWebExtensionsApi.cs
index 450fa43..f7a7067 100644
--- a/src/WebExtensions.Net/Extensions/Menus/IWebExtensionsApi.cs
+++ b/src/WebExtensions.Net/Extensions/Menus/IWebExtensionsApi.cs
@@ -1,10 +1,12 @@
-using WebExtensions.Net.Menus;
+using JsBind.Net;
+using WebExtensions.Net.Menus;
 
 namespace WebExtensions.Net
 {
     public partial interface IWebExtensionsApi
     {
         /// <summary>The part of the menus API that is available in all extension contexts, including content scripts. Use the browser.contextMenus API to add items to the browser's menus. You can choose what types of objects your context menu additions apply to, such as images, hyperlinks, and pages.<br />Requires manifest permission menus, menus.</summary>
+        [JsAccessPath("contextMenus")]
         IContextMenusApi ContextMenus { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Extensions/Notifications/INotificationsApi.cs b/src/WebExtensions.Net/Extensions/Notifications/INotificationsApi.cs
index d049214..2a8a2ed 100644
--- a/src/WebExtensions.Net/Extensions/Notifications/INotificationsApi.cs
+++ b/src/WebExtensions.Net/Extensions/Notifications/INotificationsApi.cs
@@ -1,4 +1,5 @@
 using System.Threading.Tasks;
+using JsBind.Net;
 
 namespace WebExtensions.Net.Notifications
 {
@@ -8,6 +9,7 @@ public partial interface INotificationsApi
         /// <param name="notificationId">Identifier of the notification.</param>
         /// <param name="options">Contents of the notification.</param>
         /// <returns>Indicates whether a matching notification is updated.</returns>
+        [JsAccessPath("update")]
         ValueTask<bool> Update(string notificationId, NotificationOptions options);
     }
 }
diff --git a/src/WebExtensions.Net/Extensions/Runtime/OnMessageEvent.cs b/src/WebExtensions.Net/Extensions/Runtime/OnMessageEvent.cs
index e1bd7f0..fe3169d 100644
--- a/src/WebExtensions.Net/Extensions/Runtime/OnMessageEvent.cs
+++ b/src/WebExtensions.Net/Extensions/Runtime/OnMessageEvent.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Threading.Tasks;
-using WebExtensions.Net.Runtime;
 using JsBind.Net;
 
 namespace WebExtensions.Net.Runtime
@@ -9,6 +8,7 @@ public partial class OnMessageEvent
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a message is sent from either an extension process or a content script.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<object, MessageSender, Action<object>, bool> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -17,6 +17,7 @@ public virtual ValueTask AddListener(Func<object, MessageSender, Action<object>,
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action<object>, bool> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -24,6 +25,7 @@ public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action<ob
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<object, MessageSender, Action<object>, bool> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Extensions/Runtime/Port.cs b/src/WebExtensions.Net/Extensions/Runtime/Port.cs
index 7a135b5..f5d2817 100644
--- a/src/WebExtensions.Net/Extensions/Runtime/Port.cs
+++ b/src/WebExtensions.Net/Extensions/Runtime/Port.cs
@@ -1,4 +1,5 @@
 using System.Threading.Tasks;
+using JsBind.Net;
 
 namespace WebExtensions.Net.Runtime
 {
@@ -6,6 +7,7 @@ public partial class Port
     {
         /// <summary>Post a message to the port.</summary>
         /// <param name="message">JSON-serializable message.</param>
+        [JsAccessPath("postMessage")]
         public virtual ValueTask PostMessage(object message)
         {
             return InvokeVoidAsync("postMessage", message);
diff --git a/src/WebExtensions.Net/Generated/Action/Details.cs b/src/WebExtensions.Net/Generated/Action/Details.cs
index fb32343..1ab138b 100644
--- a/src/WebExtensions.Net/Generated/Action/Details.cs
+++ b/src/WebExtensions.Net/Generated/Action/Details.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.ActionNs
     public partial class Details : BaseObject
     {
         /// <summary>When setting a value, it will be specific to the specified tab, and will automatically reset when the tab navigates. When getting, specifies the tab to get the value from; if there is no tab-specific value, the window one will be inherited.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>When setting a value, it will be specific to the specified window. When getting, specifies the window to get the value from; if there is no window-specific value, the global one will be inherited.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/IActionApi.cs b/src/WebExtensions.Net/Generated/Action/IActionApi.cs
index 3a80099..cdfae5c 100644
--- a/src/WebExtensions.Net/Generated/Action/IActionApi.cs
+++ b/src/WebExtensions.Net/Generated/Action/IActionApi.cs
@@ -1,79 +1,98 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.ActionNs
 {
     /// <summary>Use browser actions to put icons in the main browser toolbar, to the right of the address bar. In addition to its icon, a browser action can also have a tooltip, a badge, and a popup.</summary>
+    [JsAccessPath("action")]
     public partial interface IActionApi
     {
         /// <summary>Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.</summary>
+        [JsAccessPath("onClicked")]
         OnClickedEvent OnClicked { get; }
 
         /// <summary>Disables the browser action for a tab.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the browser action.</param>
+        [JsAccessPath("disable")]
         ValueTask Disable(int? tabId = null);
 
         /// <summary>Enables the browser action for a tab. By default, browser actions are enabled.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the browser action.</param>
+        [JsAccessPath("enable")]
         ValueTask Enable(int? tabId = null);
 
         /// <summary>Gets the background color of the browser action badge.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getBadgeBackgroundColor")]
         ValueTask<ColorArray> GetBadgeBackgroundColor(Details details);
 
         /// <summary>Gets the badge text of the browser action. If no tab nor window is specified is specified, the global badge text is returned.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getBadgeText")]
         ValueTask<string> GetBadgeText(Details details);
 
         /// <summary>Gets the text color of the browser action badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("getBadgeTextColor")]
         ValueTask GetBadgeTextColor(Details details);
 
         /// <summary>Gets the html document set as the popup for this browser action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getPopup")]
         ValueTask<string> GetPopup(Details details);
 
         /// <summary>Gets the title of the browser action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getTitle")]
         ValueTask<string> GetTitle(Details details);
 
         /// <summary>Returns the user-specified settings relating to an extension's action.</summary>
         /// <returns>The collection of user-specified settings relating to an extension's action.</returns>
+        [JsAccessPath("getUserSettings")]
         ValueTask<UserSettings> GetUserSettings();
 
         /// <summary>Checks whether the browser action is enabled.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("isEnabled")]
         ValueTask IsEnabled(Details details);
 
         /// <summary>Opens the extension popup window in the specified window.</summary>
         /// <param name="options">An object with information about the popup to open.</param>
+        [JsAccessPath("openPopup")]
         ValueTask OpenPopup(Options options = null);
 
         /// <summary>Sets the background color for the badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeBackgroundColor")]
         ValueTask SetBadgeBackgroundColor(SetBadgeBackgroundColorDetails details);
 
         /// <summary>Sets the badge text for the browser action. The badge is displayed on top of the icon.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeText")]
         ValueTask SetBadgeText(SetBadgeTextDetails details);
 
         /// <summary>Sets the text color for the badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeTextColor")]
         ValueTask SetBadgeTextColor(SetBadgeTextColorDetails details);
 
         /// <summary>Sets the icon for the browser action. The icon can be specified either as the path to an image file or as the pixel data from a canvas element, or as dictionary of either one of those. Either the 'b'path'/b' or the 'b'imageData'/b' property must be specified.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setIcon")]
         ValueTask SetIcon(SetIconDetails details);
 
         /// <summary>Sets the html document to be opened as a popup when the user clicks on the browser action's icon.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setPopup")]
         ValueTask SetPopup(SetPopupDetails details);
 
         /// <summary>Sets the title of the browser action. This shows up in the tooltip.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setTitle")]
         ValueTask SetTitle(SetTitleDetails details);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Action/OnClickData.cs b/src/WebExtensions.Net/Generated/Action/OnClickData.cs
index 678a8fd..c6c6cc0 100644
--- a/src/WebExtensions.Net/Generated/Action/OnClickData.cs
+++ b/src/WebExtensions.Net/Generated/Action/OnClickData.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.ActionNs
     public partial class OnClickData : BaseObject
     {
         /// <summary>An integer value of button by which menu item was clicked.</summary>
+        [JsAccessPath("button")]
         [JsonPropertyName("button")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Button { get; set; }
 
         /// <summary>An array of keyboard modifiers that were held while the menu item was clicked.</summary>
+        [JsAccessPath("modifiers")]
         [JsonPropertyName("modifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Modifiers { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/OnClickedEvent.cs b/src/WebExtensions.Net/Generated/Action/OnClickedEvent.cs
index 9adf295..eeddb5a 100644
--- a/src/WebExtensions.Net/Generated/Action/OnClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Action/OnClickedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Action/Options.cs b/src/WebExtensions.Net/Generated/Action/Options.cs
index 6c7d7e8..c52f7e5 100644
--- a/src/WebExtensions.Net/Generated/Action/Options.cs
+++ b/src/WebExtensions.Net/Generated/Action/Options.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class Options : BaseObject
     {
         /// <summary>Defaults to the $(topic:current-window)[current window].</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetBadgeBackgroundColorDetails.cs b/src/WebExtensions.Net/Generated/Action/SetBadgeBackgroundColorDetails.cs
index 000316d..cbdefed 100644
--- a/src/WebExtensions.Net/Generated/Action/SetBadgeBackgroundColorDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetBadgeBackgroundColorDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetBadgeBackgroundColorDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("color")]
         [JsonPropertyName("color")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ColorValue Color { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetBadgeTextColorDetails.cs b/src/WebExtensions.Net/Generated/Action/SetBadgeTextColorDetails.cs
index 868f217..d23e0d8 100644
--- a/src/WebExtensions.Net/Generated/Action/SetBadgeTextColorDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetBadgeTextColorDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetBadgeTextColorDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("color")]
         [JsonPropertyName("color")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ColorValue Color { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetBadgeTextDetails.cs b/src/WebExtensions.Net/Generated/Action/SetBadgeTextDetails.cs
index f75fc53..59c6fe3 100644
--- a/src/WebExtensions.Net/Generated/Action/SetBadgeTextDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetBadgeTextDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetBadgeTextDetails : BaseObject
     {
         /// <summary>Any number of characters can be passed, but only about four can fit in the space.</summary>
+        [JsAccessPath("text")]
         [JsonPropertyName("text")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Text Text { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetIconDetails.cs b/src/WebExtensions.Net/Generated/Action/SetIconDetails.cs
index 420ceed..44e9e88 100644
--- a/src/WebExtensions.Net/Generated/Action/SetIconDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetIconDetails.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetIconDetails : BaseObject
     {
         /// <summary>Either an ImageData object or a dictionary {size -> ImageData} representing icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.imageData = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("imageData")]
         [JsonPropertyName("imageData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ImageData ImageData { get; set; }
 
         /// <summary>Either a relative image path or a dictionary {size -> relative image path} pointing to icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.path = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Path Path { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetPopupDetails.cs b/src/WebExtensions.Net/Generated/Action/SetPopupDetails.cs
index f6427bd..31611f2 100644
--- a/src/WebExtensions.Net/Generated/Action/SetPopupDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetPopupDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetPopupDetails : BaseObject
     {
         /// <summary>The html file to show in a popup.  If set to the empty string (''), no popup is shown.</summary>
+        [JsAccessPath("popup")]
         [JsonPropertyName("popup")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Popup Popup { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/SetTitleDetails.cs b/src/WebExtensions.Net/Generated/Action/SetTitleDetails.cs
index e55689a..f49f74f 100644
--- a/src/WebExtensions.Net/Generated/Action/SetTitleDetails.cs
+++ b/src/WebExtensions.Net/Generated/Action/SetTitleDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class SetTitleDetails : BaseObject
     {
         /// <summary>The string the browser action should display when moused over.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Title Title { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Action/UserSettings.cs b/src/WebExtensions.Net/Generated/Action/UserSettings.cs
index 1f05d86..c625de9 100644
--- a/src/WebExtensions.Net/Generated/Action/UserSettings.cs
+++ b/src/WebExtensions.Net/Generated/Action/UserSettings.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ActionNs
     public partial class UserSettings : BaseObject
     {
         /// <summary>Whether the extension's action icon is visible on browser windows' top-level toolbar (i.e., whether the extension has been 'pinned' by the user).</summary>
+        [JsAccessPath("isOnToolbar")]
         [JsonPropertyName("isOnToolbar")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsOnToolbar { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Alarms/Alarm.cs b/src/WebExtensions.Net/Generated/Alarms/Alarm.cs
index 2facf7b..d86f6e6 100644
--- a/src/WebExtensions.Net/Generated/Alarms/Alarm.cs
+++ b/src/WebExtensions.Net/Generated/Alarms/Alarm.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Alarms
     public partial class Alarm : BaseObject
     {
         /// <summary>Name of this alarm.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>When present, signals that the alarm triggers periodically after so many minutes.</summary>
+        [JsAccessPath("periodInMinutes")]
         [JsonPropertyName("periodInMinutes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? PeriodInMinutes { get; set; }
 
         /// <summary>Time when the alarm is scheduled to fire, in milliseconds past the epoch.</summary>
+        [JsAccessPath("scheduledTime")]
         [JsonPropertyName("scheduledTime")]
         public EpochTime ScheduledTime { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Alarms/AlarmInfo.cs b/src/WebExtensions.Net/Generated/Alarms/AlarmInfo.cs
index e776947..0bd2986 100644
--- a/src/WebExtensions.Net/Generated/Alarms/AlarmInfo.cs
+++ b/src/WebExtensions.Net/Generated/Alarms/AlarmInfo.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Alarms
     public partial class AlarmInfo : BaseObject
     {
         /// <summary>Number of minutes from the current time after which the alarm should first fire.</summary>
+        [JsAccessPath("delayInMinutes")]
         [JsonPropertyName("delayInMinutes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? DelayInMinutes { get; set; }
 
         /// <summary>Number of minutes after which the alarm should recur repeatedly.</summary>
+        [JsAccessPath("periodInMinutes")]
         [JsonPropertyName("periodInMinutes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? PeriodInMinutes { get; set; }
 
         /// <summary>Time when the alarm is scheduled to first fire, in milliseconds past the epoch.</summary>
+        [JsAccessPath("when")]
         [JsonPropertyName("when")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? When { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Alarms/IAlarmsApi.cs b/src/WebExtensions.Net/Generated/Alarms/IAlarmsApi.cs
index c83f55b..4ed34b7 100644
--- a/src/WebExtensions.Net/Generated/Alarms/IAlarmsApi.cs
+++ b/src/WebExtensions.Net/Generated/Alarms/IAlarmsApi.cs
@@ -1,39 +1,48 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Alarms
 {
     /// <summary></summary>
+    [JsAccessPath("alarms")]
     public partial interface IAlarmsApi
     {
         /// <summary>Fired when an alarm has expired. Useful for transient background pages.</summary>
+        [JsAccessPath("onAlarm")]
         OnAlarmEvent OnAlarm { get; }
 
         /// <summary>Clears the alarm with the given name.</summary>
         /// <param name="name">The name of the alarm to clear. Defaults to the empty string.</param>
         /// <returns>Whether an alarm of the given name was found to clear.</returns>
+        [JsAccessPath("clear")]
         ValueTask<bool> Clear(string name = null);
 
         /// <summary>Clears all alarms.</summary>
         /// <returns>Whether any alarm was found to clear.</returns>
+        [JsAccessPath("clearAll")]
         ValueTask<bool> ClearAll();
 
         /// <summary>Creates an alarm. After the delay is expired, the onAlarm event is fired. If there is another alarm with the same name (or no name if none is specified), it will be cancelled and replaced by this alarm.</summary>
         /// <param name="alarmInfo">Details about the alarm. The alarm first fires either at 'when' milliseconds past the epoch (if 'when' is provided), after 'delayInMinutes' minutes from the current time (if 'delayInMinutes' is provided instead), or after 'periodInMinutes' minutes from the current time (if only 'periodInMinutes' is provided). Users should never provide both 'when' and 'delayInMinutes'. If 'periodInMinutes' is provided, then the alarm recurs repeatedly after that many minutes.</param>
+        [JsAccessPath("create")]
         ValueTask Create(AlarmInfo alarmInfo);
 
         /// <summary>Creates an alarm. After the delay is expired, the onAlarm event is fired. If there is another alarm with the same name (or no name if none is specified), it will be cancelled and replaced by this alarm.</summary>
         /// <param name="name">Optional name to identify this alarm. Defaults to the empty string.</param>
         /// <param name="alarmInfo">Details about the alarm. The alarm first fires either at 'when' milliseconds past the epoch (if 'when' is provided), after 'delayInMinutes' minutes from the current time (if 'delayInMinutes' is provided instead), or after 'periodInMinutes' minutes from the current time (if only 'periodInMinutes' is provided). Users should never provide both 'when' and 'delayInMinutes'. If 'periodInMinutes' is provided, then the alarm recurs repeatedly after that many minutes.</param>
+        [JsAccessPath("create")]
         ValueTask Create(string name, AlarmInfo alarmInfo);
 
         /// <summary>Retrieves details about the specified alarm.</summary>
         /// <param name="name">The name of the alarm to get. Defaults to the empty string.</param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<Alarm> Get(string name = null);
 
         /// <summary>Gets an array of all the alarms.</summary>
         /// <returns></returns>
+        [JsAccessPath("getAll")]
         ValueTask<IEnumerable<Alarm>> GetAll();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Alarms/OnAlarmEvent.cs b/src/WebExtensions.Net/Generated/Alarms/OnAlarmEvent.cs
index 88b87c7..5cd7630 100644
--- a/src/WebExtensions.Net/Generated/Alarms/OnAlarmEvent.cs
+++ b/src/WebExtensions.Net/Generated/Alarms/OnAlarmEvent.cs
@@ -12,6 +12,7 @@ public partial class OnAlarmEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an alarm has expired. Useful for transient background pages.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Alarm> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Alarm> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Alarm> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Alarm> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Alarm> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/BookmarkTreeNode.cs b/src/WebExtensions.Net/Generated/Bookmarks/BookmarkTreeNode.cs
index 3bec33f..7b1a2f1 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/BookmarkTreeNode.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/BookmarkTreeNode.cs
@@ -10,51 +10,61 @@ namespace WebExtensions.Net.Bookmarks
     public partial class BookmarkTreeNode : BaseObject
     {
         /// <summary>An ordered list of children of this node.</summary>
+        [JsAccessPath("children")]
         [JsonPropertyName("children")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<BookmarkTreeNode> Children { get; set; }
 
         /// <summary>When this node was created, in milliseconds since the epoch (<c>new Date(dateAdded)</c>).</summary>
+        [JsAccessPath("dateAdded")]
         [JsonPropertyName("dateAdded")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? DateAdded { get; set; }
 
         /// <summary>When the contents of this folder last changed, in milliseconds since the epoch.</summary>
+        [JsAccessPath("dateGroupModified")]
         [JsonPropertyName("dateGroupModified")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? DateGroupModified { get; set; }
 
         /// <summary>The unique identifier for the node. IDs are unique within the current profile, and they remain valid even after the browser is restarted.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>The 0-based position of this node within its parent folder.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
 
         /// <summary>The <c>id</c> of the parent folder.  Omitted for the root node.</summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ParentId { get; set; }
 
         /// <summary>The text displayed for the node.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>Indicates the type of the BookmarkTreeNode, which can be one of bookmark, folder or separator.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BookmarkTreeNodeType? Type { get; set; }
 
         /// <summary>Indicates the reason why this node is unmodifiable. The <c>managed</c> value indicates that this node was configured by the system administrator or by the custodian of a supervised user. Omitted if the node can be modified by the user and the extension (default).</summary>
+        [JsAccessPath("unmodifiable")]
         [JsonPropertyName("unmodifiable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BookmarkTreeNodeUnmodifiable? Unmodifiable { get; set; }
 
         /// <summary>The URL navigated to when a user clicks the bookmark. Omitted for folders.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/ChangeInfo.cs b/src/WebExtensions.Net/Generated/Bookmarks/ChangeInfo.cs
index f0814f1..94b3a1f 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/ChangeInfo.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/ChangeInfo.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Bookmarks
     public partial class ChangeInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/Changes.cs b/src/WebExtensions.Net/Generated/Bookmarks/Changes.cs
index a2bf44e..801a020 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/Changes.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/Changes.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Bookmarks
     public partial class Changes : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/CreateDetails.cs b/src/WebExtensions.Net/Generated/Bookmarks/CreateDetails.cs
index c50bdf6..24512ea 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/CreateDetails.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/CreateDetails.cs
@@ -9,26 +9,31 @@ namespace WebExtensions.Net.Bookmarks
     public partial class CreateDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
 
         /// <summary>Defaults to the Other Bookmarks folder.</summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ParentId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>Indicates the type of BookmarkTreeNode to create, which can be one of bookmark, folder or separator.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BookmarkTreeNodeType? Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/Destination.cs b/src/WebExtensions.Net/Generated/Bookmarks/Destination.cs
index 7f88094..ba6020b 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/Destination.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/Destination.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Bookmarks
     public partial class Destination : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ParentId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/IBookmarksApi.cs b/src/WebExtensions.Net/Generated/Bookmarks/IBookmarksApi.cs
index f9d6588..974e1b5 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/IBookmarksApi.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/IBookmarksApi.cs
@@ -1,85 +1,104 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Bookmarks
 {
     /// <summary>Use the <c>browser.bookmarks</c> API to create, organize, and otherwise manipulate bookmarks. Also see $(topic:override)[Override Pages], which you can use to create a custom Bookmark Manager page.</summary>
+    [JsAccessPath("bookmarks")]
     public partial interface IBookmarksApi
     {
         /// <summary>Fired when a bookmark or folder changes.  'b'Note:'/b' Currently, only title and url changes trigger this.</summary>
+        [JsAccessPath("onChanged")]
         OnChangedEvent OnChanged { get; }
 
         /// <summary>Fired when a bookmark or folder is created.</summary>
+        [JsAccessPath("onCreated")]
         OnCreatedEvent OnCreated { get; }
 
         /// <summary>Fired when a bookmark or folder is moved to a different parent folder.</summary>
+        [JsAccessPath("onMoved")]
         OnMovedEvent OnMoved { get; }
 
         /// <summary>Fired when a bookmark or folder is removed.  When a folder is removed recursively, a single notification is fired for the folder, and none for its contents.</summary>
+        [JsAccessPath("onRemoved")]
         OnRemovedEvent OnRemoved { get; }
 
         /// <summary>Creates a bookmark or folder under the specified parentId.  If url is NULL or missing, it will be a folder.</summary>
         /// <param name="bookmark"></param>
         /// <returns></returns>
+        [JsAccessPath("create")]
         ValueTask<BookmarkTreeNode> Create(CreateDetails bookmark);
 
         /// <summary>Retrieves the specified BookmarkTreeNode(s).</summary>
         /// <param name="idOrIdList">A single string-valued id, or an array of string-valued ids</param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<IEnumerable<BookmarkTreeNode>> Get(string idOrIdList);
 
         /// <summary>Retrieves the specified BookmarkTreeNode(s).</summary>
         /// <param name="idOrIdList">A single string-valued id, or an array of string-valued ids</param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<IEnumerable<BookmarkTreeNode>> Get(IEnumerable<string> idOrIdList);
 
         /// <summary>Retrieves the children of the specified BookmarkTreeNode id.</summary>
         /// <param name="id"></param>
         /// <returns></returns>
+        [JsAccessPath("getChildren")]
         ValueTask<IEnumerable<BookmarkTreeNode>> GetChildren(string id);
 
         /// <summary>Retrieves the recently added bookmarks.</summary>
         /// <param name="numberOfItems">The maximum number of items to return.</param>
         /// <returns></returns>
+        [JsAccessPath("getRecent")]
         ValueTask<IEnumerable<BookmarkTreeNode>> GetRecent(int numberOfItems);
 
         /// <summary>Retrieves part of the Bookmarks hierarchy, starting at the specified node.</summary>
         /// <param name="id">The ID of the root of the subtree to retrieve.</param>
         /// <returns></returns>
+        [JsAccessPath("getSubTree")]
         ValueTask<IEnumerable<BookmarkTreeNode>> GetSubTree(string id);
 
         /// <summary>Retrieves the entire Bookmarks hierarchy.</summary>
         /// <returns></returns>
+        [JsAccessPath("getTree")]
         ValueTask<IEnumerable<BookmarkTreeNode>> GetTree();
 
         /// <summary>Moves the specified BookmarkTreeNode to the provided location.</summary>
         /// <param name="id"></param>
         /// <param name="destination"></param>
         /// <returns></returns>
+        [JsAccessPath("move")]
         ValueTask<BookmarkTreeNode> Move(string id, Destination destination);
 
         /// <summary>Removes a bookmark or an empty bookmark folder.</summary>
         /// <param name="id"></param>
+        [JsAccessPath("remove")]
         ValueTask Remove(string id);
 
         /// <summary>Recursively removes a bookmark folder.</summary>
         /// <param name="id"></param>
+        [JsAccessPath("removeTree")]
         ValueTask RemoveTree(string id);
 
         /// <summary>Searches for BookmarkTreeNodes matching the given query. Queries specified with an object produce BookmarkTreeNodes matching all specified properties.</summary>
         /// <param name="query">Either a string of words that are matched against bookmark URLs and titles, or an object. If an object, the properties <c>query</c>, <c>url</c>, and <c>title</c> may be specified and bookmarks matching all specified properties will be produced.</param>
         /// <returns></returns>
+        [JsAccessPath("search")]
         ValueTask<IEnumerable<BookmarkTreeNode>> Search(string query);
 
         /// <summary>Searches for BookmarkTreeNodes matching the given query. Queries specified with an object produce BookmarkTreeNodes matching all specified properties.</summary>
         /// <param name="query">Either a string of words that are matched against bookmark URLs and titles, or an object. If an object, the properties <c>query</c>, <c>url</c>, and <c>title</c> may be specified and bookmarks matching all specified properties will be produced.</param>
         /// <returns></returns>
+        [JsAccessPath("search")]
         ValueTask<IEnumerable<BookmarkTreeNode>> Search(object query);
 
         /// <summary>Updates the properties of a bookmark or folder. Specify only the properties that you want to change; unspecified properties will be left unchanged.  'b'Note:'/b' Currently, only 'title' and 'url' are supported.</summary>
         /// <param name="id"></param>
         /// <param name="changes"></param>
         /// <returns></returns>
+        [JsAccessPath("update")]
         ValueTask<BookmarkTreeNode> Update(string id, Changes changes);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/MoveInfo.cs b/src/WebExtensions.Net/Generated/Bookmarks/MoveInfo.cs
index 5e675a4..305b50d 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/MoveInfo.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/MoveInfo.cs
@@ -9,19 +9,23 @@ namespace WebExtensions.Net.Bookmarks
     public partial class MoveInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         public int Index { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("oldIndex")]
         [JsonPropertyName("oldIndex")]
         public int OldIndex { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("oldParentId")]
         [JsonPropertyName("oldParentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OldParentId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ParentId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/OnChangedEvent.cs b/src/WebExtensions.Net/Generated/Bookmarks/OnChangedEvent.cs
index 6ed0cb8..8d1ea7c 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/OnChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/OnChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a bookmark or folder changes.  'b'Note:'/b' Currently, only title and url changes trigger this.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, ChangeInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, ChangeInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, ChangeInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, ChangeInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, ChangeInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/OnCreatedEvent.cs b/src/WebExtensions.Net/Generated/Bookmarks/OnCreatedEvent.cs
index d571a07..4f33b26 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/OnCreatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/OnCreatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCreatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a bookmark or folder is created.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, BookmarkTreeNode> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, BookmarkTreeNode> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, BookmarkTreeNode> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, BookmarkTreeNode> call
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, BookmarkTreeNode> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/OnMovedEvent.cs b/src/WebExtensions.Net/Generated/Bookmarks/OnMovedEvent.cs
index aa3b58d..f5a2f01 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/OnMovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/OnMovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnMovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a bookmark or folder is moved to a different parent folder.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, MoveInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, MoveInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, MoveInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, MoveInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, MoveInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/OnRemovedEvent.cs b/src/WebExtensions.Net/Generated/Bookmarks/OnRemovedEvent.cs
index 9abae1f..e7c8e98 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/OnRemovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/OnRemovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnRemovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a bookmark or folder is removed.  When a folder is removed recursively, a single notification is fired for the folder, and none for its contents.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, RemoveInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, RemoveInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, RemoveInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, RemoveInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, RemoveInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Bookmarks/RemoveInfo.cs b/src/WebExtensions.Net/Generated/Bookmarks/RemoveInfo.cs
index 9839d43..a6e3e5c 100644
--- a/src/WebExtensions.Net/Generated/Bookmarks/RemoveInfo.cs
+++ b/src/WebExtensions.Net/Generated/Bookmarks/RemoveInfo.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Bookmarks
     public partial class RemoveInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         public int Index { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("node")]
         [JsonPropertyName("node")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BookmarkTreeNode Node { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ParentId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/Details.cs b/src/WebExtensions.Net/Generated/BrowserAction/Details.cs
index 1e42dc0..df869e1 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/Details.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/Details.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.BrowserAction
     public partial class Details : BaseObject
     {
         /// <summary>When setting a value, it will be specific to the specified tab, and will automatically reset when the tab navigates. When getting, specifies the tab to get the value from; if there is no tab-specific value, the window one will be inherited.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>When setting a value, it will be specific to the specified window. When getting, specifies the window to get the value from; if there is no window-specific value, the global one will be inherited.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/IBrowserActionApi.cs b/src/WebExtensions.Net/Generated/BrowserAction/IBrowserActionApi.cs
index 19bfe68..bc50df4 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/IBrowserActionApi.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/IBrowserActionApi.cs
@@ -1,74 +1,92 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.BrowserAction
 {
     /// <summary>Use browser actions to put icons in the main browser toolbar, to the right of the address bar. In addition to its icon, a browser action can also have a tooltip, a badge, and a popup.</summary>
+    [JsAccessPath("browserAction")]
     public partial interface IBrowserActionApi
     {
         /// <summary>Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.</summary>
+        [JsAccessPath("onClicked")]
         OnClickedEvent OnClicked { get; }
 
         /// <summary>Disables the browser action for a tab.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the browser action.</param>
+        [JsAccessPath("disable")]
         ValueTask Disable(int? tabId = null);
 
         /// <summary>Enables the browser action for a tab. By default, browser actions are enabled.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the browser action.</param>
+        [JsAccessPath("enable")]
         ValueTask Enable(int? tabId = null);
 
         /// <summary>Gets the background color of the browser action badge.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getBadgeBackgroundColor")]
         ValueTask<ColorArray> GetBadgeBackgroundColor(Details details);
 
         /// <summary>Gets the badge text of the browser action. If no tab nor window is specified is specified, the global badge text is returned.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getBadgeText")]
         ValueTask<string> GetBadgeText(Details details);
 
         /// <summary>Gets the text color of the browser action badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("getBadgeTextColor")]
         ValueTask GetBadgeTextColor(Details details);
 
         /// <summary>Gets the html document set as the popup for this browser action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getPopup")]
         ValueTask<string> GetPopup(Details details);
 
         /// <summary>Gets the title of the browser action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getTitle")]
         ValueTask<string> GetTitle(Details details);
 
         /// <summary>Checks whether the browser action is enabled.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("isEnabled")]
         ValueTask IsEnabled(Details details);
 
         /// <summary>Opens the extension popup window in the active window.</summary>
+        [JsAccessPath("openPopup")]
         ValueTask OpenPopup();
 
         /// <summary>Sets the background color for the badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeBackgroundColor")]
         ValueTask SetBadgeBackgroundColor(SetBadgeBackgroundColorDetails details);
 
         /// <summary>Sets the badge text for the browser action. The badge is displayed on top of the icon.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeText")]
         ValueTask SetBadgeText(SetBadgeTextDetails details);
 
         /// <summary>Sets the text color for the badge.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setBadgeTextColor")]
         ValueTask SetBadgeTextColor(SetBadgeTextColorDetails details);
 
         /// <summary>Sets the icon for the browser action. The icon can be specified either as the path to an image file or as the pixel data from a canvas element, or as dictionary of either one of those. Either the 'b'path'/b' or the 'b'imageData'/b' property must be specified.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setIcon")]
         ValueTask SetIcon(SetIconDetails details);
 
         /// <summary>Sets the html document to be opened as a popup when the user clicks on the browser action's icon.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setPopup")]
         ValueTask SetPopup(SetPopupDetails details);
 
         /// <summary>Sets the title of the browser action. This shows up in the tooltip.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setTitle")]
         ValueTask SetTitle(SetTitleDetails details);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/OnClickData.cs b/src/WebExtensions.Net/Generated/BrowserAction/OnClickData.cs
index aaa8dd2..ea45f17 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/OnClickData.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/OnClickData.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.BrowserAction
     public partial class OnClickData : BaseObject
     {
         /// <summary>An integer value of button by which menu item was clicked.</summary>
+        [JsAccessPath("button")]
         [JsonPropertyName("button")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Button { get; set; }
 
         /// <summary>An array of keyboard modifiers that were held while the menu item was clicked.</summary>
+        [JsAccessPath("modifiers")]
         [JsonPropertyName("modifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Modifiers { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/OnClickedEvent.cs b/src/WebExtensions.Net/Generated/BrowserAction/OnClickedEvent.cs
index 8c906c6..05830ef 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/OnClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/OnClickedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeBackgroundColorDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeBackgroundColorDetails.cs
index 1345e28..bd0951e 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeBackgroundColorDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeBackgroundColorDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetBadgeBackgroundColorDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("color")]
         [JsonPropertyName("color")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ColorValue Color { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextColorDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextColorDetails.cs
index 95d1f1c..004b590 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextColorDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextColorDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetBadgeTextColorDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("color")]
         [JsonPropertyName("color")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ColorValue Color { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextDetails.cs
index a614a85..237cf24 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetBadgeTextDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetBadgeTextDetails : BaseObject
     {
         /// <summary>Any number of characters can be passed, but only about four can fit in the space.</summary>
+        [JsAccessPath("text")]
         [JsonPropertyName("text")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Text Text { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetIconDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetIconDetails.cs
index f06af32..96a72c3 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetIconDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetIconDetails.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetIconDetails : BaseObject
     {
         /// <summary>Either an ImageData object or a dictionary {size -> ImageData} representing icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.imageData = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("imageData")]
         [JsonPropertyName("imageData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ImageData ImageData { get; set; }
 
         /// <summary>Either a relative image path or a dictionary {size -> relative image path} pointing to icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.path = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Path Path { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetPopupDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetPopupDetails.cs
index 912da80..ca75144 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetPopupDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetPopupDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetPopupDetails : BaseObject
     {
         /// <summary>The html file to show in a popup.  If set to the empty string (''), no popup is shown.</summary>
+        [JsAccessPath("popup")]
         [JsonPropertyName("popup")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Popup Popup { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserAction/SetTitleDetails.cs b/src/WebExtensions.Net/Generated/BrowserAction/SetTitleDetails.cs
index 6bf1c38..7746554 100644
--- a/src/WebExtensions.Net/Generated/BrowserAction/SetTitleDetails.cs
+++ b/src/WebExtensions.Net/Generated/BrowserAction/SetTitleDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.BrowserAction
     public partial class SetTitleDetails : BaseObject
     {
         /// <summary>The string the browser action should display when moused over.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Title Title { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowserSettings/ColorManagement/IColorManagementApi.cs b/src/WebExtensions.Net/Generated/BrowserSettings/ColorManagement/IColorManagementApi.cs
index 504991f..0206f10 100644
--- a/src/WebExtensions.Net/Generated/BrowserSettings/ColorManagement/IColorManagementApi.cs
+++ b/src/WebExtensions.Net/Generated/BrowserSettings/ColorManagement/IColorManagementApi.cs
@@ -1,17 +1,22 @@
+using JsBind.Net;
 using WebExtensions.Net.Types;
 
 namespace WebExtensions.Net.BrowserSettings.ColorManagement
 {
     /// <summary>Use the <c>browserSettings.colorManagement</c> API to query and set items related to color management.</summary>
+    [JsAccessPath("colorManagement")]
     public partial interface IColorManagementApi
     {
         /// <summary>This setting controls the mode used for color management and must be a string from $(ref:browserSettings.ColorManagementMode)</summary>
+        [JsAccessPath("mode")]
         Setting Mode { get; }
 
         /// <summary>This boolean setting controls whether or not native sRGB color management is used.</summary>
+        [JsAccessPath("useNativeSRGB")]
         Setting UseNativeSRGB { get; }
 
         /// <summary>This boolean setting controls whether or not the WebRender compositor is used.</summary>
+        [JsAccessPath("useWebRenderCompositor")]
         Setting UseWebRenderCompositor { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/BrowserSettings/IBrowserSettingsApi.cs b/src/WebExtensions.Net/Generated/BrowserSettings/IBrowserSettingsApi.cs
index 0e5812f..13f21f0 100644
--- a/src/WebExtensions.Net/Generated/BrowserSettings/IBrowserSettingsApi.cs
+++ b/src/WebExtensions.Net/Generated/BrowserSettings/IBrowserSettingsApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System;
 using WebExtensions.Net.BrowserSettings.ColorManagement;
 using WebExtensions.Net.Types;
@@ -5,64 +6,84 @@
 namespace WebExtensions.Net.BrowserSettings
 {
     /// <summary>Use the <c>browser.browserSettings</c> API to control global settings of the browser.</summary>
+    [JsAccessPath("browserSettings")]
     public partial interface IBrowserSettingsApi
     {
         /// <summary>Use the <c>browserSettings.colorManagement</c> API to query and set items related to color management.<br />Requires manifest permission browserSettings.</summary>
+        [JsAccessPath("colorManagement")]
         IColorManagementApi ColorManagement { get; }
 
         /// <summary>Allows or disallows pop-up windows from opening in response to user events.</summary>
+        [JsAccessPath("allowPopupsForUserEvents")]
         Setting AllowPopupsForUserEvents { get; }
 
         /// <summary>Enables or disables the browser cache.</summary>
+        [JsAccessPath("cacheEnabled")]
         Setting CacheEnabled { get; }
 
         /// <summary>This boolean setting controls whether the selected tab can be closed with a double click.</summary>
+        [JsAccessPath("closeTabsByDoubleClick")]
         Setting CloseTabsByDoubleClick { get; }
 
         /// <summary>Controls after which mouse event context menus popup. This setting's value is of type ContextMenuMouseEvent, which has possible values of <c>mouseup</c> and <c>mousedown</c>.</summary>
+        [JsAccessPath("contextMenuShowEvent")]
         Setting ContextMenuShowEvent { get; }
 
         /// <summary>Returns whether the FTP protocol is enabled. Read-only.</summary>
+        [JsAccessPath("ftpProtocolEnabled")]
         [Obsolete("FTP support was removed from Firefox in bug 1574475")]
         Setting FtpProtocolEnabled { get; }
 
         /// <summary>Returns the value of the overridden home page. Read-only.</summary>
+        [JsAccessPath("homepageOverride")]
         Setting HomepageOverride { get; }
 
         /// <summary>Controls the behaviour of image animation in the browser. This setting's value is of type ImageAnimationBehavior, defaulting to <c>normal</c>.</summary>
+        [JsAccessPath("imageAnimationBehavior")]
         Setting ImageAnimationBehavior { get; }
 
         /// <summary>Returns the value of the overridden new tab page. Read-only.</summary>
+        [JsAccessPath("newTabPageOverride")]
         Setting NewTabPageOverride { get; }
 
         /// <summary>Controls where new tabs are opened. `afterCurrent` will open all new tabs next to the current tab, `relatedAfterCurrent` will open only related tabs next to the current tab, and `atEnd` will open all tabs at the end of the tab strip. The default is `relatedAfterCurrent`.</summary>
+        [JsAccessPath("newTabPosition")]
         Setting NewTabPosition { get; }
 
         /// <summary>This boolean setting controls whether bookmarks are opened in the current tab or in a new tab.</summary>
+        [JsAccessPath("openBookmarksInNewTabs")]
         Setting OpenBookmarksInNewTabs { get; }
 
         /// <summary>This boolean setting controls whether search results are opened in the current tab or in a new tab.</summary>
+        [JsAccessPath("openSearchResultsInNewTabs")]
         Setting OpenSearchResultsInNewTabs { get; }
 
         /// <summary>This boolean setting controls whether urlbar results are opened in the current tab or in a new tab.</summary>
+        [JsAccessPath("openUrlbarResultsInNewTabs")]
         Setting OpenUrlbarResultsInNewTabs { get; }
 
         /// <summary>This setting controls whether a light or dark color scheme overrides the page's preferred color scheme.</summary>
+        [JsAccessPath("overrideContentColorScheme")]
         Setting OverrideContentColorScheme { get; }
 
         /// <summary>This setting controls whether the user-chosen colors override the page's colors.</summary>
+        [JsAccessPath("overrideDocumentColors")]
         Setting OverrideDocumentColors { get; }
 
         /// <summary>This setting controls whether the document's fonts are used.</summary>
+        [JsAccessPath("useDocumentFonts")]
         Setting UseDocumentFonts { get; }
 
         /// <summary>Disables webAPI notifications.</summary>
+        [JsAccessPath("webNotificationsDisabled")]
         Setting WebNotificationsDisabled { get; }
 
         /// <summary>This boolean setting controls whether zoom is applied to the full page or to text only.</summary>
+        [JsAccessPath("zoomFullPage")]
         Setting ZoomFullPage { get; }
 
         /// <summary>This boolean setting controls whether zoom is applied on a per-site basis or to the current tab only. If privacy.resistFingerprinting is true, this setting has no effect and zoom is applied to the current tab only.</summary>
+        [JsAccessPath("zoomSiteSpecific")]
         Setting ZoomSiteSpecific { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/BrowsingData/DataTypeSet.cs b/src/WebExtensions.Net/Generated/BrowsingData/DataTypeSet.cs
index a8e1798..5632ca3 100644
--- a/src/WebExtensions.Net/Generated/BrowsingData/DataTypeSet.cs
+++ b/src/WebExtensions.Net/Generated/BrowsingData/DataTypeSet.cs
@@ -9,56 +9,67 @@ namespace WebExtensions.Net.BrowsingData
     public partial class DataTypeSet : BaseObject
     {
         /// <summary>The browser's cache. Note: when removing data, this clears the <em>entire</em> cache: it is not limited to the range you specify.</summary>
+        [JsAccessPath("cache")]
         [JsonPropertyName("cache")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Cache { get; set; }
 
         /// <summary>The browser's cookies.</summary>
+        [JsAccessPath("cookies")]
         [JsonPropertyName("cookies")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Cookies { get; set; }
 
         /// <summary>The browser's download list.</summary>
+        [JsAccessPath("downloads")]
         [JsonPropertyName("downloads")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Downloads { get; set; }
 
         /// <summary>The browser's stored form data.</summary>
+        [JsAccessPath("formData")]
         [JsonPropertyName("formData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? FormData { get; set; }
 
         /// <summary>The browser's history.</summary>
+        [JsAccessPath("history")]
         [JsonPropertyName("history")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? History { get; set; }
 
         /// <summary>Websites' IndexedDB data.</summary>
+        [JsAccessPath("indexedDB")]
         [JsonPropertyName("indexedDB")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IndexedDB { get; set; }
 
         /// <summary>Websites' local storage data.</summary>
+        [JsAccessPath("localStorage")]
         [JsonPropertyName("localStorage")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? LocalStorage { get; set; }
 
         /// <summary>Stored passwords.</summary>
+        [JsAccessPath("passwords")]
         [JsonPropertyName("passwords")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Passwords { get; set; }
 
         /// <summary>Plugins' data.</summary>
+        [JsAccessPath("pluginData")]
         [JsonPropertyName("pluginData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? PluginData { get; set; }
 
         /// <summary>Server-bound certificates.</summary>
+        [JsAccessPath("serverBoundCertificates")]
         [JsonPropertyName("serverBoundCertificates")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ServerBoundCertificates { get; set; }
 
         /// <summary>Service Workers.</summary>
+        [JsAccessPath("serviceWorkers")]
         [JsonPropertyName("serviceWorkers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ServiceWorkers { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowsingData/IBrowsingDataApi.cs b/src/WebExtensions.Net/Generated/BrowsingData/IBrowsingDataApi.cs
index 9e81233..9a710e0 100644
--- a/src/WebExtensions.Net/Generated/BrowsingData/IBrowsingDataApi.cs
+++ b/src/WebExtensions.Net/Generated/BrowsingData/IBrowsingDataApi.cs
@@ -1,49 +1,61 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.BrowsingData
 {
     /// <summary>Use the <c>chrome.browsingData</c> API to remove browsing data from a user's local profile.</summary>
+    [JsAccessPath("browsingData")]
     public partial interface IBrowsingDataApi
     {
         /// <summary>Clears various types of browsing data stored in a user's profile.</summary>
         /// <param name="options"></param>
         /// <param name="dataToRemove">The set of data types to remove.</param>
+        [JsAccessPath("remove")]
         ValueTask Remove(RemovalOptions options, DataTypeSet dataToRemove);
 
         /// <summary>Clears the browser's cache.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeCache")]
         ValueTask RemoveCache(RemovalOptions options);
 
         /// <summary>Clears the browser's cookies and server-bound certificates modified within a particular timeframe.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeCookies")]
         ValueTask RemoveCookies(RemovalOptions options);
 
         /// <summary>Clears the browser's list of downloaded files (<em>not</em> the downloaded files themselves).</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeDownloads")]
         ValueTask RemoveDownloads(RemovalOptions options);
 
         /// <summary>Clears the browser's stored form data (autofill).</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeFormData")]
         ValueTask RemoveFormData(RemovalOptions options);
 
         /// <summary>Clears the browser's history.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeHistory")]
         ValueTask RemoveHistory(RemovalOptions options);
 
         /// <summary>Clears websites' local storage data.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removeLocalStorage")]
         ValueTask RemoveLocalStorage(RemovalOptions options);
 
         /// <summary>Clears the browser's stored passwords.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removePasswords")]
         ValueTask RemovePasswords(RemovalOptions options);
 
         /// <summary>Clears plugins' data.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("removePluginData")]
         ValueTask RemovePluginData(RemovalOptions options);
 
         /// <summary>Reports which types of data are currently selected in the 'Clear browsing data' settings UI.  Note: some of the data types included in this API are not available in the settings UI, and some UI settings control more than one data type listed here.</summary>
         /// <returns></returns>
+        [JsAccessPath("settings")]
         ValueTask<Result> Settings();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/BrowsingData/OriginTypes.cs b/src/WebExtensions.Net/Generated/BrowsingData/OriginTypes.cs
index 407f72b..49c4cb5 100644
--- a/src/WebExtensions.Net/Generated/BrowsingData/OriginTypes.cs
+++ b/src/WebExtensions.Net/Generated/BrowsingData/OriginTypes.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.BrowsingData
     public partial class OriginTypes : BaseObject
     {
         /// <summary>Extensions and packaged applications a user has installed (be _really_ careful!).</summary>
+        [JsAccessPath("extension")]
         [JsonPropertyName("extension")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Extension { get; set; }
 
         /// <summary>Websites that have been installed as hosted applications (be careful!).</summary>
+        [JsAccessPath("protectedWeb")]
         [JsonPropertyName("protectedWeb")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ProtectedWeb { get; set; }
 
         /// <summary>Normal websites.</summary>
+        [JsAccessPath("unprotectedWeb")]
         [JsonPropertyName("unprotectedWeb")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? UnprotectedWeb { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowsingData/RemovalOptions.cs b/src/WebExtensions.Net/Generated/BrowsingData/RemovalOptions.cs
index c045ff2..f105f29 100644
--- a/src/WebExtensions.Net/Generated/BrowsingData/RemovalOptions.cs
+++ b/src/WebExtensions.Net/Generated/BrowsingData/RemovalOptions.cs
@@ -11,21 +11,25 @@ namespace WebExtensions.Net.BrowsingData
     public partial class RemovalOptions : BaseObject
     {
         /// <summary>Only remove data associated with this specific cookieStoreId.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>Only remove data associated with these hostnames (only applies to cookies and localStorage).</summary>
+        [JsAccessPath("hostnames")]
         [JsonPropertyName("hostnames")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Hostnames { get; set; }
 
         /// <summary>An object whose properties specify which origin types ought to be cleared. If this object isn't specified, it defaults to clearing only "unprotected" origins. Please ensure that you <em>really</em> want to remove application data before adding 'protectedWeb' or 'extensions'.</summary>
+        [JsAccessPath("originTypes")]
         [JsonPropertyName("originTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public OriginTypes OriginTypes { get; set; }
 
         /// <summary>Remove data accumulated on or after this date, represented in milliseconds since the epoch (accessible via the <c>getTime</c> method of the JavaScript <c>Date</c> object). If absent, defaults to 0 (which would remove all browsing data).</summary>
+        [JsAccessPath("since")]
         [JsonPropertyName("since")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date Since { get; set; }
diff --git a/src/WebExtensions.Net/Generated/BrowsingData/Result.cs b/src/WebExtensions.Net/Generated/BrowsingData/Result.cs
index f73ede8..b3699eb 100644
--- a/src/WebExtensions.Net/Generated/BrowsingData/Result.cs
+++ b/src/WebExtensions.Net/Generated/BrowsingData/Result.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.BrowsingData
     public partial class Result : BaseObject
     {
         /// <summary>All of the types will be present in the result, with values of <c>true</c> if they are permitted to be removed (e.g., by enterprise policy) and <c>false</c> if not.</summary>
+        [JsAccessPath("dataRemovalPermitted")]
         [JsonPropertyName("dataRemovalPermitted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DataTypeSet DataRemovalPermitted { get; set; }
 
         /// <summary>All of the types will be present in the result, with values of <c>true</c> if they are both selected to be removed and permitted to be removed, otherwise <c>false</c>.</summary>
+        [JsAccessPath("dataToRemove")]
         [JsonPropertyName("dataToRemove")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DataTypeSet DataToRemove { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("options")]
         [JsonPropertyName("options")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public RemovalOptions Options { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Clipboard/IClipboardApi.cs b/src/WebExtensions.Net/Generated/Clipboard/IClipboardApi.cs
index 143f232..230467f 100644
--- a/src/WebExtensions.Net/Generated/Clipboard/IClipboardApi.cs
+++ b/src/WebExtensions.Net/Generated/Clipboard/IClipboardApi.cs
@@ -1,13 +1,16 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Clipboard
 {
     /// <summary>Offers the ability to write to the clipboard. Reading is not supported because the clipboard can already be read through the standard web platform APIs.</summary>
+    [JsAccessPath("clipboard")]
     public partial interface IClipboardApi
     {
         /// <summary>Copy an image to the clipboard. The image is re-encoded before it is written to the clipboard. If the image is invalid, the clipboard is not modified.</summary>
         /// <param name="imageData">The image data to be copied.</param>
         /// <param name="imageType">The type of imageData.</param>
+        [JsAccessPath("setImageData")]
         ValueTask SetImageData(object imageData, string imageType);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Commands/ChangeInfo.cs b/src/WebExtensions.Net/Generated/Commands/ChangeInfo.cs
index f747cea..9f7b4c9 100644
--- a/src/WebExtensions.Net/Generated/Commands/ChangeInfo.cs
+++ b/src/WebExtensions.Net/Generated/Commands/ChangeInfo.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Commands
     public partial class ChangeInfo : BaseObject
     {
         /// <summary>The name of the shortcut.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The new shortcut active for this command, or blank if not active.</summary>
+        [JsAccessPath("newShortcut")]
         [JsonPropertyName("newShortcut")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string NewShortcut { get; set; }
 
         /// <summary>The old shortcut which is no longer active for this command, or blank if the shortcut was previously inactive.</summary>
+        [JsAccessPath("oldShortcut")]
         [JsonPropertyName("oldShortcut")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OldShortcut { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Commands/Command.cs b/src/WebExtensions.Net/Generated/Commands/Command.cs
index 4188f74..02da3be 100644
--- a/src/WebExtensions.Net/Generated/Commands/Command.cs
+++ b/src/WebExtensions.Net/Generated/Commands/Command.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Commands
     public partial class Command : BaseObject
     {
         /// <summary>The Extension Command description</summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
 
         /// <summary>The name of the Extension Command</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The shortcut active for this command, or blank if not active.</summary>
+        [JsAccessPath("shortcut")]
         [JsonPropertyName("shortcut")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Shortcut { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Commands/Detail.cs b/src/WebExtensions.Net/Generated/Commands/Detail.cs
index be62af6..d7271f0 100644
--- a/src/WebExtensions.Net/Generated/Commands/Detail.cs
+++ b/src/WebExtensions.Net/Generated/Commands/Detail.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Commands
     public partial class Detail : BaseObject
     {
         /// <summary>The new description for the command.</summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
 
         /// <summary>The name of the command.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("shortcut")]
         [JsonPropertyName("shortcut")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Shortcut { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Commands/ICommandsApi.cs b/src/WebExtensions.Net/Generated/Commands/ICommandsApi.cs
index 2ca5b28..b9e0e9f 100644
--- a/src/WebExtensions.Net/Generated/Commands/ICommandsApi.cs
+++ b/src/WebExtensions.Net/Generated/Commands/ICommandsApi.cs
@@ -1,27 +1,34 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Commands
 {
     /// <summary>Use the commands API to add keyboard shortcuts that trigger actions in your extension, for example, an action to open the browser action or send a command to the xtension.</summary>
+    [JsAccessPath("commands")]
     public partial interface ICommandsApi
     {
         /// <summary>Fired when a registered command's shortcut is changed.</summary>
+        [JsAccessPath("onChanged")]
         OnChangedEvent OnChanged { get; }
 
         /// <summary>Fired when a registered command is activated using a keyboard shortcut.</summary>
+        [JsAccessPath("onCommand")]
         OnCommandEvent OnCommand { get; }
 
         /// <summary>Returns all the registered extension commands for this extension and their shortcut (if active).</summary>
         /// <returns></returns>
+        [JsAccessPath("getAll")]
         ValueTask<IEnumerable<Command>> GetAll();
 
         /// <summary>Reset a command's details to what is specified in the manifest.</summary>
         /// <param name="name">The name of the command.</param>
+        [JsAccessPath("reset")]
         ValueTask Reset(string name);
 
         /// <summary>Update the details of an already defined command.</summary>
         /// <param name="detail">The new description for the command.</param>
+        [JsAccessPath("update")]
         ValueTask Update(Detail detail);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Commands/OnChangedEvent.cs b/src/WebExtensions.Net/Generated/Commands/OnChangedEvent.cs
index 02f98cd..9618196 100644
--- a/src/WebExtensions.Net/Generated/Commands/OnChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Commands/OnChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a registered command's shortcut is changed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ChangeInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ChangeInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ChangeInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ChangeInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ChangeInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Commands/OnCommandEvent.cs b/src/WebExtensions.Net/Generated/Commands/OnCommandEvent.cs
index fd19541..0552b86 100644
--- a/src/WebExtensions.Net/Generated/Commands/OnCommandEvent.cs
+++ b/src/WebExtensions.Net/Generated/Commands/OnCommandEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCommandEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a registered command is activated using a keyboard shortcut.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/ContentScripts/IContentScriptsApi.cs b/src/WebExtensions.Net/Generated/ContentScripts/IContentScriptsApi.cs
index 1358713..766c46e 100644
--- a/src/WebExtensions.Net/Generated/ContentScripts/IContentScriptsApi.cs
+++ b/src/WebExtensions.Net/Generated/ContentScripts/IContentScriptsApi.cs
@@ -1,12 +1,15 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.ContentScripts
 {
     /// <summary></summary>
+    [JsAccessPath("contentScripts")]
     public partial interface IContentScriptsApi
     {
         /// <summary>Register a content script programmatically</summary>
         /// <param name="contentScriptOptions"></param>
+        [JsAccessPath("register")]
         ValueTask Register(RegisteredContentScriptOptions contentScriptOptions);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/ContentScripts/RegisteredContentScriptOptions.cs b/src/WebExtensions.Net/Generated/ContentScripts/RegisteredContentScriptOptions.cs
index bdae2b3..940c036 100644
--- a/src/WebExtensions.Net/Generated/ContentScripts/RegisteredContentScriptOptions.cs
+++ b/src/WebExtensions.Net/Generated/ContentScripts/RegisteredContentScriptOptions.cs
@@ -12,51 +12,61 @@ namespace WebExtensions.Net.ContentScripts
     public partial class RegisteredContentScriptOptions : BaseObject
     {
         /// <summary>If allFrames is <c>true</c>, implies that the JavaScript or CSS should be injected into all frames of current page. By default, it's <c>false</c> and is only injected into the top frame.</summary>
+        [JsAccessPath("allFrames")]
         [JsonPropertyName("allFrames")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllFrames { get; set; }
 
         /// <summary>limit the set of matched tabs to those that belong to the given cookie store id</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public CookieStoreId CookieStoreId { get; set; }
 
         /// <summary>The list of CSS files to inject</summary>
+        [JsAccessPath("css")]
         [JsonPropertyName("css")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ExtensionFileOrCode> Css { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("excludeGlobs")]
         [JsonPropertyName("excludeGlobs")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> ExcludeGlobs { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("excludeMatches")]
         [JsonPropertyName("excludeMatches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MatchPattern> ExcludeMatches { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("includeGlobs")]
         [JsonPropertyName("includeGlobs")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> IncludeGlobs { get; set; }
 
         /// <summary>The list of JS files to inject</summary>
+        [JsAccessPath("js")]
         [JsonPropertyName("js")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ExtensionFileOrCode> Js { get; set; }
 
         /// <summary>If matchAboutBlank is true, then the code is also injected in about:blank and about:srcdoc frames if your extension has access to its parent document. Code cannot be inserted in top-level about:-frames. By default it is <c>false</c>.</summary>
+        [JsAccessPath("matchAboutBlank")]
         [JsonPropertyName("matchAboutBlank")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? MatchAboutBlank { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("matches")]
         [JsonPropertyName("matches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MatchPattern> Matches { get; set; }
 
         /// <summary>The soonest that the JavaScript or CSS will be injected into the tab. Defaults to "document_idle".</summary>
+        [JsAccessPath("runAt")]
         [JsonPropertyName("runAt")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public RunAt? RunAt { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/CallbackDetails.cs b/src/WebExtensions.Net/Generated/Cookies/CallbackDetails.cs
index 16b8030..ddb9ddd 100644
--- a/src/WebExtensions.Net/Generated/Cookies/CallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/CallbackDetails.cs
@@ -9,26 +9,31 @@ namespace WebExtensions.Net.Cookies
     public partial class CallbackDetails : BaseObject
     {
         /// <summary>The first-party domain associated with the cookie that's been removed.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>The name of the cookie that's been removed.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The storage partition, if the cookie is part of partitioned storage. null if not partitioned.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>The ID of the cookie store from which the cookie was removed.</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>The URL associated with the cookie that's been removed.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/ChangeInfo.cs b/src/WebExtensions.Net/Generated/Cookies/ChangeInfo.cs
index b404ab9..f821ebd 100644
--- a/src/WebExtensions.Net/Generated/Cookies/ChangeInfo.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/ChangeInfo.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Cookies
     public partial class ChangeInfo : BaseObject
     {
         /// <summary>The underlying reason behind the cookie's change.</summary>
+        [JsAccessPath("cause")]
         [JsonPropertyName("cause")]
         public OnChangedCause Cause { get; set; }
 
         /// <summary>Information about the cookie that was set or removed.</summary>
+        [JsAccessPath("cookie")]
         [JsonPropertyName("cookie")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Cookie Cookie { get; set; }
 
         /// <summary>True if a cookie was removed.</summary>
+        [JsAccessPath("removed")]
         [JsonPropertyName("removed")]
         public bool Removed { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Cookies/Cookie.cs b/src/WebExtensions.Net/Generated/Cookies/Cookie.cs
index 1c667c6..d27df45 100644
--- a/src/WebExtensions.Net/Generated/Cookies/Cookie.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/Cookie.cs
@@ -9,61 +9,74 @@ namespace WebExtensions.Net.Cookies
     public partial class Cookie : BaseObject
     {
         /// <summary>The domain of the cookie (e.g. "www.google.com", "example.com").</summary>
+        [JsAccessPath("domain")]
         [JsonPropertyName("domain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Domain { get; set; }
 
         /// <summary>The expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.</summary>
+        [JsAccessPath("expirationDate")]
         [JsonPropertyName("expirationDate")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? ExpirationDate { get; set; }
 
         /// <summary>The first-party domain of the cookie.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>True if the cookie is a host-only cookie (i.e. a request's host must exactly match the domain of the cookie).</summary>
+        [JsAccessPath("hostOnly")]
         [JsonPropertyName("hostOnly")]
         public bool HostOnly { get; set; }
 
         /// <summary>True if the cookie is marked as HttpOnly (i.e. the cookie is inaccessible to client-side scripts).</summary>
+        [JsAccessPath("httpOnly")]
         [JsonPropertyName("httpOnly")]
         public bool HttpOnly { get; set; }
 
         /// <summary>The name of the cookie.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The cookie's storage partition, if any. null if not partitioned.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>The path of the cookie.</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Path { get; set; }
 
         /// <summary>The cookie's same-site status (i.e. whether the cookie is sent with cross-site requests).</summary>
+        [JsAccessPath("sameSite")]
         [JsonPropertyName("sameSite")]
         public SameSiteStatus SameSite { get; set; }
 
         /// <summary>True if the cookie is marked as Secure (i.e. its scope is limited to secure channels, typically HTTPS).</summary>
+        [JsAccessPath("secure")]
         [JsonPropertyName("secure")]
         public bool Secure { get; set; }
 
         /// <summary>True if the cookie is a session cookie, as opposed to a persistent cookie with an expiration date.</summary>
+        [JsAccessPath("session")]
         [JsonPropertyName("session")]
         public bool Session { get; set; }
 
         /// <summary>The ID of the cookie store containing this cookie, as provided in getAllCookieStores().</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>The value of the cookie.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/CookieStore.cs b/src/WebExtensions.Net/Generated/Cookies/CookieStore.cs
index 4d41e5c..472d044 100644
--- a/src/WebExtensions.Net/Generated/Cookies/CookieStore.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/CookieStore.cs
@@ -10,15 +10,18 @@ namespace WebExtensions.Net.Cookies
     public partial class CookieStore : BaseObject
     {
         /// <summary>The unique identifier for the cookie store.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>Indicates if this is an incognito cookie store</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         public bool Incognito { get; set; }
 
         /// <summary>Identifiers of all the browser tabs that share this cookie store.</summary>
+        [JsAccessPath("tabIds")]
         [JsonPropertyName("tabIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> TabIds { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/GetAllDetails.cs b/src/WebExtensions.Net/Generated/Cookies/GetAllDetails.cs
index 9357656..eec3744 100644
--- a/src/WebExtensions.Net/Generated/Cookies/GetAllDetails.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/GetAllDetails.cs
@@ -9,46 +9,55 @@ namespace WebExtensions.Net.Cookies
     public partial class GetAllDetails : BaseObject
     {
         /// <summary>Restricts the retrieved cookies to those whose domains match or are subdomains of this one.</summary>
+        [JsAccessPath("domain")]
         [JsonPropertyName("domain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Domain { get; set; }
 
         /// <summary>Restricts the retrieved cookies to those whose first-party domains match this one. This attribute is required if First-Party Isolation is enabled. To not filter by a specific first-party domain, use `null` or `undefined`.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>Filters the cookies by name.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>Selects a specific storage partition to look up cookies. Defaults to null, in which case only non-partitioned cookies are retrieved. If an object iis passed, partitioned cookies are also included, and filtered based on the keys present in the given PartitionKey description. An empty object ({}) returns all cookies (partitioned + unpartitioned), a non-empty object (e.g. {topLevelSite: '...'}) only returns cookies whose partition match all given attributes.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>Restricts the retrieved cookies to those whose path exactly matches this string.</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Path { get; set; }
 
         /// <summary>Filters the cookies by their Secure property.</summary>
+        [JsAccessPath("secure")]
         [JsonPropertyName("secure")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Secure { get; set; }
 
         /// <summary>Filters out session vs. persistent cookies.</summary>
+        [JsAccessPath("session")]
         [JsonPropertyName("session")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Session { get; set; }
 
         /// <summary>The cookie store to retrieve cookies from. If omitted, the current execution context's cookie store will be used.</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>Restricts the retrieved cookies to those that would match the given URL.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/GetDetails.cs b/src/WebExtensions.Net/Generated/Cookies/GetDetails.cs
index 100f124..6e735d2 100644
--- a/src/WebExtensions.Net/Generated/Cookies/GetDetails.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/GetDetails.cs
@@ -9,26 +9,31 @@ namespace WebExtensions.Net.Cookies
     public partial class GetDetails : BaseObject
     {
         /// <summary>The first-party domain which the cookie to retrieve is associated. This attribute is required if First-Party Isolation is enabled.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>The name of the cookie to retrieve.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The storage partition, if the cookie is part of partitioned storage. By default, only non-partitioned cookies are returned.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>The ID of the cookie store in which to look for the cookie. By default, the current execution context's cookie store will be used.</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>The URL with which the cookie to retrieve is associated. This argument may be a full URL, in which case any data following the URL path (e.g. the query string) is simply ignored. If host permissions for this URL are not specified in the manifest file, the API call will fail.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/ICookiesApi.cs b/src/WebExtensions.Net/Generated/Cookies/ICookiesApi.cs
index 90425bf..e91a53c 100644
--- a/src/WebExtensions.Net/Generated/Cookies/ICookiesApi.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/ICookiesApi.cs
@@ -1,36 +1,44 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Cookies
 {
     /// <summary>Use the <c>browser.cookies</c> API to query and modify cookies, and to be notified when they change.</summary>
+    [JsAccessPath("cookies")]
     public partial interface ICookiesApi
     {
         /// <summary>Fired when a cookie is set or removed. As a special case, note that updating a cookie's properties is implemented as a two step process: the cookie to be updated is first removed entirely, generating a notification with "cause" of "overwrite" .  Afterwards, a new cookie is written with the updated values, generating a second notification with "cause" "explicit".</summary>
+        [JsAccessPath("onChanged")]
         OnChangedEvent OnChanged { get; }
 
         /// <summary>Retrieves information about a single cookie. If more than one cookie of the same name exists for the given URL, the one with the longest path will be returned. For cookies with the same path length, the cookie with the earliest creation time will be returned.</summary>
         /// <param name="details">Details to identify the cookie being retrieved.</param>
         /// <returns>Contains details about the cookie. This parameter is null if no such cookie was found.</returns>
+        [JsAccessPath("get")]
         ValueTask<Cookie> Get(GetDetails details);
 
         /// <summary>Retrieves all cookies from a single cookie store that match the given information.  The cookies returned will be sorted, with those with the longest path first.  If multiple cookies have the same path length, those with the earliest creation time will be first.</summary>
         /// <param name="details">Information to filter the cookies being retrieved.</param>
         /// <returns>All the existing, unexpired cookies that match the given cookie info.</returns>
+        [JsAccessPath("getAll")]
         ValueTask<IEnumerable<Cookie>> GetAll(GetAllDetails details);
 
         /// <summary>Lists all existing cookie stores.</summary>
         /// <returns>All the existing cookie stores.</returns>
+        [JsAccessPath("getAllCookieStores")]
         ValueTask<IEnumerable<CookieStore>> GetAllCookieStores();
 
         /// <summary>Deletes a cookie by name.</summary>
         /// <param name="details">Information to identify the cookie to remove.</param>
         /// <returns>Contains details about the cookie that's been removed.  If removal failed for any reason, this will be "null", and $(ref:runtime.lastError) will be set.</returns>
+        [JsAccessPath("remove")]
         ValueTask<CallbackDetails> Remove(RemoveDetails details);
 
         /// <summary>Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.</summary>
         /// <param name="details">Details about the cookie being set.</param>
         /// <returns>Contains details about the cookie that's been set.  If setting failed for any reason, this will be "null", and $(ref:runtime.lastError) will be set.</returns>
+        [JsAccessPath("set")]
         ValueTask<Cookie> Set(SetDetails details);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Cookies/OnChangedEvent.cs b/src/WebExtensions.Net/Generated/Cookies/OnChangedEvent.cs
index 3187b6d..daf2a3f 100644
--- a/src/WebExtensions.Net/Generated/Cookies/OnChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/OnChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a cookie is set or removed. As a special case, note that updating a cookie's properties is implemented as a two step process: the cookie to be updated is first removed entirely, generating a notification with "cause" of "overwrite" .  Afterwards, a new cookie is written with the updated values, generating a second notification with "cause" "explicit".</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ChangeInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ChangeInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ChangeInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ChangeInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ChangeInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Cookies/PartitionKey.cs b/src/WebExtensions.Net/Generated/Cookies/PartitionKey.cs
index 3ba6276..c2ae51f 100644
--- a/src/WebExtensions.Net/Generated/Cookies/PartitionKey.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/PartitionKey.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Cookies
     public partial class PartitionKey : BaseObject
     {
         /// <summary>The first-party URL of the cookie, if the cookie is in storage partitioned by the top-level site.</summary>
+        [JsAccessPath("topLevelSite")]
         [JsonPropertyName("topLevelSite")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string TopLevelSite { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/RemoveDetails.cs b/src/WebExtensions.Net/Generated/Cookies/RemoveDetails.cs
index bcc4c2e..06375e9 100644
--- a/src/WebExtensions.Net/Generated/Cookies/RemoveDetails.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/RemoveDetails.cs
@@ -9,26 +9,31 @@ namespace WebExtensions.Net.Cookies
     public partial class RemoveDetails : BaseObject
     {
         /// <summary>The first-party domain associated with the cookie. This attribute is required if First-Party Isolation is enabled.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>The name of the cookie to remove.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The storage partition, if the cookie is part of partitioned storage. By default, non-partitioned storage is used.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>The ID of the cookie store to look in for the cookie. If unspecified, the cookie is looked for by default in the current execution context's cookie store.</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>The URL associated with the cookie. If host permissions for this URL are not specified in the manifest file, the API call will fail.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Cookies/SetDetails.cs b/src/WebExtensions.Net/Generated/Cookies/SetDetails.cs
index eae3991..837794c 100644
--- a/src/WebExtensions.Net/Generated/Cookies/SetDetails.cs
+++ b/src/WebExtensions.Net/Generated/Cookies/SetDetails.cs
@@ -9,61 +9,73 @@ namespace WebExtensions.Net.Cookies
     public partial class SetDetails : BaseObject
     {
         /// <summary>The domain of the cookie. If omitted, the cookie becomes a host-only cookie.</summary>
+        [JsAccessPath("domain")]
         [JsonPropertyName("domain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Domain { get; set; }
 
         /// <summary>The expiration date of the cookie as the number of seconds since the UNIX epoch. If omitted, the cookie becomes a session cookie.</summary>
+        [JsAccessPath("expirationDate")]
         [JsonPropertyName("expirationDate")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? ExpirationDate { get; set; }
 
         /// <summary>The first-party domain of the cookie. This attribute is required if First-Party Isolation is enabled.</summary>
+        [JsAccessPath("firstPartyDomain")]
         [JsonPropertyName("firstPartyDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FirstPartyDomain { get; set; }
 
         /// <summary>Whether the cookie should be marked as HttpOnly. Defaults to false.</summary>
+        [JsAccessPath("httpOnly")]
         [JsonPropertyName("httpOnly")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? HttpOnly { get; set; }
 
         /// <summary>The name of the cookie. Empty by default if omitted.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The storage partition, if the cookie is part of partitioned storage. By default, non-partitioned storage is used.</summary>
+        [JsAccessPath("partitionKey")]
         [JsonPropertyName("partitionKey")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public PartitionKey PartitionKey { get; set; }
 
         /// <summary>The path of the cookie. Defaults to the path portion of the url parameter.</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Path { get; set; }
 
         /// <summary>The cookie's same-site status.</summary>
+        [JsAccessPath("sameSite")]
         [JsonPropertyName("sameSite")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public SameSiteStatus? SameSite { get; set; }
 
         /// <summary>Whether the cookie should be marked as Secure. Defaults to false.</summary>
+        [JsAccessPath("secure")]
         [JsonPropertyName("secure")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Secure { get; set; }
 
         /// <summary>The ID of the cookie store in which to set the cookie. By default, the cookie is set in the current execution context's cookie store.</summary>
+        [JsAccessPath("storeId")]
         [JsonPropertyName("storeId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StoreId { get; set; }
 
         /// <summary>The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie. If host permissions for this URL are not specified in the manifest file, the API call will fail.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>The value of the cookie. Empty by default if omitted.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Action.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Action.cs
index 1ac4de6..797cad3 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Action.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Action.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class Action : BaseObject
     {
         /// <summary>Describes how the redirect should be performed. Only valid when type is 'redirect'.</summary>
+        [JsAccessPath("redirect")]
         [JsonPropertyName("redirect")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Redirect Redirect { get; set; }
 
         /// <summary>The request headers to modify for the request. Only valid when type is 'modifyHeaders'.</summary>
+        [JsAccessPath("requestHeaders")]
         [JsonPropertyName("requestHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<RequestHeader> RequestHeaders { get; set; }
 
         /// <summary>The response headers to modify for the request. Only valid when type is 'modifyHeaders'.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ResponseHeader> ResponseHeaders { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Type { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/AddOrReplaceParam.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/AddOrReplaceParam.cs
index 5d861ab..0a40d94 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/AddOrReplaceParam.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/AddOrReplaceParam.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class AddOrReplaceParam : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("key")]
         [JsonPropertyName("key")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Key { get; set; }
 
         /// <summary>If true, the query key is replaced only if it's already present. Otherwise, the key is also added if it's missing.</summary>
+        [JsAccessPath("replaceOnly")]
         [JsonPropertyName("replaceOnly")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ReplaceOnly { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Condition.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Condition.cs
index 8573d78..c789f36 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Condition.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Condition.cs
@@ -10,71 +10,85 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class Condition : BaseObject
     {
         /// <summary>Specifies whether the network request is first-party or third-party to the domain from which it originated. If omitted, all requests are matched.</summary>
+        [JsAccessPath("domainType")]
         [JsonPropertyName("domainType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DomainType { get; set; }
 
         /// <summary>The rule will not match network requests originating from the list of 'initiatorDomains'. If the list is empty or omitted, no domains are excluded. This takes precedence over 'initiatorDomains'.</summary>
+        [JsAccessPath("excludedInitiatorDomains")]
         [JsonPropertyName("excludedInitiatorDomains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> ExcludedInitiatorDomains { get; set; }
 
         /// <summary>The rule will not match network requests when the domains matches one from the list of 'excludedRequestDomains'. If the list is empty or omitted, no domains are excluded. This takes precedence over 'requestDomains'.</summary>
+        [JsAccessPath("excludedRequestDomains")]
         [JsonPropertyName("excludedRequestDomains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> ExcludedRequestDomains { get; set; }
 
         /// <summary>List of request methods which the rule won't match. Cannot be specified if 'requestMethods' is specified. If neither of them is specified, all request methods are matched.</summary>
+        [JsAccessPath("excludedRequestMethods")]
         [JsonPropertyName("excludedRequestMethods")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> ExcludedRequestMethods { get; set; }
 
         /// <summary>List of resource types which the rule won't match. Cannot be specified if 'resourceTypes' is specified. If neither of them is specified, all resource types except 'main_frame' are matched.</summary>
+        [JsAccessPath("excludedResourceTypes")]
         [JsonPropertyName("excludedResourceTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ResourceType> ExcludedResourceTypes { get; set; }
 
         /// <summary>List of tabIds which the rule should not match. An ID of -1 excludes requests which don't originate from a tab. Only supported for session-scoped rules.</summary>
+        [JsAccessPath("excludedTabIds")]
         [JsonPropertyName("excludedTabIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> ExcludedTabIds { get; set; }
 
         /// <summary>The rule will only match network requests originating from the list of 'initiatorDomains'. If the list is omitted, the rule is applied to requests from all domains.</summary>
+        [JsAccessPath("initiatorDomains")]
         [JsonPropertyName("initiatorDomains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> InitiatorDomains { get; set; }
 
         /// <summary>Whether 'urlFilter' or 'regexFilter' is case-sensitive.</summary>
+        [JsAccessPath("isUrlFilterCaseSensitive")]
         [JsonPropertyName("isUrlFilterCaseSensitive")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsUrlFilterCaseSensitive { get; set; }
 
         /// <summary>Regular expression to match against the network request url. Only one of 'urlFilter' or 'regexFilter' can be specified.</summary>
+        [JsAccessPath("regexFilter")]
         [JsonPropertyName("regexFilter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RegexFilter { get; set; }
 
         /// <summary>The rule will only match network requests when the domain matches one from the list of 'requestDomains'. If the list is omitted, the rule is applied to requests from all domains.</summary>
+        [JsAccessPath("requestDomains")]
         [JsonPropertyName("requestDomains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> RequestDomains { get; set; }
 
         /// <summary>List of HTTP request methods which the rule can match. Should be a lower-case method such as 'connect', 'delete', 'get', 'head', 'options', 'patch', 'post', 'put'.'</summary>
+        [JsAccessPath("requestMethods")]
         [JsonPropertyName("requestMethods")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> RequestMethods { get; set; }
 
         /// <summary>List of resource types which the rule can match. When the rule action is 'allowAllRequests', this must be specified and may only contain 'main_frame' or 'sub_frame'. Cannot be specified if 'excludedResourceTypes' is specified. If neither of them is specified, all resource types except 'main_frame' are matched.</summary>
+        [JsAccessPath("resourceTypes")]
         [JsonPropertyName("resourceTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ResourceType> ResourceTypes { get; set; }
 
         /// <summary>List of tabIds which the rule should match. An ID of -1 matches requests which don't originate from a tab. Only supported for session-scoped rules.</summary>
+        [JsAccessPath("tabIds")]
         [JsonPropertyName("tabIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> TabIds { get; set; }
 
         /// <summary>TODO: link to doc explaining supported pattern. The pattern which is matched against the network request url. Only one of 'urlFilter' or 'regexFilter' can be specified.</summary>
+        [JsAccessPath("urlFilter")]
         [JsonPropertyName("urlFilter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlFilter { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IDeclarativeNetRequestApi.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IDeclarativeNetRequestApi.cs
index c4dbad3..2bb785f 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IDeclarativeNetRequestApi.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IDeclarativeNetRequestApi.cs
@@ -1,69 +1,87 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.DeclarativeNetRequest
 {
     /// <summary>Use the declarativeNetRequest API to block or modify network requests by specifying declarative rules.</summary>
+    [JsAccessPath("declarativeNetRequest")]
     public partial interface IDeclarativeNetRequestApi
     {
         /// <summary>Ruleset ID for the dynamic rules added by the extension.</summary>
+        [JsAccessPath("DYNAMIC_RULESET_ID")]
         string DYNAMIC_RULESET_ID { get; }
 
         /// <summary>The minimum number of static rules guaranteed to an extension across its enabled static rulesets. Any rules above this limit will count towards the global static rule limit.</summary>
+        [JsAccessPath("GUARANTEED_MINIMUM_STATIC_RULES")]
         double GUARANTEED_MINIMUM_STATIC_RULES { get; }
 
         /// <summary>The maximum number of dynamic and session rules an extension can add. NOTE: in the Firefox we are enforcing this limit to the session and dynamic rules count separately, instead of enforcing it to the rules count for both combined as the Chrome implementation does.</summary>
+        [JsAccessPath("MAX_NUMBER_OF_DYNAMIC_AND_SESSION_RULES")]
         double MAX_NUMBER_OF_DYNAMIC_AND_SESSION_RULES { get; }
 
         /// <summary>The maximum number of static Rulesets an extension can enable at any one time.</summary>
+        [JsAccessPath("MAX_NUMBER_OF_ENABLED_STATIC_RULESETS")]
         double MAX_NUMBER_OF_ENABLED_STATIC_RULESETS { get; }
 
         /// <summary>The maximum number of regular expression rules that an extension can add. This limit is evaluated separately for the set of session rules, dynamic rules and those specified in the rule_resources file.</summary>
+        [JsAccessPath("MAX_NUMBER_OF_REGEX_RULES")]
         double MAX_NUMBER_OF_REGEX_RULES { get; }
 
         /// <summary>The maximum number of static Rulesets an extension can specify as part of the rule_resources manifest key.</summary>
+        [JsAccessPath("MAX_NUMBER_OF_STATIC_RULESETS")]
         double MAX_NUMBER_OF_STATIC_RULESETS { get; }
 
         /// <summary>Ruleset ID for the session-scoped rules added by the extension.</summary>
+        [JsAccessPath("SESSION_RULESET_ID")]
         string SESSION_RULESET_ID { get; }
 
         /// <summary>Returns the remaining number of static rules an extension can enable</summary>
         /// <returns></returns>
+        [JsAccessPath("getAvailableStaticRuleCount")]
         ValueTask<int> GetAvailableStaticRuleCount();
 
         /// <summary>Returns the current set of dynamic rules for the extension.</summary>
         /// <returns></returns>
+        [JsAccessPath("getDynamicRules")]
         ValueTask<IEnumerable<Rule>> GetDynamicRules();
 
         /// <summary>Returns the ids for the current set of enabled static rulesets.</summary>
         /// <returns></returns>
+        [JsAccessPath("getEnabledRulesets")]
         ValueTask<IEnumerable<string>> GetEnabledRulesets();
 
         /// <summary>Returns the current set of session scoped rules for the extension.</summary>
         /// <returns></returns>
+        [JsAccessPath("getSessionRules")]
         ValueTask<IEnumerable<Rule>> GetSessionRules();
 
         /// <summary>Checks if the given regular expression will be supported as a 'regexFilter' rule condition.</summary>
         /// <param name="regexOptions"></param>
         /// <returns></returns>
+        [JsAccessPath("isRegexSupported")]
         ValueTask<IsRegexSupportedCallbackResult> IsRegexSupported(RegexOptions regexOptions);
 
         /// <summary>Checks if any of the extension's declarativeNetRequest rules would match a hypothetical request.</summary>
         /// <param name="request">The details of the request to test.</param>
         /// <param name="options"></param>
         /// <returns></returns>
+        [JsAccessPath("testMatchOutcome")]
         ValueTask<TestMatchOutcomeCallbackResult> TestMatchOutcome(Request request, TestMatchOutcomeOptions options = null);
 
         /// <summary>Modifies the current set of dynamic rules for the extension. The rules with IDs listed in options.removeRuleIds are first removed, and then the rules given in options.addRules are added. These rules are persisted across browser sessions and extension updates.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("updateDynamicRules")]
         ValueTask UpdateDynamicRules(UpdateDynamicRulesOptions options);
 
         /// <summary>Returns the ids for the current set of enabled static rulesets.</summary>
         /// <param name="updateRulesetOptions"></param>
+        [JsAccessPath("updateEnabledRulesets")]
         ValueTask UpdateEnabledRulesets(UpdateRulesetOptions updateRulesetOptions);
 
         /// <summary>Modifies the current set of session scoped rules for the extension. The rules with IDs listed in options.removeRuleIds are first removed, and then the rules given in options.addRules are added. These rules are not persisted across sessions and are backed in memory.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("updateSessionRules")]
         ValueTask UpdateSessionRules(UpdateSessionRulesOptions options);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IsRegexSupportedCallbackResult.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IsRegexSupportedCallbackResult.cs
index dbcfe64..f12eea9 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IsRegexSupportedCallbackResult.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/IsRegexSupportedCallbackResult.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class IsRegexSupportedCallbackResult : BaseObject
     {
         /// <summary>Whether the given regex is supported</summary>
+        [JsAccessPath("isSupported")]
         [JsonPropertyName("isSupported")]
         public bool IsSupported { get; set; }
 
         /// <summary>Specifies the reason why the regular expression is not supported. Only provided if 'isSupported' is false.</summary>
+        [JsAccessPath("reason")]
         [JsonPropertyName("reason")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UnsupportedRegexReason? Reason { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/MatchedRule.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/MatchedRule.cs
index 252d722..e2cc0c5 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/MatchedRule.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/MatchedRule.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class MatchedRule : BaseObject
     {
         /// <summary>ID of the extension, if this rule belongs to a different extension.</summary>
+        [JsAccessPath("extensionId")]
         [JsonPropertyName("extensionId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ExtensionId { get; set; }
 
         /// <summary>A matching rule's ID.</summary>
+        [JsAccessPath("ruleId")]
         [JsonPropertyName("ruleId")]
         public int RuleId { get; set; }
 
         /// <summary>ID of the Ruleset this rule belongs to.</summary>
+        [JsAccessPath("rulesetId")]
         [JsonPropertyName("rulesetId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RulesetId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/QueryTransform.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/QueryTransform.cs
index e816794..d333af8 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/QueryTransform.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/QueryTransform.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class QueryTransform : BaseObject
     {
         /// <summary>The list of query key-value pairs to be added or replaced.</summary>
+        [JsAccessPath("addOrReplaceParams")]
         [JsonPropertyName("addOrReplaceParams")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<AddOrReplaceParam> AddOrReplaceParams { get; set; }
 
         /// <summary>The list of query keys to be removed.</summary>
+        [JsAccessPath("removeParams")]
         [JsonPropertyName("removeParams")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> RemoveParams { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Redirect.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Redirect.cs
index 3434f68..117be29 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Redirect.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Redirect.cs
@@ -9,21 +9,25 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class Redirect : BaseObject
     {
         /// <summary>Path relative to the extension directory. Should start with '/'.</summary>
+        [JsAccessPath("extensionPath")]
         [JsonPropertyName("extensionPath")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ExtensionPath { get; set; }
 
         /// <summary>Substitution pattern for rules which specify a 'regexFilter'. The first match of regexFilter within the url will be replaced with this pattern. Within regexSubstitution, backslash-escaped digits (\1 to \9) can be used to insert the corresponding capture groups. \0 refers to the entire matching text.</summary>
+        [JsAccessPath("regexSubstitution")]
         [JsonPropertyName("regexSubstitution")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RegexSubstitution { get; set; }
 
         /// <summary>Url transformations to perform.</summary>
+        [JsAccessPath("transform")]
         [JsonPropertyName("transform")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlTransform Transform { get; set; }
 
         /// <summary>The redirect url. Redirects to JavaScript urls are not allowed.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RegexOptions.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RegexOptions.cs
index 89a2548..9d548bb 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RegexOptions.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RegexOptions.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class RegexOptions : BaseObject
     {
         /// <summary>Whether the 'regex' specified is case sensitive.</summary>
+        [JsAccessPath("isCaseSensitive")]
         [JsonPropertyName("isCaseSensitive")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsCaseSensitive { get; set; }
 
         /// <summary>The regular expresson to check.</summary>
+        [JsAccessPath("regex")]
         [JsonPropertyName("regex")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Regex { get; set; }
 
         /// <summary>Whether the 'regex' specified requires capturing. Capturing is only required for redirect rules which specify a 'regexSubstition' action.</summary>
+        [JsAccessPath("requireCapturing")]
         [JsonPropertyName("requireCapturing")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? RequireCapturing { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Request.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Request.cs
index c02e25a..e0ebbfd 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Request.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Request.cs
@@ -9,25 +9,30 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class Request : BaseObject
     {
         /// <summary>The initiator URL (if any) for the hypothetical request.</summary>
+        [JsAccessPath("initiator")]
         [JsonPropertyName("initiator")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Initiator { get; set; }
 
         /// <summary>Standard HTTP method of the hypothetical request.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>The ID of the tab in which the hypothetical request takes place. Does not need to correspond to a real tab ID. Default is -1, meaning that the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>The resource type of the hypothetical request.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary>The URL of the hypothetical request.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RequestHeader.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RequestHeader.cs
index d36ce05..9468f03 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RequestHeader.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/RequestHeader.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class RequestHeader : BaseObject
     {
         /// <summary>The name of the request header to be modified.</summary>
+        [JsAccessPath("header")]
         [JsonPropertyName("header")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Header { get; set; }
 
         /// <summary>The operation to be performed on a header.</summary>
+        [JsAccessPath("operation")]
         [JsonPropertyName("operation")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Operation { get; set; }
 
         /// <summary>The new value for the header. Must be specified for the 'append' and 'set' operations.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/ResponseHeader.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/ResponseHeader.cs
index ba6f806..9e86f4e 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/ResponseHeader.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/ResponseHeader.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class ResponseHeader : BaseObject
     {
         /// <summary>The name of the response header to be modified.</summary>
+        [JsAccessPath("header")]
         [JsonPropertyName("header")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Header { get; set; }
 
         /// <summary>The operation to be performed on a header.</summary>
+        [JsAccessPath("operation")]
         [JsonPropertyName("operation")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Operation { get; set; }
 
         /// <summary>The new value for the header. Must be specified for the 'append' and 'set' operations.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Rule.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Rule.cs
index 9578c26..41ca995 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Rule.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/Rule.cs
@@ -9,20 +9,24 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class Rule : BaseObject
     {
         /// <summary>The action to take if this rule is matched.</summary>
+        [JsAccessPath("action")]
         [JsonPropertyName("action")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Action Action { get; set; }
 
         /// <summary>The condition under which this rule is triggered.</summary>
+        [JsAccessPath("condition")]
         [JsonPropertyName("condition")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Condition Condition { get; set; }
 
         /// <summary>An id which uniquely identifies a rule. Mandatory and should be >= 1.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         public int Id { get; set; }
 
         /// <summary>Rule priority. Defaults to 1. When specified, should be >= 1</summary>
+        [JsAccessPath("priority")]
         [JsonPropertyName("priority")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Priority { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeCallbackResult.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeCallbackResult.cs
index 75b9d67..46867e7 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeCallbackResult.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeCallbackResult.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class TestMatchOutcomeCallbackResult : BaseObject
     {
         /// <summary>The rules (if any) that match the hypothetical request.</summary>
+        [JsAccessPath("matchedRules")]
         [JsonPropertyName("matchedRules")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MatchedRule> MatchedRules { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeOptions.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeOptions.cs
index 1ee7f98..3bf6ac5 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeOptions.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/TestMatchOutcomeOptions.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class TestMatchOutcomeOptions : BaseObject
     {
         /// <summary>Whether to account for rules from other installed extensions during rule evaluation.</summary>
+        [JsAccessPath("includeOtherExtensions")]
         [JsonPropertyName("includeOtherExtensions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludeOtherExtensions { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateDynamicRulesOptions.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateDynamicRulesOptions.cs
index 46660fc..173be7d 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateDynamicRulesOptions.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateDynamicRulesOptions.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class UpdateDynamicRulesOptions : BaseObject
     {
         /// <summary>Rules to add.</summary>
+        [JsAccessPath("addRules")]
         [JsonPropertyName("addRules")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Rule> AddRules { get; set; }
 
         /// <summary>IDs of the rules to remove. Any invalid IDs will be ignored.</summary>
+        [JsAccessPath("removeRuleIds")]
         [JsonPropertyName("removeRuleIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> RemoveRuleIds { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateRulesetOptions.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateRulesetOptions.cs
index 1264627..e9f1034 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateRulesetOptions.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateRulesetOptions.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class UpdateRulesetOptions : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("disableRulesetIds")]
         [JsonPropertyName("disableRulesetIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> DisableRulesetIds { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("enableRulesetIds")]
         [JsonPropertyName("enableRulesetIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> EnableRulesetIds { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateSessionRulesOptions.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateSessionRulesOptions.cs
index 62a7399..390bc2b 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateSessionRulesOptions.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UpdateSessionRulesOptions.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class UpdateSessionRulesOptions : BaseObject
     {
         /// <summary>Rules to add.</summary>
+        [JsAccessPath("addRules")]
         [JsonPropertyName("addRules")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Rule> AddRules { get; set; }
 
         /// <summary>IDs of the rules to remove. Any invalid IDs will be ignored.</summary>
+        [JsAccessPath("removeRuleIds")]
         [JsonPropertyName("removeRuleIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> RemoveRuleIds { get; set; }
diff --git a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UrlTransform.cs b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UrlTransform.cs
index ca9706c..850682c 100644
--- a/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UrlTransform.cs
+++ b/src/WebExtensions.Net/Generated/DeclarativeNetRequest/UrlTransform.cs
@@ -9,46 +9,55 @@ namespace WebExtensions.Net.DeclarativeNetRequest
     public partial class UrlTransform : BaseObject
     {
         /// <summary>The new fragment for the request. Should be either empty, in which case the existing fragment is cleared; or should begin with '#'.</summary>
+        [JsAccessPath("fragment")]
         [JsonPropertyName("fragment")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Fragment { get; set; }
 
         /// <summary>The new host name for the request.</summary>
+        [JsAccessPath("host")]
         [JsonPropertyName("host")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Host { get; set; }
 
         /// <summary>The new password for the request.</summary>
+        [JsAccessPath("password")]
         [JsonPropertyName("password")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Password { get; set; }
 
         /// <summary>The new path for the request. If empty, the existing path is cleared.</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Path { get; set; }
 
         /// <summary>The new port for the request. If empty, the existing port is cleared.</summary>
+        [JsAccessPath("port")]
         [JsonPropertyName("port")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Port { get; set; }
 
         /// <summary>The new query for the request. Should be either empty, in which case the existing query is cleared; or should begin with '?'. Cannot be specified if 'queryTransform' is specified.</summary>
+        [JsAccessPath("query")]
         [JsonPropertyName("query")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Query { get; set; }
 
         /// <summary>Add, remove or replace query key-value pairs. Cannot be specified if 'query' is specified.</summary>
+        [JsAccessPath("queryTransform")]
         [JsonPropertyName("queryTransform")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public QueryTransform QueryTransform { get; set; }
 
         /// <summary>The new scheme for the request.</summary>
+        [JsAccessPath("scheme")]
         [JsonPropertyName("scheme")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Scheme { get; set; }
 
         /// <summary>The new username for the request.</summary>
+        [JsAccessPath("username")]
         [JsonPropertyName("username")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Username { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Devtools/IDevtoolsApi.cs b/src/WebExtensions.Net/Generated/Devtools/IDevtoolsApi.cs
index 762905e..310973d 100644
--- a/src/WebExtensions.Net/Generated/Devtools/IDevtoolsApi.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/IDevtoolsApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using WebExtensions.Net.Devtools.InspectedWindow;
 using WebExtensions.Net.Devtools.Network;
 using WebExtensions.Net.Devtools.Panels;
@@ -5,15 +6,19 @@
 namespace WebExtensions.Net.Devtools
 {
     /// <summary></summary>
+    [JsAccessPath("devtools")]
     public partial interface IDevtoolsApi
     {
         /// <summary>Use the <c>chrome.devtools.inspectedWindow</c> API to interact with the inspected window: obtain the tab ID for the inspected page, evaluate the code in the context of the inspected window, reload the page, or obtain the list of resources within the page.</summary>
+        [JsAccessPath("inspectedWindow")]
         IInspectedWindowApi InspectedWindow { get; }
 
         /// <summary>Use the <c>chrome.devtools.network</c> API to retrieve the information about network requests displayed by the Developer Tools in the Network panel.</summary>
+        [JsAccessPath("network")]
         INetworkApi Network { get; }
 
         /// <summary>Use the <c>chrome.devtools.panels</c> API to integrate your extension into Developer Tools window UI: create your own panels, access existing panels, and add sidebars.</summary>
+        [JsAccessPath("panels")]
         IPanelsApi Panels { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/EvalResult.cs b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/EvalResult.cs
index 0aad6cc..d4fb410 100644
--- a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/EvalResult.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/EvalResult.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -18,11 +19,13 @@ public EvalResult() : base(propertyTypes, propertyNames)
         }
 
         /// <summary>The result of evaluation.</summary>
+        [JsAccessPath("result")]
         [JsonPropertyName("result")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public JsonElement Result { get; set; }
 
         /// <summary>An object providing details if an exception occurred while evaluating the expression.</summary>
+        [JsAccessPath("exceptionInfo")]
         [JsonPropertyName("exceptionInfo")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ExceptionInfo ExceptionInfo { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ExceptionInfo.cs b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ExceptionInfo.cs
index 22c7a5a..b594b46 100644
--- a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ExceptionInfo.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ExceptionInfo.cs
@@ -10,29 +10,35 @@ namespace WebExtensions.Net.Devtools.InspectedWindow
     public partial class ExceptionInfo : BaseObject
     {
         /// <summary>Set if the error occurred on the DevTools side before the expression is evaluated.</summary>
+        [JsAccessPath("code")]
         [JsonPropertyName("code")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Code { get; set; }
 
         /// <summary>Set if the error occurred on the DevTools side before the expression is evaluated.</summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
 
         /// <summary>Set if the error occurred on the DevTools side before the expression is evaluated, contains the array of the values that may be substituted into the description string to provide more information about the cause of the error.</summary>
+        [JsAccessPath("details")]
         [JsonPropertyName("details")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<object> Details { get; set; }
 
         /// <summary>Set if the error occurred on the DevTools side before the expression is evaluated.</summary>
+        [JsAccessPath("isError")]
         [JsonPropertyName("isError")]
         public bool IsError { get; set; }
 
         /// <summary>Set if the evaluated code produces an unhandled exception.</summary>
+        [JsAccessPath("isException")]
         [JsonPropertyName("isException")]
         public bool IsException { get; set; }
 
         /// <summary>Set if the evaluated code produces an unhandled exception.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/IInspectedWindowApi.cs b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/IInspectedWindowApi.cs
index 55cf376..19dbeb1 100644
--- a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/IInspectedWindowApi.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/IInspectedWindowApi.cs
@@ -1,21 +1,26 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Devtools.InspectedWindow
 {
     /// <summary>Use the <c>chrome.devtools.inspectedWindow</c> API to interact with the inspected window: obtain the tab ID for the inspected page, evaluate the code in the context of the inspected window, reload the page, or obtain the list of resources within the page.</summary>
+    [JsAccessPath("inspectedWindow")]
     public partial interface IInspectedWindowApi
     {
         /// <summary>The ID of the tab being inspected. This ID may be used with chrome.tabs.* API.</summary>
+        [JsAccessPath("tabId")]
         int TabId { get; }
 
         /// <summary>Evaluates a JavaScript expression in the context of the main frame of the inspected page. The expression must evaluate to a JSON-compliant object, otherwise an exception is thrown. The eval function can report either a DevTools-side error or a JavaScript exception that occurs during evaluation. In either case, the <c>result</c> parameter of the callback is <c>undefined</c>. In the case of a DevTools-side error, the <c>isException</c> parameter is non-null and has <c>isError</c> set to true and <c>code</c> set to an error code. In the case of a JavaScript error, <c>isException</c> is set to true and <c>value</c> is set to the string value of thrown object.</summary>
         /// <param name="expression">An expression to evaluate.</param>
         /// <param name="options">The options parameter can contain one or more options.</param>
         /// <returns></returns>
+        [JsAccessPath("eval")]
         ValueTask<EvalResult> Eval(string expression, object options = null);
 
         /// <summary>Reloads the inspected page.</summary>
         /// <param name="reloadOptions"></param>
+        [JsAccessPath("reload")]
         ValueTask Reload(ReloadOptions reloadOptions = null);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ReloadOptions.cs b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ReloadOptions.cs
index 0012967..5f81039 100644
--- a/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ReloadOptions.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/InspectedWindow/ReloadOptions.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Devtools.InspectedWindow
     public partial class ReloadOptions : BaseObject
     {
         /// <summary>When true, the loader will bypass the cache for all inspected page resources loaded before the <c>load</c> event is fired. The effect is similar to pressing Ctrl+Shift+R in the inspected window or within the Developer Tools window.</summary>
+        [JsAccessPath("ignoreCache")]
         [JsonPropertyName("ignoreCache")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IgnoreCache { get; set; }
 
         /// <summary>If specified, the script will be injected into every frame of the inspected page immediately upon load, before any of the frame's scripts. The script will not be injected after subsequent reloads-for example, if the user presses Ctrl+R.</summary>
+        [JsAccessPath("injectedScript")]
         [JsonPropertyName("injectedScript")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string InjectedScript { get; set; }
 
         /// <summary>If specified, the string will override the value of the <c>User-Agent</c> HTTP header that's sent while loading the resources of the inspected page. The string will also override the value of the <c>navigator.userAgent</c> property that's returned to any scripts that are running within the inspected page.</summary>
+        [JsAccessPath("userAgent")]
         [JsonPropertyName("userAgent")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UserAgent { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Devtools/Network/INetworkApi.cs b/src/WebExtensions.Net/Generated/Devtools/Network/INetworkApi.cs
index 222be6b..9425eb8 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Network/INetworkApi.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Network/INetworkApi.cs
@@ -1,19 +1,24 @@
+using JsBind.Net;
 using System.Text.Json;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Devtools.Network
 {
     /// <summary>Use the <c>chrome.devtools.network</c> API to retrieve the information about network requests displayed by the Developer Tools in the Network panel.</summary>
+    [JsAccessPath("network")]
     public partial interface INetworkApi
     {
         /// <summary>Fired when the inspected window navigates to a new page.</summary>
+        [JsAccessPath("onNavigated")]
         OnNavigatedEvent OnNavigated { get; }
 
         /// <summary>Fired when a network request is finished and all request data are available.</summary>
+        [JsAccessPath("onRequestFinished")]
         OnRequestFinishedEvent OnRequestFinished { get; }
 
         /// <summary>Returns HAR log that contains all known network requests.</summary>
         /// <returns>A HAR log. See HAR specification for details.</returns>
+        [JsAccessPath("getHAR")]
         ValueTask<JsonElement> GetHAR();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Devtools/Network/OnNavigatedEvent.cs b/src/WebExtensions.Net/Generated/Devtools/Network/OnNavigatedEvent.cs
index b278465..17104ef 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Network/OnNavigatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Network/OnNavigatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnNavigatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the inspected window navigates to a new page.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Devtools/Network/OnRequestFinishedEvent.cs b/src/WebExtensions.Net/Generated/Devtools/Network/OnRequestFinishedEvent.cs
index b7040a6..369f630 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Network/OnRequestFinishedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Network/OnRequestFinishedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnRequestFinishedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a network request is finished and all request data are available.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Request> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Request> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Request> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Request> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Request> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Devtools/Network/Request.cs b/src/WebExtensions.Net/Generated/Devtools/Network/Request.cs
index 4392a8d..23a85d3 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Network/Request.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Network/Request.cs
@@ -11,6 +11,7 @@ public partial class Request : BaseObject
     {
         /// <summary>Returns content of the response body.</summary>
         /// <param name="callback">A function that receives the response body when the request completes.</param>
+        [JsAccessPath("getContent")]
         public virtual ValueTask GetContent(Action<string, string> callback)
         {
             return InvokeVoidAsync("getContent", callback);
diff --git a/src/WebExtensions.Net/Generated/Devtools/Panels/ElementsPanel.cs b/src/WebExtensions.Net/Generated/Devtools/Panels/ElementsPanel.cs
index 68954b1..23683ac 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Panels/ElementsPanel.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Panels/ElementsPanel.cs
@@ -11,6 +11,7 @@ public partial class ElementsPanel : BaseObject
         /// <summary>Creates a pane within panel's sidebar.</summary>
         /// <param name="title">Text that is displayed in sidebar caption.</param>
         /// <returns>An ExtensionSidebarPane object for created sidebar pane.</returns>
+        [JsAccessPath("createSidebarPane")]
         public virtual ValueTask<ExtensionSidebarPane> CreateSidebarPane(string title)
         {
             return InvokeAsync<ExtensionSidebarPane>("createSidebarPane", title);
diff --git a/src/WebExtensions.Net/Generated/Devtools/Panels/ExtensionSidebarPane.cs b/src/WebExtensions.Net/Generated/Devtools/Panels/ExtensionSidebarPane.cs
index 8dbaf60..fc685f7 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Panels/ExtensionSidebarPane.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Panels/ExtensionSidebarPane.cs
@@ -12,6 +12,7 @@ public partial class ExtensionSidebarPane : BaseObject
         /// <summary>Sets an expression that is evaluated within the inspected page. The result is displayed in the sidebar pane.</summary>
         /// <param name="expression">An expression to be evaluated in context of the inspected page. JavaScript objects and DOM nodes are displayed in an expandable tree similar to the console/watch.</param>
         /// <param name="rootTitle">An optional title for the root of the expression tree.</param>
+        [JsAccessPath("setExpression")]
         public virtual ValueTask SetExpression(string expression, string rootTitle = null)
         {
             return InvokeVoidAsync("setExpression", expression, rootTitle);
@@ -20,6 +21,7 @@ public virtual ValueTask SetExpression(string expression, string rootTitle = nul
         /// <summary>Sets a JSON-compliant object to be displayed in the sidebar pane.</summary>
         /// <param name="jsonObject">An object to be displayed in context of the inspected page. Evaluated in the context of the caller (API client).</param>
         /// <param name="rootTitle">An optional title for the root of the expression tree.</param>
+        [JsAccessPath("setObject")]
         public virtual ValueTask SetObject(string jsonObject, string rootTitle = null)
         {
             return InvokeVoidAsync("setObject", jsonObject, rootTitle);
@@ -27,6 +29,7 @@ public virtual ValueTask SetObject(string jsonObject, string rootTitle = null)
 
         /// <summary>Sets an HTML page to be displayed in the sidebar pane.</summary>
         /// <param name="path">Relative path of an extension page to display within the sidebar.</param>
+        [JsAccessPath("setPage")]
         public virtual ValueTask SetPage(ExtensionUrl path)
         {
             return InvokeVoidAsync("setPage", path);
diff --git a/src/WebExtensions.Net/Generated/Devtools/Panels/IPanelsApi.cs b/src/WebExtensions.Net/Generated/Devtools/Panels/IPanelsApi.cs
index 2b937cb..5ccb779 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Panels/IPanelsApi.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Panels/IPanelsApi.cs
@@ -1,21 +1,27 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 using WebExtensions.Net.Manifest;
 
 namespace WebExtensions.Net.Devtools.Panels
 {
     /// <summary>Use the <c>chrome.devtools.panels</c> API to integrate your extension into Developer Tools window UI: create your own panels, access existing panels, and add sidebars.</summary>
+    [JsAccessPath("panels")]
     public partial interface IPanelsApi
     {
         /// <summary>Elements panel.</summary>
+        [JsAccessPath("elements")]
         ElementsPanel Elements { get; }
 
         /// <summary>Fired when the devtools theme changes.</summary>
+        [JsAccessPath("onThemeChanged")]
         OnThemeChangedEvent OnThemeChanged { get; }
 
         /// <summary>Sources panel.</summary>
+        [JsAccessPath("sources")]
         SourcesPanel Sources { get; }
 
         /// <summary>The name of the current devtools theme.</summary>
+        [JsAccessPath("themeName")]
         string ThemeName { get; }
 
         /// <summary>Creates an extension panel.</summary>
@@ -23,6 +29,7 @@ public partial interface IPanelsApi
         /// <param name="iconPath">Path of the panel's icon relative to the extension directory, or an empty string to use the default extension icon as the panel icon.</param>
         /// <param name="pagePath">Path of the panel's HTML page relative to the extension directory.</param>
         /// <returns>An ExtensionPanel object representing the created panel.</returns>
+        [JsAccessPath("create")]
         ValueTask<ExtensionPanel> Create(string title, string iconPath, ExtensionUrl pagePath);
 
         /// <summary>Creates an extension panel.</summary>
@@ -30,6 +37,7 @@ public partial interface IPanelsApi
         /// <param name="iconPath">Path of the panel's icon relative to the extension directory, or an empty string to use the default extension icon as the panel icon.</param>
         /// <param name="pagePath">Path of the panel's HTML page relative to the extension directory.</param>
         /// <returns>An ExtensionPanel object representing the created panel.</returns>
+        [JsAccessPath("create")]
         ValueTask<ExtensionPanel> Create(string title, ExtensionUrl iconPath, ExtensionUrl pagePath);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Devtools/Panels/OnThemeChangedEvent.cs b/src/WebExtensions.Net/Generated/Devtools/Panels/OnThemeChangedEvent.cs
index 0e59f11..2c3048d 100644
--- a/src/WebExtensions.Net/Generated/Devtools/Panels/OnThemeChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Devtools/Panels/OnThemeChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnThemeChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the devtools theme changes.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Downloads/BooleanDelta.cs b/src/WebExtensions.Net/Generated/Downloads/BooleanDelta.cs
index a8959ff..14be44e 100644
--- a/src/WebExtensions.Net/Generated/Downloads/BooleanDelta.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/BooleanDelta.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Downloads
     public partial class BooleanDelta : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("current")]
         [JsonPropertyName("current")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Current { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("previous")]
         [JsonPropertyName("previous")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Previous { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/DoubleDelta.cs b/src/WebExtensions.Net/Generated/Downloads/DoubleDelta.cs
index 00590d3..d89b380 100644
--- a/src/WebExtensions.Net/Generated/Downloads/DoubleDelta.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/DoubleDelta.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Downloads
     public partial class DoubleDelta : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("current")]
         [JsonPropertyName("current")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? Current { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("previous")]
         [JsonPropertyName("previous")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? Previous { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/DownloadDelta.cs b/src/WebExtensions.Net/Generated/Downloads/DownloadDelta.cs
index a793d01..23fcf98 100644
--- a/src/WebExtensions.Net/Generated/Downloads/DownloadDelta.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/DownloadDelta.cs
@@ -9,70 +9,84 @@ namespace WebExtensions.Net.Downloads
     public partial class DownloadDelta : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("canResume")]
         [JsonPropertyName("canResume")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BooleanDelta CanResume { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>danger</c>.</summary>
+        [JsAccessPath("danger")]
         [JsonPropertyName("danger")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta Danger { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>endTime</c>.</summary>
+        [JsAccessPath("endTime")]
         [JsonPropertyName("endTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta EndTime { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>error</c>.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta Error { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("exists")]
         [JsonPropertyName("exists")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BooleanDelta Exists { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>filename</c>.</summary>
+        [JsAccessPath("filename")]
         [JsonPropertyName("filename")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta Filename { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>fileSize</c>.</summary>
+        [JsAccessPath("fileSize")]
         [JsonPropertyName("fileSize")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DoubleDelta FileSize { get; set; }
 
         /// <summary>The <c>id</c> of the <see href='#type-DownloadItem'>DownloadItem</see> that changed.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         public int Id { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>mime</c>.</summary>
+        [JsAccessPath("mime")]
         [JsonPropertyName("mime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta Mime { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>paused</c>.</summary>
+        [JsAccessPath("paused")]
         [JsonPropertyName("paused")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public BooleanDelta Paused { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>startTime</c>.</summary>
+        [JsAccessPath("startTime")]
         [JsonPropertyName("startTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta StartTime { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>state</c>.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta State { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>totalBytes</c>.</summary>
+        [JsAccessPath("totalBytes")]
         [JsonPropertyName("totalBytes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DoubleDelta TotalBytes { get; set; }
 
         /// <summary>Describes a change in a <see href='#type-DownloadItem'>DownloadItem</see>'s <c>url</c>.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public StringDelta Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/DownloadItem.cs b/src/WebExtensions.Net/Generated/Downloads/DownloadItem.cs
index 8d5c9f5..94042e2 100644
--- a/src/WebExtensions.Net/Generated/Downloads/DownloadItem.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/DownloadItem.cs
@@ -9,96 +9,117 @@ namespace WebExtensions.Net.Downloads
     public partial class DownloadItem : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("byExtensionId")]
         [JsonPropertyName("byExtensionId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ByExtensionId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("byExtensionName")]
         [JsonPropertyName("byExtensionName")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ByExtensionName { get; set; }
 
         /// <summary>Number of bytes received so far from the host, without considering file compression.</summary>
+        [JsAccessPath("bytesReceived")]
         [JsonPropertyName("bytesReceived")]
         public double BytesReceived { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("canResume")]
         [JsonPropertyName("canResume")]
         public bool CanResume { get; set; }
 
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>Indication of whether this download is thought to be safe or known to be suspicious.</summary>
+        [JsAccessPath("danger")]
         [JsonPropertyName("danger")]
         public DangerType Danger { get; set; }
 
         /// <summary>Number of milliseconds between the unix epoch and when this download ended.</summary>
+        [JsAccessPath("endTime")]
         [JsonPropertyName("endTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string EndTime { get; set; }
 
         /// <summary>Number indicating why a download was interrupted.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public InterruptReason? Error { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("estimatedEndTime")]
         [JsonPropertyName("estimatedEndTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string EstimatedEndTime { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("exists")]
         [JsonPropertyName("exists")]
         public bool Exists { get; set; }
 
         /// <summary>Absolute local path.</summary>
+        [JsAccessPath("filename")]
         [JsonPropertyName("filename")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Filename { get; set; }
 
         /// <summary>Number of bytes in the whole file post-decompression, or -1 if unknown.</summary>
+        [JsAccessPath("fileSize")]
         [JsonPropertyName("fileSize")]
         public double FileSize { get; set; }
 
         /// <summary>An identifier that is persistent across browser sessions.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         public int Id { get; set; }
 
         /// <summary>False if this download is recorded in the history, true if it is not recorded.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         public bool Incognito { get; set; }
 
         /// <summary>The file's MIME type.</summary>
+        [JsAccessPath("mime")]
         [JsonPropertyName("mime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Mime { get; set; }
 
         /// <summary>True if the download has stopped reading data from the host, but kept the connection open.</summary>
+        [JsAccessPath("paused")]
         [JsonPropertyName("paused")]
         public bool Paused { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("referrer")]
         [JsonPropertyName("referrer")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Referrer { get; set; }
 
         /// <summary>Number of milliseconds between the unix epoch and when this download began.</summary>
+        [JsAccessPath("startTime")]
         [JsonPropertyName("startTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StartTime { get; set; }
 
         /// <summary>Indicates whether the download is progressing, interrupted, or complete.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         public State State { get; set; }
 
         /// <summary>Number of bytes in the whole file, without considering file compression, or -1 if unknown.</summary>
+        [JsAccessPath("totalBytes")]
         [JsonPropertyName("totalBytes")]
         public double TotalBytes { get; set; }
 
         /// <summary>Absolute URL.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/DownloadOptions.cs b/src/WebExtensions.Net/Generated/Downloads/DownloadOptions.cs
index 4960741..16e8e5e 100644
--- a/src/WebExtensions.Net/Generated/Downloads/DownloadOptions.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/DownloadOptions.cs
@@ -10,51 +10,61 @@ namespace WebExtensions.Net.Downloads
     public partial class DownloadOptions : BaseObject
     {
         /// <summary>When this flag is set to <c>true</c>, then the browser will allow downloads to proceed after encountering HTTP errors such as <c>404 Not Found</c>.</summary>
+        [JsAccessPath("allowHttpErrors")]
         [JsonPropertyName("allowHttpErrors")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllowHttpErrors { get; set; }
 
         /// <summary>Post body.</summary>
+        [JsAccessPath("body")]
         [JsonPropertyName("body")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Body { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("conflictAction")]
         [JsonPropertyName("conflictAction")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public FilenameConflictAction? ConflictAction { get; set; }
 
         /// <summary>The cookie store ID of the contextual identity; requires "cookies" permission.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>A file path relative to the Downloads directory to contain the downloaded file.</summary>
+        [JsAccessPath("filename")]
         [JsonPropertyName("filename")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Filename { get; set; }
 
         /// <summary>Extra HTTP headers to send with the request if the URL uses the HTTP[s] protocol. Each header is represented as a dictionary containing the keys <c>name</c> and either <c>value</c> or <c>binaryValue</c>, restricted to those allowed by XMLHttpRequest.</summary>
+        [JsAccessPath("headers")]
         [JsonPropertyName("headers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Header> Headers { get; set; }
 
         /// <summary>Whether to associate the download with a private browsing session.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The HTTP method to use if the URL uses the HTTP[S] protocol.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>Use a file-chooser to allow the user to select a filename. If the option is not specified, the file chooser will be shown only if the Firefox "Always ask you where to save files" option is enabled (i.e. the pref <c>browser.download.useDownloadDir</c> is set to <c>false</c>).</summary>
+        [JsAccessPath("saveAs")]
         [JsonPropertyName("saveAs")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? SaveAs { get; set; }
 
         /// <summary>The URL to download.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/DownloadQuery.cs b/src/WebExtensions.Net/Generated/Downloads/DownloadQuery.cs
index 2b6d15d..d6bfea0 100644
--- a/src/WebExtensions.Net/Generated/Downloads/DownloadQuery.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/DownloadQuery.cs
@@ -10,131 +10,157 @@ namespace WebExtensions.Net.Downloads
     public partial class DownloadQuery : BaseObject
     {
         /// <summary>Number of bytes received so far from the host, without considering file compression.</summary>
+        [JsAccessPath("bytesReceived")]
         [JsonPropertyName("bytesReceived")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? BytesReceived { get; set; }
 
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>Indication of whether this download is thought to be safe or known to be suspicious.</summary>
+        [JsAccessPath("danger")]
         [JsonPropertyName("danger")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DangerType? Danger { get; set; }
 
         /// <summary>Limits results to downloads that ended after the given ms since the epoch.</summary>
+        [JsAccessPath("endedAfter")]
         [JsonPropertyName("endedAfter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DownloadTime EndedAfter { get; set; }
 
         /// <summary>Limits results to downloads that ended before the given ms since the epoch.</summary>
+        [JsAccessPath("endedBefore")]
         [JsonPropertyName("endedBefore")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DownloadTime EndedBefore { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("endTime")]
         [JsonPropertyName("endTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string EndTime { get; set; }
 
         /// <summary>Why a download was interrupted.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public InterruptReason? Error { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("exists")]
         [JsonPropertyName("exists")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Exists { get; set; }
 
         /// <summary>Absolute local path.</summary>
+        [JsAccessPath("filename")]
         [JsonPropertyName("filename")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Filename { get; set; }
 
         /// <summary>Limits results to <see href='#type-DownloadItem'>DownloadItems</see> whose <c>filename</c> matches the given regular expression.</summary>
+        [JsAccessPath("filenameRegex")]
         [JsonPropertyName("filenameRegex")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FilenameRegex { get; set; }
 
         /// <summary>Number of bytes in the whole file post-decompression, or -1 if unknown.</summary>
+        [JsAccessPath("fileSize")]
         [JsonPropertyName("fileSize")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? FileSize { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Id { get; set; }
 
         /// <summary>Setting this integer limits the number of results. Otherwise, all matching <see href='#type-DownloadItem'>DownloadItems</see> will be returned.</summary>
+        [JsAccessPath("limit")]
         [JsonPropertyName("limit")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Limit { get; set; }
 
         /// <summary>The file's MIME type.</summary>
+        [JsAccessPath("mime")]
         [JsonPropertyName("mime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Mime { get; set; }
 
         /// <summary>Setting elements of this array to <see href='#type-DownloadItem'>DownloadItem</see> properties in order to sort the search results. For example, setting <c>orderBy='startTime'</c> sorts the <see href='#type-DownloadItem'>DownloadItems</see> by their start time in ascending order. To specify descending order, prefix <c>orderBy</c> with a hyphen: '-startTime'.</summary>
+        [JsAccessPath("orderBy")]
         [JsonPropertyName("orderBy")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> OrderBy { get; set; }
 
         /// <summary>True if the download has stopped reading data from the host, but kept the connection open.</summary>
+        [JsAccessPath("paused")]
         [JsonPropertyName("paused")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Paused { get; set; }
 
         /// <summary>This array of search terms limits results to <see href='#type-DownloadItem'>DownloadItems</see> whose <c>filename</c> or <c>url</c> contain all of the search terms that do not begin with a dash '-' and none of the search terms that do begin with a dash.</summary>
+        [JsAccessPath("query")]
         [JsonPropertyName("query")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Query { get; set; }
 
         /// <summary>Limits results to downloads that started after the given ms since the epoch.</summary>
+        [JsAccessPath("startedAfter")]
         [JsonPropertyName("startedAfter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DownloadTime StartedAfter { get; set; }
 
         /// <summary>Limits results to downloads that started before the given ms since the epoch.</summary>
+        [JsAccessPath("startedBefore")]
         [JsonPropertyName("startedBefore")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public DownloadTime StartedBefore { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("startTime")]
         [JsonPropertyName("startTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StartTime { get; set; }
 
         /// <summary>Indicates whether the download is progressing, interrupted, or complete.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public State? State { get; set; }
 
         /// <summary>Number of bytes in the whole file, without considering file compression, or -1 if unknown.</summary>
+        [JsAccessPath("totalBytes")]
         [JsonPropertyName("totalBytes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? TotalBytes { get; set; }
 
         /// <summary>Limits results to downloads whose totalBytes is greater than the given integer.</summary>
+        [JsAccessPath("totalBytesGreater")]
         [JsonPropertyName("totalBytesGreater")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? TotalBytesGreater { get; set; }
 
         /// <summary>Limits results to downloads whose totalBytes is less than the given integer.</summary>
+        [JsAccessPath("totalBytesLess")]
         [JsonPropertyName("totalBytesLess")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? TotalBytesLess { get; set; }
 
         /// <summary>Absolute URL.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Limits results to <see href='#type-DownloadItem'>DownloadItems</see> whose <c>url</c> matches the given regular expression.</summary>
+        [JsAccessPath("urlRegex")]
         [JsonPropertyName("urlRegex")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlRegex { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/GetFileIconOptions.cs b/src/WebExtensions.Net/Generated/Downloads/GetFileIconOptions.cs
index 066f64f..bc9268c 100644
--- a/src/WebExtensions.Net/Generated/Downloads/GetFileIconOptions.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/GetFileIconOptions.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Downloads
     public partial class GetFileIconOptions : BaseObject
     {
         /// <summary>The size of the icon.  The returned icon will be square with dimensions size * size pixels.  The default size for the icon is 32x32 pixels.</summary>
+        [JsAccessPath("size")]
         [JsonPropertyName("size")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Size { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/Header.cs b/src/WebExtensions.Net/Generated/Downloads/Header.cs
index f027e0f..f7fd3c2 100644
--- a/src/WebExtensions.Net/Generated/Downloads/Header.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/Header.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Downloads
     public partial class Header : BaseObject
     {
         /// <summary>Name of the HTTP header.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>Value of the HTTP header.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Downloads/IDownloadsApi.cs b/src/WebExtensions.Net/Generated/Downloads/IDownloadsApi.cs
index 1eeb4a0..5efd6bb 100644
--- a/src/WebExtensions.Net/Generated/Downloads/IDownloadsApi.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/IDownloadsApi.cs
@@ -1,67 +1,83 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Downloads
 {
     /// <summary></summary>
+    [JsAccessPath("downloads")]
     public partial interface IDownloadsApi
     {
         /// <summary>When any of a <see href='#type-DownloadItem'>DownloadItem</see>'s properties except <c>bytesReceived</c> changes, this event fires with the <c>downloadId</c> and an object containing the properties that changed.</summary>
+        [JsAccessPath("onChanged")]
         OnChangedEvent OnChanged { get; }
 
         /// <summary>This event fires with the <see href='#type-DownloadItem'>DownloadItem</see> object when a download begins.</summary>
+        [JsAccessPath("onCreated")]
         OnCreatedEvent OnCreated { get; }
 
         /// <summary>Fires with the <c>downloadId</c> when a download is erased from history.</summary>
+        [JsAccessPath("onErased")]
         OnErasedEvent OnErased { get; }
 
         /// <summary>Cancel a download. When <c>callback</c> is run, the download is cancelled, completed, interrupted or doesn't exist anymore.</summary>
         /// <param name="downloadId">The id of the download to cancel.</param>
+        [JsAccessPath("cancel")]
         ValueTask Cancel(int downloadId);
 
         /// <summary>Download a URL. If the URL uses the HTTP[S] protocol, then the request will include all cookies currently set for its hostname. If both <c>filename</c> and <c>saveAs</c> are specified, then the Save As dialog will be displayed, pre-populated with the specified <c>filename</c>. If the download started successfully, <c>callback</c> will be called with the new <see href='#type-DownloadItem'>DownloadItem</see>'s <c>downloadId</c>. If there was an error starting the download, then <c>callback</c> will be called with <c>downloadId=undefined</c> and <see href='extension.html#property-lastError'>chrome.extension.lastError</see> will contain a descriptive string. The error strings are not guaranteed to remain backwards compatible between releases. You must not parse it.</summary>
         /// <param name="options">What to download and how.</param>
         /// <returns></returns>
+        [JsAccessPath("download")]
         ValueTask<int> Download(DownloadOptions options);
 
         /// <summary>Erase matching <see href='#type-DownloadItem'>DownloadItems</see> from history</summary>
         /// <param name="query"></param>
         /// <returns></returns>
+        [JsAccessPath("erase")]
         ValueTask<IEnumerable<int>> Erase(DownloadQuery query);
 
         /// <summary>Retrieve an icon for the specified download. For new downloads, file icons are available after the <see href='#event-onCreated'>onCreated</see> event has been received. The image returned by this function while a download is in progress may be different from the image returned after the download is complete. Icon retrieval is done by querying the underlying operating system or toolkit depending on the platform. The icon that is returned will therefore depend on a number of factors including state of the download, platform, registered file types and visual theme. If a file icon cannot be determined, <see href='extension.html#property-lastError'>chrome.extension.lastError</see> will contain an error message.</summary>
         /// <param name="downloadId">The identifier for the download.</param>
         /// <param name="options"></param>
         /// <returns></returns>
+        [JsAccessPath("getFileIcon")]
         ValueTask<string> GetFileIcon(int downloadId, GetFileIconOptions options = null);
 
         /// <summary>Open the downloaded file.</summary>
         /// <param name="downloadId"></param>
+        [JsAccessPath("open")]
         ValueTask Open(int downloadId);
 
         /// <summary>Pause the download. If the request was successful the download is in a paused state. Otherwise <see href='extension.html#property-lastError'>chrome.extension.lastError</see> contains an error message. The request will fail if the download is not active.</summary>
         /// <param name="downloadId">The id of the download to pause.</param>
+        [JsAccessPath("pause")]
         ValueTask Pause(int downloadId);
 
         /// <summary></summary>
         /// <param name="downloadId"></param>
+        [JsAccessPath("removeFile")]
         ValueTask RemoveFile(int downloadId);
 
         /// <summary>Resume a paused download. If the request was successful the download is in progress and unpaused. Otherwise <see href='extension.html#property-lastError'>chrome.extension.lastError</see> contains an error message. The request will fail if the download is not active.</summary>
         /// <param name="downloadId">The id of the download to resume.</param>
+        [JsAccessPath("resume")]
         ValueTask Resume(int downloadId);
 
         /// <summary>Find <see href='#type-DownloadItem'>DownloadItems</see>. Set <c>query</c> to the empty object to get all <see href='#type-DownloadItem'>DownloadItems</see>. To get a specific <see href='#type-DownloadItem'>DownloadItem</see>, set only the <c>id</c> field.</summary>
         /// <param name="query"></param>
         /// <returns></returns>
+        [JsAccessPath("search")]
         ValueTask<IEnumerable<DownloadItem>> Search(DownloadQuery query);
 
         /// <summary>Show the downloaded file in its folder in a file manager.</summary>
         /// <param name="downloadId"></param>
         /// <returns></returns>
+        [JsAccessPath("show")]
         ValueTask<bool> Show(int downloadId);
 
         /// <summary></summary>
+        [JsAccessPath("showDefaultFolder")]
         ValueTask ShowDefaultFolder();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Downloads/OnChangedEvent.cs b/src/WebExtensions.Net/Generated/Downloads/OnChangedEvent.cs
index 49f9b06..5d599be 100644
--- a/src/WebExtensions.Net/Generated/Downloads/OnChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/OnChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">When any of a <see href='#type-DownloadItem'>DownloadItem</see>'s properties except <c>bytesReceived</c> changes, this event fires with the <c>downloadId</c> and an object containing the properties that changed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<DownloadDelta> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<DownloadDelta> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<DownloadDelta> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<DownloadDelta> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<DownloadDelta> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Downloads/OnCreatedEvent.cs b/src/WebExtensions.Net/Generated/Downloads/OnCreatedEvent.cs
index ffbea79..52d0484 100644
--- a/src/WebExtensions.Net/Generated/Downloads/OnCreatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/OnCreatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCreatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">This event fires with the <see href='#type-DownloadItem'>DownloadItem</see> object when a download begins.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<DownloadItem> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<DownloadItem> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<DownloadItem> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<DownloadItem> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<DownloadItem> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Downloads/OnErasedEvent.cs b/src/WebExtensions.Net/Generated/Downloads/OnErasedEvent.cs
index 78eabcd..9d1c0d6 100644
--- a/src/WebExtensions.Net/Generated/Downloads/OnErasedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/OnErasedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnErasedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fires with the <c>downloadId</c> when a download is erased from history.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Downloads/StringDelta.cs b/src/WebExtensions.Net/Generated/Downloads/StringDelta.cs
index fb93af8..3f92b65 100644
--- a/src/WebExtensions.Net/Generated/Downloads/StringDelta.cs
+++ b/src/WebExtensions.Net/Generated/Downloads/StringDelta.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Downloads
     public partial class StringDelta : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("current")]
         [JsonPropertyName("current")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Current { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("previous")]
         [JsonPropertyName("previous")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Previous { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Events/Event.cs b/src/WebExtensions.Net/Generated/Events/Event.cs
index b9e387c..57baaaf 100644
--- a/src/WebExtensions.Net/Generated/Events/Event.cs
+++ b/src/WebExtensions.Net/Generated/Events/Event.cs
@@ -11,6 +11,7 @@ public partial class Event : BaseObject
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Called when an event occurs. The parameters of this function depend on the type of event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -19,6 +20,7 @@ public virtual ValueTask AddListener(Action callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -26,6 +28,7 @@ public virtual ValueTask<bool> HasListener(Action callback)
 
         /// <summary></summary>
         /// <returns>True if any event listeners are registered to the event.</returns>
+        [JsAccessPath("hasListeners")]
         public virtual ValueTask<bool> HasListeners()
         {
             return InvokeAsync<bool>("hasListeners");
@@ -33,6 +36,7 @@ public virtual ValueTask<bool> HasListeners()
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Events/UrlFilter.cs b/src/WebExtensions.Net/Generated/Events/UrlFilter.cs
index c6b3761..27485b3 100644
--- a/src/WebExtensions.Net/Generated/Events/UrlFilter.cs
+++ b/src/WebExtensions.Net/Generated/Events/UrlFilter.cs
@@ -10,101 +10,121 @@ namespace WebExtensions.Net.Events
     public partial class UrlFilter : BaseObject
     {
         /// <summary>Matches if the host name of the URL contains a specified string. To test whether a host name component has a prefix 'foo', use hostContains: '.foo'. This matches 'www.foobar.com' and 'foo.com', because an implicit dot is added at the beginning of the host name. Similarly, hostContains can be used to match against component suffix ('foo.') and to exactly match against components ('.foo.'). Suffix- and exact-matching for the last components need to be done separately using hostSuffix, because no implicit dot is added at the end of the host name.</summary>
+        [JsAccessPath("hostContains")]
         [JsonPropertyName("hostContains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HostContains { get; set; }
 
         /// <summary>Matches if the host name of the URL is equal to a specified string.</summary>
+        [JsAccessPath("hostEquals")]
         [JsonPropertyName("hostEquals")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HostEquals { get; set; }
 
         /// <summary>Matches if the host name of the URL starts with a specified string.</summary>
+        [JsAccessPath("hostPrefix")]
         [JsonPropertyName("hostPrefix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HostPrefix { get; set; }
 
         /// <summary>Matches if the host name of the URL ends with a specified string.</summary>
+        [JsAccessPath("hostSuffix")]
         [JsonPropertyName("hostSuffix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HostSuffix { get; set; }
 
         /// <summary>Matches if the URL without query segment and fragment identifier matches a specified regular expression. Port numbers are stripped from the URL if they match the default port number. The regular expressions use the <see href="https://github.com/google/re2/blob/master/doc/syntax.txt">RE2 syntax</see>.</summary>
+        [JsAccessPath("originAndPathMatches")]
         [JsonPropertyName("originAndPathMatches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginAndPathMatches { get; set; }
 
         /// <summary>Matches if the path segment of the URL contains a specified string.</summary>
+        [JsAccessPath("pathContains")]
         [JsonPropertyName("pathContains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PathContains { get; set; }
 
         /// <summary>Matches if the path segment of the URL is equal to a specified string.</summary>
+        [JsAccessPath("pathEquals")]
         [JsonPropertyName("pathEquals")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PathEquals { get; set; }
 
         /// <summary>Matches if the path segment of the URL starts with a specified string.</summary>
+        [JsAccessPath("pathPrefix")]
         [JsonPropertyName("pathPrefix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PathPrefix { get; set; }
 
         /// <summary>Matches if the path segment of the URL ends with a specified string.</summary>
+        [JsAccessPath("pathSuffix")]
         [JsonPropertyName("pathSuffix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PathSuffix { get; set; }
 
         /// <summary>Matches if the port of the URL is contained in any of the specified port lists. For example <c>[80, 443, [1000, 1200]]</c> matches all requests on port 80, 443 and in the range 1000-1200.</summary>
+        [JsAccessPath("ports")]
         [JsonPropertyName("ports")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Port> Ports { get; set; }
 
         /// <summary>Matches if the query segment of the URL contains a specified string.</summary>
+        [JsAccessPath("queryContains")]
         [JsonPropertyName("queryContains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string QueryContains { get; set; }
 
         /// <summary>Matches if the query segment of the URL is equal to a specified string.</summary>
+        [JsAccessPath("queryEquals")]
         [JsonPropertyName("queryEquals")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string QueryEquals { get; set; }
 
         /// <summary>Matches if the query segment of the URL starts with a specified string.</summary>
+        [JsAccessPath("queryPrefix")]
         [JsonPropertyName("queryPrefix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string QueryPrefix { get; set; }
 
         /// <summary>Matches if the query segment of the URL ends with a specified string.</summary>
+        [JsAccessPath("querySuffix")]
         [JsonPropertyName("querySuffix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string QuerySuffix { get; set; }
 
         /// <summary>Matches if the scheme of the URL is equal to any of the schemes specified in the array.</summary>
+        [JsAccessPath("schemes")]
         [JsonPropertyName("schemes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Schemes { get; set; }
 
         /// <summary>Matches if the URL (without fragment identifier) contains a specified string. Port numbers are stripped from the URL if they match the default port number.</summary>
+        [JsAccessPath("urlContains")]
         [JsonPropertyName("urlContains")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlContains { get; set; }
 
         /// <summary>Matches if the URL (without fragment identifier) is equal to a specified string. Port numbers are stripped from the URL if they match the default port number.</summary>
+        [JsAccessPath("urlEquals")]
         [JsonPropertyName("urlEquals")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlEquals { get; set; }
 
         /// <summary>Matches if the URL (without fragment identifier) matches a specified regular expression. Port numbers are stripped from the URL if they match the default port number. The regular expressions use the <see href="https://github.com/google/re2/blob/master/doc/syntax.txt">RE2 syntax</see>.</summary>
+        [JsAccessPath("urlMatches")]
         [JsonPropertyName("urlMatches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlMatches { get; set; }
 
         /// <summary>Matches if the URL (without fragment identifier) starts with a specified string. Port numbers are stripped from the URL if they match the default port number.</summary>
+        [JsAccessPath("urlPrefix")]
         [JsonPropertyName("urlPrefix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlPrefix { get; set; }
 
         /// <summary>Matches if the URL (without fragment identifier) ends with a specified string. Port numbers are stripped from the URL if they match the default port number.</summary>
+        [JsAccessPath("urlSuffix")]
         [JsonPropertyName("urlSuffix")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UrlSuffix { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Extension/FetchProperties.cs b/src/WebExtensions.Net/Generated/Extension/FetchProperties.cs
index c2721f3..000bf4e 100644
--- a/src/WebExtensions.Net/Generated/Extension/FetchProperties.cs
+++ b/src/WebExtensions.Net/Generated/Extension/FetchProperties.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Extension
     public partial class FetchProperties : BaseObject
     {
         /// <summary>Find a view according to a tab id. If this field is omitted, returns all views.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>The type of view to get. If omitted, returns all views (including background pages and tabs). Valid values: 'tab', 'popup', 'sidebar'.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ViewType? Type { get; set; }
 
         /// <summary>The window to restrict the search to. If omitted, returns all views.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Extension/IExtensionApi.cs b/src/WebExtensions.Net/Generated/Extension/IExtensionApi.cs
index 964b400..05f4aeb 100644
--- a/src/WebExtensions.Net/Generated/Extension/IExtensionApi.cs
+++ b/src/WebExtensions.Net/Generated/Extension/IExtensionApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System;
 using System.Collections.Generic;
 using System.Text.Json;
@@ -6,36 +7,44 @@
 namespace WebExtensions.Net.Extension
 {
     /// <summary>The <c>browser.extension</c> API has utilities that can be used by any extension page. It includes support for exchanging messages between an extension and its content scripts or between extensions, as described in detail in $(topic:messaging)[Message Passing].</summary>
+    [JsAccessPath("extension")]
     public partial interface IExtensionApi
     {
         /// <summary>True for content scripts running inside incognito tabs, and for extension pages running inside an incognito process. The latter only applies to extensions with 'split' incognito_behavior.</summary>
+        [JsAccessPath("inIncognitoContext")]
         bool? InIncognitoContext { get; }
 
         /// <summary>Set for the lifetime of a callback if an ansychronous extension api has resulted in an error. If no error has occured lastError will be <c>undefined</c>.</summary>
+        [JsAccessPath("lastError")]
         [Obsolete("Please use $(ref:runtime.lastError).")]
         LastError LastError { get; }
 
         /// <summary>Returns the JavaScript 'window' object for the background page running inside the current extension. Returns null if the extension has no background page.</summary>
         /// <returns></returns>
+        [JsAccessPath("getBackgroundPage")]
         ValueTask<JsonElement> GetBackgroundPage();
 
         /// <summary>Converts a relative path within an extension install directory to a fully-qualified URL.</summary>
         /// <param name="path">A path to a resource within an extension expressed relative to its install directory.</param>
         /// <returns>The fully-qualified URL to the resource.</returns>
+        [JsAccessPath("getURL")]
         [Obsolete("Please use $(ref:runtime.getURL).")]
         ValueTask<string> GetURL(string path);
 
         /// <summary>Returns an array of the JavaScript 'window' objects for each of the pages running inside the current extension.</summary>
         /// <param name="fetchProperties"></param>
         /// <returns>Array of global objects</returns>
+        [JsAccessPath("getViews")]
         ValueTask<IEnumerable<object>> GetViews(FetchProperties fetchProperties = null);
 
         /// <summary>Retrieves the state of the extension's access to the 'file://' scheme (as determined by the user-controlled 'Allow access to File URLs' checkbox.</summary>
         /// <returns>True if the extension can access the 'file://' scheme, false otherwise.</returns>
+        [JsAccessPath("isAllowedFileSchemeAccess")]
         ValueTask<bool> IsAllowedFileSchemeAccess();
 
         /// <summary>Retrieves the state of the extension's access to Incognito-mode (as determined by the user-controlled 'Allowed in Incognito' checkbox.</summary>
         /// <returns>True if the extension has access to Incognito mode, false otherwise.</returns>
+        [JsAccessPath("isAllowedIncognitoAccess")]
         ValueTask<bool> IsAllowedIncognitoAccess();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Extension/LastError.cs b/src/WebExtensions.Net/Generated/Extension/LastError.cs
index 8125f93..337474d 100644
--- a/src/WebExtensions.Net/Generated/Extension/LastError.cs
+++ b/src/WebExtensions.Net/Generated/Extension/LastError.cs
@@ -11,6 +11,7 @@ namespace WebExtensions.Net.Extension
     public partial class LastError : BaseObject
     {
         /// <summary>Description of the error that has taken place.</summary>
+        [JsAccessPath("message")]
         [JsonPropertyName("message")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Message { get; set; }
diff --git a/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionCode.cs b/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionCode.cs
index 5432ad1..067958e 100644
--- a/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionCode.cs
+++ b/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionCode.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.ExtensionTypes
     public partial class ExtensionCode : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("code")]
         [JsonPropertyName("code")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Code { get; set; }
diff --git a/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionFile.cs b/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionFile.cs
index 87fd8d7..02bb3aa 100644
--- a/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionFile.cs
+++ b/src/WebExtensions.Net/Generated/ExtensionTypes/ExtensionFile.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.ExtensionTypes
     public partial class ExtensionFile : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("file")]
         [JsonPropertyName("file")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ExtensionUrl File { get; set; }
diff --git a/src/WebExtensions.Net/Generated/ExtensionTypes/ImageDetails.cs b/src/WebExtensions.Net/Generated/ExtensionTypes/ImageDetails.cs
index 4e3044f..cddbdb0 100644
--- a/src/WebExtensions.Net/Generated/ExtensionTypes/ImageDetails.cs
+++ b/src/WebExtensions.Net/Generated/ExtensionTypes/ImageDetails.cs
@@ -9,26 +9,31 @@ namespace WebExtensions.Net.ExtensionTypes
     public partial class ImageDetails : BaseObject
     {
         /// <summary>The format of the resulting image.  Default is <c>"jpeg"</c>.</summary>
+        [JsAccessPath("format")]
         [JsonPropertyName("format")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ImageFormat? Format { get; set; }
 
         /// <summary>When format is <c>"jpeg"</c>, controls the quality of the resulting image.  This value is ignored for PNG images.  As quality is decreased, the resulting image will have more visual artifacts, and the number of bytes needed to store it will decrease.</summary>
+        [JsAccessPath("quality")]
         [JsonPropertyName("quality")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Quality { get; set; }
 
         /// <summary>The area of the document to capture, in CSS pixels, relative to the page.  If omitted, capture the visible viewport.</summary>
+        [JsAccessPath("rect")]
         [JsonPropertyName("rect")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Rect Rect { get; set; }
 
         /// <summary>If true, temporarily resets the scroll position of the document to 0. Only takes effect if rect is also specified.</summary>
+        [JsAccessPath("resetScrollPosition")]
         [JsonPropertyName("resetScrollPosition")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ResetScrollPosition { get; set; }
 
         /// <summary>The scale of the resulting image.  Defaults to <c>devicePixelRatio</c>.</summary>
+        [JsAccessPath("scale")]
         [JsonPropertyName("scale")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? Scale { get; set; }
diff --git a/src/WebExtensions.Net/Generated/ExtensionTypes/InjectDetails.cs b/src/WebExtensions.Net/Generated/ExtensionTypes/InjectDetails.cs
index 718c166..135235d 100644
--- a/src/WebExtensions.Net/Generated/ExtensionTypes/InjectDetails.cs
+++ b/src/WebExtensions.Net/Generated/ExtensionTypes/InjectDetails.cs
@@ -9,36 +9,43 @@ namespace WebExtensions.Net.ExtensionTypes
     public partial class InjectDetails : BaseObject
     {
         /// <summary>If allFrames is <c>true</c>, implies that the JavaScript or CSS should be injected into all frames of current page. By default, it's <c>false</c> and is only injected into the top frame.</summary>
+        [JsAccessPath("allFrames")]
         [JsonPropertyName("allFrames")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllFrames { get; set; }
 
         /// <summary>JavaScript or CSS code to inject.<br /><br />'b'Warning:'/b'<br />Be careful using the <c>code</c> parameter. Incorrect use of it may open your extension to <see href="https://en.wikipedia.org/wiki/Cross-site_scripting">cross site scripting</see> attacks.</summary>
+        [JsAccessPath("code")]
         [JsonPropertyName("code")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Code { get; set; }
 
         /// <summary>The css origin of the stylesheet to inject. Defaults to "author".</summary>
+        [JsAccessPath("cssOrigin")]
         [JsonPropertyName("cssOrigin")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public CSSOrigin? CssOrigin { get; set; }
 
         /// <summary>JavaScript or CSS file to inject.</summary>
+        [JsAccessPath("file")]
         [JsonPropertyName("file")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string File { get; set; }
 
         /// <summary>The ID of the frame to inject the script into. This may not be used in combination with <c>allFrames</c>.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? FrameId { get; set; }
 
         /// <summary>If matchAboutBlank is true, then the code is also injected in about:blank and about:srcdoc frames if your extension has access to its parent document. Code cannot be inserted in top-level about:-frames. By default it is <c>false</c>.</summary>
+        [JsAccessPath("matchAboutBlank")]
         [JsonPropertyName("matchAboutBlank")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? MatchAboutBlank { get; set; }
 
         /// <summary>The soonest that the JavaScript or CSS will be injected into the tab. Defaults to "document_idle".</summary>
+        [JsAccessPath("runAt")]
         [JsonPropertyName("runAt")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public RunAt? RunAt { get; set; }
diff --git a/src/WebExtensions.Net/Generated/ExtensionTypes/Rect.cs b/src/WebExtensions.Net/Generated/ExtensionTypes/Rect.cs
index dd75a2e..51703fd 100644
--- a/src/WebExtensions.Net/Generated/ExtensionTypes/Rect.cs
+++ b/src/WebExtensions.Net/Generated/ExtensionTypes/Rect.cs
@@ -9,18 +9,22 @@ namespace WebExtensions.Net.ExtensionTypes
     public partial class Rect : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("height")]
         [JsonPropertyName("height")]
         public double Height { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("width")]
         [JsonPropertyName("width")]
         public double Width { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("x")]
         [JsonPropertyName("x")]
         public double X { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("y")]
         [JsonPropertyName("y")]
         public double Y { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/History/AddUrlDetails.cs b/src/WebExtensions.Net/Generated/History/AddUrlDetails.cs
index 559ced1..eab8613 100644
--- a/src/WebExtensions.Net/Generated/History/AddUrlDetails.cs
+++ b/src/WebExtensions.Net/Generated/History/AddUrlDetails.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.History
     public partial class AddUrlDetails : BaseObject
     {
         /// <summary>The title of the page.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The $(topic:transition-types)[transition type] for this visit from its referrer.</summary>
+        [JsAccessPath("transition")]
         [JsonPropertyName("transition")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public TransitionType? Transition { get; set; }
 
         /// <summary>The URL to add. Must be a valid URL that can be added to history.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>The date when this visit occurred.</summary>
+        [JsAccessPath("visitTime")]
         [JsonPropertyName("visitTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date VisitTime { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/Changed.cs b/src/WebExtensions.Net/Generated/History/Changed.cs
index 7ee35fa..fa0a8c0 100644
--- a/src/WebExtensions.Net/Generated/History/Changed.cs
+++ b/src/WebExtensions.Net/Generated/History/Changed.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.History
     public partial class Changed : BaseObject
     {
         /// <summary>The new title for the URL.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The URL for which the title has changed</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/DeleteUrlDetails.cs b/src/WebExtensions.Net/Generated/History/DeleteUrlDetails.cs
index d19079c..98e295e 100644
--- a/src/WebExtensions.Net/Generated/History/DeleteUrlDetails.cs
+++ b/src/WebExtensions.Net/Generated/History/DeleteUrlDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.History
     public partial class DeleteUrlDetails : BaseObject
     {
         /// <summary>The URL to remove.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/GetVisitsDetails.cs b/src/WebExtensions.Net/Generated/History/GetVisitsDetails.cs
index 5c8acc3..99c2146 100644
--- a/src/WebExtensions.Net/Generated/History/GetVisitsDetails.cs
+++ b/src/WebExtensions.Net/Generated/History/GetVisitsDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.History
     public partial class GetVisitsDetails : BaseObject
     {
         /// <summary>The URL for which to retrieve visit information.  It must be in the format as returned from a call to history.search.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/HistoryItem.cs b/src/WebExtensions.Net/Generated/History/HistoryItem.cs
index 00879cd..f8e77de 100644
--- a/src/WebExtensions.Net/Generated/History/HistoryItem.cs
+++ b/src/WebExtensions.Net/Generated/History/HistoryItem.cs
@@ -9,31 +9,37 @@ namespace WebExtensions.Net.History
     public partial class HistoryItem : BaseObject
     {
         /// <summary>The unique identifier for the item.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>When this page was last loaded, represented in milliseconds since the epoch.</summary>
+        [JsAccessPath("lastVisitTime")]
         [JsonPropertyName("lastVisitTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? LastVisitTime { get; set; }
 
         /// <summary>The title of the page when it was last loaded.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The number of times the user has navigated to this page by typing in the address.</summary>
+        [JsAccessPath("typedCount")]
         [JsonPropertyName("typedCount")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TypedCount { get; set; }
 
         /// <summary>The URL navigated to by a user.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>The number of times the user has navigated to this page.</summary>
+        [JsAccessPath("visitCount")]
         [JsonPropertyName("visitCount")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? VisitCount { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/IHistoryApi.cs b/src/WebExtensions.Net/Generated/History/IHistoryApi.cs
index d7ff8d9..4391223 100644
--- a/src/WebExtensions.Net/Generated/History/IHistoryApi.cs
+++ b/src/WebExtensions.Net/Generated/History/IHistoryApi.cs
@@ -1,43 +1,54 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.History
 {
     /// <summary>Use the <c>browser.history</c> API to interact with the browser's record of visited pages. You can add, remove, and query for URLs in the browser's history. To override the history page with your own version, see $(topic:override)[Override Pages].</summary>
+    [JsAccessPath("history")]
     public partial interface IHistoryApi
     {
         /// <summary>Fired when the title of a URL is changed in the browser history.</summary>
+        [JsAccessPath("onTitleChanged")]
         OnTitleChangedEvent OnTitleChanged { get; }
 
         /// <summary>Fired when a URL is visited, providing the HistoryItem data for that URL.  This event fires before the page has loaded.</summary>
+        [JsAccessPath("onVisited")]
         OnVisitedEvent OnVisited { get; }
 
         /// <summary>Fired when one or more URLs are removed from the history service.  When all visits have been removed the URL is purged from history.</summary>
+        [JsAccessPath("onVisitRemoved")]
         OnVisitRemovedEvent OnVisitRemoved { get; }
 
         /// <summary>Adds a URL to the history with a default visitTime of the current time and a default $(topic:transition-types)[transition type] of "link".</summary>
         /// <param name="details"></param>
+        [JsAccessPath("addUrl")]
         ValueTask AddUrl(AddUrlDetails details);
 
         /// <summary>Deletes all items from the history.</summary>
+        [JsAccessPath("deleteAll")]
         ValueTask DeleteAll();
 
         /// <summary>Removes all items within the specified date range from the history.  Pages will not be removed from the history unless all visits fall within the range.</summary>
         /// <param name="range"></param>
+        [JsAccessPath("deleteRange")]
         ValueTask DeleteRange(Range range);
 
         /// <summary>Removes all occurrences of the given URL from the history.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("deleteUrl")]
         ValueTask DeleteUrl(DeleteUrlDetails details);
 
         /// <summary>Retrieves information about visits to a URL.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getVisits")]
         ValueTask<IEnumerable<VisitItem>> GetVisits(GetVisitsDetails details);
 
         /// <summary>Searches the history for the last visit time of each page matching the query.</summary>
         /// <param name="query"></param>
         /// <returns></returns>
+        [JsAccessPath("search")]
         ValueTask<IEnumerable<HistoryItem>> Search(Query query);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/History/OnTitleChangedEvent.cs b/src/WebExtensions.Net/Generated/History/OnTitleChangedEvent.cs
index a179c97..508c831 100644
--- a/src/WebExtensions.Net/Generated/History/OnTitleChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/History/OnTitleChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnTitleChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the title of a URL is changed in the browser history.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Changed> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Changed> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Changed> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Changed> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Changed> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/History/OnVisitRemovedEvent.cs b/src/WebExtensions.Net/Generated/History/OnVisitRemovedEvent.cs
index 3bcec89..4c04bd2 100644
--- a/src/WebExtensions.Net/Generated/History/OnVisitRemovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/History/OnVisitRemovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnVisitRemovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when one or more URLs are removed from the history service.  When all visits have been removed the URL is purged from history.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Removed> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Removed> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Removed> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Removed> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Removed> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/History/OnVisitedEvent.cs b/src/WebExtensions.Net/Generated/History/OnVisitedEvent.cs
index e72398e..1ab0a5c 100644
--- a/src/WebExtensions.Net/Generated/History/OnVisitedEvent.cs
+++ b/src/WebExtensions.Net/Generated/History/OnVisitedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnVisitedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a URL is visited, providing the HistoryItem data for that URL.  This event fires before the page has loaded.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<HistoryItem> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<HistoryItem> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<HistoryItem> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<HistoryItem> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<HistoryItem> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/History/Query.cs b/src/WebExtensions.Net/Generated/History/Query.cs
index ce13dab..6775a6c 100644
--- a/src/WebExtensions.Net/Generated/History/Query.cs
+++ b/src/WebExtensions.Net/Generated/History/Query.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.History
     public partial class Query : BaseObject
     {
         /// <summary>Limit results to those visited before this date.</summary>
+        [JsAccessPath("endTime")]
         [JsonPropertyName("endTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date EndTime { get; set; }
 
         /// <summary>The maximum number of results to retrieve.  Defaults to 100.</summary>
+        [JsAccessPath("maxResults")]
         [JsonPropertyName("maxResults")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? MaxResults { get; set; }
 
         /// <summary>Limit results to those visited after this date. If not specified, this defaults to 24 hours in the past.</summary>
+        [JsAccessPath("startTime")]
         [JsonPropertyName("startTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date StartTime { get; set; }
 
         /// <summary>A free-text query to the history service.  Leave empty to retrieve all pages.</summary>
+        [JsAccessPath("text")]
         [JsonPropertyName("text")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Text { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/Range.cs b/src/WebExtensions.Net/Generated/History/Range.cs
index 6b3711e..47770d4 100644
--- a/src/WebExtensions.Net/Generated/History/Range.cs
+++ b/src/WebExtensions.Net/Generated/History/Range.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.History
     public partial class Range : BaseObject
     {
         /// <summary>Items added to history before this date.</summary>
+        [JsAccessPath("endTime")]
         [JsonPropertyName("endTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date EndTime { get; set; }
 
         /// <summary>Items added to history after this date.</summary>
+        [JsAccessPath("startTime")]
         [JsonPropertyName("startTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Date StartTime { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/Removed.cs b/src/WebExtensions.Net/Generated/History/Removed.cs
index d3bdda1..4558fe1 100644
--- a/src/WebExtensions.Net/Generated/History/Removed.cs
+++ b/src/WebExtensions.Net/Generated/History/Removed.cs
@@ -10,10 +10,12 @@ namespace WebExtensions.Net.History
     public partial class Removed : BaseObject
     {
         /// <summary>True if all history was removed.  If true, then urls will be empty.</summary>
+        [JsAccessPath("allHistory")]
         [JsonPropertyName("allHistory")]
         public bool AllHistory { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("urls")]
         [JsonPropertyName("urls")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Urls { get; set; }
diff --git a/src/WebExtensions.Net/Generated/History/VisitItem.cs b/src/WebExtensions.Net/Generated/History/VisitItem.cs
index c448051..6fd566a 100644
--- a/src/WebExtensions.Net/Generated/History/VisitItem.cs
+++ b/src/WebExtensions.Net/Generated/History/VisitItem.cs
@@ -9,25 +9,30 @@ namespace WebExtensions.Net.History
     public partial class VisitItem : BaseObject
     {
         /// <summary>The unique identifier for the item.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>The visit ID of the referrer.</summary>
+        [JsAccessPath("referringVisitId")]
         [JsonPropertyName("referringVisitId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ReferringVisitId { get; set; }
 
         /// <summary>The $(topic:transition-types)[transition type] for this visit from its referrer.</summary>
+        [JsAccessPath("transition")]
         [JsonPropertyName("transition")]
         public TransitionType Transition { get; set; }
 
         /// <summary>The unique identifier for this visit.</summary>
+        [JsAccessPath("visitId")]
         [JsonPropertyName("visitId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string VisitId { get; set; }
 
         /// <summary>When this visit occurred, represented in milliseconds since the epoch.</summary>
+        [JsAccessPath("visitTime")]
         [JsonPropertyName("visitTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? VisitTime { get; set; }
diff --git a/src/WebExtensions.Net/Generated/I18n/II18nApi.cs b/src/WebExtensions.Net/Generated/I18n/II18nApi.cs
index 217ecc3..df82b2f 100644
--- a/src/WebExtensions.Net/Generated/I18n/II18nApi.cs
+++ b/src/WebExtensions.Net/Generated/I18n/II18nApi.cs
@@ -1,28 +1,34 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.I18n
 {
     /// <summary>Use the <c>browser.i18n</c> infrastructure to implement internationalization across your whole app or extension.</summary>
+    [JsAccessPath("i18n")]
     public partial interface II18nApi
     {
         /// <summary>Detects the language of the provided text using CLD.</summary>
         /// <param name="text">User input string to be translated.</param>
         /// <returns>LanguageDetectionResult object that holds detected langugae reliability and array of DetectedLanguage</returns>
+        [JsAccessPath("detectLanguage")]
         ValueTask<Result> DetectLanguage(string text);
 
         /// <summary>Gets the accept-languages of the browser. This is different from the locale used by the browser; to get the locale, use $(ref:i18n.getUILanguage).</summary>
         /// <returns>Array of LanguageCode</returns>
+        [JsAccessPath("getAcceptLanguages")]
         ValueTask<IEnumerable<LanguageCode>> GetAcceptLanguages();
 
         /// <summary>Gets the localized string for the specified message. If the message is missing, this method returns an empty string (''). If the format of the <c>getMessage()</c> call is wrong - for example, <em>messageName</em> is not a string or the <em>substitutions</em> array has more than 9 elements - this method returns <c>undefined</c>.</summary>
         /// <param name="messageName">The name of the message, as specified in the <c>$(topic:i18n-messages)[messages.json]</c> file.</param>
         /// <param name="substitutions">Substitution strings, if the message requires any.</param>
         /// <returns>Message localized for current locale.</returns>
+        [JsAccessPath("getMessage")]
         ValueTask<string> GetMessage(string messageName, object substitutions = null);
 
         /// <summary>Gets the browser UI language of the browser. This is different from $(ref:i18n.getAcceptLanguages) which returns the preferred user languages.</summary>
         /// <returns>The browser UI language code such as en-US or fr-FR.</returns>
+        [JsAccessPath("getUILanguage")]
         ValueTask<string> GetUILanguage();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/I18n/LanguageType.cs b/src/WebExtensions.Net/Generated/I18n/LanguageType.cs
index 61d56b5..341069c 100644
--- a/src/WebExtensions.Net/Generated/I18n/LanguageType.cs
+++ b/src/WebExtensions.Net/Generated/I18n/LanguageType.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.I18n
     public partial class LanguageType : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("language")]
         [JsonPropertyName("language")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public LanguageCode Language { get; set; }
 
         /// <summary>The percentage of the detected language</summary>
+        [JsAccessPath("percentage")]
         [JsonPropertyName("percentage")]
         public int Percentage { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/I18n/Result.cs b/src/WebExtensions.Net/Generated/I18n/Result.cs
index 6061434..feb7f79 100644
--- a/src/WebExtensions.Net/Generated/I18n/Result.cs
+++ b/src/WebExtensions.Net/Generated/I18n/Result.cs
@@ -10,10 +10,12 @@ namespace WebExtensions.Net.I18n
     public partial class Result : BaseObject
     {
         /// <summary>CLD detected language reliability</summary>
+        [JsAccessPath("isReliable")]
         [JsonPropertyName("isReliable")]
         public bool IsReliable { get; set; }
 
         /// <summary>array of detectedLanguage</summary>
+        [JsAccessPath("languages")]
         [JsonPropertyName("languages")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<LanguageType> Languages { get; set; }
diff --git a/src/WebExtensions.Net/Generated/IWebExtensionsApi.cs b/src/WebExtensions.Net/Generated/IWebExtensionsApi.cs
index 14fa68f..17ff88e 100644
--- a/src/WebExtensions.Net/Generated/IWebExtensionsApi.cs
+++ b/src/WebExtensions.Net/Generated/IWebExtensionsApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System;
 using WebExtensions.Net.ActionNs;
 using WebExtensions.Net.Alarms;
@@ -39,115 +40,152 @@
 namespace WebExtensions.Net
 {
     /// <summary>Web Extension Api</summary>
+    [JsAccessPath("browser")]
     public partial interface IWebExtensionsApi
     {
         /// <summary>Use browser actions to put icons in the main browser toolbar, to the right of the address bar. In addition to its icon, a browser action can also have a tooltip, a badge, and a popup.<br />Requires manifest permission manifest:action, manifest:browser_action.</summary>
+        [JsAccessPath("action")]
         IActionApi Action { get; }
 
         /// <summary><br />Requires manifest permission alarms.</summary>
+        [JsAccessPath("alarms")]
         IAlarmsApi Alarms { get; }
 
         /// <summary>Use the <c>browser.bookmarks</c> API to create, organize, and otherwise manipulate bookmarks. Also see $(topic:override)[Override Pages], which you can use to create a custom Bookmark Manager page.<br />Requires manifest permission bookmarks.</summary>
+        [JsAccessPath("bookmarks")]
         IBookmarksApi Bookmarks { get; }
 
         /// <summary>Use browser actions to put icons in the main browser toolbar, to the right of the address bar. In addition to its icon, a browser action can also have a tooltip, a badge, and a popup.<br />Requires manifest permission manifest:action, manifest:browser_action.</summary>
+        [JsAccessPath("browserAction")]
         [Obsolete("Deprecated in Manifest V3, use action API.")]
         IBrowserActionApi BrowserAction { get; }
 
         /// <summary>Use the <c>browser.browserSettings</c> API to control global settings of the browser.<br />Requires manifest permission browserSettings.</summary>
+        [JsAccessPath("browserSettings")]
         IBrowserSettingsApi BrowserSettings { get; }
 
         /// <summary>Use the <c>chrome.browsingData</c> API to remove browsing data from a user's local profile.<br />Requires manifest permission browsingData.</summary>
+        [JsAccessPath("browsingData")]
         IBrowsingDataApi BrowsingData { get; }
 
         /// <summary>Offers the ability to write to the clipboard. Reading is not supported because the clipboard can already be read through the standard web platform APIs.<br />Requires manifest permission clipboardWrite.</summary>
+        [JsAccessPath("clipboard")]
         IClipboardApi Clipboard { get; }
 
         /// <summary>Use the commands API to add keyboard shortcuts that trigger actions in your extension, for example, an action to open the browser action or send a command to the xtension.<br />Requires manifest permission manifest:commands.</summary>
+        [JsAccessPath("commands")]
         ICommandsApi Commands { get; }
 
         /// <summary></summary>
+        [JsAccessPath("contentScripts")]
         IContentScriptsApi ContentScripts { get; }
 
         /// <summary>Use the <c>browser.cookies</c> API to query and modify cookies, and to be notified when they change.<br />Requires manifest permission cookies.</summary>
+        [JsAccessPath("cookies")]
         ICookiesApi Cookies { get; }
 
         /// <summary>Use the declarativeNetRequest API to block or modify network requests by specifying declarative rules.<br />Requires manifest permission declarativeNetRequest, declarativeNetRequestWithHostAccess.</summary>
+        [JsAccessPath("declarativeNetRequest")]
         IDeclarativeNetRequestApi DeclarativeNetRequest { get; }
 
         /// <summary><br />Requires manifest permission manifest:devtools_page.</summary>
+        [JsAccessPath("devtools")]
         IDevtoolsApi Devtools { get; }
 
         /// <summary><br />Requires manifest permission downloads.</summary>
+        [JsAccessPath("downloads")]
         IDownloadsApi Downloads { get; }
 
         /// <summary>The <c>browser.extension</c> API has utilities that can be used by any extension page. It includes support for exchanging messages between an extension and its content scripts or between extensions, as described in detail in $(topic:messaging)[Message Passing].</summary>
+        [JsAccessPath("extension")]
         IExtensionApi Extension { get; }
 
         /// <summary>Use the <c>browser.history</c> API to interact with the browser's record of visited pages. You can add, remove, and query for URLs in the browser's history. To override the history page with your own version, see $(topic:override)[Override Pages].<br />Requires manifest permission history.</summary>
+        [JsAccessPath("history")]
         IHistoryApi History { get; }
 
         /// <summary>Use the <c>browser.i18n</c> infrastructure to implement internationalization across your whole app or extension.</summary>
+        [JsAccessPath("i18n")]
         II18nApi I18n { get; }
 
         /// <summary>Use the chrome.identity API to get OAuth2 access tokens. <br />Requires manifest permission identity.</summary>
+        [JsAccessPath("identity")]
         IIdentityApi Identity { get; }
 
         /// <summary>Use the <c>browser.idle</c> API to detect when the machine's idle state changes.<br />Requires manifest permission idle.</summary>
+        [JsAccessPath("idle")]
         IIdleApi Idle { get; }
 
         /// <summary>The <c>browser.management</c> API provides ways to manage the list of extensions that are installed and running.</summary>
+        [JsAccessPath("management")]
         IManagementApi Management { get; }
 
         /// <summary>The part of the menus API that is available in all extension contexts, including content scripts. Use the browser.menus API to add items to the browser's menus. You can choose what types of objects your context menu additions apply to, such as images, hyperlinks, and pages.<br />Requires manifest permission menus.</summary>
+        [JsAccessPath("menus")]
         IMenusApi Menus { get; }
 
         /// <summary><br />Requires manifest permission notifications.</summary>
+        [JsAccessPath("notifications")]
         INotificationsApi Notifications { get; }
 
         /// <summary>The omnibox API allows you to register a keyword with Firefox's address bar.<br />Requires manifest permission manifest:omnibox.</summary>
+        [JsAccessPath("omnibox")]
         IOmniboxApi Omnibox { get; }
 
         /// <summary>Use the <c>browser.pageAction</c> API to put icons inside the address bar. Page actions represent actions that can be taken on the current page, but that aren't applicable to all pages.<br />Requires manifest permission manifest:page_action.</summary>
+        [JsAccessPath("pageAction")]
         IPageActionApi PageAction { get; }
 
         /// <summary></summary>
+        [JsAccessPath("permissions")]
         IPermissionsApi Permissions { get; }
 
         /// <summary><br />Requires manifest permission privacy.</summary>
+        [JsAccessPath("privacy")]
         IPrivacyApi Privacy { get; }
 
         /// <summary>Provides access to global proxy settings for Firefox and proxy event listeners to handle dynamic proxy implementations.<br />Requires manifest permission proxy.</summary>
+        [JsAccessPath("proxy")]
         IProxyApi Proxy { get; }
 
         /// <summary>Use the <c>browser.runtime</c> API to retrieve the background page, return details about the manifest, and listen for and respond to events in the app or extension lifecycle. You can also use this API to convert the relative path of URLs to fully-qualified URLs.</summary>
+        [JsAccessPath("runtime")]
         IRuntimeApi Runtime { get; }
 
         /// <summary>Use the scripting API to execute script in different contexts.<br />Requires manifest permission scripting.</summary>
+        [JsAccessPath("scripting")]
         IScriptingApi Scripting { get; }
 
         /// <summary>Use browser.search to interact with search engines.<br />Requires manifest permission search.</summary>
+        [JsAccessPath("search")]
         ISearchApi Search { get; }
 
         /// <summary>Use the <c>chrome.sessions</c> API to query and restore tabs and windows from a browsing session.<br />Requires manifest permission sessions.</summary>
+        [JsAccessPath("sessions")]
         ISessionsApi Sessions { get; }
 
         /// <summary>Use the <c>browser.storage</c> API to store, retrieve, and track changes to user data.<br />Requires manifest permission storage.</summary>
+        [JsAccessPath("storage")]
         IStorageApi Storage { get; }
 
         /// <summary>Use the <c>browser.tabs</c> API to interact with the browser's tab system. You can use this API to create, modify, and rearrange tabs in the browser.</summary>
+        [JsAccessPath("tabs")]
         ITabsApi Tabs { get; }
 
         /// <summary>Use the chrome.topSites API to access the top sites that are displayed on the new tab page. <br />Requires manifest permission topSites.</summary>
+        [JsAccessPath("topSites")]
         ITopSitesApi TopSites { get; }
 
         /// <summary>Use the <c>browser.webNavigation</c> API to receive notifications about the status of navigation requests in-flight.<br />Requires manifest permission webNavigation.</summary>
+        [JsAccessPath("webNavigation")]
         IWebNavigationApi WebNavigation { get; }
 
         /// <summary>Use the <c>browser.webRequest</c> API to observe and analyze traffic and to intercept, block, or modify requests in-flight.<br />Requires manifest permission webRequest.</summary>
+        [JsAccessPath("webRequest")]
         IWebRequestApi WebRequest { get; }
 
         /// <summary>Use the <c>browser.windows</c> API to interact with browser windows. You can use this API to create, modify, and rearrange windows in the browser.</summary>
+        [JsAccessPath("windows")]
         IWindowsApi Windows { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Identity/IIdentityApi.cs b/src/WebExtensions.Net/Generated/Identity/IIdentityApi.cs
index 7a4404e..0734250 100644
--- a/src/WebExtensions.Net/Generated/Identity/IIdentityApi.cs
+++ b/src/WebExtensions.Net/Generated/Identity/IIdentityApi.cs
@@ -1,18 +1,22 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Identity
 {
     /// <summary>Use the chrome.identity API to get OAuth2 access tokens. </summary>
+    [JsAccessPath("identity")]
     public partial interface IIdentityApi
     {
         /// <summary>Generates a redirect URL to be used in |launchWebAuthFlow|.</summary>
         /// <param name="path">The path appended to the end of the generated URL. </param>
         /// <returns></returns>
+        [JsAccessPath("getRedirectURL")]
         ValueTask<string> GetRedirectURL(string path = null);
 
         /// <summary>Starts an auth flow at the specified URL.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("launchWebAuthFlow")]
         ValueTask<string> LaunchWebAuthFlow(LaunchWebAuthFlowDetails details);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Identity/LaunchWebAuthFlowDetails.cs b/src/WebExtensions.Net/Generated/Identity/LaunchWebAuthFlowDetails.cs
index 348b9c5..e9c54d6 100644
--- a/src/WebExtensions.Net/Generated/Identity/LaunchWebAuthFlowDetails.cs
+++ b/src/WebExtensions.Net/Generated/Identity/LaunchWebAuthFlowDetails.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.Identity
     public partial class LaunchWebAuthFlowDetails : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("interactive")]
         [JsonPropertyName("interactive")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Interactive { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpUrl Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Idle/IIdleApi.cs b/src/WebExtensions.Net/Generated/Idle/IIdleApi.cs
index 0a55972..f423953 100644
--- a/src/WebExtensions.Net/Generated/Idle/IIdleApi.cs
+++ b/src/WebExtensions.Net/Generated/Idle/IIdleApi.cs
@@ -1,20 +1,25 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Idle
 {
     /// <summary>Use the <c>browser.idle</c> API to detect when the machine's idle state changes.</summary>
+    [JsAccessPath("idle")]
     public partial interface IIdleApi
     {
         /// <summary>Fired when the system changes to an active or idle state. The event fires with "idle" if the the user has not generated any input for a specified number of seconds, and "active" when the user generates input on an idle system.</summary>
+        [JsAccessPath("onStateChanged")]
         OnStateChangedEvent OnStateChanged { get; }
 
         /// <summary>Returns "idle" if the user has not generated any input for a specified number of seconds, or "active" otherwise.</summary>
         /// <param name="detectionIntervalInSeconds">The system is considered idle if detectionIntervalInSeconds seconds have elapsed since the last user input detected.</param>
         /// <returns></returns>
+        [JsAccessPath("queryState")]
         ValueTask<IdleState> QueryState(int detectionIntervalInSeconds);
 
         /// <summary>Sets the interval, in seconds, used to determine when the system is in an idle state for onStateChanged events. The default interval is 60 seconds.</summary>
         /// <param name="intervalInSeconds">Threshold, in seconds, used to determine when the system is in an idle state.</param>
+        [JsAccessPath("setDetectionInterval")]
         ValueTask SetDetectionInterval(int intervalInSeconds);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Idle/OnStateChangedEvent.cs b/src/WebExtensions.Net/Generated/Idle/OnStateChangedEvent.cs
index af528f9..0cb137e 100644
--- a/src/WebExtensions.Net/Generated/Idle/OnStateChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Idle/OnStateChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnStateChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the system changes to an active or idle state. The event fires with "idle" if the the user has not generated any input for a specified number of seconds, and "active" when the user generates input on an idle system.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<IdleState> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<IdleState> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<IdleState> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<IdleState> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<IdleState> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Management/ExtensionInfo.cs b/src/WebExtensions.Net/Generated/Management/ExtensionInfo.cs
index 946fc37..d48d115 100644
--- a/src/WebExtensions.Net/Generated/Management/ExtensionInfo.cs
+++ b/src/WebExtensions.Net/Generated/Management/ExtensionInfo.cs
@@ -10,82 +10,99 @@ namespace WebExtensions.Net.Management
     public partial class ExtensionInfo : BaseObject
     {
         /// <summary>The description of this extension.</summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
 
         /// <summary>A reason the item is disabled.</summary>
+        [JsAccessPath("disabledReason")]
         [JsonPropertyName("disabledReason")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ExtensionDisabledReason? DisabledReason { get; set; }
 
         /// <summary>Whether it is currently enabled or disabled.</summary>
+        [JsAccessPath("enabled")]
         [JsonPropertyName("enabled")]
         public bool Enabled { get; set; }
 
         /// <summary>The URL of the homepage of this extension.</summary>
+        [JsAccessPath("homepageUrl")]
         [JsonPropertyName("homepageUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HomepageUrl { get; set; }
 
         /// <summary>Returns a list of host based permissions.</summary>
+        [JsAccessPath("hostPermissions")]
         [JsonPropertyName("hostPermissions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> HostPermissions { get; set; }
 
         /// <summary>A list of icon information. Note that this just reflects what was declared in the manifest, and the actual image at that url may be larger or smaller than what was declared, so you might consider using explicit width and height attributes on img tags referencing these images. See the <see href='manifest/icons'>manifest documentation on icons</see> for more details.</summary>
+        [JsAccessPath("icons")]
         [JsonPropertyName("icons")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<IconInfo> Icons { get; set; }
 
         /// <summary>The extension's unique identifier.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>How the extension was installed.</summary>
+        [JsAccessPath("installType")]
         [JsonPropertyName("installType")]
         public ExtensionInstallType InstallType { get; set; }
 
         /// <summary>Whether this extension can be disabled or uninstalled by the user.</summary>
+        [JsAccessPath("mayDisable")]
         [JsonPropertyName("mayDisable")]
         public bool MayDisable { get; set; }
 
         /// <summary>The name of this extension.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The url for the item's options page, if it has one.</summary>
+        [JsAccessPath("optionsUrl")]
         [JsonPropertyName("optionsUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OptionsUrl { get; set; }
 
         /// <summary>Returns a list of API based permissions.</summary>
+        [JsAccessPath("permissions")]
         [JsonPropertyName("permissions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Permissions { get; set; }
 
         /// <summary>A short version of the name of this extension.</summary>
+        [JsAccessPath("shortName")]
         [JsonPropertyName("shortName")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ShortName { get; set; }
 
         /// <summary>The type of this extension, 'extension' or 'theme'.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ExtensionType Type { get; set; }
 
         /// <summary>The update URL of this extension.</summary>
+        [JsAccessPath("updateUrl")]
         [JsonPropertyName("updateUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string UpdateUrl { get; set; }
 
         /// <summary>The <see href='manifest/version'>version</see> of this extension.</summary>
+        [JsAccessPath("version")]
         [JsonPropertyName("version")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Version { get; set; }
 
         /// <summary>The <see href='manifest/version#version_name'>version name</see> of this extension if the manifest specified one.</summary>
+        [JsAccessPath("versionName")]
         [JsonPropertyName("versionName")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string VersionName { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Management/IManagementApi.cs b/src/WebExtensions.Net/Generated/Management/IManagementApi.cs
index efc0559..eb9bd33 100644
--- a/src/WebExtensions.Net/Generated/Management/IManagementApi.cs
+++ b/src/WebExtensions.Net/Generated/Management/IManagementApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using WebExtensions.Net.Manifest;
@@ -5,45 +6,56 @@
 namespace WebExtensions.Net.Management
 {
     /// <summary>The <c>browser.management</c> API provides ways to manage the list of extensions that are installed and running.</summary>
+    [JsAccessPath("management")]
     public partial interface IManagementApi
     {
         /// <summary>Fired when an addon has been disabled.</summary>
+        [JsAccessPath("onDisabled")]
         OnDisabledEvent OnDisabled { get; }
 
         /// <summary>Fired when an addon has been enabled.</summary>
+        [JsAccessPath("onEnabled")]
         OnEnabledEvent OnEnabled { get; }
 
         /// <summary>Fired when an addon has been installed.</summary>
+        [JsAccessPath("onInstalled")]
         OnInstalledEvent OnInstalled { get; }
 
         /// <summary>Fired when an addon has been uninstalled.</summary>
+        [JsAccessPath("onUninstalled")]
         OnUninstalledEvent OnUninstalled { get; }
 
         /// <summary>Returns information about the installed extension that has the given ID.</summary>
         /// <param name="id">The ID from an item of $(ref:management.ExtensionInfo).</param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<ExtensionInfo> Get(ExtensionID id);
 
         /// <summary>Returns a list of information about installed extensions.</summary>
         /// <returns></returns>
+        [JsAccessPath("getAll")]
         ValueTask<IEnumerable<ExtensionInfo>> GetAll();
 
         /// <summary>Returns information about the calling extension. Note: This function can be used without requesting the 'management' permission in the manifest.</summary>
         /// <returns></returns>
+        [JsAccessPath("getSelf")]
         ValueTask<ExtensionInfo> GetSelf();
 
         /// <summary>Installs and enables a theme extension from the given url.</summary>
         /// <param name="options"></param>
         /// <returns></returns>
+        [JsAccessPath("install")]
         ValueTask<Result> Install(InstallOptions options);
 
         /// <summary>Enables or disables the given add-on.</summary>
         /// <param name="id">ID of the add-on to enable/disable.</param>
         /// <param name="enabled">Whether to enable or disable the add-on.</param>
+        [JsAccessPath("setEnabled")]
         ValueTask SetEnabled(string id, bool enabled);
 
         /// <summary>Uninstalls the calling extension. Note: This function can be used without requesting the 'management' permission in the manifest.</summary>
         /// <param name="options"></param>
+        [JsAccessPath("uninstallSelf")]
         ValueTask UninstallSelf(UninstallSelfOptions options = null);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Management/IconInfo.cs b/src/WebExtensions.Net/Generated/Management/IconInfo.cs
index 7b704f2..a24e80c 100644
--- a/src/WebExtensions.Net/Generated/Management/IconInfo.cs
+++ b/src/WebExtensions.Net/Generated/Management/IconInfo.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Management
     public partial class IconInfo : BaseObject
     {
         /// <summary>A number representing the width and height of the icon. Likely values include (but are not limited to) 128, 48, 24, and 16.</summary>
+        [JsAccessPath("size")]
         [JsonPropertyName("size")]
         public int Size { get; set; }
 
         /// <summary>The URL for this icon image. To display a grayscale version of the icon (to indicate that an extension is disabled, for example), append <c>?grayscale=true</c> to the URL.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Management/InstallOptions.cs b/src/WebExtensions.Net/Generated/Management/InstallOptions.cs
index 82f90e7..96debbe 100644
--- a/src/WebExtensions.Net/Generated/Management/InstallOptions.cs
+++ b/src/WebExtensions.Net/Generated/Management/InstallOptions.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.Management
     public partial class InstallOptions : BaseObject
     {
         /// <summary>A hash of the XPI file, using sha256 or stronger.</summary>
+        [JsAccessPath("hash")]
         [JsonPropertyName("hash")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Hash { get; set; }
 
         /// <summary>URL pointing to the XPI file on addons.mozilla.org or similar.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpUrl Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Management/OnDisabledEvent.cs b/src/WebExtensions.Net/Generated/Management/OnDisabledEvent.cs
index c80d7a4..1b0afbb 100644
--- a/src/WebExtensions.Net/Generated/Management/OnDisabledEvent.cs
+++ b/src/WebExtensions.Net/Generated/Management/OnDisabledEvent.cs
@@ -12,6 +12,7 @@ public partial class OnDisabledEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an addon has been disabled.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Management/OnEnabledEvent.cs b/src/WebExtensions.Net/Generated/Management/OnEnabledEvent.cs
index bf02fb4..c34027a 100644
--- a/src/WebExtensions.Net/Generated/Management/OnEnabledEvent.cs
+++ b/src/WebExtensions.Net/Generated/Management/OnEnabledEvent.cs
@@ -12,6 +12,7 @@ public partial class OnEnabledEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an addon has been enabled.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Management/OnInstalledEvent.cs b/src/WebExtensions.Net/Generated/Management/OnInstalledEvent.cs
index 0079268..963b0fa 100644
--- a/src/WebExtensions.Net/Generated/Management/OnInstalledEvent.cs
+++ b/src/WebExtensions.Net/Generated/Management/OnInstalledEvent.cs
@@ -12,6 +12,7 @@ public partial class OnInstalledEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an addon has been installed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Management/OnUninstalledEvent.cs b/src/WebExtensions.Net/Generated/Management/OnUninstalledEvent.cs
index 5f98e93..01f06ca 100644
--- a/src/WebExtensions.Net/Generated/Management/OnUninstalledEvent.cs
+++ b/src/WebExtensions.Net/Generated/Management/OnUninstalledEvent.cs
@@ -12,6 +12,7 @@ public partial class OnUninstalledEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an addon has been uninstalled.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ExtensionInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ExtensionInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ExtensionInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Management/Result.cs b/src/WebExtensions.Net/Generated/Management/Result.cs
index 90c5f2c..f1a578d 100644
--- a/src/WebExtensions.Net/Generated/Management/Result.cs
+++ b/src/WebExtensions.Net/Generated/Management/Result.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.Management
     public partial class Result : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ExtensionID Id { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Management/UninstallSelfOptions.cs b/src/WebExtensions.Net/Generated/Management/UninstallSelfOptions.cs
index 307e351..19c8c65 100644
--- a/src/WebExtensions.Net/Generated/Management/UninstallSelfOptions.cs
+++ b/src/WebExtensions.Net/Generated/Management/UninstallSelfOptions.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Management
     public partial class UninstallSelfOptions : BaseObject
     {
         /// <summary>The message to display to a user when being asked to confirm removal of the extension.</summary>
+        [JsAccessPath("dialogMessage")]
         [JsonPropertyName("dialogMessage")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DialogMessage { get; set; }
 
         /// <summary>Whether or not a confirm-uninstall dialog should prompt the user. Defaults to false.</summary>
+        [JsAccessPath("showConfirmDialog")]
         [JsonPropertyName("showConfirmDialog")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ShowConfirmDialog { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Menus/ContextOptions.cs b/src/WebExtensions.Net/Generated/Menus/ContextOptions.cs
index 3b51ad7..5bd89ca 100644
--- a/src/WebExtensions.Net/Generated/Menus/ContextOptions.cs
+++ b/src/WebExtensions.Net/Generated/Menus/ContextOptions.cs
@@ -9,21 +9,25 @@ namespace WebExtensions.Net.Menus
     public partial class ContextOptions : BaseObject
     {
         /// <summary>Required when context is 'bookmark'. Requires 'bookmark' permission.</summary>
+        [JsAccessPath("bookmarkId")]
         [JsonPropertyName("bookmarkId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string BookmarkId { get; set; }
 
         /// <summary>ContextType to override, to allow menu items from other extensions in the menu. Currently only 'bookmark' and 'tab' are supported. showDefaults cannot be used with this option.</summary>
+        [JsAccessPath("context")]
         [JsonPropertyName("context")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Context { get; set; }
 
         /// <summary>Whether to also include default menu items in the menu.</summary>
+        [JsAccessPath("showDefaults")]
         [JsonPropertyName("showDefaults")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ShowDefaults { get; set; }
 
         /// <summary>Required when context is 'tab'. Requires 'tabs' permission.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Menus/CreateProperties.cs b/src/WebExtensions.Net/Generated/Menus/CreateProperties.cs
index 0b0503b..acbca56 100644
--- a/src/WebExtensions.Net/Generated/Menus/CreateProperties.cs
+++ b/src/WebExtensions.Net/Generated/Menus/CreateProperties.cs
@@ -13,71 +13,85 @@ namespace WebExtensions.Net.Menus
     public partial class CreateProperties : BaseObject
     {
         /// <summary>The initial state of a checkbox or radio item: true for selected and false for unselected. Only one radio item can be selected at a time in a given group of radio items.</summary>
+        [JsAccessPath("checked")]
         [JsonPropertyName("checked")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Checked { get; set; }
 
         /// <summary>Specifies a command to issue for the context click.</summary>
+        [JsAccessPath("command")]
         [JsonPropertyName("command")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Command Command { get; set; }
 
         /// <summary>List of contexts this menu item will appear in. Defaults to ['page'] if not specified.</summary>
+        [JsAccessPath("contexts")]
         [JsonPropertyName("contexts")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ContextType> Contexts { get; set; }
 
         /// <summary>Lets you restrict the item to apply only to documents whose URL matches one of the given patterns. (This applies to frames as well.) For details on the format of a pattern, see $(topic:match_patterns)[Match Patterns].</summary>
+        [JsAccessPath("documentUrlPatterns")]
         [JsonPropertyName("documentUrlPatterns")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> DocumentUrlPatterns { get; set; }
 
         /// <summary>Whether this context menu item is enabled or disabled. Defaults to true.</summary>
+        [JsAccessPath("enabled")]
         [JsonPropertyName("enabled")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Enabled { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("icons")]
         [JsonPropertyName("icons")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Icons { get; set; }
 
         /// <summary>The unique ID to assign to this item. Mandatory for event pages. Cannot be the same as another ID for this extension.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>A function that will be called back when the menu item is clicked. Event pages cannot use this; instead, they should register a listener for $(ref:contextMenus.onClicked).</summary>
+        [JsAccessPath("onclick")]
         [JsonPropertyName("onclick")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Action<OnClickData, Tab> Onclick { get; set; }
 
         /// <summary>The ID of a parent menu item; this makes the item a child of a previously added item.</summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public CreatePropertiesParentId ParentId { get; set; }
 
         /// <summary>Similar to documentUrlPatterns, but lets you filter based on the src attribute of img/audio/video tags and the href of anchor tags.</summary>
+        [JsAccessPath("targetUrlPatterns")]
         [JsonPropertyName("targetUrlPatterns")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> TargetUrlPatterns { get; set; }
 
         /// <summary>The text to be displayed in the item; this is <em>required</em> unless <c>type</c> is 'separator'. When the context is 'selection', you can use <c>%s</c> within the string to show the selected text. For example, if this parameter's value is "Translate '%s' to Pig Latin" and the user selects the word "cool", the context menu item for the selection is "Translate 'cool' to Pig Latin".</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The type of menu item. Defaults to 'normal' if not specified.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ItemType? Type { get; set; }
 
         /// <summary>List of view types where the menu item will be shown. Defaults to any view, including those without a viewType.</summary>
+        [JsAccessPath("viewTypes")]
         [JsonPropertyName("viewTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ViewType> ViewTypes { get; set; }
 
         /// <summary>Whether the item is visible in the menu.</summary>
+        [JsAccessPath("visible")]
         [JsonPropertyName("visible")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Visible { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Menus/IMenusApi.cs b/src/WebExtensions.Net/Generated/Menus/IMenusApi.cs
index 2414b64..ad512dd 100644
--- a/src/WebExtensions.Net/Generated/Menus/IMenusApi.cs
+++ b/src/WebExtensions.Net/Generated/Menus/IMenusApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -6,57 +7,71 @@
 namespace WebExtensions.Net.Menus
 {
     /// <summary>The part of the menus API that is available in all extension contexts, including content scripts.</summary>
+    [JsAccessPath("menus")]
     public partial interface IMenusApi
     {
         /// <summary>The maximum number of top level extension items that can be added to an extension action context menu. Any items beyond this limit will be ignored.</summary>
+        [JsAccessPath("ACTION_MENU_TOP_LEVEL_LIMIT")]
         int ACTION_MENU_TOP_LEVEL_LIMIT { get; }
 
         /// <summary>Fired when a context menu item is clicked.</summary>
+        [JsAccessPath("onClicked")]
         OnClickedEvent OnClicked { get; }
 
         /// <summary>Fired when a menu is hidden. This event is only fired if onShown has fired before.</summary>
+        [JsAccessPath("onHidden")]
         Event OnHidden { get; }
 
         /// <summary>Fired when a menu is shown. The extension can add, modify or remove menu items and call menus.refresh() to update the menu.</summary>
+        [JsAccessPath("onShown")]
         OnShownEvent OnShown { get; }
 
         /// <summary>Creates a new context menu item. Note that if an error occurs during creation, you may not find out until the creation callback fires (the details will be in $(ref:runtime.lastError)).</summary>
         /// <param name="createProperties"></param>
         /// <param name="callback">Called when the item has been created in the browser. If there were any problems creating the item, details will be available in $(ref:runtime.lastError).</param>
         /// <returns>The ID of the newly created item.</returns>
+        [JsAccessPath("create")]
         ValueTask<CreateReturnType> Create(CreateProperties createProperties, Action callback = null);
 
         /// <summary>Retrieve the element that was associated with a recent contextmenu event.</summary>
         /// <param name="targetElementId">The identifier of the clicked element, available as info.targetElementId in the menus.onShown, onClicked or onclick event.</param>
         /// <returns></returns>
+        [JsAccessPath("getTargetElement")]
         ValueTask<JsonElement> GetTargetElement(int targetElementId);
 
         /// <summary>Show the matching menu items from this extension instead of the default menu. This should be called during a 'contextmenu' DOM event handler, and only applies to the menu that opens after this event.</summary>
         /// <param name="contextOptions"></param>
+        [JsAccessPath("overrideContext")]
         ValueTask OverrideContext(ContextOptions contextOptions);
 
         /// <summary>Updates the extension items in the shown menu, including changes that have been made since the menu was shown. Has no effect if the menu is hidden. Rebuilding a shown menu is an expensive operation, only invoke this method when necessary.</summary>
+        [JsAccessPath("refresh")]
         ValueTask Refresh();
 
         /// <summary>Removes a context menu item.</summary>
         /// <param name="menuItemId">The ID of the context menu item to remove.</param>
+        [JsAccessPath("remove")]
         ValueTask Remove(int menuItemId);
 
         /// <summary>Removes a context menu item.</summary>
         /// <param name="menuItemId">The ID of the context menu item to remove.</param>
+        [JsAccessPath("remove")]
         ValueTask Remove(string menuItemId);
 
         /// <summary>Removes all context menu items added by this extension.</summary>
+        [JsAccessPath("removeAll")]
         ValueTask RemoveAll();
 
         /// <summary>Updates a previously created context menu item.</summary>
         /// <param name="id">The ID of the item to update.</param>
         /// <param name="updateProperties">The properties to update. Accepts the same values as the create function.</param>
+        [JsAccessPath("update")]
         ValueTask Update(int id, UpdateProperties updateProperties);
 
         /// <summary>Updates a previously created context menu item.</summary>
         /// <param name="id">The ID of the item to update.</param>
         /// <param name="updateProperties">The properties to update. Accepts the same values as the create function.</param>
+        [JsAccessPath("update")]
         ValueTask Update(string id, UpdateProperties updateProperties);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Menus/Info.cs b/src/WebExtensions.Net/Generated/Menus/Info.cs
index 005d859..d19a538 100644
--- a/src/WebExtensions.Net/Generated/Menus/Info.cs
+++ b/src/WebExtensions.Net/Generated/Menus/Info.cs
@@ -11,60 +11,72 @@ namespace WebExtensions.Net.Menus
     public partial class Info : BaseObject
     {
         /// <summary>A list of all contexts that apply to the menu.</summary>
+        [JsAccessPath("contexts")]
         [JsonPropertyName("contexts")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ContextType> Contexts { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("editable")]
         [JsonPropertyName("editable")]
         public bool Editable { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("frameUrl")]
         [JsonPropertyName("frameUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FrameUrl { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("linkText")]
         [JsonPropertyName("linkText")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string LinkText { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("linkUrl")]
         [JsonPropertyName("linkUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string LinkUrl { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("mediaType")]
         [JsonPropertyName("mediaType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string MediaType { get; set; }
 
         /// <summary>A list of IDs of the menu items that were shown.</summary>
+        [JsAccessPath("menuIds")]
         [JsonPropertyName("menuIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MenuId> MenuIds { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("pageUrl")]
         [JsonPropertyName("pageUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PageUrl { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("selectionText")]
         [JsonPropertyName("selectionText")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SelectionText { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("srcUrl")]
         [JsonPropertyName("srcUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SrcUrl { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("targetElementId")]
         [JsonPropertyName("targetElementId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TargetElementId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("viewType")]
         [JsonPropertyName("viewType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ViewType? ViewType { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Menus/OnClickData.cs b/src/WebExtensions.Net/Generated/Menus/OnClickData.cs
index 195abfe..89f6655 100644
--- a/src/WebExtensions.Net/Generated/Menus/OnClickData.cs
+++ b/src/WebExtensions.Net/Generated/Menus/OnClickData.cs
@@ -11,90 +11,108 @@ namespace WebExtensions.Net.Menus
     public partial class OnClickData : BaseObject
     {
         /// <summary>The id of the bookmark where the context menu was clicked, if it was on a bookmark.</summary>
+        [JsAccessPath("bookmarkId")]
         [JsonPropertyName("bookmarkId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string BookmarkId { get; set; }
 
         /// <summary>An integer value of button by which menu item was clicked.</summary>
+        [JsAccessPath("button")]
         [JsonPropertyName("button")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Button { get; set; }
 
         /// <summary>A flag indicating the state of a checkbox or radio item after it is clicked.</summary>
+        [JsAccessPath("checked")]
         [JsonPropertyName("checked")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Checked { get; set; }
 
         /// <summary>A flag indicating whether the element is editable (text input, textarea, etc.).</summary>
+        [JsAccessPath("editable")]
         [JsonPropertyName("editable")]
         public bool Editable { get; set; }
 
         /// <summary>The id of the frame of the element where the context menu was clicked.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? FrameId { get; set; }
 
         /// <summary> The URL of the frame of the element where the context menu was clicked, if it was in a frame.</summary>
+        [JsAccessPath("frameUrl")]
         [JsonPropertyName("frameUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FrameUrl { get; set; }
 
         /// <summary>If the element is a link, the text of that link.</summary>
+        [JsAccessPath("linkText")]
         [JsonPropertyName("linkText")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string LinkText { get; set; }
 
         /// <summary>If the element is a link, the URL it points to.</summary>
+        [JsAccessPath("linkUrl")]
         [JsonPropertyName("linkUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string LinkUrl { get; set; }
 
         /// <summary>One of 'image', 'video', or 'audio' if the context menu was activated on one of these types of elements.</summary>
+        [JsAccessPath("mediaType")]
         [JsonPropertyName("mediaType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string MediaType { get; set; }
 
         /// <summary>The ID of the menu item that was clicked.</summary>
+        [JsAccessPath("menuItemId")]
         [JsonPropertyName("menuItemId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public OnClickDataMenuItemId MenuItemId { get; set; }
 
         /// <summary>An array of keyboard modifiers that were held while the menu item was clicked.</summary>
+        [JsAccessPath("modifiers")]
         [JsonPropertyName("modifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Modifiers { get; set; }
 
         /// <summary>The URL of the page where the menu item was clicked. This property is not set if the click occured in a context where there is no current page, such as in a launcher context menu.</summary>
+        [JsAccessPath("pageUrl")]
         [JsonPropertyName("pageUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PageUrl { get; set; }
 
         /// <summary>The parent ID, if any, for the item clicked.</summary>
+        [JsAccessPath("parentMenuItemId")]
         [JsonPropertyName("parentMenuItemId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ParentMenuItemId ParentMenuItemId { get; set; }
 
         /// <summary>The text for the context selection, if any.</summary>
+        [JsAccessPath("selectionText")]
         [JsonPropertyName("selectionText")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SelectionText { get; set; }
 
         /// <summary>Will be present for elements with a 'src' URL.</summary>
+        [JsAccessPath("srcUrl")]
         [JsonPropertyName("srcUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SrcUrl { get; set; }
 
         /// <summary>An identifier of the clicked element, if any. Use menus.getTargetElement in the page to find the corresponding element.</summary>
+        [JsAccessPath("targetElementId")]
         [JsonPropertyName("targetElementId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TargetElementId { get; set; }
 
         /// <summary>The type of view where the menu is clicked. May be unset if the menu is not associated with a view.</summary>
+        [JsAccessPath("viewType")]
         [JsonPropertyName("viewType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ViewType? ViewType { get; set; }
 
         /// <summary>A flag indicating the state of a checkbox or radio item before it was clicked.</summary>
+        [JsAccessPath("wasChecked")]
         [JsonPropertyName("wasChecked")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? WasChecked { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Menus/OnClickedEvent.cs b/src/WebExtensions.Net/Generated/Menus/OnClickedEvent.cs
index a435ad1..a15901a 100644
--- a/src/WebExtensions.Net/Generated/Menus/OnClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Menus/OnClickedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a context menu item is clicked.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnClickData, Tab> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<OnClickData, Tab> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnClickData, Tab> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<OnClickData, Tab> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnClickData, Tab> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Menus/OnShownEvent.cs b/src/WebExtensions.Net/Generated/Menus/OnShownEvent.cs
index dfe98c7..87490b3 100644
--- a/src/WebExtensions.Net/Generated/Menus/OnShownEvent.cs
+++ b/src/WebExtensions.Net/Generated/Menus/OnShownEvent.cs
@@ -13,6 +13,7 @@ public partial class OnShownEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a menu is shown. The extension can add, modify or remove menu items and call menus.refresh() to update the menu.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Info, Tab> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<Info, Tab> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Info, Tab> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<Info, Tab> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Info, Tab> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Menus/UpdateProperties.cs b/src/WebExtensions.Net/Generated/Menus/UpdateProperties.cs
index f40b2c3..963e0d3 100644
--- a/src/WebExtensions.Net/Generated/Menus/UpdateProperties.cs
+++ b/src/WebExtensions.Net/Generated/Menus/UpdateProperties.cs
@@ -13,61 +13,73 @@ namespace WebExtensions.Net.Menus
     public partial class UpdateProperties : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("checked")]
         [JsonPropertyName("checked")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Checked { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("contexts")]
         [JsonPropertyName("contexts")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ContextType> Contexts { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("documentUrlPatterns")]
         [JsonPropertyName("documentUrlPatterns")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> DocumentUrlPatterns { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("enabled")]
         [JsonPropertyName("enabled")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Enabled { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("icons")]
         [JsonPropertyName("icons")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Icons { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("onclick")]
         [JsonPropertyName("onclick")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Action<OnClickData, Tab> Onclick { get; set; }
 
         /// <summary>Note: You cannot change an item to be a child of one of its own descendants.</summary>
+        [JsAccessPath("parentId")]
         [JsonPropertyName("parentId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UpdatePropertiesParentId ParentId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("targetUrlPatterns")]
         [JsonPropertyName("targetUrlPatterns")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> TargetUrlPatterns { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ItemType? Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("viewTypes")]
         [JsonPropertyName("viewTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ViewType> ViewTypes { get; set; }
 
         /// <summary>Whether the item is visible in the menu.</summary>
+        [JsAccessPath("visible")]
         [JsonPropertyName("visible")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Visible { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Notifications/INotificationsApi.cs b/src/WebExtensions.Net/Generated/Notifications/INotificationsApi.cs
index 4943bb1..eba62d6 100644
--- a/src/WebExtensions.Net/Generated/Notifications/INotificationsApi.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/INotificationsApi.cs
@@ -1,41 +1,51 @@
+using JsBind.Net;
 using System.Text.Json;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Notifications
 {
     /// <summary></summary>
+    [JsAccessPath("notifications")]
     public partial interface INotificationsApi
     {
         /// <summary>Fired when the  user pressed a button in the notification.</summary>
+        [JsAccessPath("onButtonClicked")]
         OnButtonClickedEvent OnButtonClicked { get; }
 
         /// <summary>Fired when the user clicked in a non-button area of the notification.</summary>
+        [JsAccessPath("onClicked")]
         OnClickedEvent OnClicked { get; }
 
         /// <summary>Fired when the notification closed, either by the system or by user action.</summary>
+        [JsAccessPath("onClosed")]
         OnClosedEvent OnClosed { get; }
 
         /// <summary>Fired when the notification is shown.</summary>
+        [JsAccessPath("onShown")]
         OnShownEvent OnShown { get; }
 
         /// <summary>Clears an existing notification.</summary>
         /// <param name="notificationId">The id of the notification to be updated.</param>
         /// <returns>Indicates whether a matching notification existed.</returns>
+        [JsAccessPath("clear")]
         ValueTask<bool> Clear(string notificationId);
 
         /// <summary>Creates and displays a notification.</summary>
         /// <param name="options">Contents of the notification.</param>
         /// <returns>The notification id (either supplied or generated) that represents the created notification.</returns>
+        [JsAccessPath("create")]
         ValueTask<string> Create(NotificationOptions options);
 
         /// <summary>Creates and displays a notification.</summary>
         /// <param name="notificationId">Identifier of the notification. If it is empty, this method generates an id. If it matches an existing notification, this method first clears that notification before proceeding with the create operation.</param>
         /// <param name="options">Contents of the notification.</param>
         /// <returns>The notification id (either supplied or generated) that represents the created notification.</returns>
+        [JsAccessPath("create")]
         ValueTask<string> Create(string notificationId, NotificationOptions options);
 
         /// <summary>Retrieves all the notifications.</summary>
         /// <returns>The set of notifications currently in the system.</returns>
+        [JsAccessPath("getAll")]
         ValueTask<JsonElement> GetAll();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Notifications/NotificationItem.cs b/src/WebExtensions.Net/Generated/Notifications/NotificationItem.cs
index eaa63f0..edbdcf4 100644
--- a/src/WebExtensions.Net/Generated/Notifications/NotificationItem.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/NotificationItem.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Notifications
     public partial class NotificationItem : BaseObject
     {
         /// <summary>Additional details about this item.</summary>
+        [JsAccessPath("message")]
         [JsonPropertyName("message")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Message { get; set; }
 
         /// <summary>Title of one item of a list notification.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Notifications/NotificationOptions.cs b/src/WebExtensions.Net/Generated/Notifications/NotificationOptions.cs
index 9d98125..400d9d4 100644
--- a/src/WebExtensions.Net/Generated/Notifications/NotificationOptions.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/NotificationOptions.cs
@@ -10,61 +10,73 @@ namespace WebExtensions.Net.Notifications
     public partial class NotificationOptions : BaseObject
     {
         /// <summary>A URL to the app icon mask.</summary>
+        [JsAccessPath("appIconMaskUrl")]
         [JsonPropertyName("appIconMaskUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string AppIconMaskUrl { get; set; }
 
         /// <summary>Alternate notification content with a lower-weight font.</summary>
+        [JsAccessPath("contextMessage")]
         [JsonPropertyName("contextMessage")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ContextMessage { get; set; }
 
         /// <summary>A timestamp associated with the notification, in milliseconds past the epoch.</summary>
+        [JsAccessPath("eventTime")]
         [JsonPropertyName("eventTime")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? EventTime { get; set; }
 
         /// <summary>A URL to the sender's avatar, app icon, or a thumbnail for image notifications.</summary>
+        [JsAccessPath("iconUrl")]
         [JsonPropertyName("iconUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string IconUrl { get; set; }
 
         /// <summary>A URL to the image thumbnail for image-type notifications.</summary>
+        [JsAccessPath("imageUrl")]
         [JsonPropertyName("imageUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ImageUrl { get; set; }
 
         /// <summary>Whether to show UI indicating that the app will visibly respond to clicks on the body of a notification.</summary>
+        [JsAccessPath("isClickable")]
         [JsonPropertyName("isClickable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsClickable { get; set; }
 
         /// <summary>Items for multi-item notifications.</summary>
+        [JsAccessPath("items")]
         [JsonPropertyName("items")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<NotificationItem> Items { get; set; }
 
         /// <summary>Main notification content.</summary>
+        [JsAccessPath("message")]
         [JsonPropertyName("message")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Message { get; set; }
 
         /// <summary>Priority ranges from -2 to 2. -2 is lowest priority. 2 is highest. Zero is default.</summary>
+        [JsAccessPath("priority")]
         [JsonPropertyName("priority")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Priority { get; set; }
 
         /// <summary>Current progress ranges from 0 to 100.</summary>
+        [JsAccessPath("progress")]
         [JsonPropertyName("progress")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Progress { get; set; }
 
         /// <summary>Title of the notification (e.g. sender name for email).</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>Which type of notification to display.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public TemplateType Type { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Notifications/OnButtonClickedEvent.cs b/src/WebExtensions.Net/Generated/Notifications/OnButtonClickedEvent.cs
index d988fe9..32fe6bb 100644
--- a/src/WebExtensions.Net/Generated/Notifications/OnButtonClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/OnButtonClickedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnButtonClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the  user pressed a button in the notification.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, double> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, double> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, double> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, double> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, double> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Notifications/OnClickedEvent.cs b/src/WebExtensions.Net/Generated/Notifications/OnClickedEvent.cs
index 4ecbafc..8528acc 100644
--- a/src/WebExtensions.Net/Generated/Notifications/OnClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/OnClickedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the user clicked in a non-button area of the notification.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Notifications/OnClosedEvent.cs b/src/WebExtensions.Net/Generated/Notifications/OnClosedEvent.cs
index 50685ae..3f1ee42 100644
--- a/src/WebExtensions.Net/Generated/Notifications/OnClosedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/OnClosedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnClosedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the notification closed, either by the system or by user action.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, bool> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, bool> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, bool> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, bool> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, bool> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Notifications/OnShownEvent.cs b/src/WebExtensions.Net/Generated/Notifications/OnShownEvent.cs
index 35587e6..20ff537 100644
--- a/src/WebExtensions.Net/Generated/Notifications/OnShownEvent.cs
+++ b/src/WebExtensions.Net/Generated/Notifications/OnShownEvent.cs
@@ -12,6 +12,7 @@ public partial class OnShownEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the notification is shown.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Omnibox/DefaultSuggestResult.cs b/src/WebExtensions.Net/Generated/Omnibox/DefaultSuggestResult.cs
index 0912489..40b7909 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/DefaultSuggestResult.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/DefaultSuggestResult.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Omnibox
     public partial class DefaultSuggestResult : BaseObject
     {
         /// <summary>The text that is displayed in the URL dropdown.</summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Omnibox/IOmniboxApi.cs b/src/WebExtensions.Net/Generated/Omnibox/IOmniboxApi.cs
index 5e4dfa1..396d3ea 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/IOmniboxApi.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/IOmniboxApi.cs
@@ -1,28 +1,36 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 using WebExtensions.Net.Events;
 
 namespace WebExtensions.Net.Omnibox
 {
     /// <summary>The omnibox API allows you to register a keyword with Firefox's address bar.</summary>
+    [JsAccessPath("omnibox")]
     public partial interface IOmniboxApi
     {
         /// <summary>User has deleted a suggested result.</summary>
+        [JsAccessPath("onDeleteSuggestion")]
         OnDeleteSuggestionEvent OnDeleteSuggestion { get; }
 
         /// <summary>User has ended the keyword input session without accepting the input.</summary>
+        [JsAccessPath("onInputCancelled")]
         Event OnInputCancelled { get; }
 
         /// <summary>User has changed what is typed into the omnibox.</summary>
+        [JsAccessPath("onInputChanged")]
         OnInputChangedEvent OnInputChanged { get; }
 
         /// <summary>User has accepted what is typed into the omnibox.</summary>
+        [JsAccessPath("onInputEntered")]
         OnInputEnteredEvent OnInputEntered { get; }
 
         /// <summary>User has started a keyword input session by typing the extension's keyword. This is guaranteed to be sent exactly once per input session, and before any onInputChanged events.</summary>
+        [JsAccessPath("onInputStarted")]
         Event OnInputStarted { get; }
 
         /// <summary>Sets the description and styling for the default suggestion. The default suggestion is the text that is displayed in the first suggestion row underneath the URL bar.</summary>
         /// <param name="suggestion">A partial SuggestResult object, without the 'content' parameter.</param>
+        [JsAccessPath("setDefaultSuggestion")]
         ValueTask SetDefaultSuggestion(DefaultSuggestResult suggestion);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Omnibox/OnDeleteSuggestionEvent.cs b/src/WebExtensions.Net/Generated/Omnibox/OnDeleteSuggestionEvent.cs
index 2f5dd66..78611fb 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/OnDeleteSuggestionEvent.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/OnDeleteSuggestionEvent.cs
@@ -12,6 +12,7 @@ public partial class OnDeleteSuggestionEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">User has deleted a suggested result.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Omnibox/OnInputChangedEvent.cs b/src/WebExtensions.Net/Generated/Omnibox/OnInputChangedEvent.cs
index 7e84538..db14254 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/OnInputChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/OnInputChangedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnInputChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">User has changed what is typed into the omnibox.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, Action<IEnumerable<SuggestResult>>> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<string, Action<IEnumerable<SuggestRe
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, Action<IEnumerable<SuggestResult>>> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<string, Action<IEnumerable<Sug
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, Action<IEnumerable<SuggestResult>>> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Omnibox/OnInputEnteredEvent.cs b/src/WebExtensions.Net/Generated/Omnibox/OnInputEnteredEvent.cs
index b10c298..1ef155c 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/OnInputEnteredEvent.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/OnInputEnteredEvent.cs
@@ -12,6 +12,7 @@ public partial class OnInputEnteredEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">User has accepted what is typed into the omnibox.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<string, OnInputEnteredDisposition> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<string, OnInputEnteredDisposition> c
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<string, OnInputEnteredDisposition> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<string, OnInputEnteredDisposit
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<string, OnInputEnteredDisposition> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Omnibox/SuggestResult.cs b/src/WebExtensions.Net/Generated/Omnibox/SuggestResult.cs
index 671b25d..63601e7 100644
--- a/src/WebExtensions.Net/Generated/Omnibox/SuggestResult.cs
+++ b/src/WebExtensions.Net/Generated/Omnibox/SuggestResult.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Omnibox
     public partial class SuggestResult : BaseObject
     {
         /// <summary>The text that is put into the URL bar, and that is sent to the extension when the user chooses this entry.</summary>
+        [JsAccessPath("content")]
         [JsonPropertyName("content")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Content { get; set; }
 
         /// <summary>Whether the suggest result can be deleted by the user.</summary>
+        [JsAccessPath("deletable")]
         [JsonPropertyName("deletable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Deletable { get; set; }
 
         /// <summary>The text that is displayed in the URL dropdown. Can contain XML-style markup for styling. The supported tags are 'url' (for a literal URL), 'match' (for highlighting text that matched what the user's query), and 'dim' (for dim helper text). The styles can be nested, eg. 'dim''match'dimmed match'/match''/dim'. You must escape the five predefined entities to display them as text: stackoverflow.com/a/1091953/89484 </summary>
+        [JsAccessPath("description")]
         [JsonPropertyName("description")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Description { get; set; }
diff --git a/src/WebExtensions.Net/Generated/PageAction/GetPopupDetails.cs b/src/WebExtensions.Net/Generated/PageAction/GetPopupDetails.cs
index 70d6ff3..47a1a29 100644
--- a/src/WebExtensions.Net/Generated/PageAction/GetPopupDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/GetPopupDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.PageAction
     public partial class GetPopupDetails : BaseObject
     {
         /// <summary>Specify the tab to get the popup from.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/PageAction/GetTitleDetails.cs b/src/WebExtensions.Net/Generated/PageAction/GetTitleDetails.cs
index 83f9797..439e211 100644
--- a/src/WebExtensions.Net/Generated/PageAction/GetTitleDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/GetTitleDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.PageAction
     public partial class GetTitleDetails : BaseObject
     {
         /// <summary>Specify the tab to get the title from.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/PageAction/IPageActionApi.cs b/src/WebExtensions.Net/Generated/PageAction/IPageActionApi.cs
index f1e0702..f4b428f 100644
--- a/src/WebExtensions.Net/Generated/PageAction/IPageActionApi.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/IPageActionApi.cs
@@ -1,48 +1,60 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.PageAction
 {
     /// <summary>Use the <c>browser.pageAction</c> API to put icons inside the address bar. Page actions represent actions that can be taken on the current page, but that aren't applicable to all pages.</summary>
+    [JsAccessPath("pageAction")]
     public partial interface IPageActionApi
     {
         /// <summary>Fired when a page action icon is clicked.  This event will not fire if the page action has a popup.</summary>
+        [JsAccessPath("onClicked")]
         OnClickedEvent OnClicked { get; }
 
         /// <summary>Gets the html document set as the popup for this page action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getPopup")]
         ValueTask<string> GetPopup(GetPopupDetails details);
 
         /// <summary>Gets the title of the page action.</summary>
         /// <param name="details"></param>
         /// <returns></returns>
+        [JsAccessPath("getTitle")]
         ValueTask<string> GetTitle(GetTitleDetails details);
 
         /// <summary>Hides the page action.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the page action.</param>
+        [JsAccessPath("hide")]
         ValueTask Hide(int tabId);
 
         /// <summary>Checks whether the page action is shown.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("isShown")]
         ValueTask IsShown(IsShownDetails details);
 
         /// <summary>Opens the extension page action in the active window.</summary>
+        [JsAccessPath("openPopup")]
         ValueTask OpenPopup();
 
         /// <summary>Sets the icon for the page action. The icon can be specified either as the path to an image file or as the pixel data from a canvas element, or as dictionary of either one of those. Either the 'b'path'/b' or the 'b'imageData'/b' property must be specified.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setIcon")]
         ValueTask SetIcon(SetIconDetails details);
 
         /// <summary>Sets the html document to be opened as a popup when the user clicks on the page action's icon.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setPopup")]
         ValueTask SetPopup(SetPopupDetails details);
 
         /// <summary>Sets the title of the page action. This is displayed in a tooltip over the page action.</summary>
         /// <param name="details"></param>
+        [JsAccessPath("setTitle")]
         ValueTask SetTitle(SetTitleDetails details);
 
         /// <summary>Shows the page action. The page action is shown whenever the tab is selected.</summary>
         /// <param name="tabId">The id of the tab for which you want to modify the page action.</param>
+        [JsAccessPath("show")]
         ValueTask Show(int tabId);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/PageAction/IsShownDetails.cs b/src/WebExtensions.Net/Generated/PageAction/IsShownDetails.cs
index a60c309..638b86d 100644
--- a/src/WebExtensions.Net/Generated/PageAction/IsShownDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/IsShownDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.PageAction
     public partial class IsShownDetails : BaseObject
     {
         /// <summary>Specify the tab to get the shownness from.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/PageAction/OnClickData.cs b/src/WebExtensions.Net/Generated/PageAction/OnClickData.cs
index ff22704..3e6bd25 100644
--- a/src/WebExtensions.Net/Generated/PageAction/OnClickData.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/OnClickData.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.PageAction
     public partial class OnClickData : BaseObject
     {
         /// <summary>An integer value of button by which menu item was clicked.</summary>
+        [JsAccessPath("button")]
         [JsonPropertyName("button")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Button { get; set; }
 
         /// <summary>An array of keyboard modifiers that were held while the menu item was clicked.</summary>
+        [JsAccessPath("modifiers")]
         [JsonPropertyName("modifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Modifiers { get; set; }
diff --git a/src/WebExtensions.Net/Generated/PageAction/OnClickedEvent.cs b/src/WebExtensions.Net/Generated/PageAction/OnClickedEvent.cs
index c8e4a8b..0764492 100644
--- a/src/WebExtensions.Net/Generated/PageAction/OnClickedEvent.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/OnClickedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnClickedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a page action icon is clicked.  This event will not fire if the page action has a popup.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -21,6 +22,7 @@ public virtual ValueTask AddListener(Action<Tab, OnClickData> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -28,6 +30,7 @@ public virtual ValueTask<bool> HasListener(Action<Tab, OnClickData> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Tab, OnClickData> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/PageAction/SetIconDetails.cs b/src/WebExtensions.Net/Generated/PageAction/SetIconDetails.cs
index 40b0a23..c2ad911 100644
--- a/src/WebExtensions.Net/Generated/PageAction/SetIconDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/SetIconDetails.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.PageAction
     public partial class SetIconDetails : BaseObject
     {
         /// <summary>Either an ImageData object or a dictionary {size -> ImageData} representing icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.imageData = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("imageData")]
         [JsonPropertyName("imageData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ImageData ImageData { get; set; }
 
         /// <summary>Either a relative image path or a dictionary {size -> relative image path} pointing to icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals <c>scale</c>, then image with size <c>scale</c> * 19 will be selected. Initially only scales 1 and 2 will be supported. At least one image must be specified. Note that 'details.path = foo' is equivalent to 'details.imageData = {'19': foo}'</summary>
+        [JsAccessPath("path")]
         [JsonPropertyName("path")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Path Path { get; set; }
 
         /// <summary>The id of the tab for which you want to modify the page action.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/PageAction/SetPopupDetails.cs b/src/WebExtensions.Net/Generated/PageAction/SetPopupDetails.cs
index 6bac4ae..6759b33 100644
--- a/src/WebExtensions.Net/Generated/PageAction/SetPopupDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/SetPopupDetails.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.PageAction
     public partial class SetPopupDetails : BaseObject
     {
         /// <summary>The html file to show in a popup.  If set to the empty string (''), no popup is shown.</summary>
+        [JsAccessPath("popup")]
         [JsonPropertyName("popup")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Popup Popup { get; set; }
 
         /// <summary>The id of the tab for which you want to modify the page action.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/PageAction/SetTitleDetails.cs b/src/WebExtensions.Net/Generated/PageAction/SetTitleDetails.cs
index d4b6bf3..13add37 100644
--- a/src/WebExtensions.Net/Generated/PageAction/SetTitleDetails.cs
+++ b/src/WebExtensions.Net/Generated/PageAction/SetTitleDetails.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.PageAction
     public partial class SetTitleDetails : BaseObject
     {
         /// <summary>The id of the tab for which you want to modify the page action.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The tooltip string.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Title Title { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Permissions/AnyPermissions.cs b/src/WebExtensions.Net/Generated/Permissions/AnyPermissions.cs
index 5331a60..7cf8d10 100644
--- a/src/WebExtensions.Net/Generated/Permissions/AnyPermissions.cs
+++ b/src/WebExtensions.Net/Generated/Permissions/AnyPermissions.cs
@@ -11,11 +11,13 @@ namespace WebExtensions.Net.Permissions
     public partial class AnyPermissions : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("origins")]
         [JsonPropertyName("origins")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MatchPattern> Origins { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("permissions")]
         [JsonPropertyName("permissions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Permission> Permissions { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Permissions/IPermissionsApi.cs b/src/WebExtensions.Net/Generated/Permissions/IPermissionsApi.cs
index 55cb8ea..2a5d5ea 100644
--- a/src/WebExtensions.Net/Generated/Permissions/IPermissionsApi.cs
+++ b/src/WebExtensions.Net/Generated/Permissions/IPermissionsApi.cs
@@ -1,32 +1,40 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Permissions
 {
     /// <summary></summary>
+    [JsAccessPath("permissions")]
     public partial interface IPermissionsApi
     {
         /// <summary>Fired when the extension acquires new permissions.</summary>
+        [JsAccessPath("onAdded")]
         OnAddedEvent OnAdded { get; }
 
         /// <summary>Fired when permissions are removed from the extension.</summary>
+        [JsAccessPath("onRemoved")]
         OnRemovedEvent OnRemoved { get; }
 
         /// <summary>Check if the extension has the given permissions.</summary>
         /// <param name="permissions"></param>
         /// <returns></returns>
+        [JsAccessPath("contains")]
         ValueTask<bool> Contains(AnyPermissions permissions);
 
         /// <summary>Get a list of all the extension's permissions.</summary>
         /// <returns></returns>
+        [JsAccessPath("getAll")]
         ValueTask<AnyPermissions> GetAll();
 
         /// <summary>Relinquish the given permissions.</summary>
         /// <param name="permissions"></param>
+        [JsAccessPath("remove")]
         ValueTask Remove(PermissionsType permissions);
 
         /// <summary>Request the given permissions.</summary>
         /// <param name="permissions"></param>
         /// <returns></returns>
+        [JsAccessPath("request")]
         ValueTask<bool> Request(PermissionsType permissions);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Permissions/OnAddedEvent.cs b/src/WebExtensions.Net/Generated/Permissions/OnAddedEvent.cs
index 54f6e85..afd3323 100644
--- a/src/WebExtensions.Net/Generated/Permissions/OnAddedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Permissions/OnAddedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnAddedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the extension acquires new permissions.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<PermissionsType> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<PermissionsType> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<PermissionsType> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<PermissionsType> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<PermissionsType> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Permissions/OnRemovedEvent.cs b/src/WebExtensions.Net/Generated/Permissions/OnRemovedEvent.cs
index 33b1980..fe1aab1 100644
--- a/src/WebExtensions.Net/Generated/Permissions/OnRemovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Permissions/OnRemovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnRemovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when permissions are removed from the extension.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<PermissionsType> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<PermissionsType> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<PermissionsType> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<PermissionsType> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<PermissionsType> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Permissions/PermissionsType.cs b/src/WebExtensions.Net/Generated/Permissions/PermissionsType.cs
index c462654..f3f3312 100644
--- a/src/WebExtensions.Net/Generated/Permissions/PermissionsType.cs
+++ b/src/WebExtensions.Net/Generated/Permissions/PermissionsType.cs
@@ -11,11 +11,13 @@ namespace WebExtensions.Net.Permissions
     public partial class PermissionsType : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("origins")]
         [JsonPropertyName("origins")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<MatchPattern> Origins { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("permissions")]
         [JsonPropertyName("permissions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<OptionalPermission> Permissions { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Privacy/IPrivacyApi.cs b/src/WebExtensions.Net/Generated/Privacy/IPrivacyApi.cs
index 2b034fe..1c254fb 100644
--- a/src/WebExtensions.Net/Generated/Privacy/IPrivacyApi.cs
+++ b/src/WebExtensions.Net/Generated/Privacy/IPrivacyApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using WebExtensions.Net.Privacy.Network;
 using WebExtensions.Net.Privacy.Services;
 using WebExtensions.Net.Privacy.Websites;
@@ -5,15 +6,19 @@
 namespace WebExtensions.Net.Privacy
 {
     /// <summary></summary>
+    [JsAccessPath("privacy")]
     public partial interface IPrivacyApi
     {
         /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.<br />Requires manifest permission privacy.</summary>
+        [JsAccessPath("network")]
         INetworkApi Network { get; }
 
         /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.<br />Requires manifest permission privacy.</summary>
+        [JsAccessPath("services")]
         IServicesApi Services { get; }
 
         /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.<br />Requires manifest permission privacy.</summary>
+        [JsAccessPath("websites")]
         IWebsitesApi Websites { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Privacy/Network/INetworkApi.cs b/src/WebExtensions.Net/Generated/Privacy/Network/INetworkApi.cs
index c993245..b341b22 100644
--- a/src/WebExtensions.Net/Generated/Privacy/Network/INetworkApi.cs
+++ b/src/WebExtensions.Net/Generated/Privacy/Network/INetworkApi.cs
@@ -1,26 +1,34 @@
+using JsBind.Net;
 using WebExtensions.Net.Types;
 
 namespace WebExtensions.Net.Privacy.Network
 {
     /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.</summary>
+    [JsAccessPath("network")]
     public partial interface INetworkApi
     {
         /// <summary>Allow users to query the status of 'Global Privacy Control'. This setting's value is of type boolean, defaulting to <c>false</c>.</summary>
+        [JsAccessPath("globalPrivacyControl")]
         Setting GlobalPrivacyControl { get; }
 
         /// <summary>Allow users to query the mode for 'HTTPS-Only Mode'. This setting's value is of type HTTPSOnlyModeOption, defaulting to <c>never</c>.</summary>
+        [JsAccessPath("httpsOnlyMode")]
         Setting HttpsOnlyMode { get; }
 
         /// <summary>If enabled, the browser attempts to speed up your web browsing experience by pre-resolving DNS entries, prerendering sites (<c>&amp;lt;link rel='prefetch' ...&amp;gt;</c>), and preemptively opening TCP and SSL connections to servers.  This preference's value is a boolean, defaulting to <c>true</c>.</summary>
+        [JsAccessPath("networkPredictionEnabled")]
         Setting NetworkPredictionEnabled { get; }
 
         /// <summary>Allow users to enable and disable RTCPeerConnections (aka WebRTC).</summary>
+        [JsAccessPath("peerConnectionEnabled")]
         Setting PeerConnectionEnabled { get; }
 
         /// <summary>This property controls the minimum and maximum TLS versions. This setting's value is an object of $(ref:tlsVersionRestrictionConfig).</summary>
+        [JsAccessPath("tlsVersionRestriction")]
         Setting TlsVersionRestriction { get; }
 
         /// <summary>Allow users to specify the media performance/privacy tradeoffs which impacts how WebRTC traffic will be routed and how much local address information is exposed. This preference's value is of type IPHandlingPolicy, defaulting to <c>default</c>.</summary>
+        [JsAccessPath("webRTCIPHandlingPolicy")]
         Setting WebRTCIPHandlingPolicy { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Privacy/Services/IServicesApi.cs b/src/WebExtensions.Net/Generated/Privacy/Services/IServicesApi.cs
index 27d602f..98a9b42 100644
--- a/src/WebExtensions.Net/Generated/Privacy/Services/IServicesApi.cs
+++ b/src/WebExtensions.Net/Generated/Privacy/Services/IServicesApi.cs
@@ -1,11 +1,14 @@
+using JsBind.Net;
 using WebExtensions.Net.Types;
 
 namespace WebExtensions.Net.Privacy.Services
 {
     /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.</summary>
+    [JsAccessPath("services")]
     public partial interface IServicesApi
     {
         /// <summary>If enabled, the password manager will ask if you want to save passwords. This preference's value is a boolean, defaulting to <c>true</c>.</summary>
+        [JsAccessPath("passwordSavingEnabled")]
         Setting PasswordSavingEnabled { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Privacy/Websites/IWebsitesApi.cs b/src/WebExtensions.Net/Generated/Privacy/Websites/IWebsitesApi.cs
index f2515df..67c4836 100644
--- a/src/WebExtensions.Net/Generated/Privacy/Websites/IWebsitesApi.cs
+++ b/src/WebExtensions.Net/Generated/Privacy/Websites/IWebsitesApi.cs
@@ -1,26 +1,34 @@
+using JsBind.Net;
 using WebExtensions.Net.Types;
 
 namespace WebExtensions.Net.Privacy.Websites
 {
     /// <summary>Use the <c>browser.privacy</c> API to control usage of the features in the browser that can affect a user's privacy.</summary>
+    [JsAccessPath("websites")]
     public partial interface IWebsitesApi
     {
         /// <summary>Allow users to specify the default settings for allowing cookies, as well as whether all cookies should be created as non-persistent cookies. This setting's value is of type CookieConfig.</summary>
+        [JsAccessPath("cookieConfig")]
         Setting CookieConfig { get; }
 
         /// <summary>If enabled, the browser will associate all data (including cookies, HSTS data, cached images, and more) for any third party domains with the domain in the address bar. This prevents third party trackers from using directly stored information to identify you across different websites, but may break websites where you login with a third party account (such as a Facebook or Google login.) The value of this preference is of type boolean, and the default value is <c>false</c>.</summary>
+        [JsAccessPath("firstPartyIsolate")]
         Setting FirstPartyIsolate { get; }
 
         /// <summary>If enabled, the browser sends auditing pings when requested by a website (<c>&amp;lt;a ping&amp;gt;</c>). The value of this preference is of type boolean, and the default value is <c>true</c>.</summary>
+        [JsAccessPath("hyperlinkAuditingEnabled")]
         Setting HyperlinkAuditingEnabled { get; }
 
         /// <summary>If enabled, the browser sends <c>referer</c> headers with your requests. Yes, the name of this preference doesn't match the misspelled header. No, we're not going to change it. The value of this preference is of type boolean, and the default value is <c>true</c>.</summary>
+        [JsAccessPath("referrersEnabled")]
         Setting ReferrersEnabled { get; }
 
         /// <summary>If enabled, the browser attempts to appear similar to other users by reporting generic information to websites. This can prevent websites from uniquely identifying users. Examples of data that is spoofed include number of CPU cores, precision of JavaScript timers, the local timezone, and disabling features such as GamePad support, and the WebSpeech and Navigator APIs. The value of this preference is of type boolean, and the default value is <c>false</c>.</summary>
+        [JsAccessPath("resistFingerprinting")]
         Setting ResistFingerprinting { get; }
 
         /// <summary>Allow users to specify the mode for tracking protection. This setting's value is of type TrackingProtectionModeOption, defaulting to <c>private_browsing_only</c>.</summary>
+        [JsAccessPath("trackingProtectionMode")]
         Setting TrackingProtectionMode { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Proxy/Details.cs b/src/WebExtensions.Net/Generated/Proxy/Details.cs
index e8c7f78..2c3eb42 100644
--- a/src/WebExtensions.Net/Generated/Proxy/Details.cs
+++ b/src/WebExtensions.Net/Generated/Proxy/Details.cs
@@ -10,74 +10,90 @@ namespace WebExtensions.Net.Proxy
     public partial class Details : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>Indicates if this response was fetched from disk cache.</summary>
+        [JsAccessPath("fromCache")]
         [JsonPropertyName("fromCache")]
         public bool FromCache { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The HTTP request headers that are going to be sent out with this request.</summary>
+        [JsAccessPath("requestHeaders")]
         [JsonPropertyName("requestHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders RequestHeaders { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Url classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Proxy/IProxyApi.cs b/src/WebExtensions.Net/Generated/Proxy/IProxyApi.cs
index 3a3b128..0d8245d 100644
--- a/src/WebExtensions.Net/Generated/Proxy/IProxyApi.cs
+++ b/src/WebExtensions.Net/Generated/Proxy/IProxyApi.cs
@@ -1,17 +1,22 @@
+using JsBind.Net;
 using WebExtensions.Net.Types;
 
 namespace WebExtensions.Net.Proxy
 {
     /// <summary>Provides access to global proxy settings for Firefox and proxy event listeners to handle dynamic proxy implementations.</summary>
+    [JsAccessPath("proxy")]
     public partial interface IProxyApi
     {
         /// <summary>Notifies about errors caused by the invalid use of the proxy API.</summary>
+        [JsAccessPath("onError")]
         OnErrorEvent OnError { get; }
 
         /// <summary>Fired when proxy data is needed for a request.</summary>
+        [JsAccessPath("onRequest")]
         OnRequestEvent OnRequest { get; }
 
         /// <summary>Configures proxy settings. This setting's value is an object of type ProxyConfig.</summary>
+        [JsAccessPath("settings")]
         Setting Settings { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Proxy/OnErrorEvent.cs b/src/WebExtensions.Net/Generated/Proxy/OnErrorEvent.cs
index 0c297ef..d78cdcf 100644
--- a/src/WebExtensions.Net/Generated/Proxy/OnErrorEvent.cs
+++ b/src/WebExtensions.Net/Generated/Proxy/OnErrorEvent.cs
@@ -12,6 +12,7 @@ public partial class OnErrorEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Notifies about errors caused by the invalid use of the proxy API.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<object> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<object> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<object> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<object> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<object> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Proxy/OnRequestEvent.cs b/src/WebExtensions.Net/Generated/Proxy/OnRequestEvent.cs
index 0d770cb..df176f2 100644
--- a/src/WebExtensions.Net/Generated/Proxy/OnRequestEvent.cs
+++ b/src/WebExtensions.Net/Generated/Proxy/OnRequestEvent.cs
@@ -14,6 +14,7 @@ public partial class OnRequestEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when proxy data is needed for a request.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Details> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -23,6 +24,7 @@ public virtual ValueTask AddListener(Action<Details> callback)
         /// <param name="callback">Fired when proxy data is needed for a request.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Details> callback, RequestFilter filter, IEnumerable<string> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -31,6 +33,7 @@ public virtual ValueTask AddListener(Action<Details> callback, RequestFilter fil
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Details> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -41,6 +44,7 @@ public virtual ValueTask<bool> HasListener(Action<Details> callback)
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Details> callback, RequestFilter filter, IEnumerable<string> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -48,6 +52,7 @@ public virtual ValueTask<bool> HasListener(Action<Details> callback, RequestFilt
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Details> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -57,6 +62,7 @@ public virtual ValueTask RemoveListener(Action<Details> callback)
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Details> callback, RequestFilter filter, IEnumerable<string> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/Runtime/BrowserInfo.cs b/src/WebExtensions.Net/Generated/Runtime/BrowserInfo.cs
index 6dd60a4..1987871 100644
--- a/src/WebExtensions.Net/Generated/Runtime/BrowserInfo.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/BrowserInfo.cs
@@ -9,21 +9,25 @@ namespace WebExtensions.Net.Runtime
     public partial class BrowserInfo : BaseObject
     {
         /// <summary>The browser's build ID/date, for example '20160101'.</summary>
+        [JsAccessPath("buildID")]
         [JsonPropertyName("buildID")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string BuildID { get; set; }
 
         /// <summary>The name of the browser, for example 'Firefox'.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>The name of the browser vendor, for example 'Mozilla'.</summary>
+        [JsAccessPath("vendor")]
         [JsonPropertyName("vendor")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Vendor { get; set; }
 
         /// <summary>The browser's version, for example '42.0.0' or '0.8.1pre'.</summary>
+        [JsAccessPath("version")]
         [JsonPropertyName("version")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Version { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Runtime/ConnectInfo.cs b/src/WebExtensions.Net/Generated/Runtime/ConnectInfo.cs
index c67d1de..dd482d6 100644
--- a/src/WebExtensions.Net/Generated/Runtime/ConnectInfo.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/ConnectInfo.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Runtime
     public partial class ConnectInfo : BaseObject
     {
         /// <summary>Whether the TLS channel ID will be passed into onConnectExternal for processes that are listening for the connection event.</summary>
+        [JsAccessPath("includeTlsChannelId")]
         [JsonPropertyName("includeTlsChannelId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludeTlsChannelId { get; set; }
 
         /// <summary>Will be passed into onConnect for processes that are listening for the connection event.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Runtime/IRuntimeApi.cs b/src/WebExtensions.Net/Generated/Runtime/IRuntimeApi.cs
index af92df5..c04bb7f 100644
--- a/src/WebExtensions.Net/Generated/Runtime/IRuntimeApi.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/IRuntimeApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System.Text.Json;
 using System.Threading.Tasks;
 using WebExtensions.Net.Events;
@@ -5,88 +6,111 @@
 namespace WebExtensions.Net.Runtime
 {
     /// <summary>Use the <c>browser.runtime</c> API to retrieve the background page, return details about the manifest, and listen for and respond to events in the app or extension lifecycle. You can also use this API to convert the relative path of URLs to fully-qualified URLs.</summary>
+    [JsAccessPath("runtime")]
     public partial interface IRuntimeApi
     {
         /// <summary>The ID of the extension/app.</summary>
+        [JsAccessPath("id")]
         string Id { get; }
 
         /// <summary>This will be defined during an API method callback if there was an error</summary>
+        [JsAccessPath("lastError")]
         LastError LastError { get; }
 
         /// <summary>Fired when a connection is made from either an extension process or a content script.</summary>
+        [JsAccessPath("onConnect")]
         OnConnectEvent OnConnect { get; }
 
         /// <summary>Fired when a connection is made from another extension.</summary>
+        [JsAccessPath("onConnectExternal")]
         OnConnectExternalEvent OnConnectExternal { get; }
 
         /// <summary>Fired when the extension is first installed, when the extension is updated to a new version, and when the browser is updated to a new version.</summary>
+        [JsAccessPath("onInstalled")]
         OnInstalledEvent OnInstalled { get; }
 
         /// <summary>Fired when a message is sent from either an extension process or a content script.</summary>
+        [JsAccessPath("onMessage")]
         OnMessageEvent OnMessage { get; }
 
         /// <summary>Fired when a message is sent from another extension/app. Cannot be used in a content script.</summary>
+        [JsAccessPath("onMessageExternal")]
         OnMessageExternalEvent OnMessageExternal { get; }
 
         /// <summary>Fired when a profile that has this extension installed first starts up. This event is not fired for incognito profiles.</summary>
+        [JsAccessPath("onStartup")]
         Event OnStartup { get; }
 
         /// <summary>Sent to the event page just before it is unloaded. This gives the extension opportunity to do some clean up. Note that since the page is unloading, any asynchronous operations started while handling this event are not guaranteed to complete. If more activity for the event page occurs before it gets unloaded the onSuspendCanceled event will be sent and the page won't be unloaded. </summary>
+        [JsAccessPath("onSuspend")]
         Event OnSuspend { get; }
 
         /// <summary>Sent after onSuspend to indicate that the app won't be unloaded after all.</summary>
+        [JsAccessPath("onSuspendCanceled")]
         Event OnSuspendCanceled { get; }
 
         /// <summary>Fired when an update is available, but isn't installed immediately because the app is currently running. If you do nothing, the update will be installed the next time the background page gets unloaded, if you want it to be installed sooner you can explicitly call $(ref:runtime.reload). If your extension is using a persistent background page, the background page of course never gets unloaded, so unless you call $(ref:runtime.reload) manually in response to this event the update will not get installed until the next time the browser itself restarts. If no handlers are listening for this event, and your extension has a persistent background page, it behaves as if $(ref:runtime.reload) is called in response to this event.</summary>
+        [JsAccessPath("onUpdateAvailable")]
         OnUpdateAvailableEvent OnUpdateAvailable { get; }
 
         /// <summary>Attempts to connect to connect listeners within an extension/app (such as the background page), or other extensions/apps. This is useful for content scripts connecting to their extension processes, inter-app/extension communication, and $(topic:manifest/externally_connectable)[web messaging]. Note that this does not connect to any listeners in a content script. Extensions may connect to content scripts embedded in tabs via $(ref:tabs.connect).</summary>
         /// <param name="extensionId">The ID of the extension or app to connect to. If omitted, a connection will be attempted with your own extension. Required if sending messages from a web page for $(topic:manifest/externally_connectable)[web messaging].</param>
         /// <param name="connectInfo"></param>
         /// <returns>Port through which messages can be sent and received. The port's $(ref:runtime.Port onDisconnect) event is fired if the extension/app does not exist. </returns>
+        [JsAccessPath("connect")]
         ValueTask<Port> Connect(string extensionId = null, ConnectInfo connectInfo = null);
 
         /// <summary>Connects to a native application in the host machine.</summary>
         /// <param name="application">The name of the registered application to connect to.</param>
         /// <returns>Port through which messages can be sent and received with the application</returns>
+        [JsAccessPath("connectNative")]
         ValueTask<Port> ConnectNative(string application);
 
         /// <summary>Retrieves the JavaScript 'window' object for the background page running inside the current extension/app. If the background page is an event page, the system will ensure it is loaded before calling the callback. If there is no background page, an error is set.</summary>
         /// <returns>The JavaScript 'window' object for the background page.</returns>
+        [JsAccessPath("getBackgroundPage")]
         ValueTask<JsonElement> GetBackgroundPage();
 
         /// <summary>Returns information about the current browser.</summary>
         /// <returns></returns>
+        [JsAccessPath("getBrowserInfo")]
         ValueTask<BrowserInfo> GetBrowserInfo();
 
         /// <summary>Get the frameId of any window global or frame element.</summary>
         /// <param name="target">A WindowProxy or a Browsing Context container element (IFrame, Frame, Embed, Object) for the target frame.</param>
         /// <returns>The frameId of the target frame, or -1 if it doesn't exist.</returns>
+        [JsAccessPath("getFrameId")]
         ValueTask<double> GetFrameId(object target);
 
         /// <summary>Returns details about the app or extension from the manifest. The object returned is a serialization of the full $(topic:manifest)[manifest file].</summary>
         /// <returns>The manifest details.</returns>
+        [JsAccessPath("getManifest")]
         ValueTask<JsonElement> GetManifest();
 
         /// <summary>Returns information about the current platform.</summary>
         /// <returns></returns>
+        [JsAccessPath("getPlatformInfo")]
         ValueTask<PlatformInfo> GetPlatformInfo();
 
         /// <summary>Converts a relative path within an app/extension install directory to a fully-qualified URL.</summary>
         /// <param name="path">A path to a resource within an app/extension expressed relative to its install directory.</param>
         /// <returns>The fully-qualified URL to the resource.</returns>
+        [JsAccessPath("getURL")]
         ValueTask<string> GetURL(string path);
 
         /// <summary>Open your Extension's options page, if possible.<br />The precise behavior may depend on your manifest's <c>$(topic:optionsV2)[options_ui]</c> or <c>$(topic:options)[options_page]</c> key, or what the browser happens to support at the time.<br />If your Extension does not declare an options page, or the browser failed to create one for some other reason, the callback will set $(ref:lastError).<br /></summary>
+        [JsAccessPath("openOptionsPage")]
         ValueTask OpenOptionsPage();
 
         /// <summary>Reloads the app or extension.</summary>
+        [JsAccessPath("reload")]
         ValueTask Reload();
 
         /// <summary>Sends a single message to event listeners within your extension/app or a different extension/app. Similar to $(ref:runtime.connect) but only sends a single message, with an optional response. If sending to your extension, the $(ref:runtime.onMessage) event will be fired in each page, or $(ref:runtime.onMessageExternal), if a different extension. Note that extensions cannot send messages to content scripts using this method. To send messages to content scripts, use $(ref:tabs.sendMessage).</summary>
         /// <param name="message"></param>
         /// <param name="options"></param>
         /// <returns>The JSON response object sent by the handler of the message. If an error occurs while connecting to the extension, the callback will be called with no arguments and $(ref:runtime.lastError) will be set to the error message.</returns>
+        [JsAccessPath("sendMessage")]
         ValueTask<JsonElement> SendMessage(object message, object options = null);
 
         /// <summary>Sends a single message to event listeners within your extension/app or a different extension/app. Similar to $(ref:runtime.connect) but only sends a single message, with an optional response. If sending to your extension, the $(ref:runtime.onMessage) event will be fired in each page, or $(ref:runtime.onMessageExternal), if a different extension. Note that extensions cannot send messages to content scripts using this method. To send messages to content scripts, use $(ref:tabs.sendMessage).</summary>
@@ -94,16 +118,19 @@ public partial interface IRuntimeApi
         /// <param name="message"></param>
         /// <param name="options"></param>
         /// <returns>The JSON response object sent by the handler of the message. If an error occurs while connecting to the extension, the callback will be called with no arguments and $(ref:runtime.lastError) will be set to the error message.</returns>
+        [JsAccessPath("sendMessage")]
         ValueTask<JsonElement> SendMessage(string extensionId, object message, object options = null);
 
         /// <summary>Send a single message to a native application.</summary>
         /// <param name="application">The name of the native messaging host.</param>
         /// <param name="message">The message that will be passed to the native messaging host.</param>
         /// <returns>The response message sent by the native messaging host. If an error occurs while connecting to the native messaging host, the callback will be called with no arguments and $(ref:runtime.lastError) will be set to the error message.</returns>
+        [JsAccessPath("sendNativeMessage")]
         ValueTask<JsonElement> SendNativeMessage(string application, object message);
 
         /// <summary>Sets the URL to be visited upon uninstallation. This may be used to clean up server-side data, do analytics, and implement surveys. Maximum 1023 characters.</summary>
         /// <param name="url">URL to be opened after the extension is uninstalled. This URL must have an http: or https: scheme. Set an empty string to not open a new tab upon uninstallation.</param>
+        [JsAccessPath("setUninstallURL")]
         ValueTask SetUninstallURL(string url = null);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Runtime/LastError.cs b/src/WebExtensions.Net/Generated/Runtime/LastError.cs
index 4bde289..84c3805 100644
--- a/src/WebExtensions.Net/Generated/Runtime/LastError.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/LastError.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Runtime
     public partial class LastError : BaseObject
     {
         /// <summary>Details about the error which occurred.</summary>
+        [JsAccessPath("message")]
         [JsonPropertyName("message")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Message { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Runtime/MessageSender.cs b/src/WebExtensions.Net/Generated/Runtime/MessageSender.cs
index b160448..385f4e8 100644
--- a/src/WebExtensions.Net/Generated/Runtime/MessageSender.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/MessageSender.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.Runtime
     public partial class MessageSender : BaseObject
     {
         /// <summary>The $(topic:frame_ids)[frame] that opened the connection. 0 for top-level frames, positive for child frames. This will only be set when <c>tab</c> is set.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? FrameId { get; set; }
 
         /// <summary>The ID of the extension or app that opened the connection, if any.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>The $(ref:tabs.Tab) which opened the connection, if any. This property will 'strong'only'/strong' be present when the connection was opened from a tab (including content scripts), and 'strong'only'/strong' if the receiver is an extension, not an app.</summary>
+        [JsAccessPath("tab")]
         [JsonPropertyName("tab")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Tab Tab { get; set; }
 
         /// <summary>The URL of the page or frame that opened the connection. If the sender is in an iframe, it will be iframe's URL not the URL of the page which hosts it.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnConnectEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnConnectEvent.cs
index c037900..c804ac2 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnConnectEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnConnectEvent.cs
@@ -12,6 +12,7 @@ public partial class OnConnectEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a connection is made from either an extension process or a content script.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Port> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Port> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Port> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Port> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Port> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnConnectExternalEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnConnectExternalEvent.cs
index f964b30..5cfe228 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnConnectExternalEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnConnectExternalEvent.cs
@@ -12,6 +12,7 @@ public partial class OnConnectExternalEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a connection is made from another extension.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Port> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Port> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Port> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Port> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Port> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnInstalledEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnInstalledEvent.cs
index 8443177..11a9337 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnInstalledEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnInstalledEvent.cs
@@ -12,6 +12,7 @@ public partial class OnInstalledEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the extension is first installed, when the extension is updated to a new version, and when the browser is updated to a new version.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnInstalledEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnInstalledEventCallbackDetails> cal
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnInstalledEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<OnInstalledEventCallbackDetail
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnInstalledEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnInstalledEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/Runtime/OnInstalledEventCallbackDetails.cs
index e4d6d3f..1dc4db6 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnInstalledEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnInstalledEventCallbackDetails.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Runtime
     public partial class OnInstalledEventCallbackDetails : BaseObject
     {
         /// <summary>Indicates the previous version of the extension, which has just been updated. This is present only if 'reason' is 'update'.</summary>
+        [JsAccessPath("previousVersion")]
         [JsonPropertyName("previousVersion")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string PreviousVersion { get; set; }
 
         /// <summary>The reason that this event is being dispatched.</summary>
+        [JsAccessPath("reason")]
         [JsonPropertyName("reason")]
         public OnInstalledReason Reason { get; set; }
 
         /// <summary>Indicates whether the addon is installed as a temporary extension.</summary>
+        [JsAccessPath("temporary")]
         [JsonPropertyName("temporary")]
         public bool Temporary { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnMessageEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnMessageEvent.cs
index da9fe57..91a7f26 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnMessageEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnMessageEvent.cs
@@ -12,6 +12,7 @@ public partial class OnMessageEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a message is sent from either an extension process or a content script.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Func<object, MessageSender, Action, bool> c
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action, b
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnMessageExternalEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnMessageExternalEvent.cs
index 83f0582..4b20172 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnMessageExternalEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnMessageExternalEvent.cs
@@ -12,6 +12,7 @@ public partial class OnMessageExternalEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a message is sent from another extension/app. Cannot be used in a content script.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Func<object, MessageSender, Action, bool> c
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Func<object, MessageSender, Action, b
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<object, MessageSender, Action, bool> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEvent.cs b/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEvent.cs
index a2a5260..2bbca08 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEvent.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEvent.cs
@@ -12,6 +12,7 @@ public partial class OnUpdateAvailableEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an update is available, but isn't installed immediately because the app is currently running. If you do nothing, the update will be installed the next time the background page gets unloaded, if you want it to be installed sooner you can explicitly call $(ref:runtime.reload). If your extension is using a persistent background page, the background page of course never gets unloaded, so unless you call $(ref:runtime.reload) manually in response to this event the update will not get installed until the next time the browser itself restarts. If no handlers are listening for this event, and your extension has a persistent background page, it behaves as if $(ref:runtime.reload) is called in response to this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnUpdateAvailableEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnUpdateAvailableEventCallbackDetail
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnUpdateAvailableEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<OnUpdateAvailableEventCallback
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnUpdateAvailableEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEventCallbackDetails.cs
index 4f13ff5..757d564 100644
--- a/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/OnUpdateAvailableEventCallbackDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Runtime
     public partial class OnUpdateAvailableEventCallbackDetails : BaseObject
     {
         /// <summary>The version number of the available update.</summary>
+        [JsAccessPath("version")]
         [JsonPropertyName("version")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Version { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Runtime/PlatformInfo.cs b/src/WebExtensions.Net/Generated/Runtime/PlatformInfo.cs
index 4ebbcc3..345439f 100644
--- a/src/WebExtensions.Net/Generated/Runtime/PlatformInfo.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/PlatformInfo.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Runtime
     public partial class PlatformInfo : BaseObject
     {
         /// <summary>The machine's processor architecture.</summary>
+        [JsAccessPath("arch")]
         [JsonPropertyName("arch")]
         public PlatformArch Arch { get; set; }
 
         /// <summary>The operating system the browser is running on.</summary>
+        [JsAccessPath("os")]
         [JsonPropertyName("os")]
         public PlatformOs Os { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Runtime/Port.cs b/src/WebExtensions.Net/Generated/Runtime/Port.cs
index b0b0f79..61ef3ee 100644
--- a/src/WebExtensions.Net/Generated/Runtime/Port.cs
+++ b/src/WebExtensions.Net/Generated/Runtime/Port.cs
@@ -11,26 +11,31 @@ namespace WebExtensions.Net.Runtime
     public partial class Port : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("disconnect")]
         [JsonPropertyName("disconnect")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Action Disconnect { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("onDisconnect")]
         [JsonPropertyName("onDisconnect")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Event OnDisconnect { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("onMessage")]
         [JsonPropertyName("onMessage")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Event OnMessage { get; set; }
 
         /// <summary>This property will 'b'only'/b' be present on ports passed to onConnect/onConnectExternal listeners.</summary>
+        [JsAccessPath("sender")]
         [JsonPropertyName("sender")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public MessageSender Sender { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/CSSInjection.cs b/src/WebExtensions.Net/Generated/Scripting/CSSInjection.cs
index b0bbf79..a3f8994 100644
--- a/src/WebExtensions.Net/Generated/Scripting/CSSInjection.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/CSSInjection.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.Scripting
     public partial class CSSInjection : BaseObject
     {
         /// <summary>A string containing the CSS to inject. Exactly one of <c>files</c> and <c>css</c> must be specified.</summary>
+        [JsAccessPath("css")]
         [JsonPropertyName("css")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Css { get; set; }
 
         /// <summary>The path of the CSS files to inject, relative to the extension's root directory. Exactly one of <c>files</c> and <c>css</c> must be specified.</summary>
+        [JsAccessPath("files")]
         [JsonPropertyName("files")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Files { get; set; }
 
         /// <summary>The style origin for the injection. Defaults to <c>'AUTHOR'</c>.</summary>
+        [JsAccessPath("origin")]
         [JsonPropertyName("origin")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Origin { get; set; }
 
         /// <summary>Details specifying the target into which to inject the CSS.</summary>
+        [JsAccessPath("target")]
         [JsonPropertyName("target")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public InjectionTarget Target { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/ContentScriptFilter.cs b/src/WebExtensions.Net/Generated/Scripting/ContentScriptFilter.cs
index dc4cd87..0404795 100644
--- a/src/WebExtensions.Net/Generated/Scripting/ContentScriptFilter.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/ContentScriptFilter.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.Scripting
     public partial class ContentScriptFilter : BaseObject
     {
         /// <summary>The IDs of specific scripts to retrieve with <c>getRegisteredContentScripts()</c> or to unregister with <c>unregisterContentScripts()</c>.</summary>
+        [JsAccessPath("ids")]
         [JsonPropertyName("ids")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Ids { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/IScriptingApi.cs b/src/WebExtensions.Net/Generated/Scripting/IScriptingApi.cs
index f590869..c546996 100644
--- a/src/WebExtensions.Net/Generated/Scripting/IScriptingApi.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/IScriptingApi.cs
@@ -1,39 +1,48 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Scripting
 {
     /// <summary>Use the scripting API to execute script in different contexts.</summary>
+    [JsAccessPath("scripting")]
     public partial interface IScriptingApi
     {
         /// <summary>Injects a script into a target context. The script will be run at <c>document_idle</c>.</summary>
         /// <param name="injection">The details of the script which to inject.</param>
         /// <returns></returns>
+        [JsAccessPath("executeScript")]
         ValueTask<IEnumerable<InjectionResult>> ExecuteScript(ScriptInjection injection);
 
         /// <summary>Returns all dynamically registered content scripts for this extension that match the given filter.</summary>
         /// <param name="filter">An object to filter the extension's dynamically registered scripts.</param>
         /// <returns></returns>
+        [JsAccessPath("getRegisteredContentScripts")]
         ValueTask<IEnumerable<RegisteredContentScript>> GetRegisteredContentScripts(ContentScriptFilter filter = null);
 
         /// <summary>Inserts a CSS stylesheet into a target context. If multiple frames are specified, unsuccessful injections are ignored.</summary>
         /// <param name="injection">The details of the styles to insert.</param>
+        [JsAccessPath("insertCSS")]
         ValueTask InsertCSS(CSSInjection injection);
 
         /// <summary>Registers one or more content scripts for this extension.</summary>
         /// <param name="scripts">Contains a list of scripts to be registered. If there are errors during script parsing/file validation, or if the IDs specified already exist, then no scripts are registered.</param>
+        [JsAccessPath("registerContentScripts")]
         ValueTask RegisterContentScripts(IEnumerable<RegisteredContentScript> scripts);
 
         /// <summary>Removes a CSS stylesheet that was previously inserted by this extension from a target context.</summary>
         /// <param name="injection">The details of the styles to remove. Note that the <c>css</c>, <c>files</c>, and <c>origin</c> properties must exactly match the stylesheet inserted through <c>insertCSS</c>. Attempting to remove a non-existent stylesheet is a no-op.</param>
+        [JsAccessPath("removeCSS")]
         ValueTask RemoveCSS(CSSInjection injection);
 
         /// <summary>Unregisters one or more content scripts for this extension.</summary>
         /// <param name="filter">If specified, only unregisters dynamic content scripts which match the filter. Otherwise, all of the extension's dynamic content scripts are unregistered.</param>
+        [JsAccessPath("unregisterContentScripts")]
         ValueTask UnregisterContentScripts(ContentScriptFilter filter = null);
 
         /// <summary>Updates one or more content scripts for this extension.</summary>
         /// <param name="scripts">Contains a list of scripts to be updated. If there are errors during script parsing/file validation, or if the IDs specified do not already exist, then no scripts are updated.</param>
+        [JsAccessPath("updateContentScripts")]
         ValueTask UpdateContentScripts(IEnumerable<Script> scripts);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Scripting/InjectionResult.cs b/src/WebExtensions.Net/Generated/Scripting/InjectionResult.cs
index dd7a749..9d5e3c5 100644
--- a/src/WebExtensions.Net/Generated/Scripting/InjectionResult.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/InjectionResult.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Scripting
     public partial class InjectionResult : BaseObject
     {
         /// <summary>The error property is set when the script execution failed. The value is typically an (Error) object with a message property, but could be any value (including primitives and undefined) if the script threw or rejected with such a value.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Error { get; set; }
 
         /// <summary>The frame ID associated with the injection.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The result of the script execution.</summary>
+        [JsAccessPath("result")]
         [JsonPropertyName("result")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Result { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/InjectionTarget.cs b/src/WebExtensions.Net/Generated/Scripting/InjectionTarget.cs
index 82ea002..54c18f0 100644
--- a/src/WebExtensions.Net/Generated/Scripting/InjectionTarget.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/InjectionTarget.cs
@@ -10,16 +10,19 @@ namespace WebExtensions.Net.Scripting
     public partial class InjectionTarget : BaseObject
     {
         /// <summary>Whether the script should inject into all frames within the tab. Defaults to false. This must not be true if <c>frameIds</c> is specified.</summary>
+        [JsAccessPath("allFrames")]
         [JsonPropertyName("allFrames")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllFrames { get; set; }
 
         /// <summary>The IDs of specific frames to inject into.</summary>
+        [JsAccessPath("frameIds")]
         [JsonPropertyName("frameIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<double> FrameIds { get; set; }
 
         /// <summary>The ID of the tab into which to inject.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public double TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Scripting/RegisteredContentScript.cs b/src/WebExtensions.Net/Generated/Scripting/RegisteredContentScript.cs
index 748dd7a..86d9081 100644
--- a/src/WebExtensions.Net/Generated/Scripting/RegisteredContentScript.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/RegisteredContentScript.cs
@@ -12,41 +12,49 @@ namespace WebExtensions.Net.Scripting
     public partial class RegisteredContentScript : BaseObject
     {
         /// <summary>If specified true, it will inject into all frames, even if the frame is not the top-most frame in the tab. Each frame is checked independently for URL requirements; it will not inject into child frames if the URL requirements are not met. Defaults to false, meaning that only the top frame is matched.</summary>
+        [JsAccessPath("allFrames")]
         [JsonPropertyName("allFrames")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllFrames { get; set; }
 
         /// <summary>The list of CSS files to be injected into matching pages. These are injected in the order they appear in this array.</summary>
+        [JsAccessPath("css")]
         [JsonPropertyName("css")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ExtensionUrl> Css { get; set; }
 
         /// <summary>Excludes pages that this content script would otherwise be injected into.</summary>
+        [JsAccessPath("excludeMatches")]
         [JsonPropertyName("excludeMatches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> ExcludeMatches { get; set; }
 
         /// <summary>The id of the content script, specified in the API call.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Id { get; set; }
 
         /// <summary>The list of JavaScript files to be injected into matching pages. These are injected in the order they appear in this array.</summary>
+        [JsAccessPath("js")]
         [JsonPropertyName("js")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ExtensionUrl> Js { get; set; }
 
         /// <summary>Specifies which pages this content script will be injected into. Must be specified for <c>registerContentScripts()</c>.</summary>
+        [JsAccessPath("matches")]
         [JsonPropertyName("matches")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Matches { get; set; }
 
         /// <summary>Specifies if this content script will persist into future sessions. Defaults to true.</summary>
+        [JsAccessPath("persistAcrossSessions")]
         [JsonPropertyName("persistAcrossSessions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? PersistAcrossSessions { get; set; }
 
         /// <summary>Specifies when JavaScript files are injected into the web page. The preferred and default value is <c>document_idle</c>.</summary>
+        [JsAccessPath("runAt")]
         [JsonPropertyName("runAt")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public RunAt? RunAt { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/Script.cs b/src/WebExtensions.Net/Generated/Scripting/Script.cs
index 0a6047c..6d97a50 100644
--- a/src/WebExtensions.Net/Generated/Scripting/Script.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/Script.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Scripting
     public partial class Script : BaseObject
     {
         /// <summary>Specifies if this content script will persist into future sessions.</summary>
+        [JsAccessPath("persistAcrossSessions")]
         [JsonPropertyName("persistAcrossSessions")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? PersistAcrossSessions { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Scripting/ScriptInjection.cs b/src/WebExtensions.Net/Generated/Scripting/ScriptInjection.cs
index 472a37c..8cf5518 100644
--- a/src/WebExtensions.Net/Generated/Scripting/ScriptInjection.cs
+++ b/src/WebExtensions.Net/Generated/Scripting/ScriptInjection.cs
@@ -11,31 +11,37 @@ namespace WebExtensions.Net.Scripting
     public partial class ScriptInjection : BaseObject
     {
         /// <summary>The arguments to curry into a provided function. This is only valid if the <c>func</c> parameter is specified. These arguments must be JSON-serializable.</summary>
+        [JsAccessPath("args")]
         [JsonPropertyName("args")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<object> Args { get; set; }
 
         /// <summary>The path of the JS files to inject, relative to the extension's root directory. Exactly one of <c>files</c> and <c>func</c> must be specified.</summary>
+        [JsAccessPath("files")]
         [JsonPropertyName("files")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Files { get; set; }
 
         /// <summary>A JavaScript function to inject. This function will be serialized, and then deserialized for injection. This means that any bound parameters and execution context will be lost. Exactly one of <c>files</c> and <c>func</c> must be specified.</summary>
+        [JsAccessPath("func")]
         [JsonPropertyName("func")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Action Func { get; set; }
 
         /// <summary>Whether the injection should be triggered in the target as soon as possible (but not necessarily prior to page load).</summary>
+        [JsAccessPath("injectImmediately")]
         [JsonPropertyName("injectImmediately")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? InjectImmediately { get; set; }
 
         /// <summary>Details specifying the target into which to inject the script.</summary>
+        [JsAccessPath("target")]
         [JsonPropertyName("target")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public InjectionTarget Target { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("world")]
         [JsonPropertyName("world")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ExecutionWorld? World { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Search/ISearchApi.cs b/src/WebExtensions.Net/Generated/Search/ISearchApi.cs
index fe83301..ca1303c 100644
--- a/src/WebExtensions.Net/Generated/Search/ISearchApi.cs
+++ b/src/WebExtensions.Net/Generated/Search/ISearchApi.cs
@@ -1,19 +1,24 @@
+using JsBind.Net;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Search
 {
     /// <summary>Use browser.search to interact with search engines.</summary>
+    [JsAccessPath("search")]
     public partial interface ISearchApi
     {
         /// <summary>Gets a list of search engines.</summary>
+        [JsAccessPath("get")]
         ValueTask Get();
 
         /// <summary>Use the chrome.search API to search via the default provider.</summary>
         /// <param name="queryInfo"></param>
+        [JsAccessPath("query")]
         ValueTask Query(QueryInfo queryInfo);
 
         /// <summary>Perform a search.</summary>
         /// <param name="searchProperties"></param>
+        [JsAccessPath("search")]
         ValueTask Search(SearchProperties searchProperties);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Search/QueryInfo.cs b/src/WebExtensions.Net/Generated/Search/QueryInfo.cs
index 7a4662e..b817985 100644
--- a/src/WebExtensions.Net/Generated/Search/QueryInfo.cs
+++ b/src/WebExtensions.Net/Generated/Search/QueryInfo.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Search
     public partial class QueryInfo : BaseObject
     {
         /// <summary>Location where search results should be displayed. CURRENT_TAB is the default.</summary>
+        [JsAccessPath("disposition")]
         [JsonPropertyName("disposition")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Disposition? Disposition { get; set; }
 
         /// <summary>Location where search results should be displayed. tabId cannot be used with disposition.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>String to query with the default search provider.</summary>
+        [JsAccessPath("text")]
         [JsonPropertyName("text")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Text { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Search/SearchProperties.cs b/src/WebExtensions.Net/Generated/Search/SearchProperties.cs
index 8f72ad0..1ee819d 100644
--- a/src/WebExtensions.Net/Generated/Search/SearchProperties.cs
+++ b/src/WebExtensions.Net/Generated/Search/SearchProperties.cs
@@ -9,21 +9,25 @@ namespace WebExtensions.Net.Search
     public partial class SearchProperties : BaseObject
     {
         /// <summary>Location where search results should be displayed. NEW_TAB is the default.</summary>
+        [JsAccessPath("disposition")]
         [JsonPropertyName("disposition")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Disposition? Disposition { get; set; }
 
         /// <summary>Search engine to use. Uses the default if not specified.</summary>
+        [JsAccessPath("engine")]
         [JsonPropertyName("engine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Engine { get; set; }
 
         /// <summary>Terms to search for.</summary>
+        [JsAccessPath("query")]
         [JsonPropertyName("query")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Query { get; set; }
 
         /// <summary>The ID of the tab for the search results. If not specified, a new tab is created, unless disposition is set. tabId cannot be used with disposition.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Sessions/Filter.cs b/src/WebExtensions.Net/Generated/Sessions/Filter.cs
index 0f17dd1..ab483e8 100644
--- a/src/WebExtensions.Net/Generated/Sessions/Filter.cs
+++ b/src/WebExtensions.Net/Generated/Sessions/Filter.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Sessions
     public partial class Filter : BaseObject
     {
         /// <summary>The maximum number of entries to be fetched in the requested list. Omit this parameter to fetch the maximum number of entries ($(ref:sessions.MAX_SESSION_RESULTS)).</summary>
+        [JsAccessPath("maxResults")]
         [JsonPropertyName("maxResults")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? MaxResults { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Sessions/ISessionsApi.cs b/src/WebExtensions.Net/Generated/Sessions/ISessionsApi.cs
index 31736cd..9aa64c6 100644
--- a/src/WebExtensions.Net/Generated/Sessions/ISessionsApi.cs
+++ b/src/WebExtensions.Net/Generated/Sessions/ISessionsApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using WebExtensions.Net.Events;
@@ -5,63 +6,76 @@
 namespace WebExtensions.Net.Sessions
 {
     /// <summary>Use the <c>chrome.sessions</c> API to query and restore tabs and windows from a browsing session.</summary>
+    [JsAccessPath("sessions")]
     public partial interface ISessionsApi
     {
         /// <summary>The maximum number of $(ref:sessions.Session) that will be included in a requested list.</summary>
+        [JsAccessPath("MAX_SESSION_RESULTS")]
         int MAX_SESSION_RESULTS { get; }
 
         /// <summary>Fired when recently closed tabs and/or windows are changed. This event does not monitor synced sessions changes.</summary>
+        [JsAccessPath("onChanged")]
         Event OnChanged { get; }
 
         /// <summary>Forget a recently closed tab.</summary>
         /// <param name="windowId">The windowId of the window to which the recently closed tab to be forgotten belongs.</param>
         /// <param name="sessionId">The sessionId (closedId) of the recently closed tab to be forgotten.</param>
+        [JsAccessPath("forgetClosedTab")]
         ValueTask ForgetClosedTab(int windowId, string sessionId);
 
         /// <summary>Forget a recently closed window.</summary>
         /// <param name="sessionId">The sessionId (closedId) of the recently closed window to be forgotten.</param>
+        [JsAccessPath("forgetClosedWindow")]
         ValueTask ForgetClosedWindow(string sessionId);
 
         /// <summary>Gets the list of recently closed tabs and/or windows.</summary>
         /// <param name="filter"></param>
         /// <returns>The list of closed entries in reverse order that they were closed (the most recently closed tab or window will be at index <c>0</c>). The entries may contain either tabs or windows.</returns>
+        [JsAccessPath("getRecentlyClosed")]
         ValueTask<IEnumerable<Session>> GetRecentlyClosed(Filter filter = null);
 
         /// <summary>Retrieve a value that was set for a given key on a given tab.</summary>
         /// <param name="tabId">The id of the tab whose value is being retrieved from.</param>
         /// <param name="key">The key which corresponds to the value.</param>
+        [JsAccessPath("getTabValue")]
         ValueTask GetTabValue(int tabId, string key);
 
         /// <summary>Retrieve a value that was set for a given key on a given window.</summary>
         /// <param name="windowId">The id of the window whose value is being retrieved from.</param>
         /// <param name="key">The key which corresponds to the value.</param>
+        [JsAccessPath("getWindowValue")]
         ValueTask GetWindowValue(int windowId, string key);
 
         /// <summary>Remove a key/value pair that was set on a given tab.</summary>
         /// <param name="tabId">The id of the tab whose key/value pair is being removed.</param>
         /// <param name="key">The key which corresponds to the value.</param>
+        [JsAccessPath("removeTabValue")]
         ValueTask RemoveTabValue(int tabId, string key);
 
         /// <summary>Remove a key/value pair that was set on a given window.</summary>
         /// <param name="windowId">The id of the window whose key/value pair is being removed.</param>
         /// <param name="key">The key which corresponds to the value.</param>
+        [JsAccessPath("removeWindowValue")]
         ValueTask RemoveWindowValue(int windowId, string key);
 
         /// <summary>Reopens a $(ref:windows.Window) or $(ref:tabs.Tab), with an optional callback to run when the entry has been restored.</summary>
         /// <param name="sessionId">The $(ref:windows.Window.sessionId), or $(ref:tabs.Tab.sessionId) to restore. If this parameter is not specified, the most recently closed session is restored.</param>
         /// <returns>A $(ref:sessions.Session) containing the restored $(ref:windows.Window) or $(ref:tabs.Tab) object.</returns>
+        [JsAccessPath("restore")]
         ValueTask<Session> Restore(string sessionId = null);
 
         /// <summary>Set a key/value pair on a given tab.</summary>
         /// <param name="tabId">The id of the tab that the key/value pair is being set on.</param>
         /// <param name="key">The key which corresponds to the value being set.</param>
         /// <param name="value">The value being set.</param>
+        [JsAccessPath("setTabValue")]
         ValueTask SetTabValue(int tabId, string key, object value);
 
         /// <summary>Set a key/value pair on a given window.</summary>
         /// <param name="windowId">The id of the window that the key/value pair is being set on.</param>
         /// <param name="key">The key which corresponds to the value being set.</param>
         /// <param name="value">The value being set.</param>
+        [JsAccessPath("setWindowValue")]
         ValueTask SetWindowValue(int windowId, string key, object value);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Sessions/Session.cs b/src/WebExtensions.Net/Generated/Sessions/Session.cs
index db52476..bd55d00 100644
--- a/src/WebExtensions.Net/Generated/Sessions/Session.cs
+++ b/src/WebExtensions.Net/Generated/Sessions/Session.cs
@@ -11,15 +11,18 @@ namespace WebExtensions.Net.Sessions
     public partial class Session : BaseObject
     {
         /// <summary>The time when the window or tab was closed or modified, represented in milliseconds since the epoch.</summary>
+        [JsAccessPath("lastModified")]
         [JsonPropertyName("lastModified")]
         public EpochTime LastModified { get; set; }
 
         /// <summary>The $(ref:tabs.Tab), if this entry describes a tab. Either this or $(ref:sessions.Session.window) will be set.</summary>
+        [JsAccessPath("tab")]
         [JsonPropertyName("tab")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Tab Tab { get; set; }
 
         /// <summary>The $(ref:windows.Window), if this entry describes a window. Either this or $(ref:sessions.Session.tab) will be set.</summary>
+        [JsAccessPath("window")]
         [JsonPropertyName("window")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Window Window { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Storage/IStorageApi.cs b/src/WebExtensions.Net/Generated/Storage/IStorageApi.cs
index 1c6cc77..0c05db6 100644
--- a/src/WebExtensions.Net/Generated/Storage/IStorageApi.cs
+++ b/src/WebExtensions.Net/Generated/Storage/IStorageApi.cs
@@ -1,21 +1,29 @@
+using JsBind.Net;
+
 namespace WebExtensions.Net.Storage
 {
     /// <summary>Use the <c>browser.storage</c> API to store, retrieve, and track changes to user data.</summary>
+    [JsAccessPath("storage")]
     public partial interface IStorageApi
     {
         /// <summary>Items in the <c>local</c> storage area are local to each machine.</summary>
+        [JsAccessPath("local")]
         StorageArea Local { get; }
 
         /// <summary>Items in the <c>managed</c> storage area are set by administrators or native applications, and are read-only for the extension; trying to modify this namespace results in an error.</summary>
+        [JsAccessPath("managed")]
         StorageArea Managed { get; }
 
         /// <summary>Fired when one or more items change.</summary>
+        [JsAccessPath("onChanged")]
         OnChangedEvent OnChanged { get; }
 
         /// <summary>Items in the <c>session</c> storage area are kept in memory, and only until the either browser or extension is closed or reloaded.</summary>
+        [JsAccessPath("session")]
         StorageArea Session { get; }
 
         /// <summary>Items in the <c>sync</c> storage area are synced by the browser.</summary>
+        [JsAccessPath("sync")]
         StorageAreaSync Sync { get; }
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Storage/OnChangedEvent.cs b/src/WebExtensions.Net/Generated/Storage/OnChangedEvent.cs
index 588b8fa..ea4e9b3 100644
--- a/src/WebExtensions.Net/Generated/Storage/OnChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Storage/OnChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when one or more items change.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<object, string> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<object, string> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<object, string> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<object, string> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<object, string> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Storage/StorageArea.cs b/src/WebExtensions.Net/Generated/Storage/StorageArea.cs
index 7e5c30f..949f401 100644
--- a/src/WebExtensions.Net/Generated/Storage/StorageArea.cs
+++ b/src/WebExtensions.Net/Generated/Storage/StorageArea.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.Storage
     public partial class StorageArea : BaseObject
     {
         /// <summary>Removes all items from storage.</summary>
+        [JsAccessPath("clear")]
         public virtual ValueTask Clear()
         {
             return InvokeVoidAsync("clear");
@@ -18,6 +19,7 @@ public virtual ValueTask Clear()
         /// <summary>Gets one or more items from storage.</summary>
         /// <param name="keys">A single key to get, list of keys to get, or a dictionary specifying default values (see description of the object).  An empty list or object will return an empty result object.  Pass in <c>null</c> to get the entire contents of storage.</param>
         /// <returns>Object with items in their key-value mappings.</returns>
+        [JsAccessPath("get")]
         public virtual ValueTask<JsonElement> Get(StorageAreaGetKeys keys = null)
         {
             return InvokeAsync<JsonElement>("get", keys);
@@ -25,6 +27,7 @@ public virtual ValueTask<JsonElement> Get(StorageAreaGetKeys keys = null)
 
         /// <summary>Removes one or more items from storage.</summary>
         /// <param name="keys">A single key or a list of keys for items to remove.</param>
+        [JsAccessPath("remove")]
         public virtual ValueTask Remove(StorageAreaRemoveKeys keys)
         {
             return InvokeVoidAsync("remove", keys);
@@ -32,6 +35,7 @@ public virtual ValueTask Remove(StorageAreaRemoveKeys keys)
 
         /// <summary>Sets multiple items.</summary>
         /// <param name="items">An object which gives each key/value pair to update storage with. Any other key/value pairs in storage will not be affected.<br />Primitive values such as numbers will serialize as expected. Values with a <c>typeof</c> <c>"object"</c> and <c>"function"</c> will typically serialize to <c>{}</c>, with the exception of <c>Array</c> (serializes as expected), <c>Date</c>, and <c>Regex</c> (serialize using their <c>String</c> representation).<br /></param>
+        [JsAccessPath("set")]
         public virtual ValueTask Set(object items)
         {
             return InvokeVoidAsync("set", items);
diff --git a/src/WebExtensions.Net/Generated/Storage/StorageAreaSync.cs b/src/WebExtensions.Net/Generated/Storage/StorageAreaSync.cs
index 585be72..f65e979 100644
--- a/src/WebExtensions.Net/Generated/Storage/StorageAreaSync.cs
+++ b/src/WebExtensions.Net/Generated/Storage/StorageAreaSync.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.Storage
     public partial class StorageAreaSync : BaseObject
     {
         /// <summary>Removes all items from storage.</summary>
+        [JsAccessPath("clear")]
         public virtual ValueTask Clear()
         {
             return InvokeVoidAsync("clear");
@@ -18,6 +19,7 @@ public virtual ValueTask Clear()
         /// <summary>Gets one or more items from storage.</summary>
         /// <param name="keys">A single key to get, list of keys to get, or a dictionary specifying default values (see description of the object).  An empty list or object will return an empty result object.  Pass in <c>null</c> to get the entire contents of storage.</param>
         /// <returns>Object with items in their key-value mappings.</returns>
+        [JsAccessPath("get")]
         public virtual ValueTask<JsonElement> Get(StorageAreaSyncGetKeys keys = null)
         {
             return InvokeAsync<JsonElement>("get", keys);
@@ -26,6 +28,7 @@ public virtual ValueTask<JsonElement> Get(StorageAreaSyncGetKeys keys = null)
         /// <summary>Gets the amount of space (in bytes) being used by one or more items.</summary>
         /// <param name="keys">A single key or list of keys to get the total usage for. An empty list will return 0. Pass in <c>null</c> to get the total usage of all of storage.</param>
         /// <returns>Amount of space being used in storage, in bytes.</returns>
+        [JsAccessPath("getBytesInUse")]
         public virtual ValueTask<int> GetBytesInUse(StorageAreaSyncGetBytesInUseKeys keys = null)
         {
             return InvokeAsync<int>("getBytesInUse", keys);
@@ -33,6 +36,7 @@ public virtual ValueTask<int> GetBytesInUse(StorageAreaSyncGetBytesInUseKeys key
 
         /// <summary>Removes one or more items from storage.</summary>
         /// <param name="keys">A single key or a list of keys for items to remove.</param>
+        [JsAccessPath("remove")]
         public virtual ValueTask Remove(StorageAreaSyncRemoveKeys keys)
         {
             return InvokeVoidAsync("remove", keys);
@@ -40,6 +44,7 @@ public virtual ValueTask Remove(StorageAreaSyncRemoveKeys keys)
 
         /// <summary>Sets multiple items.</summary>
         /// <param name="items">An object which gives each key/value pair to update storage with. Any other key/value pairs in storage will not be affected.<br />Primitive values such as numbers will serialize as expected. Values with a <c>typeof</c> <c>"object"</c> and <c>"function"</c> will typically serialize to <c>{}</c>, with the exception of <c>Array</c> (serializes as expected), <c>Date</c>, and <c>Regex</c> (serialize using their <c>String</c> representation).<br /></param>
+        [JsAccessPath("set")]
         public virtual ValueTask Set(object items)
         {
             return InvokeVoidAsync("set", items);
diff --git a/src/WebExtensions.Net/Generated/Tabs/ActiveInfo.cs b/src/WebExtensions.Net/Generated/Tabs/ActiveInfo.cs
index 9219496..5409461 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ActiveInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ActiveInfo.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Tabs
     public partial class ActiveInfo : BaseObject
     {
         /// <summary>The ID of the tab that was previously active, if that tab is still open.</summary>
+        [JsAccessPath("previousTabId")]
         [JsonPropertyName("previousTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? PreviousTabId { get; set; }
 
         /// <summary>The ID of the tab that has become active.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The ID of the window the active tab changed inside of.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         public int WindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/AttachInfo.cs b/src/WebExtensions.Net/Generated/Tabs/AttachInfo.cs
index dcf9ddd..8155d60 100644
--- a/src/WebExtensions.Net/Generated/Tabs/AttachInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/AttachInfo.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Tabs
     public partial class AttachInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("newPosition")]
         [JsonPropertyName("newPosition")]
         public int NewPosition { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("newWindowId")]
         [JsonPropertyName("newWindowId")]
         public int NewWindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/CallbackHighlightInfo.cs b/src/WebExtensions.Net/Generated/Tabs/CallbackHighlightInfo.cs
index d510e25..8124fab 100644
--- a/src/WebExtensions.Net/Generated/Tabs/CallbackHighlightInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/CallbackHighlightInfo.cs
@@ -10,11 +10,13 @@ namespace WebExtensions.Net.Tabs
     public partial class CallbackHighlightInfo : BaseObject
     {
         /// <summary>All highlighted tabs in the window.</summary>
+        [JsAccessPath("tabIds")]
         [JsonPropertyName("tabIds")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> TabIds { get; set; }
 
         /// <summary>The window whose tabs changed.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         public int WindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ChangeInfo.cs b/src/WebExtensions.Net/Generated/Tabs/ChangeInfo.cs
index 8d85402..08c7bcf 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ChangeInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ChangeInfo.cs
@@ -9,66 +9,79 @@ namespace WebExtensions.Net.Tabs
     public partial class ChangeInfo : BaseObject
     {
         /// <summary>The tab's new attention state.</summary>
+        [JsAccessPath("attention")]
         [JsonPropertyName("attention")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Attention { get; set; }
 
         /// <summary>The tab's new audible state.</summary>
+        [JsAccessPath("audible")]
         [JsonPropertyName("audible")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Audible { get; set; }
 
         /// <summary>The tab's new autoDiscardable state.</summary>
+        [JsAccessPath("autoDiscardable")]
         [JsonPropertyName("autoDiscardable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AutoDiscardable { get; set; }
 
         /// <summary>True while the tab is not loaded with content.</summary>
+        [JsAccessPath("discarded")]
         [JsonPropertyName("discarded")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Discarded { get; set; }
 
         /// <summary>The tab's new favicon URL. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("favIconUrl")]
         [JsonPropertyName("favIconUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FavIconUrl { get; set; }
 
         /// <summary>The tab's new hidden state.</summary>
+        [JsAccessPath("hidden")]
         [JsonPropertyName("hidden")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Hidden { get; set; }
 
         /// <summary>Whether the document in the tab can be rendered in reader mode.</summary>
+        [JsAccessPath("isArticle")]
         [JsonPropertyName("isArticle")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsArticle { get; set; }
 
         /// <summary>The tab's new muted state and the reason for the change.</summary>
+        [JsAccessPath("mutedInfo")]
         [JsonPropertyName("mutedInfo")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public MutedInfo MutedInfo { get; set; }
 
         /// <summary>The tab's new pinned state.</summary>
+        [JsAccessPath("pinned")]
         [JsonPropertyName("pinned")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Pinned { get; set; }
 
         /// <summary>The tab's new sharing state for screen, microphone and camera.</summary>
+        [JsAccessPath("sharingState")]
         [JsonPropertyName("sharingState")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public SharingState SharingState { get; set; }
 
         /// <summary>The status of the tab. Can be either <em>loading</em> or <em>complete</em>.</summary>
+        [JsAccessPath("status")]
         [JsonPropertyName("status")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Status { get; set; }
 
         /// <summary>The title of the tab if it has changed. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The tab's URL if it has changed. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ConnectInfo.cs b/src/WebExtensions.Net/Generated/Tabs/ConnectInfo.cs
index 661389b..9685ee7 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ConnectInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ConnectInfo.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Tabs
     public partial class ConnectInfo : BaseObject
     {
         /// <summary>Open a port to a specific $(topic:frame_ids)[frame] identified by <c>frameId</c> instead of all frames in the tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? FrameId { get; set; }
 
         /// <summary>Will be passed into onConnect for content scripts that are listening for the connection event.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/CreateProperties.cs b/src/WebExtensions.Net/Generated/Tabs/CreateProperties.cs
index 257468e..cbc9cff 100644
--- a/src/WebExtensions.Net/Generated/Tabs/CreateProperties.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/CreateProperties.cs
@@ -9,56 +9,67 @@ namespace WebExtensions.Net.Tabs
     public partial class CreateProperties : BaseObject
     {
         /// <summary>Whether the tab should become the active tab in the window. Does not affect whether the window is focused (see $(ref:windows.update)). Defaults to <c>true</c>.</summary>
+        [JsAccessPath("active")]
         [JsonPropertyName("active")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Active { get; set; }
 
         /// <summary>The CookieStoreId for the tab that opened this tab.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>Whether the tab is marked as 'discarded' when created.</summary>
+        [JsAccessPath("discarded")]
         [JsonPropertyName("discarded")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Discarded { get; set; }
 
         /// <summary>The position the tab should take in the window. The provided value will be clamped to between zero and the number of tabs in the window.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
 
         /// <summary>Whether the tab should be muted when created.</summary>
+        [JsAccessPath("muted")]
         [JsonPropertyName("muted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Muted { get; set; }
 
         /// <summary>The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as the newly created tab.</summary>
+        [JsAccessPath("openerTabId")]
         [JsonPropertyName("openerTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? OpenerTabId { get; set; }
 
         /// <summary>Whether the document in the tab should be opened in reader mode.</summary>
+        [JsAccessPath("openInReaderMode")]
         [JsonPropertyName("openInReaderMode")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? OpenInReaderMode { get; set; }
 
         /// <summary>Whether the tab should be pinned. Defaults to <c>false</c></summary>
+        [JsAccessPath("pinned")]
         [JsonPropertyName("pinned")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Pinned { get; set; }
 
         /// <summary>The title used for display if the tab is created in discarded mode.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The URL to navigate the tab to initially. Fully-qualified URLs must include a scheme (i.e. 'http://www.google.com', not 'www.google.com'). Relative URLs will be relative to the current page within the extension. Defaults to the New Tab Page.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>The window to create the new tab in. Defaults to the $(topic:current-window)[current window].</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/DetachInfo.cs b/src/WebExtensions.Net/Generated/Tabs/DetachInfo.cs
index 91f2a62..89492ce 100644
--- a/src/WebExtensions.Net/Generated/Tabs/DetachInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/DetachInfo.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Tabs
     public partial class DetachInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("oldPosition")]
         [JsonPropertyName("oldPosition")]
         public int OldPosition { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("oldWindowId")]
         [JsonPropertyName("oldWindowId")]
         public int OldWindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/DuplicateProperties.cs b/src/WebExtensions.Net/Generated/Tabs/DuplicateProperties.cs
index 92dfea6..4ce253f 100644
--- a/src/WebExtensions.Net/Generated/Tabs/DuplicateProperties.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/DuplicateProperties.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Tabs
     public partial class DuplicateProperties : BaseObject
     {
         /// <summary>Whether the tab should become the active tab in the window. Does not affect whether the window is focused (see $(ref:windows.update)). Defaults to <c>true</c>.</summary>
+        [JsAccessPath("active")]
         [JsonPropertyName("active")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Active { get; set; }
 
         /// <summary>The position the new tab should take in the window. The provided value will be clamped to between zero and the number of tabs in the window.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/HighlightHighlightInfo.cs b/src/WebExtensions.Net/Generated/Tabs/HighlightHighlightInfo.cs
index d645130..6af5f29 100644
--- a/src/WebExtensions.Net/Generated/Tabs/HighlightHighlightInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/HighlightHighlightInfo.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Tabs
     public partial class HighlightHighlightInfo : BaseObject
     {
         /// <summary>If true, the $(ref:windows.Window) returned will have a <c>tabs</c> property that contains a list of the $(ref:tabs.Tab) objects. The <c>Tab</c> objects only contain the <c>url</c>, <c>title</c> and <c>favIconUrl</c> properties if the extension's manifest file includes the <c>"tabs"</c> permission. If false, the $(ref:windows.Window) won't have the <c>tabs</c> property.</summary>
+        [JsAccessPath("populate")]
         [JsonPropertyName("populate")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Populate { get; set; }
 
         /// <summary>One or more tab indices to highlight.</summary>
+        [JsAccessPath("tabs")]
         [JsonPropertyName("tabs")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HighlightInfoTabs Tabs { get; set; }
 
         /// <summary>The window that contains the tabs.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ITabsApi.cs b/src/WebExtensions.Net/Generated/Tabs/ITabsApi.cs
index 7d8c47e..703d51f 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ITabsApi.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ITabsApi.cs
@@ -1,3 +1,4 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -8,196 +9,241 @@
 namespace WebExtensions.Net.Tabs
 {
     /// <summary>Use the <c>browser.tabs</c> API to interact with the browser's tab system. You can use this API to create, modify, and rearrange tabs in the browser.</summary>
+    [JsAccessPath("tabs")]
     public partial interface ITabsApi
     {
         /// <summary>Fires when the active tab in a window changes. Note that the tab's URL may not be set at the time this event fired, but you can listen to onUpdated events to be notified when a URL is set.</summary>
+        [JsAccessPath("onActivated")]
         OnActivatedEvent OnActivated { get; }
 
         /// <summary>Fired when a tab is attached to a window, for example because it was moved between windows.</summary>
+        [JsAccessPath("onAttached")]
         OnAttachedEvent OnAttached { get; }
 
         /// <summary>Fired when a tab is created. Note that the tab's URL may not be set at the time this event fired, but you can listen to onUpdated events to be notified when a URL is set.</summary>
+        [JsAccessPath("onCreated")]
         OnCreatedEvent OnCreated { get; }
 
         /// <summary>Fired when a tab is detached from a window, for example because it is being moved between windows.</summary>
+        [JsAccessPath("onDetached")]
         OnDetachedEvent OnDetached { get; }
 
         /// <summary>Fired when the highlighted or selected tabs in a window changes.</summary>
+        [JsAccessPath("onHighlighted")]
         OnHighlightedEvent OnHighlighted { get; }
 
         /// <summary>Fired when a tab is moved within a window. Only one move event is fired, representing the tab the user directly moved. Move events are not fired for the other tabs that must move in response. This event is not fired when a tab is moved between windows. For that, see $(ref:tabs.onDetached).</summary>
+        [JsAccessPath("onMoved")]
         OnMovedEvent OnMoved { get; }
 
         /// <summary>Fired when a tab is closed.</summary>
+        [JsAccessPath("onRemoved")]
         OnRemovedEvent OnRemoved { get; }
 
         /// <summary>Fired when a tab is replaced with another tab due to prerendering or instant.</summary>
+        [JsAccessPath("onReplaced")]
         OnReplacedEvent OnReplaced { get; }
 
         /// <summary>Fired when a tab is updated.</summary>
+        [JsAccessPath("onUpdated")]
         OnUpdatedEvent OnUpdated { get; }
 
         /// <summary>Fired when a tab is zoomed.</summary>
+        [JsAccessPath("onZoomChange")]
         OnZoomChangeEvent OnZoomChange { get; }
 
         /// <summary>An ID which represents the absence of a browser tab.</summary>
+        [JsAccessPath("TAB_ID_NONE")]
         int TAB_ID_NONE { get; }
 
         /// <summary>Captures an area of a specified tab. You must have $(topic:declare_permissions)[&amp;lt;all_urls&amp;gt;] permission to use this method.</summary>
         /// <param name="tabId">The tab to capture. Defaults to the active tab of the current window.</param>
         /// <param name="options"></param>
+        [JsAccessPath("captureTab")]
         ValueTask CaptureTab(int? tabId = null, ImageDetails options = null);
 
         /// <summary>Captures an area of the currently active tab in the specified window. You must have $(topic:declare_permissions)[&amp;lt;all_urls&amp;gt;] permission to use this method.</summary>
         /// <param name="windowId">The target window. Defaults to the $(topic:current-window)[current window].</param>
         /// <param name="options"></param>
         /// <returns>A data URL which encodes an image of the visible area of the captured tab. May be assigned to the 'src' property of an HTML Image element for display.</returns>
+        [JsAccessPath("captureVisibleTab")]
         ValueTask<string> CaptureVisibleTab(int? windowId = null, ImageDetails options = null);
 
         /// <summary>Connects to the content script(s) in the specified tab. The $(ref:runtime.onConnect) event is fired in each content script running in the specified tab for the current extension. For more details, see $(topic:messaging)[Content Script Messaging].</summary>
         /// <param name="tabId"></param>
         /// <param name="connectInfo"></param>
         /// <returns>A port that can be used to communicate with the content scripts running in the specified tab. The port's $(ref:runtime.Port) event is fired if the tab closes or does not exist. </returns>
+        [JsAccessPath("connect")]
         ValueTask<Port> Connect(int tabId, ConnectInfo connectInfo = null);
 
         /// <summary>Creates a new tab.</summary>
         /// <param name="createProperties"></param>
         /// <returns>Details about the created tab. Will contain the ID of the new tab.</returns>
+        [JsAccessPath("create")]
         ValueTask<Tab> Create(CreateProperties createProperties);
 
         /// <summary>Detects the primary language of the content in a tab.</summary>
         /// <param name="tabId">Defaults to the active tab of the $(topic:current-window)[current window].</param>
         /// <returns>An ISO language code such as <c>en</c> or <c>fr</c>. For a complete list of languages supported by this method, see <see href='http://src.chromium.org/viewvc/chrome/trunk/src/third_party/cld/languages/internal/languages.cc'>kLanguageInfoTable</see>. The 2nd to 4th columns will be checked and the first non-NULL value will be returned except for Simplified Chinese for which zh-CN will be returned. For an unknown language, <c>und</c> will be returned.</returns>
+        [JsAccessPath("detectLanguage")]
         ValueTask<string> DetectLanguage(int? tabId = null);
 
         /// <summary>discards one or more tabs.</summary>
         /// <param name="tabIds">The tab or list of tabs to discard.</param>
+        [JsAccessPath("discard")]
         ValueTask Discard(int tabIds);
 
         /// <summary>discards one or more tabs.</summary>
         /// <param name="tabIds">The tab or list of tabs to discard.</param>
+        [JsAccessPath("discard")]
         ValueTask Discard(IEnumerable<int> tabIds);
 
         /// <summary>Duplicates a tab.</summary>
         /// <param name="tabId">The ID of the tab which is to be duplicated.</param>
         /// <param name="duplicateProperties"></param>
         /// <returns>Details about the duplicated tab. The $(ref:tabs.Tab) object doesn't contain <c>url</c>, <c>title</c> and <c>favIconUrl</c> if the <c>"tabs"</c> permission has not been requested.</returns>
+        [JsAccessPath("duplicate")]
         ValueTask<Tab> Duplicate(int tabId, DuplicateProperties duplicateProperties = null);
 
         /// <summary>Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="details">Details of the script to run.</param>
         /// <returns>The result of the script in every injected frame.</returns>
+        [JsAccessPath("executeScript")]
         ValueTask<IEnumerable<object>> ExecuteScript(InjectDetails details);
 
         /// <summary>Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="tabId">The ID of the tab in which to run the script; defaults to the active tab of the current window.</param>
         /// <param name="details">Details of the script to run.</param>
         /// <returns>The result of the script in every injected frame.</returns>
+        [JsAccessPath("executeScript")]
         ValueTask<IEnumerable<object>> ExecuteScript(int? tabId, InjectDetails details);
 
         /// <summary>Retrieves details about the specified tab.</summary>
         /// <param name="tabId"></param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<Tab> Get(int tabId);
 
         /// <summary>Gets the tab that this script call is being made from. May be undefined if called from a non-tab context (for example: a background page or popup view).</summary>
         /// <returns></returns>
+        [JsAccessPath("getCurrent")]
         ValueTask<Tab> GetCurrent();
 
         /// <summary>Gets the current zoom factor of a specified tab.</summary>
         /// <param name="tabId">The ID of the tab to get the current zoom factor from; defaults to the active tab of the current window.</param>
         /// <returns>The tab's current zoom factor.</returns>
+        [JsAccessPath("getZoom")]
         ValueTask<double> GetZoom(int? tabId = null);
 
         /// <summary>Gets the current zoom settings of a specified tab.</summary>
         /// <param name="tabId">The ID of the tab to get the current zoom settings from; defaults to the active tab of the current window.</param>
         /// <returns>The tab's current zoom settings.</returns>
+        [JsAccessPath("getZoomSettings")]
         ValueTask<ZoomSettings> GetZoomSettings(int? tabId = null);
 
         /// <summary>Navigate to previous page in tab's history, if available.</summary>
         /// <param name="tabId">The ID of the tab to navigate backward.</param>
+        [JsAccessPath("goBack")]
         ValueTask GoBack(int? tabId = null);
 
         /// <summary>Navigate to next page in tab's history, if available</summary>
         /// <param name="tabId">The ID of the tab to navigate forward.</param>
+        [JsAccessPath("goForward")]
         ValueTask GoForward(int? tabId = null);
 
         /// <summary>Hides one or more tabs. The <c>"tabHide"</c> permission is required to hide tabs.  Not all tabs are hidable.  Returns an array of hidden tabs.</summary>
         /// <param name="tabIds">The TAB ID or list of TAB IDs to hide.</param>
+        [JsAccessPath("hide")]
         ValueTask Hide(int tabIds);
 
         /// <summary>Hides one or more tabs. The <c>"tabHide"</c> permission is required to hide tabs.  Not all tabs are hidable.  Returns an array of hidden tabs.</summary>
         /// <param name="tabIds">The TAB ID or list of TAB IDs to hide.</param>
+        [JsAccessPath("hide")]
         ValueTask Hide(IEnumerable<int> tabIds);
 
         /// <summary>Highlights the given tabs.</summary>
         /// <param name="highlightInfo"></param>
         /// <returns>Contains details about the window whose tabs were highlighted.</returns>
+        [JsAccessPath("highlight")]
         ValueTask<Window> Highlight(HighlightHighlightInfo highlightInfo);
 
         /// <summary>Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="details">Details of the CSS text to insert.</param>
+        [JsAccessPath("insertCSS")]
         ValueTask InsertCSS(InjectDetails details);
 
         /// <summary>Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="tabId">The ID of the tab in which to insert the CSS; defaults to the active tab of the current window.</param>
         /// <param name="details">Details of the CSS text to insert.</param>
+        [JsAccessPath("insertCSS")]
         ValueTask InsertCSS(int? tabId, InjectDetails details);
 
         /// <summary>Moves one or more tabs to a new position within its window, or to a new window. Note that tabs can only be moved to and from normal (window.type === "normal") windows.</summary>
         /// <param name="tabIds">The tab or list of tabs to move.</param>
         /// <param name="moveProperties"></param>
         /// <returns>Details about the moved tabs.</returns>
+        [JsAccessPath("move")]
         ValueTask<CallbackTabs> Move(int tabIds, MoveProperties moveProperties);
 
         /// <summary>Moves one or more tabs to a new position within its window, or to a new window. Note that tabs can only be moved to and from normal (window.type === "normal") windows.</summary>
         /// <param name="tabIds">The tab or list of tabs to move.</param>
         /// <param name="moveProperties"></param>
         /// <returns>Details about the moved tabs.</returns>
+        [JsAccessPath("move")]
         ValueTask<CallbackTabs> Move(IEnumerable<int> tabIds, MoveProperties moveProperties);
 
         /// <summary>Removes an array of tabs from their lines of succession and prepends or appends them in a chain to another tab.</summary>
         /// <param name="tabIds">An array of tab IDs to move in the line of succession. For each tab in the array, the tab's current predecessors will have their successor set to the tab's current successor, and each tab will then be set to be the successor of the previous tab in the array. Any tabs not in the same window as the tab indicated by the second argument (or the first tab in the array, if no second argument) will be skipped.</param>
         /// <param name="tabId">The ID of a tab to set as the successor of the last tab in the array, or $(ref:tabs.TAB_ID_NONE) to leave the last tab without a successor. If options.append is true, then this tab is made the predecessor of the first tab in the array instead.</param>
         /// <param name="options"></param>
+        [JsAccessPath("moveInSuccession")]
         ValueTask MoveInSuccession(IEnumerable<int> tabIds, int? tabId = null, MoveInSuccessionOptions options = null);
 
         /// <summary>Prints page in active tab.</summary>
+        [JsAccessPath("print")]
         ValueTask Print();
 
         /// <summary>Shows print preview for page in active tab.</summary>
+        [JsAccessPath("printPreview")]
         ValueTask PrintPreview();
 
         /// <summary>Gets all tabs that have the specified properties, or all tabs if no properties are specified.</summary>
         /// <param name="queryInfo"></param>
         /// <returns></returns>
+        [JsAccessPath("query")]
         ValueTask<IEnumerable<Tab>> Query(QueryInfo queryInfo);
 
         /// <summary>Reload a tab.</summary>
         /// <param name="tabId">The ID of the tab to reload; defaults to the selected tab of the current window.</param>
         /// <param name="reloadProperties"></param>
+        [JsAccessPath("reload")]
         ValueTask Reload(int? tabId = null, ReloadProperties reloadProperties = null);
 
         /// <summary>Closes one or more tabs.</summary>
         /// <param name="tabIds">The tab or list of tabs to close.</param>
+        [JsAccessPath("remove")]
         ValueTask Remove(int tabIds);
 
         /// <summary>Closes one or more tabs.</summary>
         /// <param name="tabIds">The tab or list of tabs to close.</param>
+        [JsAccessPath("remove")]
         ValueTask Remove(IEnumerable<int> tabIds);
 
         /// <summary>Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="details">Details of the CSS text to remove.</param>
+        [JsAccessPath("removeCSS")]
         ValueTask RemoveCSS(InjectDetails details);
 
         /// <summary>Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection] section of the content scripts doc.</summary>
         /// <param name="tabId">The ID of the tab from which to remove the injected CSS; defaults to the active tab of the current window.</param>
         /// <param name="details">Details of the CSS text to remove.</param>
+        [JsAccessPath("removeCSS")]
         ValueTask RemoveCSS(int? tabId, InjectDetails details);
 
         /// <summary>Saves page in active tab as a PDF file.</summary>
         /// <param name="pageSettings">The page settings used to save the PDF file.</param>
         /// <returns>Save status: saved, replaced, canceled, not_saved, not_replaced.</returns>
+        [JsAccessPath("saveAsPDF")]
         ValueTask<string> SaveAsPDF(PageSettings pageSettings);
 
         /// <summary>Sends a single message to the content script(s) in the specified tab, with an optional callback to run when a response is sent back.  The $(ref:runtime.onMessage) event is fired in each content script running in the specified tab for the current extension.</summary>
@@ -205,51 +251,62 @@ public partial interface ITabsApi
         /// <param name="message"></param>
         /// <param name="options"></param>
         /// <returns>The JSON response object sent by the handler of the message. If an error occurs while connecting to the specified tab, the callback will be called with no arguments and $(ref:runtime.lastError) will be set to the error message.</returns>
+        [JsAccessPath("sendMessage")]
         ValueTask<JsonElement> SendMessage(int tabId, object message, SendMessageOptions options = null);
 
         /// <summary>Zooms a specified tab.</summary>
         /// <param name="zoomFactor">The new zoom factor. Use a value of 0 here to set the tab to its current default zoom factor. Values greater than zero specify a (possibly non-default) zoom factor for the tab.</param>
+        [JsAccessPath("setZoom")]
         ValueTask SetZoom(double zoomFactor);
 
         /// <summary>Zooms a specified tab.</summary>
         /// <param name="tabId">The ID of the tab to zoom; defaults to the active tab of the current window.</param>
         /// <param name="zoomFactor">The new zoom factor. Use a value of 0 here to set the tab to its current default zoom factor. Values greater than zero specify a (possibly non-default) zoom factor for the tab.</param>
+        [JsAccessPath("setZoom")]
         ValueTask SetZoom(int? tabId, double zoomFactor);
 
         /// <summary>Sets the zoom settings for a specified tab, which define how zoom changes are handled. These settings are reset to defaults upon navigating the tab.</summary>
         /// <param name="zoomSettings">Defines how zoom changes are handled and at what scope.</param>
+        [JsAccessPath("setZoomSettings")]
         ValueTask SetZoomSettings(ZoomSettings zoomSettings);
 
         /// <summary>Sets the zoom settings for a specified tab, which define how zoom changes are handled. These settings are reset to defaults upon navigating the tab.</summary>
         /// <param name="tabId">The ID of the tab to change the zoom settings for; defaults to the active tab of the current window.</param>
         /// <param name="zoomSettings">Defines how zoom changes are handled and at what scope.</param>
+        [JsAccessPath("setZoomSettings")]
         ValueTask SetZoomSettings(int? tabId, ZoomSettings zoomSettings);
 
         /// <summary>Shows one or more tabs.</summary>
         /// <param name="tabIds">The TAB ID or list of TAB IDs to show.</param>
+        [JsAccessPath("show")]
         ValueTask Show(int tabIds);
 
         /// <summary>Shows one or more tabs.</summary>
         /// <param name="tabIds">The TAB ID or list of TAB IDs to show.</param>
+        [JsAccessPath("show")]
         ValueTask Show(IEnumerable<int> tabIds);
 
         /// <summary>Toggles reader mode for the document in the tab.</summary>
         /// <param name="tabId">Defaults to the active tab of the $(topic:current-window)[current window].</param>
+        [JsAccessPath("toggleReaderMode")]
         ValueTask ToggleReaderMode(int? tabId = null);
 
         /// <summary>Modifies the properties of a tab. Properties that are not specified in <c>updateProperties</c> are not modified.</summary>
         /// <param name="updateProperties"></param>
         /// <returns>Details about the updated tab. The $(ref:tabs.Tab) object doesn't contain <c>url</c>, <c>title</c> and <c>favIconUrl</c> if the <c>"tabs"</c> permission has not been requested.</returns>
+        [JsAccessPath("update")]
         ValueTask<Tab> Update(UpdateProperties updateProperties);
 
         /// <summary>Modifies the properties of a tab. Properties that are not specified in <c>updateProperties</c> are not modified.</summary>
         /// <param name="tabId">Defaults to the selected tab of the $(topic:current-window)[current window].</param>
         /// <param name="updateProperties"></param>
         /// <returns>Details about the updated tab. The $(ref:tabs.Tab) object doesn't contain <c>url</c>, <c>title</c> and <c>favIconUrl</c> if the <c>"tabs"</c> permission has not been requested.</returns>
+        [JsAccessPath("update")]
         ValueTask<Tab> Update(int? tabId, UpdateProperties updateProperties);
 
         /// <summary>Warm up a tab</summary>
         /// <param name="tabId">The ID of the tab to warm up.</param>
+        [JsAccessPath("warmup")]
         ValueTask Warmup(int? tabId = null);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Tabs/MoveInSuccessionOptions.cs b/src/WebExtensions.Net/Generated/Tabs/MoveInSuccessionOptions.cs
index a7afded..fb4d595 100644
--- a/src/WebExtensions.Net/Generated/Tabs/MoveInSuccessionOptions.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/MoveInSuccessionOptions.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Tabs
     public partial class MoveInSuccessionOptions : BaseObject
     {
         /// <summary>Whether to move the tabs before (false) or after (true) tabId in the succession. Defaults to false.</summary>
+        [JsAccessPath("append")]
         [JsonPropertyName("append")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Append { get; set; }
 
         /// <summary>Whether to link up the current predecessors or successor (depending on options.append) of tabId to the other side of the chain after it is prepended or appended. If true, one of the following happens: if options.append is false, the first tab in the array is set as the successor of any current predecessors of tabId; if options.append is true, the current successor of tabId is set as the successor of the last tab in the array. Defaults to false.</summary>
+        [JsAccessPath("insert")]
         [JsonPropertyName("insert")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Insert { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/MoveInfo.cs b/src/WebExtensions.Net/Generated/Tabs/MoveInfo.cs
index 66f5d48..8bf0a71 100644
--- a/src/WebExtensions.Net/Generated/Tabs/MoveInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/MoveInfo.cs
@@ -9,14 +9,17 @@ namespace WebExtensions.Net.Tabs
     public partial class MoveInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("fromIndex")]
         [JsonPropertyName("fromIndex")]
         public int FromIndex { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("toIndex")]
         [JsonPropertyName("toIndex")]
         public int ToIndex { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         public int WindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/MoveProperties.cs b/src/WebExtensions.Net/Generated/Tabs/MoveProperties.cs
index df523a6..8b51053 100644
--- a/src/WebExtensions.Net/Generated/Tabs/MoveProperties.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/MoveProperties.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Tabs
     public partial class MoveProperties : BaseObject
     {
         /// <summary>The position to move the window to. -1 will place the tab at the end of the window.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         public int Index { get; set; }
 
         /// <summary>Defaults to the window the tab is currently in.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/MutedInfo.cs b/src/WebExtensions.Net/Generated/Tabs/MutedInfo.cs
index 5fbc32d..ee5d3c4 100644
--- a/src/WebExtensions.Net/Generated/Tabs/MutedInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/MutedInfo.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Tabs
     public partial class MutedInfo : BaseObject
     {
         /// <summary>The ID of the extension that changed the muted state. Not set if an extension was not the reason the muted state last changed.</summary>
+        [JsAccessPath("extensionId")]
         [JsonPropertyName("extensionId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ExtensionId { get; set; }
 
         /// <summary>Whether the tab is prevented from playing sound (but hasn't necessarily recently produced sound). Equivalent to whether the muted audio indicator is showing.</summary>
+        [JsAccessPath("muted")]
         [JsonPropertyName("muted")]
         public bool Muted { get; set; }
 
         /// <summary>The reason the tab was muted or unmuted. Not set if the tab's mute state has never been changed.</summary>
+        [JsAccessPath("reason")]
         [JsonPropertyName("reason")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public MutedInfoReason? Reason { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnActivatedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnActivatedEvent.cs
index ac231e0..dcc3e09 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnActivatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnActivatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnActivatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fires when the active tab in a window changes. Note that the tab's URL may not be set at the time this event fired, but you can listen to onUpdated events to be notified when a URL is set.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ActiveInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ActiveInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ActiveInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ActiveInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ActiveInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnAttachedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnAttachedEvent.cs
index fec9c65..b39df78 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnAttachedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnAttachedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnAttachedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is attached to a window, for example because it was moved between windows.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, AttachInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, AttachInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, AttachInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int, AttachInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, AttachInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnCreatedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnCreatedEvent.cs
index d2180f1..65d8fa2 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnCreatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnCreatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCreatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is created. Note that the tab's URL may not be set at the time this event fired, but you can listen to onUpdated events to be notified when a URL is set.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Tab> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Tab> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Tab> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Tab> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Tab> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnDetachedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnDetachedEvent.cs
index 950ab5f..4e18a66 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnDetachedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnDetachedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnDetachedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is detached from a window, for example because it is being moved between windows.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, DetachInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, DetachInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, DetachInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int, DetachInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, DetachInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnHighlightedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnHighlightedEvent.cs
index 2ada0d2..f527811 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnHighlightedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnHighlightedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnHighlightedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the highlighted or selected tabs in a window changes.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<CallbackHighlightInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<CallbackHighlightInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<CallbackHighlightInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<CallbackHighlightInfo> callbac
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<CallbackHighlightInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnMovedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnMovedEvent.cs
index 7d1b7cc..a22da59 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnMovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnMovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnMovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is moved within a window. Only one move event is fired, representing the tab the user directly moved. Move events are not fired for the other tabs that must move in response. This event is not fired when a tab is moved between windows. For that, see $(ref:tabs.onDetached).</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, MoveInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, MoveInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, MoveInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int, MoveInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, MoveInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnRemovedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnRemovedEvent.cs
index ba0ded0..535ae3e 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnRemovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnRemovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnRemovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is closed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, RemoveInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, RemoveInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, RemoveInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int, RemoveInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, RemoveInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnReplacedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnReplacedEvent.cs
index fdcd58e..901586f 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnReplacedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnReplacedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnReplacedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is replaced with another tab due to prerendering or instant.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, int> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, int> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, int> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int, int> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, int> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnUpdatedEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnUpdatedEvent.cs
index 99fa2bf..9837d0a 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnUpdatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnUpdatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnUpdatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is updated.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, ChangeInfo, Tab> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int, ChangeInfo, Tab> callback)
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is updated.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int, ChangeInfo, Tab> callback, UpdateFilter filter)
         {
             return InvokeVoidAsync("addListener", callback, filter);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<int, ChangeInfo, Tab> callback, Upda
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, ChangeInfo, Tab> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<int, ChangeInfo, Tab> callback
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int, ChangeInfo, Tab> callback, UpdateFilter filter)
         {
             return InvokeAsync<bool>("hasListener", callback, filter);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<int, ChangeInfo, Tab> callback
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, ChangeInfo, Tab> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<int, ChangeInfo, Tab> callback)
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int, ChangeInfo, Tab> callback, UpdateFilter filter)
         {
             return InvokeVoidAsync("removeListener", callback, filter);
diff --git a/src/WebExtensions.Net/Generated/Tabs/OnZoomChangeEvent.cs b/src/WebExtensions.Net/Generated/Tabs/OnZoomChangeEvent.cs
index 80e7397..9ccb386 100644
--- a/src/WebExtensions.Net/Generated/Tabs/OnZoomChangeEvent.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/OnZoomChangeEvent.cs
@@ -12,6 +12,7 @@ public partial class OnZoomChangeEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a tab is zoomed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<ZoomChangeInfo> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<ZoomChangeInfo> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<ZoomChangeInfo> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<ZoomChangeInfo> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<ZoomChangeInfo> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Tabs/PageSettings.cs b/src/WebExtensions.Net/Generated/Tabs/PageSettings.cs
index 00c6719..d3207c9 100644
--- a/src/WebExtensions.Net/Generated/Tabs/PageSettings.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/PageSettings.cs
@@ -9,116 +9,139 @@ namespace WebExtensions.Net.Tabs
     public partial class PageSettings : BaseObject
     {
         /// <summary>The spacing between the bottom of the footers and the bottom edge of the paper (inches). Default: 0.</summary>
+        [JsAccessPath("edgeBottom")]
         [JsonPropertyName("edgeBottom")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? EdgeBottom { get; set; }
 
         /// <summary>The spacing between the left header/footer and the left edge of the paper (inches). Default: 0.</summary>
+        [JsAccessPath("edgeLeft")]
         [JsonPropertyName("edgeLeft")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? EdgeLeft { get; set; }
 
         /// <summary>The spacing between the right header/footer and the right edge of the paper (inches). Default: 0.</summary>
+        [JsAccessPath("edgeRight")]
         [JsonPropertyName("edgeRight")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? EdgeRight { get; set; }
 
         /// <summary>The spacing between the top of the headers and the top edge of the paper (inches). Default: 0</summary>
+        [JsAccessPath("edgeTop")]
         [JsonPropertyName("edgeTop")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? EdgeTop { get; set; }
 
         /// <summary>The text for the page's center footer. Default: ''.</summary>
+        [JsAccessPath("footerCenter")]
         [JsonPropertyName("footerCenter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FooterCenter { get; set; }
 
         /// <summary>The text for the page's left footer. Default: '&amp;PT'.</summary>
+        [JsAccessPath("footerLeft")]
         [JsonPropertyName("footerLeft")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FooterLeft { get; set; }
 
         /// <summary>The text for the page's right footer. Default: '&amp;D'.</summary>
+        [JsAccessPath("footerRight")]
         [JsonPropertyName("footerRight")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FooterRight { get; set; }
 
         /// <summary>The text for the page's center header. Default: ''.</summary>
+        [JsAccessPath("headerCenter")]
         [JsonPropertyName("headerCenter")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HeaderCenter { get; set; }
 
         /// <summary>The text for the page's left header. Default: '&amp;T'.</summary>
+        [JsAccessPath("headerLeft")]
         [JsonPropertyName("headerLeft")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HeaderLeft { get; set; }
 
         /// <summary>The text for the page's right header. Default: '&amp;U'.</summary>
+        [JsAccessPath("headerRight")]
         [JsonPropertyName("headerRight")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string HeaderRight { get; set; }
 
         /// <summary>The margin between the page content and the bottom edge of the paper (inches). Default: 0.5.</summary>
+        [JsAccessPath("marginBottom")]
         [JsonPropertyName("marginBottom")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? MarginBottom { get; set; }
 
         /// <summary>The margin between the page content and the left edge of the paper (inches). Default: 0.5.</summary>
+        [JsAccessPath("marginLeft")]
         [JsonPropertyName("marginLeft")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? MarginLeft { get; set; }
 
         /// <summary>The margin between the page content and the right edge of the paper (inches). Default: 0.5.</summary>
+        [JsAccessPath("marginRight")]
         [JsonPropertyName("marginRight")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? MarginRight { get; set; }
 
         /// <summary>The margin between the page content and the top edge of the paper (inches). Default: 0.5.</summary>
+        [JsAccessPath("marginTop")]
         [JsonPropertyName("marginTop")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? MarginTop { get; set; }
 
         /// <summary>The page content orientation: 0 = portrait, 1 = landscape. Default: 0.</summary>
+        [JsAccessPath("orientation")]
         [JsonPropertyName("orientation")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Orientation { get; set; }
 
         /// <summary>The paper height in paper size units. Default: 11.0.</summary>
+        [JsAccessPath("paperHeight")]
         [JsonPropertyName("paperHeight")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? PaperHeight { get; set; }
 
         /// <summary>The page size unit: 0 = inches, 1 = millimeters. Default: 0.</summary>
+        [JsAccessPath("paperSizeUnit")]
         [JsonPropertyName("paperSizeUnit")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? PaperSizeUnit { get; set; }
 
         /// <summary>The paper width in paper size units. Default: 8.5.</summary>
+        [JsAccessPath("paperWidth")]
         [JsonPropertyName("paperWidth")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? PaperWidth { get; set; }
 
         /// <summary>The page content scaling factor: 1.0 = 100% = normal size. Default: 1.0.</summary>
+        [JsAccessPath("scaling")]
         [JsonPropertyName("scaling")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? Scaling { get; set; }
 
         /// <summary>Whether the page background colors should be shown. Default: false.</summary>
+        [JsAccessPath("showBackgroundColors")]
         [JsonPropertyName("showBackgroundColors")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ShowBackgroundColors { get; set; }
 
         /// <summary>Whether the page background images should be shown. Default: false.</summary>
+        [JsAccessPath("showBackgroundImages")]
         [JsonPropertyName("showBackgroundImages")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ShowBackgroundImages { get; set; }
 
         /// <summary>Whether the page content should shrink to fit the page width (overrides scaling). Default: true.</summary>
+        [JsAccessPath("shrinkToFit")]
         [JsonPropertyName("shrinkToFit")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ShrinkToFit { get; set; }
 
         /// <summary>The name of the file. May include optional .pdf extension.</summary>
+        [JsAccessPath("toFileName")]
         [JsonPropertyName("toFileName")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string ToFileName { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/QueryInfo.cs b/src/WebExtensions.Net/Generated/Tabs/QueryInfo.cs
index ab09fc4..80915f5 100644
--- a/src/WebExtensions.Net/Generated/Tabs/QueryInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/QueryInfo.cs
@@ -9,111 +9,133 @@ namespace WebExtensions.Net.Tabs
     public partial class QueryInfo : BaseObject
     {
         /// <summary>Whether the tabs are active in their windows.</summary>
+        [JsAccessPath("active")]
         [JsonPropertyName("active")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Active { get; set; }
 
         /// <summary>Whether the tabs are drawing attention.</summary>
+        [JsAccessPath("attention")]
         [JsonPropertyName("attention")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Attention { get; set; }
 
         /// <summary>Whether the tabs are audible.</summary>
+        [JsAccessPath("audible")]
         [JsonPropertyName("audible")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Audible { get; set; }
 
         /// <summary>Whether the tab can be discarded automatically by the browser when resources are low.</summary>
+        [JsAccessPath("autoDiscardable")]
         [JsonPropertyName("autoDiscardable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AutoDiscardable { get; set; }
 
         /// <summary>True if the tab is using the camera.</summary>
+        [JsAccessPath("camera")]
         [JsonPropertyName("camera")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Camera { get; set; }
 
         /// <summary>The CookieStoreId used for the tab.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public CookieStoreId CookieStoreId { get; set; }
 
         /// <summary>Whether the tabs are in the $(topic:current-window)[current window].</summary>
+        [JsAccessPath("currentWindow")]
         [JsonPropertyName("currentWindow")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? CurrentWindow { get; set; }
 
         /// <summary>True while the tabs are not loaded with content.</summary>
+        [JsAccessPath("discarded")]
         [JsonPropertyName("discarded")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Discarded { get; set; }
 
         /// <summary>True while the tabs are hidden.</summary>
+        [JsAccessPath("hidden")]
         [JsonPropertyName("hidden")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Hidden { get; set; }
 
         /// <summary>Whether the tabs are highlighted.  Works as an alias of active.</summary>
+        [JsAccessPath("highlighted")]
         [JsonPropertyName("highlighted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Highlighted { get; set; }
 
         /// <summary>The position of the tabs within their windows.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Index { get; set; }
 
         /// <summary>Whether the tabs are in the last focused window.</summary>
+        [JsAccessPath("lastFocusedWindow")]
         [JsonPropertyName("lastFocusedWindow")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? LastFocusedWindow { get; set; }
 
         /// <summary>True if the tab is using the microphone.</summary>
+        [JsAccessPath("microphone")]
         [JsonPropertyName("microphone")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Microphone { get; set; }
 
         /// <summary>Whether the tabs are muted.</summary>
+        [JsAccessPath("muted")]
         [JsonPropertyName("muted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Muted { get; set; }
 
         /// <summary>The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.</summary>
+        [JsAccessPath("openerTabId")]
         [JsonPropertyName("openerTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? OpenerTabId { get; set; }
 
         /// <summary>Whether the tabs are pinned.</summary>
+        [JsAccessPath("pinned")]
         [JsonPropertyName("pinned")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Pinned { get; set; }
 
         /// <summary>True for any screen sharing, or a string to specify type of screen sharing.</summary>
+        [JsAccessPath("screen")]
         [JsonPropertyName("screen")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Screen Screen { get; set; }
 
         /// <summary>Whether the tabs have completed loading.</summary>
+        [JsAccessPath("status")]
         [JsonPropertyName("status")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public TabStatus? Status { get; set; }
 
         /// <summary>Match page titles against a pattern.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>Match tabs against one or more $(topic:match_patterns)[URL patterns]. Note that fragment identifiers are not matched.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Url Url { get; set; }
 
         /// <summary>The ID of the parent window, or $(ref:windows.WINDOW_ID_CURRENT) for the $(topic:current-window)[current window].</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
 
         /// <summary>The type of window the tabs are in.</summary>
+        [JsAccessPath("windowType")]
         [JsonPropertyName("windowType")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public WindowType? WindowType { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ReloadProperties.cs b/src/WebExtensions.Net/Generated/Tabs/ReloadProperties.cs
index 4198bf3..cbc6612 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ReloadProperties.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ReloadProperties.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Tabs
     public partial class ReloadProperties : BaseObject
     {
         /// <summary>Whether using any local cache. Default is false.</summary>
+        [JsAccessPath("bypassCache")]
         [JsonPropertyName("bypassCache")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? BypassCache { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/RemoveInfo.cs b/src/WebExtensions.Net/Generated/Tabs/RemoveInfo.cs
index 1f1fc8e..49221b6 100644
--- a/src/WebExtensions.Net/Generated/Tabs/RemoveInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/RemoveInfo.cs
@@ -9,10 +9,12 @@ namespace WebExtensions.Net.Tabs
     public partial class RemoveInfo : BaseObject
     {
         /// <summary>True when the tab is being closed because its window is being closed.</summary>
+        [JsAccessPath("isWindowClosing")]
         [JsonPropertyName("isWindowClosing")]
         public bool IsWindowClosing { get; set; }
 
         /// <summary>The window whose tab is closed.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         public int WindowId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/Tabs/SendMessageOptions.cs b/src/WebExtensions.Net/Generated/Tabs/SendMessageOptions.cs
index 3a75f98..828a803 100644
--- a/src/WebExtensions.Net/Generated/Tabs/SendMessageOptions.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/SendMessageOptions.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Tabs
     public partial class SendMessageOptions : BaseObject
     {
         /// <summary>Send a message to a specific $(topic:frame_ids)[frame] identified by <c>frameId</c> instead of all frames in the tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? FrameId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/SharingState.cs b/src/WebExtensions.Net/Generated/Tabs/SharingState.cs
index 667bba4..a2a1753 100644
--- a/src/WebExtensions.Net/Generated/Tabs/SharingState.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/SharingState.cs
@@ -9,14 +9,17 @@ namespace WebExtensions.Net.Tabs
     public partial class SharingState : BaseObject
     {
         /// <summary>True if the tab is using the camera.</summary>
+        [JsAccessPath("camera")]
         [JsonPropertyName("camera")]
         public bool Camera { get; set; }
 
         /// <summary>True if the tab is using the microphone.</summary>
+        [JsAccessPath("microphone")]
         [JsonPropertyName("microphone")]
         public bool Microphone { get; set; }
 
         /// <summary>If the tab is sharing the screen the value will be one of "Screen", "Window", or "Application", or undefined if not screen sharing.</summary>
+        [JsAccessPath("screen")]
         [JsonPropertyName("screen")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Screen { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/Tab.cs b/src/WebExtensions.Net/Generated/Tabs/Tab.cs
index e2baee1..e637d12 100644
--- a/src/WebExtensions.Net/Generated/Tabs/Tab.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/Tab.cs
@@ -9,131 +9,158 @@ namespace WebExtensions.Net.Tabs
     public partial class Tab : BaseObject
     {
         /// <summary>Whether the tab is active in its window. (Does not necessarily mean the window is focused.)</summary>
+        [JsAccessPath("active")]
         [JsonPropertyName("active")]
         public bool Active { get; set; }
 
         /// <summary>Whether the tab is drawing attention.</summary>
+        [JsAccessPath("attention")]
         [JsonPropertyName("attention")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Attention { get; set; }
 
         /// <summary>Whether the tab has produced sound over the past couple of seconds (but it might not be heard if also muted). Equivalent to whether the speaker audio indicator is showing.</summary>
+        [JsAccessPath("audible")]
         [JsonPropertyName("audible")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Audible { get; set; }
 
         /// <summary>Whether the tab can be discarded automatically by the browser when resources are low.</summary>
+        [JsAccessPath("autoDiscardable")]
         [JsonPropertyName("autoDiscardable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AutoDiscardable { get; set; }
 
         /// <summary>The CookieStoreId used for the tab.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>True while the tab is not loaded with content.</summary>
+        [JsAccessPath("discarded")]
         [JsonPropertyName("discarded")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Discarded { get; set; }
 
         /// <summary>The URL of the tab's favicon. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission. It may also be an empty string if the tab is loading.</summary>
+        [JsAccessPath("favIconUrl")]
         [JsonPropertyName("favIconUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string FavIconUrl { get; set; }
 
         /// <summary>The height of the tab in pixels.</summary>
+        [JsAccessPath("height")]
         [JsonPropertyName("height")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Height { get; set; }
 
         /// <summary>True if the tab is hidden.</summary>
+        [JsAccessPath("hidden")]
         [JsonPropertyName("hidden")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Hidden { get; set; }
 
         /// <summary>Whether the tab is highlighted. Works as an alias of active</summary>
+        [JsAccessPath("highlighted")]
         [JsonPropertyName("highlighted")]
         public bool Highlighted { get; set; }
 
         /// <summary>The ID of the tab. Tab IDs are unique within a browser session. Under some circumstances a Tab may not be assigned an ID, for example when querying foreign tabs using the $(ref:sessions) API, in which case a session ID may be present. Tab ID can also be set to $(ref:tabs.TAB_ID_NONE) for apps and devtools windows.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Id { get; set; }
 
         /// <summary>Whether the tab is in an incognito window.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         public bool Incognito { get; set; }
 
         /// <summary>The zero-based index of the tab within its window.</summary>
+        [JsAccessPath("index")]
         [JsonPropertyName("index")]
         public int Index { get; set; }
 
         /// <summary>Whether the document in the tab can be rendered in reader mode.</summary>
+        [JsAccessPath("isArticle")]
         [JsonPropertyName("isArticle")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsArticle { get; set; }
 
         /// <summary>Whether the document in the tab is being rendered in reader mode.</summary>
+        [JsAccessPath("isInReaderMode")]
         [JsonPropertyName("isInReaderMode")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IsInReaderMode { get; set; }
 
         /// <summary>The last time the tab was accessed as the number of milliseconds since epoch.</summary>
+        [JsAccessPath("lastAccessed")]
         [JsonPropertyName("lastAccessed")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public EpochTime? LastAccessed { get; set; }
 
         /// <summary>Current tab muted state and the reason for the last state change.</summary>
+        [JsAccessPath("mutedInfo")]
         [JsonPropertyName("mutedInfo")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public MutedInfo MutedInfo { get; set; }
 
         /// <summary>The ID of the tab that opened this tab, if any. This property is only present if the opener tab still exists.</summary>
+        [JsAccessPath("openerTabId")]
         [JsonPropertyName("openerTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? OpenerTabId { get; set; }
 
         /// <summary>Whether the tab is pinned.</summary>
+        [JsAccessPath("pinned")]
         [JsonPropertyName("pinned")]
         public bool Pinned { get; set; }
 
         /// <summary>The session ID used to uniquely identify a Tab obtained from the $(ref:sessions) API.</summary>
+        [JsAccessPath("sessionId")]
         [JsonPropertyName("sessionId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SessionId { get; set; }
 
         /// <summary>Current tab sharing state for screen, microphone and camera.</summary>
+        [JsAccessPath("sharingState")]
         [JsonPropertyName("sharingState")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public SharingState SharingState { get; set; }
 
         /// <summary>Either <em>loading</em> or <em>complete</em>.</summary>
+        [JsAccessPath("status")]
         [JsonPropertyName("status")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Status { get; set; }
 
         /// <summary>The ID of this tab's successor, if any; $(ref:tabs.TAB_ID_NONE) otherwise.</summary>
+        [JsAccessPath("successorTabId")]
         [JsonPropertyName("successorTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? SuccessorTabId { get; set; }
 
         /// <summary>The title of the tab. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The URL the tab is displaying. This property is only present if the extension's manifest includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>The width of the tab in pixels.</summary>
+        [JsAccessPath("width")]
         [JsonPropertyName("width")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Width { get; set; }
 
         /// <summary>The ID of the window the tab is contained within.</summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/UpdateFilter.cs b/src/WebExtensions.Net/Generated/Tabs/UpdateFilter.cs
index 20a118b..52d6334 100644
--- a/src/WebExtensions.Net/Generated/Tabs/UpdateFilter.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/UpdateFilter.cs
@@ -10,21 +10,25 @@ namespace WebExtensions.Net.Tabs
     public partial class UpdateFilter : BaseObject
     {
         /// <summary>A list of property names. Events that do not match any of the names will be filtered out.</summary>
+        [JsAccessPath("properties")]
         [JsonPropertyName("properties")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<UpdatePropertyName> Properties { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>A list of URLs or URL patterns. Events that cannot match any of the URLs will be filtered out.  Filtering with urls requires the <c>"tabs"</c> or  <c>"activeTab"</c> permission.</summary>
+        [JsAccessPath("urls")]
         [JsonPropertyName("urls")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Urls { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/UpdateProperties.cs b/src/WebExtensions.Net/Generated/Tabs/UpdateProperties.cs
index 76af05a..58c2c9e 100644
--- a/src/WebExtensions.Net/Generated/Tabs/UpdateProperties.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/UpdateProperties.cs
@@ -9,46 +9,55 @@ namespace WebExtensions.Net.Tabs
     public partial class UpdateProperties : BaseObject
     {
         /// <summary>Whether the tab should be active. Does not affect whether the window is focused (see $(ref:windows.update)).</summary>
+        [JsAccessPath("active")]
         [JsonPropertyName("active")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Active { get; set; }
 
         /// <summary>Whether the tab can be discarded automatically by the browser when resources are low.</summary>
+        [JsAccessPath("autoDiscardable")]
         [JsonPropertyName("autoDiscardable")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AutoDiscardable { get; set; }
 
         /// <summary>Adds or removes the tab from the current selection.</summary>
+        [JsAccessPath("highlighted")]
         [JsonPropertyName("highlighted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Highlighted { get; set; }
 
         /// <summary>Whether the load should replace the current history entry for the tab.</summary>
+        [JsAccessPath("loadReplace")]
         [JsonPropertyName("loadReplace")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? LoadReplace { get; set; }
 
         /// <summary>Whether the tab should be muted.</summary>
+        [JsAccessPath("muted")]
         [JsonPropertyName("muted")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Muted { get; set; }
 
         /// <summary>The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.</summary>
+        [JsAccessPath("openerTabId")]
         [JsonPropertyName("openerTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? OpenerTabId { get; set; }
 
         /// <summary>Whether the tab should be pinned.</summary>
+        [JsAccessPath("pinned")]
         [JsonPropertyName("pinned")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Pinned { get; set; }
 
         /// <summary>The ID of this tab's successor. If specified, the successor tab must be in the same window as this tab.</summary>
+        [JsAccessPath("successorTabId")]
         [JsonPropertyName("successorTabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? SuccessorTabId { get; set; }
 
         /// <summary>A URL to navigate the tab to.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ZoomChangeInfo.cs b/src/WebExtensions.Net/Generated/Tabs/ZoomChangeInfo.cs
index fa51259..1dd31da 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ZoomChangeInfo.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ZoomChangeInfo.cs
@@ -9,18 +9,22 @@ namespace WebExtensions.Net.Tabs
     public partial class ZoomChangeInfo : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("newZoomFactor")]
         [JsonPropertyName("newZoomFactor")]
         public double NewZoomFactor { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("oldZoomFactor")]
         [JsonPropertyName("oldZoomFactor")]
         public double OldZoomFactor { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("zoomSettings")]
         [JsonPropertyName("zoomSettings")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ZoomSettings ZoomSettings { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Tabs/ZoomSettings.cs b/src/WebExtensions.Net/Generated/Tabs/ZoomSettings.cs
index ee63248..a31d7c9 100644
--- a/src/WebExtensions.Net/Generated/Tabs/ZoomSettings.cs
+++ b/src/WebExtensions.Net/Generated/Tabs/ZoomSettings.cs
@@ -9,16 +9,19 @@ namespace WebExtensions.Net.Tabs
     public partial class ZoomSettings : BaseObject
     {
         /// <summary>Used to return the default zoom level for the current tab in calls to tabs.getZoomSettings.</summary>
+        [JsAccessPath("defaultZoomFactor")]
         [JsonPropertyName("defaultZoomFactor")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public double? DefaultZoomFactor { get; set; }
 
         /// <summary>Defines how zoom changes are handled, i.e. which entity is responsible for the actual scaling of the page; defaults to <c>automatic</c>.</summary>
+        [JsAccessPath("mode")]
         [JsonPropertyName("mode")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ZoomSettingsMode? Mode { get; set; }
 
         /// <summary>Defines whether zoom changes will persist for the page's origin, or only take effect in this tab; defaults to <c>per-origin</c> when in <c>automatic</c> mode, and <c>per-tab</c> otherwise.</summary>
+        [JsAccessPath("scope")]
         [JsonPropertyName("scope")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public ZoomSettingsScope? Scope { get; set; }
diff --git a/src/WebExtensions.Net/Generated/TopSites/ITopSitesApi.cs b/src/WebExtensions.Net/Generated/TopSites/ITopSitesApi.cs
index 596751e..b34bbcc 100644
--- a/src/WebExtensions.Net/Generated/TopSites/ITopSitesApi.cs
+++ b/src/WebExtensions.Net/Generated/TopSites/ITopSitesApi.cs
@@ -1,14 +1,17 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.TopSites
 {
     /// <summary>Use the chrome.topSites API to access the top sites that are displayed on the new tab page. </summary>
+    [JsAccessPath("topSites")]
     public partial interface ITopSitesApi
     {
         /// <summary>Gets a list of top sites.</summary>
         /// <param name="options"></param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<IEnumerable<MostVisitedUrl>> Get(Options options = null);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/TopSites/MostVisitedUrl.cs b/src/WebExtensions.Net/Generated/TopSites/MostVisitedUrl.cs
index 6ea76fd..4a72417 100644
--- a/src/WebExtensions.Net/Generated/TopSites/MostVisitedUrl.cs
+++ b/src/WebExtensions.Net/Generated/TopSites/MostVisitedUrl.cs
@@ -9,21 +9,25 @@ namespace WebExtensions.Net.TopSites
     public partial class MostVisitedUrl : BaseObject
     {
         /// <summary>Data URL for the favicon, if available.</summary>
+        [JsAccessPath("favicon")]
         [JsonPropertyName("favicon")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Favicon { get; set; }
 
         /// <summary>The title of the page.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The entry type, either <c>url</c> for a normal page link, or <c>search</c> for a search shortcut.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Type { get; set; }
 
         /// <summary>The most visited URL.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/TopSites/Options.cs b/src/WebExtensions.Net/Generated/TopSites/Options.cs
index b2b6697..bf5aa34 100644
--- a/src/WebExtensions.Net/Generated/TopSites/Options.cs
+++ b/src/WebExtensions.Net/Generated/TopSites/Options.cs
@@ -11,42 +11,50 @@ namespace WebExtensions.Net.TopSites
     public partial class Options : BaseObject
     {
         /// <summary>Include sites that the user has blocked from appearing on the Firefox new tab.</summary>
+        [JsAccessPath("includeBlocked")]
         [JsonPropertyName("includeBlocked")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludeBlocked { get; set; }
 
         /// <summary>Include sites favicon if available.</summary>
+        [JsAccessPath("includeFavicon")]
         [JsonPropertyName("includeFavicon")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludeFavicon { get; set; }
 
         /// <summary>Include sites that the user has pinned on the Firefox new tab.</summary>
+        [JsAccessPath("includePinned")]
         [JsonPropertyName("includePinned")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludePinned { get; set; }
 
         /// <summary>Include search shortcuts appearing on the Firefox new tab.</summary>
+        [JsAccessPath("includeSearchShortcuts")]
         [JsonPropertyName("includeSearchShortcuts")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncludeSearchShortcuts { get; set; }
 
         /// <summary>The number of top sites to return, defaults to the value used by Firefox</summary>
+        [JsAccessPath("limit")]
         [JsonPropertyName("limit")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Limit { get; set; }
 
         /// <summary>Return the sites that exactly appear on the user's new-tab page. When true, all other options are ignored except limit and includeFavicon. If the user disabled newtab Top Sites, the newtab parameter will be ignored.</summary>
+        [JsAccessPath("newtab")]
         [JsonPropertyName("newtab")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Newtab { get; set; }
 
         /// <summary>Limit the result to a single top site link per domain</summary>
+        [JsAccessPath("onePerDomain")]
         [JsonPropertyName("onePerDomain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? OnePerDomain { get; set; }
 
         /// <summary></summary>
         [Obsolete("Please use the other options to tune the results received from topSites.")]
+        [JsAccessPath("providers")]
         [JsonPropertyName("providers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Providers { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Types/CallbackDetails.cs b/src/WebExtensions.Net/Generated/Types/CallbackDetails.cs
index 46e5941..3b9dc63 100644
--- a/src/WebExtensions.Net/Generated/Types/CallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/Types/CallbackDetails.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.Types
     public partial class CallbackDetails : BaseObject
     {
         /// <summary>Whether the effective value is specific to the incognito session.<br/>This property will <em>only</em> be present if the <c>incognito</c> property in the <c>details</c> parameter of <c>get()</c> was true.</summary>
+        [JsAccessPath("incognitoSpecific")]
         [JsonPropertyName("incognitoSpecific")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? IncognitoSpecific { get; set; }
 
         /// <summary>The level of control of the setting.</summary>
+        [JsAccessPath("levelOfControl")]
         [JsonPropertyName("levelOfControl")]
         public LevelOfControl LevelOfControl { get; set; }
 
         /// <summary>The value of the setting.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Types/ClearDetails.cs b/src/WebExtensions.Net/Generated/Types/ClearDetails.cs
index 653a6cf..abcd0db 100644
--- a/src/WebExtensions.Net/Generated/Types/ClearDetails.cs
+++ b/src/WebExtensions.Net/Generated/Types/ClearDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Types
     public partial class ClearDetails : BaseObject
     {
         /// <summary>Where to clear the setting (default: regular).</summary>
+        [JsAccessPath("scope")]
         [JsonPropertyName("scope")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public SettingScope? Scope { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Types/GetDetails.cs b/src/WebExtensions.Net/Generated/Types/GetDetails.cs
index c6a887b..0e28a60 100644
--- a/src/WebExtensions.Net/Generated/Types/GetDetails.cs
+++ b/src/WebExtensions.Net/Generated/Types/GetDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.Types
     public partial class GetDetails : BaseObject
     {
         /// <summary>Whether to return the value that applies to the incognito session (default false).</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Types/SetDetails.cs b/src/WebExtensions.Net/Generated/Types/SetDetails.cs
index c1e90a1..992d935 100644
--- a/src/WebExtensions.Net/Generated/Types/SetDetails.cs
+++ b/src/WebExtensions.Net/Generated/Types/SetDetails.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.Types
     public partial class SetDetails : BaseObject
     {
         /// <summary>Where to set the setting (default: regular).</summary>
+        [JsAccessPath("scope")]
         [JsonPropertyName("scope")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public SettingScope? Scope { get; set; }
 
         /// <summary>The value of the setting. <br/>Note that every setting has a specific value type, which is described together with the setting. An extension should <em>not</em> set a value of a different type.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Types/Setting.cs b/src/WebExtensions.Net/Generated/Types/Setting.cs
index 84639e2..71752e5 100644
--- a/src/WebExtensions.Net/Generated/Types/Setting.cs
+++ b/src/WebExtensions.Net/Generated/Types/Setting.cs
@@ -10,6 +10,7 @@ public partial class Setting : BaseObject
     {
         /// <summary>Clears the setting, restoring any default value.</summary>
         /// <param name="details">Which setting to clear.</param>
+        [JsAccessPath("clear")]
         public virtual ValueTask Clear(ClearDetails details)
         {
             return InvokeVoidAsync("clear", details);
@@ -18,6 +19,7 @@ public virtual ValueTask Clear(ClearDetails details)
         /// <summary>Gets the value of a setting.</summary>
         /// <param name="details">Which setting to consider.</param>
         /// <returns>Details of the currently effective value.</returns>
+        [JsAccessPath("get")]
         public virtual ValueTask<CallbackDetails> Get(GetDetails details)
         {
             return InvokeAsync<CallbackDetails>("get", details);
@@ -25,6 +27,7 @@ public virtual ValueTask<CallbackDetails> Get(GetDetails details)
 
         /// <summary>Sets the value of a setting.</summary>
         /// <param name="details">Which setting to change.</param>
+        [JsAccessPath("set")]
         public virtual ValueTask Set(SetDetails details)
         {
             return InvokeVoidAsync("set", details);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/Detail.cs b/src/WebExtensions.Net/Generated/WebNavigation/Detail.cs
index eb305c9..6cae94c 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/Detail.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/Detail.cs
@@ -9,23 +9,28 @@ namespace WebExtensions.Net.WebNavigation
     public partial class Detail : BaseObject
     {
         /// <summary>True if the last navigation in this frame was interrupted by an error, i.e. the onErrorOccurred event fired.</summary>
+        [JsAccessPath("errorOccurred")]
         [JsonPropertyName("errorOccurred")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ErrorOccurred { get; set; }
 
         /// <summary>The ID of the frame. 0 indicates that this is the main frame; a positive value indicates the ID of a subframe.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>ID of frame that wraps the frame. Set to -1 of no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the tab in which the frame is.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The URL currently associated with this frame.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/EventUrlFilters.cs b/src/WebExtensions.Net/Generated/WebNavigation/EventUrlFilters.cs
index 58bbe35..22dfada 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/EventUrlFilters.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/EventUrlFilters.cs
@@ -11,6 +11,7 @@ namespace WebExtensions.Net.WebNavigation
     public partial class EventUrlFilters : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<UrlFilter> Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/GetAllFramesDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/GetAllFramesDetails.cs
index 3224922..1a20270 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/GetAllFramesDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/GetAllFramesDetails.cs
@@ -9,6 +9,7 @@ namespace WebExtensions.Net.WebNavigation
     public partial class GetAllFramesDetails : BaseObject
     {
         /// <summary>The ID of the tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/GetFrameCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/GetFrameCallbackDetails.cs
index 9ab6620..a1c18ec 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/GetFrameCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/GetFrameCallbackDetails.cs
@@ -9,23 +9,28 @@ namespace WebExtensions.Net.WebNavigation
     public partial class GetFrameCallbackDetails : BaseObject
     {
         /// <summary>True if the last navigation in this frame was interrupted by an error, i.e. the onErrorOccurred event fired.</summary>
+        [JsAccessPath("errorOccurred")]
         [JsonPropertyName("errorOccurred")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? ErrorOccurred { get; set; }
 
         /// <summary>The ID of the frame. 0 indicates that this is the main frame; a positive value indicates the ID of a subframe.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>ID of frame that wraps the frame. Set to -1 of no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the tab in which the frame is.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The URL currently associated with this frame, if the frame identified by the frameId existed at one point in the given tab. The fact that an URL is associated with a given frameId does not imply that the corresponding frame still exists.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/GetFrameDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/GetFrameDetails.cs
index 64f8ced..d3bb377 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/GetFrameDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/GetFrameDetails.cs
@@ -9,15 +9,18 @@ namespace WebExtensions.Net.WebNavigation
     public partial class GetFrameDetails : BaseObject
     {
         /// <summary>The ID of the frame in the given tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the process runs the renderer for this tab.</summary>
+        [JsAccessPath("processId")]
         [JsonPropertyName("processId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? ProcessId { get; set; }
 
         /// <summary>The ID of the tab in which the frame is.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/IWebNavigationApi.cs b/src/WebExtensions.Net/Generated/WebNavigation/IWebNavigationApi.cs
index e8d6310..bcfa1dd 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/IWebNavigationApi.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/IWebNavigationApi.cs
@@ -1,46 +1,59 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.WebNavigation
 {
     /// <summary>Use the <c>browser.webNavigation</c> API to receive notifications about the status of navigation requests in-flight.</summary>
+    [JsAccessPath("webNavigation")]
     public partial interface IWebNavigationApi
     {
         /// <summary>Fired when a navigation is about to occur.</summary>
+        [JsAccessPath("onBeforeNavigate")]
         OnBeforeNavigateEvent OnBeforeNavigate { get; }
 
         /// <summary>Fired when a navigation is committed. The document (and the resources it refers to, such as images and subframes) might still be downloading, but at least part of the document has been received from the server and the browser has decided to switch to the new document.</summary>
+        [JsAccessPath("onCommitted")]
         OnCommittedEvent OnCommitted { get; }
 
         /// <summary>Fired when a document, including the resources it refers to, is completely loaded and initialized.</summary>
+        [JsAccessPath("onCompleted")]
         OnCompletedEvent OnCompleted { get; }
 
         /// <summary>Fired when a new window, or a new tab in an existing window, is created to host a navigation.</summary>
+        [JsAccessPath("onCreatedNavigationTarget")]
         OnCreatedNavigationTargetEvent OnCreatedNavigationTarget { get; }
 
         /// <summary>Fired when the page's DOM is fully constructed, but the referenced resources may not finish loading.</summary>
+        [JsAccessPath("onDOMContentLoaded")]
         OnDomContentLoadedEvent OnDOMContentLoaded { get; }
 
         /// <summary>Fired when an error occurs and the navigation is aborted. This can happen if either a network error occurred, or the user aborted the navigation.</summary>
+        [JsAccessPath("onErrorOccurred")]
         OnErrorOccurredEvent OnErrorOccurred { get; }
 
         /// <summary>Fired when the frame's history was updated to a new URL. All future events for that frame will use the updated URL.</summary>
+        [JsAccessPath("onHistoryStateUpdated")]
         OnHistoryStateUpdatedEvent OnHistoryStateUpdated { get; }
 
         /// <summary>Fired when the reference fragment of a frame was updated. All future events for that frame will use the updated URL.</summary>
+        [JsAccessPath("onReferenceFragmentUpdated")]
         OnReferenceFragmentUpdatedEvent OnReferenceFragmentUpdated { get; }
 
         /// <summary>Fired when the contents of the tab is replaced by a different (usually previously pre-rendered) tab.</summary>
+        [JsAccessPath("onTabReplaced")]
         OnTabReplacedEvent OnTabReplaced { get; }
 
         /// <summary>Retrieves information about all frames of a given tab.</summary>
         /// <param name="details">Information about the tab to retrieve all frames from.</param>
         /// <returns>A list of frames in the given tab, null if the specified tab ID is invalid.</returns>
+        [JsAccessPath("getAllFrames")]
         ValueTask<IEnumerable<Detail>> GetAllFrames(GetAllFramesDetails details);
 
         /// <summary>Retrieves information about the given frame. A frame refers to an &amp;lt;iframe&amp;gt; or a &amp;lt;frame&amp;gt; of a web page and is identified by a tab ID and a frame ID.</summary>
         /// <param name="details">Information about the frame to retrieve information about.</param>
         /// <returns>Information about the requested frame, null if the specified frame ID and/or tab ID are invalid.</returns>
+        [JsAccessPath("getFrame")]
         ValueTask<GetFrameCallbackDetails> GetFrame(GetFrameDetails details);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEvent.cs
index 2972b35..0b9ac93 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEvent.cs
@@ -12,6 +12,7 @@ public partial class OnBeforeNavigateEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a navigation is about to occur.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnBeforeNavigateEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnBeforeNavigateEventCallbackDetails
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a navigation is about to occur.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnBeforeNavigateEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnBeforeNavigateEventCallbackDetails
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnBeforeNavigateEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnBeforeNavigateEventCallbackD
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnBeforeNavigateEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnBeforeNavigateEventCallbackD
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnBeforeNavigateEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnBeforeNavigateEventCallbackDeta
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnBeforeNavigateEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEventCallbackDetails.cs
index fc17067..d46922b 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnBeforeNavigateEventCallbackDetails.cs
@@ -9,22 +9,27 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnBeforeNavigateEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique for a given tab and process.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>ID of frame that wraps the frame. Set to -1 of no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation is about to occur.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the browser was about to start the navigation, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEvent.cs
index 71bf08f..7baee86 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCommittedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a navigation is committed. The document (and the resources it refers to, such as images and subframes) might still be downloading, but at least part of the document has been received from the server and the browser has decided to switch to the new document.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCommittedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnCommittedEventCallbackDetails> cal
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a navigation is committed. The document (and the resources it refers to, such as images and subframes) might still be downloading, but at least part of the document has been received from the server and the browser has decided to switch to the new document.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCommittedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnCommittedEventCallbackDetails> cal
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCommittedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCommittedEventCallbackDetail
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCommittedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCommittedEventCallbackDetail
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCommittedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnCommittedEventCallbackDetails>
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCommittedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEventCallbackDetails.cs
index 7c0173b..9dae00b 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCommittedEventCallbackDetails.cs
@@ -10,27 +10,33 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnCommittedEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the navigation was committed, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>A list of transition qualifiers.</summary>
+        [JsAccessPath("transitionQualifiers")]
         [JsonPropertyName("transitionQualifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<TransitionQualifier> TransitionQualifiers { get; set; }
 
         /// <summary>Cause of the navigation.</summary>
+        [JsAccessPath("transitionType")]
         [JsonPropertyName("transitionType")]
         public TransitionType TransitionType { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEvent.cs
index a75d4b6..3520207 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCompletedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a document, including the resources it refers to, is completely loaded and initialized.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> cal
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a document, including the resources it refers to, is completely loaded and initialized.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> cal
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetail
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetail
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails>
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEventCallbackDetails.cs
index e9c9a7b..67bf31e 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCompletedEventCallbackDetails.cs
@@ -9,18 +9,22 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnCompletedEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the document finished loading, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEvent.cs
index 5433a7d..36511d8 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCreatedNavigationTargetEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a new window, or a new tab in an existing window, is created to host a navigation.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnCreatedNavigationTargetEventCallba
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a new window, or a new tab in an existing window, is created to host a navigation.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnCreatedNavigationTargetEventCallba
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCreatedNavigationTargetEvent
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCreatedNavigationTargetEvent
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnCreatedNavigationTargetEventCal
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCreatedNavigationTargetEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEventCallbackDetails.cs
index e9bf361..562938c 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnCreatedNavigationTargetEventCallbackDetails.cs
@@ -9,26 +9,32 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnCreatedNavigationTargetEventCallbackDetails : BaseObject
     {
         /// <summary>The ID of the frame with sourceTabId in which the navigation is triggered. 0 indicates the main frame.</summary>
+        [JsAccessPath("sourceFrameId")]
         [JsonPropertyName("sourceFrameId")]
         public int SourceFrameId { get; set; }
 
         /// <summary>The ID of the process runs the renderer for the source tab.</summary>
+        [JsAccessPath("sourceProcessId")]
         [JsonPropertyName("sourceProcessId")]
         public int SourceProcessId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation is triggered.</summary>
+        [JsAccessPath("sourceTabId")]
         [JsonPropertyName("sourceTabId")]
         public int SourceTabId { get; set; }
 
         /// <summary>The ID of the tab in which the url is opened</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the browser was about to create a new view, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>The URL to be opened in the new window.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEvent.cs
index 62e032b..844d4e1 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnDomContentLoadedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the page's DOM is fully constructed, but the referenced resources may not finish loading.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnDomContentLoadedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnDomContentLoadedEventCallbackDetai
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the page's DOM is fully constructed, but the referenced resources may not finish loading.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnDomContentLoadedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnDomContentLoadedEventCallbackDetai
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnDomContentLoadedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnDomContentLoadedEventCallbac
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnDomContentLoadedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnDomContentLoadedEventCallbac
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnDomContentLoadedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnDomContentLoadedEventCallbackDe
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnDomContentLoadedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEventCallbackDetails.cs
index fb3e05a..aa3ecb8 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnDomContentLoadedEventCallbackDetails.cs
@@ -9,18 +9,22 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnDomContentLoadedEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the page's DOM was fully constructed, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEvent.cs
index 94fcc58..cc66bb9 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEvent.cs
@@ -12,6 +12,7 @@ public partial class OnErrorOccurredEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an error occurs and the navigation is aborted. This can happen if either a network error occurred, or the user aborted the navigation.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails>
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an error occurs and the navigation is aborted. This can happen if either a network error occurred, or the user aborted the navigation.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails>
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDe
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDe
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetai
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEventCallbackDetails.cs
index a665500..bf8d46a 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnErrorOccurredEventCallbackDetails.cs
@@ -9,18 +9,22 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnErrorOccurredEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the error occurred, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEvent.cs
index 135163e..3b042ea 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnHistoryStateUpdatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the frame's history was updated to a new URL. All future events for that frame will use the updated URL.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnHistoryStateUpdatedEventCallbackDe
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the frame's history was updated to a new URL. All future events for that frame will use the updated URL.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnHistoryStateUpdatedEventCallbackDe
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnHistoryStateUpdatedEventCall
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnHistoryStateUpdatedEventCall
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnHistoryStateUpdatedEventCallbac
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnHistoryStateUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEventCallbackDetails.cs
index b569ef8..911bd86 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnHistoryStateUpdatedEventCallbackDetails.cs
@@ -10,27 +10,33 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnHistoryStateUpdatedEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the navigation was committed, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>A list of transition qualifiers.</summary>
+        [JsAccessPath("transitionQualifiers")]
         [JsonPropertyName("transitionQualifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<TransitionQualifier> TransitionQualifiers { get; set; }
 
         /// <summary>Cause of the navigation.</summary>
+        [JsAccessPath("transitionType")]
         [JsonPropertyName("transitionType")]
         public TransitionType TransitionType { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEvent.cs
index e302845..59da8ce 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnReferenceFragmentUpdatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the reference fragment of a frame was updated. All future events for that frame will use the updated URL.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnReferenceFragmentUpdatedEventCallb
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the reference fragment of a frame was updated. All future events for that frame will use the updated URL.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("addListener", callback, filters);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnReferenceFragmentUpdatedEventCallb
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnReferenceFragmentUpdatedEven
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeAsync<bool>("hasListener", callback, filters);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnReferenceFragmentUpdatedEven
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnReferenceFragmentUpdatedEventCa
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filters">Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of UrlFilter are ignored for this event.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnReferenceFragmentUpdatedEventCallbackDetails> callback, EventUrlFilters filters)
         {
             return InvokeVoidAsync("removeListener", callback, filters);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEventCallbackDetails.cs
index 730b911..f702a16 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnReferenceFragmentUpdatedEventCallbackDetails.cs
@@ -10,27 +10,33 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnReferenceFragmentUpdatedEventCallbackDetails : BaseObject
     {
         /// <summary>0 indicates the navigation happens in the tab content window; a positive value indicates navigation in a subframe. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>The ID of the tab in which the navigation occurs.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the navigation was committed, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>A list of transition qualifiers.</summary>
+        [JsAccessPath("transitionQualifiers")]
         [JsonPropertyName("transitionQualifiers")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<TransitionQualifier> TransitionQualifiers { get; set; }
 
         /// <summary>Cause of the navigation.</summary>
+        [JsAccessPath("transitionType")]
         [JsonPropertyName("transitionType")]
         public TransitionType TransitionType { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEvent.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEvent.cs
index 460a508..5a44628 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnTabReplacedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the contents of the tab is replaced by a different (usually previously pre-rendered) tab.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnTabReplacedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnTabReplacedEventCallbackDetails> c
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnTabReplacedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<OnTabReplacedEventCallbackDeta
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnTabReplacedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEventCallbackDetails.cs
index fba84fb..e972ad3 100644
--- a/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebNavigation/OnTabReplacedEventCallbackDetails.cs
@@ -9,14 +9,17 @@ namespace WebExtensions.Net.WebNavigation
     public partial class OnTabReplacedEventCallbackDetails : BaseObject
     {
         /// <summary>The ID of the tab that was replaced.</summary>
+        [JsAccessPath("replacedTabId")]
         [JsonPropertyName("replacedTabId")]
         public int ReplacedTabId { get; set; }
 
         /// <summary>The ID of the tab that replaced the old tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>The time when the replacement happened, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/AuthCredentials.cs b/src/WebExtensions.Net/Generated/WebRequest/AuthCredentials.cs
index 66ab6f2..77dcc8d 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/AuthCredentials.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/AuthCredentials.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.WebRequest
     public partial class AuthCredentials : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("password")]
         [JsonPropertyName("password")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Password { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("username")]
         [JsonPropertyName("username")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Username { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/BlockingResponse.cs b/src/WebExtensions.Net/Generated/WebRequest/BlockingResponse.cs
index 53301c5..84f2679 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/BlockingResponse.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/BlockingResponse.cs
@@ -9,31 +9,37 @@ namespace WebExtensions.Net.WebRequest
     public partial class BlockingResponse : BaseObject
     {
         /// <summary>Only used as a response to the onAuthRequired event. If set, the request is made using the supplied credentials.</summary>
+        [JsAccessPath("authCredentials")]
         [JsonPropertyName("authCredentials")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public AuthCredentials AuthCredentials { get; set; }
 
         /// <summary>If true, the request is cancelled. Used in onBeforeRequest, this prevents the request from being sent.</summary>
+        [JsAccessPath("cancel")]
         [JsonPropertyName("cancel")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Cancel { get; set; }
 
         /// <summary>Only used as a response to the onBeforeRequest and onHeadersReceived events. If set, the original request is prevented from being sent/completed and is instead redirected to the given URL. Redirections to non-HTTP schemes such as data: are allowed. Redirects initiated by a redirect action use the original request method for the redirect, with one exception: If the redirect is initiated at the onHeadersReceived stage, then the redirect will be issued using the GET method.</summary>
+        [JsAccessPath("redirectUrl")]
         [JsonPropertyName("redirectUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RedirectUrl { get; set; }
 
         /// <summary>Only used as a response to the onBeforeSendHeaders event. If set, the request is made with these request headers instead.</summary>
+        [JsAccessPath("requestHeaders")]
         [JsonPropertyName("requestHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders RequestHeaders { get; set; }
 
         /// <summary>Only used as a response to the onHeadersReceived event. If set, the server is assumed to have responded with these response headers instead. Only return <c>responseHeaders</c> if you really want to modify the headers in order to limit the number of conflicts (only one extension may modify <c>responseHeaders</c> for each request).</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>Only used as a response to the onBeforeRequest event. If set, the original request is prevented from being sent/completed and is instead upgraded to a secure request.  If any extension returns <c>redirectUrl</c> during onBeforeRequest, <c>upgradeToSecure</c> will have no affect.</summary>
+        [JsAccessPath("upgradeToSecure")]
         [JsonPropertyName("upgradeToSecure")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? UpgradeToSecure { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/Challenger.cs b/src/WebExtensions.Net/Generated/WebRequest/Challenger.cs
index 4e8f784..854c100 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/Challenger.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/Challenger.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.WebRequest
     public partial class Challenger : BaseObject
     {
         /// <summary></summary>
+        [JsAccessPath("host")]
         [JsonPropertyName("host")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Host { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("port")]
         [JsonPropertyName("port")]
         public int Port { get; set; }
     }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/HttpHeader.cs b/src/WebExtensions.Net/Generated/WebRequest/HttpHeader.cs
index 7940841..9f86168 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/HttpHeader.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/HttpHeader.cs
@@ -10,16 +10,19 @@ namespace WebExtensions.Net.WebRequest
     public partial class HttpHeader : BaseObject
     {
         /// <summary>Value of the HTTP header if it cannot be represented by UTF-8, stored as individual byte values (0..255).</summary>
+        [JsAccessPath("binaryValue")]
         [JsonPropertyName("binaryValue")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<int> BinaryValue { get; set; }
 
         /// <summary>Name of the HTTP header.</summary>
+        [JsAccessPath("name")]
         [JsonPropertyName("name")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Name { get; set; }
 
         /// <summary>Value of the HTTP header if it can be represented by UTF-8.</summary>
+        [JsAccessPath("value")]
         [JsonPropertyName("value")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Value { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/IWebRequestApi.cs b/src/WebExtensions.Net/Generated/WebRequest/IWebRequestApi.cs
index e23acf2..6e7a003 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/IWebRequestApi.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/IWebRequestApi.cs
@@ -1,52 +1,67 @@
+using JsBind.Net;
 using System.Text.Json;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.WebRequest
 {
     /// <summary>Use the <c>browser.webRequest</c> API to observe and analyze traffic and to intercept, block, or modify requests in-flight.</summary>
+    [JsAccessPath("webRequest")]
     public partial interface IWebRequestApi
     {
         /// <summary>The maximum number of times that <c>handlerBehaviorChanged</c> can be called per 10 minute sustained interval. <c>handlerBehaviorChanged</c> is an expensive function call that shouldn't be called often.</summary>
+        [JsAccessPath("MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES")]
         int MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES { get; }
 
         /// <summary>Fired when an authentication failure is received. The listener has three options: it can provide authentication credentials, it can cancel the request and display the error page, or it can take no action on the challenge. If bad user credentials are provided, this may be called multiple times for the same request.</summary>
+        [JsAccessPath("onAuthRequired")]
         OnAuthRequiredEvent OnAuthRequired { get; }
 
         /// <summary>Fired when a server-initiated redirect is about to occur.</summary>
+        [JsAccessPath("onBeforeRedirect")]
         OnBeforeRedirectEvent OnBeforeRedirect { get; }
 
         /// <summary>Fired when a request is about to occur.</summary>
+        [JsAccessPath("onBeforeRequest")]
         OnBeforeRequestEvent OnBeforeRequest { get; }
 
         /// <summary>Fired before sending an HTTP request, once the request headers are available. This may occur after a TCP connection is made to the server, but before any HTTP data is sent. </summary>
+        [JsAccessPath("onBeforeSendHeaders")]
         OnBeforeSendHeadersEvent OnBeforeSendHeaders { get; }
 
         /// <summary>Fired when a request is completed.</summary>
+        [JsAccessPath("onCompleted")]
         OnCompletedEvent OnCompleted { get; }
 
         /// <summary>Fired when an error occurs.</summary>
+        [JsAccessPath("onErrorOccurred")]
         OnErrorOccurredEvent OnErrorOccurred { get; }
 
         /// <summary>Fired when HTTP response headers of a request have been received.</summary>
+        [JsAccessPath("onHeadersReceived")]
         OnHeadersReceivedEvent OnHeadersReceived { get; }
 
         /// <summary>Fired when the first byte of the response body is received. For HTTP requests, this means that the status line and response headers are available.</summary>
+        [JsAccessPath("onResponseStarted")]
         OnResponseStartedEvent OnResponseStarted { get; }
 
         /// <summary>Fired just before a request is going to be sent to the server (modifications of previous onBeforeSendHeaders callbacks are visible by the time onSendHeaders is fired).</summary>
+        [JsAccessPath("onSendHeaders")]
         OnSendHeadersEvent OnSendHeaders { get; }
 
         /// <summary>...</summary>
         /// <param name="requestId"></param>
         /// <returns></returns>
+        [JsAccessPath("filterResponseData")]
         ValueTask<JsonElement> FilterResponseData(string requestId);
 
         /// <summary>Retrieves the security information for the request.  Returns a promise that will resolve to a SecurityInfo object.</summary>
         /// <param name="requestId"></param>
         /// <param name="options"></param>
+        [JsAccessPath("getSecurityInfo")]
         ValueTask GetSecurityInfo(string requestId, Options options = null);
 
         /// <summary>Needs to be called when the behavior of the webRequest handlers has changed to prevent incorrect handling due to caching. This function call is expensive. Don't call it often.</summary>
+        [JsAccessPath("handlerBehaviorChanged")]
         ValueTask HandlerBehaviorChanged();
     }
 }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEvent.cs
index 410069b..6dbf140 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEvent.cs
@@ -13,6 +13,7 @@ public partial class OnAuthRequiredEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an authentication failure is received. The listener has three options: it can provide authentication credentials, it can cancel the request and display the error page, or it can take no action on the challenge. If bad user credentials are provided, this may be called multiple times for the same request.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Func<OnAuthRequiredEventCallbackDetails, Ac
         /// <param name="callback">Fired when an authentication failure is received. The listener has three options: it can provide authentication credentials, it can cancel the request and display the error page, or it can take no action on the challenge. If bad user credentials are provided, this may be called multiple times for the same request.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnAuthRequiredOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Func<OnAuthRequiredEventCallbackDetails, Ac
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Func<OnAuthRequiredEventCallbackDetai
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnAuthRequiredOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Func<OnAuthRequiredEventCallbackDetai
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Func<OnAuthRequiredEventCallbackDetails,
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnAuthRequiredEventCallbackDetails, Action<BlockingResponse>, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnAuthRequiredOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEventCallbackDetails.cs
index 0cb70b4..83acd4e 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnAuthRequiredEventCallbackDetails.cs
@@ -9,98 +9,119 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnAuthRequiredEventCallbackDetails : BaseObject
     {
         /// <summary>The server requesting authentication.</summary>
+        [JsAccessPath("challenger")]
         [JsonPropertyName("challenger")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Challenger Challenger { get; set; }
 
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>True for Proxy-Authenticate, false for WWW-Authenticate.</summary>
+        [JsAccessPath("isProxy")]
         [JsonPropertyName("isProxy")]
         public bool IsProxy { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The authentication realm provided by the server, if there is one.</summary>
+        [JsAccessPath("realm")]
         [JsonPropertyName("realm")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Realm { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The HTTP response headers that were received along with this response.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>The authentication scheme, e.g. Basic or Digest.</summary>
+        [JsAccessPath("scheme")]
         [JsonPropertyName("scheme")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Scheme { get; set; }
 
         /// <summary>Standard HTTP status code returned by the server.</summary>
+        [JsAccessPath("statusCode")]
         [JsonPropertyName("statusCode")]
         public int StatusCode { get; set; }
 
         /// <summary>HTTP status line of the response or the 'HTTP/0.9 200 OK' string for HTTP/0.9 responses (i.e., responses that lack a status line) or an empty string if there are no headers.</summary>
+        [JsAccessPath("statusLine")]
         [JsonPropertyName("statusLine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StatusLine { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEvent.cs
index 6118906..6bad73d 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEvent.cs
@@ -13,6 +13,7 @@ public partial class OnBeforeRedirectEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a server-initiated redirect is about to occur.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnBeforeRedirectEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Action<OnBeforeRedirectEventCallbackDetails
         /// <param name="callback">Fired when a server-initiated redirect is about to occur.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnBeforeRedirectEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnBeforeRedirectOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Action<OnBeforeRedirectEventCallbackDetails
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnBeforeRedirectEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Action<OnBeforeRedirectEventCallbackD
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnBeforeRedirectEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnBeforeRedirectOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Action<OnBeforeRedirectEventCallbackD
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnBeforeRedirectEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Action<OnBeforeRedirectEventCallbackDeta
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnBeforeRedirectEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnBeforeRedirectOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEventCallbackDetails.cs
index a8b24b7..e83eed8 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRedirectEventCallbackDetails.cs
@@ -9,93 +9,113 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnBeforeRedirectEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>Indicates if this response was fetched from disk cache.</summary>
+        [JsAccessPath("fromCache")]
         [JsonPropertyName("fromCache")]
         public bool FromCache { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.</summary>
+        [JsAccessPath("ip")]
         [JsonPropertyName("ip")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Ip { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The new URL.</summary>
+        [JsAccessPath("redirectUrl")]
         [JsonPropertyName("redirectUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RedirectUrl { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The HTTP response headers that were received along with this redirect.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>Standard HTTP status code returned by the server.</summary>
+        [JsAccessPath("statusCode")]
         [JsonPropertyName("statusCode")]
         public int StatusCode { get; set; }
 
         /// <summary>HTTP status line of the response or the 'HTTP/0.9 200 OK' string for HTTP/0.9 responses (i.e., responses that lack a status line) or an empty string if there are no headers.</summary>
+        [JsAccessPath("statusLine")]
         [JsonPropertyName("statusLine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StatusLine { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEvent.cs
index ab7d54e..32e7470 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEvent.cs
@@ -13,6 +13,7 @@ public partial class OnBeforeRequestEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a request is about to occur.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Func<OnBeforeRequestEventCallbackDetails, B
         /// <param name="callback">Fired when a request is about to occur.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeRequestOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Func<OnBeforeRequestEventCallbackDetails, B
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Func<OnBeforeRequestEventCallbackDeta
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeRequestOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Func<OnBeforeRequestEventCallbackDeta
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Func<OnBeforeRequestEventCallbackDetails
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnBeforeRequestEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeRequestOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEventCallbackDetails.cs
index 7fb8c05..7c1cf7f 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeRequestEventCallbackDetails.cs
@@ -9,70 +9,85 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnBeforeRequestEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>Contains the HTTP request body data. Only provided if extraInfoSpec contains 'requestBody'.</summary>
+        [JsAccessPath("requestBody")]
         [JsonPropertyName("requestBody")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public RequestBody RequestBody { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEvent.cs
index e464290..07af5f2 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEvent.cs
@@ -13,6 +13,7 @@ public partial class OnBeforeSendHeadersEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired before sending an HTTP request, once the request headers are available. This may occur after a TCP connection is made to the server, but before any HTTP data is sent. </param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Func<OnBeforeSendHeadersEventCallbackDetail
         /// <param name="callback">Fired before sending an HTTP request, once the request headers are available. This may occur after a TCP connection is made to the server, but before any HTTP data is sent. </param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeSendHeadersOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Func<OnBeforeSendHeadersEventCallbackDetail
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Func<OnBeforeSendHeadersEventCallback
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeSendHeadersOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Func<OnBeforeSendHeadersEventCallback
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Func<OnBeforeSendHeadersEventCallbackDet
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnBeforeSendHeadersEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnBeforeSendHeadersOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEventCallbackDetails.cs
index 7997abc..88714d0 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnBeforeSendHeadersEventCallbackDetails.cs
@@ -9,70 +9,85 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnBeforeSendHeadersEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The HTTP request headers that are going to be sent out with this request.</summary>
+        [JsAccessPath("requestHeaders")]
         [JsonPropertyName("requestHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders RequestHeaders { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEvent.cs
index e3e6594..711adb3 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnCompletedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a request is completed.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> cal
         /// <param name="callback">Fired when a request is completed.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnCompletedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Action<OnCompletedEventCallbackDetails> cal
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetail
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnCompletedOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Action<OnCompletedEventCallbackDetail
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnCompletedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnCompletedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEventCallbackDetails.cs
index 49570df..fa04afd 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnCompletedEventCallbackDetails.cs
@@ -9,96 +9,117 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnCompletedEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>Indicates if this response was fetched from disk cache.</summary>
+        [JsAccessPath("fromCache")]
         [JsonPropertyName("fromCache")]
         public bool FromCache { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.</summary>
+        [JsAccessPath("ip")]
         [JsonPropertyName("ip")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Ip { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>For http requests, the bytes transferred in the request. Only available in onCompleted.</summary>
+        [JsAccessPath("requestSize")]
         [JsonPropertyName("requestSize")]
         public int RequestSize { get; set; }
 
         /// <summary>The HTTP response headers that were received along with this response.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>For http requests, the bytes received in the request. Only available in onCompleted.</summary>
+        [JsAccessPath("responseSize")]
         [JsonPropertyName("responseSize")]
         public int ResponseSize { get; set; }
 
         /// <summary>Standard HTTP status code returned by the server.</summary>
+        [JsAccessPath("statusCode")]
         [JsonPropertyName("statusCode")]
         public int StatusCode { get; set; }
 
         /// <summary>HTTP status line of the response or the 'HTTP/0.9 200 OK' string for HTTP/0.9 responses (i.e., responses that lack a status line) or an empty string if there are no headers.</summary>
+        [JsAccessPath("statusLine")]
         [JsonPropertyName("statusLine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StatusLine { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEvent.cs
index 5dacb15..7828c29 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEvent.cs
@@ -12,6 +12,7 @@ public partial class OnErrorOccurredEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an error occurs.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails>
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when an error occurs.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails> callback, RequestFilter filter)
         {
             return InvokeVoidAsync("addListener", callback, filter);
@@ -28,6 +30,7 @@ public virtual ValueTask AddListener(Action<OnErrorOccurredEventCallbackDetails>
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -37,6 +40,7 @@ public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDe
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDetails> callback, RequestFilter filter)
         {
             return InvokeAsync<bool>("hasListener", callback, filter);
@@ -44,6 +48,7 @@ public virtual ValueTask<bool> HasListener(Action<OnErrorOccurredEventCallbackDe
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -52,6 +57,7 @@ public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetai
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnErrorOccurredEventCallbackDetails> callback, RequestFilter filter)
         {
             return InvokeVoidAsync("removeListener", callback, filter);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEventCallbackDetails.cs
index 3e42557..e843236 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnErrorOccurredEventCallbackDetails.cs
@@ -9,79 +9,96 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnErrorOccurredEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The error description. This string is <em>not</em> guaranteed to remain backwards compatible between releases. You must not parse and act based upon its content.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Error { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>Indicates if this response was fetched from disk cache.</summary>
+        [JsAccessPath("fromCache")]
         [JsonPropertyName("fromCache")]
         public bool FromCache { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.</summary>
+        [JsAccessPath("ip")]
         [JsonPropertyName("ip")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Ip { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEvent.cs
index f646ad7..6d2deb6 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnHeadersReceivedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when HTTP response headers of a request have been received.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Func<OnHeadersReceivedEventCallbackDetails,
         /// <param name="callback">Fired when HTTP response headers of a request have been received.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnHeadersReceivedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Func<OnHeadersReceivedEventCallbackDetails,
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Func<OnHeadersReceivedEventCallbackDe
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnHeadersReceivedOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Func<OnHeadersReceivedEventCallbackDe
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Func<OnHeadersReceivedEventCallbackDetai
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Func<OnHeadersReceivedEventCallbackDetails, BlockingResponse> callback, RequestFilter filter, IEnumerable<OnHeadersReceivedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEventCallbackDetails.cs
index 34aecc9..6d22ea4 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnHeadersReceivedEventCallbackDetails.cs
@@ -9,79 +9,96 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnHeadersReceivedEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The HTTP response headers that have been received with this response.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>Standard HTTP status code returned by the server.</summary>
+        [JsAccessPath("statusCode")]
         [JsonPropertyName("statusCode")]
         public int StatusCode { get; set; }
 
         /// <summary>HTTP status line of the response or the 'HTTP/0.9 200 OK' string for HTTP/0.9 responses (i.e., responses that lack a status line).</summary>
+        [JsAccessPath("statusLine")]
         [JsonPropertyName("statusLine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StatusLine { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEvent.cs
index 34f94dc..8a711c4 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEvent.cs
@@ -13,6 +13,7 @@ public partial class OnResponseStartedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the first byte of the response body is received. For HTTP requests, this means that the status line and response headers are available.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnResponseStartedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Action<OnResponseStartedEventCallbackDetail
         /// <param name="callback">Fired when the first byte of the response body is received. For HTTP requests, this means that the status line and response headers are available.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnResponseStartedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnResponseStartedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Action<OnResponseStartedEventCallbackDetail
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnResponseStartedEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Action<OnResponseStartedEventCallback
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnResponseStartedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnResponseStartedOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Action<OnResponseStartedEventCallback
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnResponseStartedEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Action<OnResponseStartedEventCallbackDet
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnResponseStartedEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnResponseStartedOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEventCallbackDetails.cs
index 6283a1b..0cbeb0b 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnResponseStartedEventCallbackDetails.cs
@@ -9,88 +9,107 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnResponseStartedEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>Indicates if this response was fetched from disk cache.</summary>
+        [JsAccessPath("fromCache")]
         [JsonPropertyName("fromCache")]
         public bool FromCache { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.</summary>
+        [JsAccessPath("ip")]
         [JsonPropertyName("ip")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Ip { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The HTTP response headers that were received along with this response.</summary>
+        [JsAccessPath("responseHeaders")]
         [JsonPropertyName("responseHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders ResponseHeaders { get; set; }
 
         /// <summary>Standard HTTP status code returned by the server.</summary>
+        [JsAccessPath("statusCode")]
         [JsonPropertyName("statusCode")]
         public int StatusCode { get; set; }
 
         /// <summary>HTTP status line of the response or the 'HTTP/0.9 200 OK' string for HTTP/0.9 responses (i.e., responses that lack a status line) or an empty string if there are no headers.</summary>
+        [JsAccessPath("statusLine")]
         [JsonPropertyName("statusLine")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string StatusLine { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEvent.cs b/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEvent.cs
index fac63a3..832fffe 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEvent.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEvent.cs
@@ -13,6 +13,7 @@ public partial class OnSendHeadersEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired just before a request is going to be sent to the server (modifications of previous onBeforeSendHeaders callbacks are visible by the time onSendHeaders is fired).</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnSendHeadersEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -22,6 +23,7 @@ public virtual ValueTask AddListener(Action<OnSendHeadersEventCallbackDetails> c
         /// <param name="callback">Fired just before a request is going to be sent to the server (modifications of previous onBeforeSendHeaders callbacks are visible by the time onSendHeaders is fired).</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<OnSendHeadersEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnSendHeadersOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("addListener", callback, filter, extraInfoSpec);
@@ -30,6 +32,7 @@ public virtual ValueTask AddListener(Action<OnSendHeadersEventCallbackDetails> c
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnSendHeadersEventCallbackDetails> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -40,6 +43,7 @@ public virtual ValueTask<bool> HasListener(Action<OnSendHeadersEventCallbackDeta
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<OnSendHeadersEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnSendHeadersOptions> extraInfoSpec)
         {
             return InvokeAsync<bool>("hasListener", callback, filter, extraInfoSpec);
@@ -47,6 +51,7 @@ public virtual ValueTask<bool> HasListener(Action<OnSendHeadersEventCallbackDeta
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnSendHeadersEventCallbackDetails> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
@@ -56,6 +61,7 @@ public virtual ValueTask RemoveListener(Action<OnSendHeadersEventCallbackDetails
         /// <param name="callback">Listener that shall be unregistered.</param>
         /// <param name="filter">A set of filters that restricts the events that will be sent to this listener.</param>
         /// <param name="extraInfoSpec">Array of extra information that should be passed to the listener function.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<OnSendHeadersEventCallbackDetails> callback, RequestFilter filter, IEnumerable<OnSendHeadersOptions> extraInfoSpec)
         {
             return InvokeVoidAsync("removeListener", callback, filter, extraInfoSpec);
diff --git a/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEventCallbackDetails.cs b/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEventCallbackDetails.cs
index 46f5e7e..ffeaf86 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEventCallbackDetails.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/OnSendHeadersEventCallbackDetails.cs
@@ -9,70 +9,85 @@ namespace WebExtensions.Net.WebRequest
     public partial class OnSendHeadersEventCallbackDetails : BaseObject
     {
         /// <summary>The cookie store ID of the contextual identity.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>URL of the page into which the requested resource will be loaded.</summary>
+        [JsAccessPath("documentUrl")]
         [JsonPropertyName("documentUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string DocumentUrl { get; set; }
 
         /// <summary>The value 0 indicates that the request happens in the main frame; a positive value indicates the ID of a subframe in which the request happens. If the document of a (sub-)frame is loaded (<c>type</c> is <c>main_frame</c> or <c>sub_frame</c>), <c>frameId</c> indicates the ID of this frame, not the ID of the outer frame. Frame IDs are unique within a tab.</summary>
+        [JsAccessPath("frameId")]
         [JsonPropertyName("frameId")]
         public int FrameId { get; set; }
 
         /// <summary>True for private browsing requests.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>Standard HTTP method.</summary>
+        [JsAccessPath("method")]
         [JsonPropertyName("method")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Method { get; set; }
 
         /// <summary>URL of the resource that triggered this request.</summary>
+        [JsAccessPath("originUrl")]
         [JsonPropertyName("originUrl")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string OriginUrl { get; set; }
 
         /// <summary>ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.</summary>
+        [JsAccessPath("parentFrameId")]
         [JsonPropertyName("parentFrameId")]
         public int ParentFrameId { get; set; }
 
         /// <summary>The HTTP request headers that have been sent out with this request.</summary>
+        [JsAccessPath("requestHeaders")]
         [JsonPropertyName("requestHeaders")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public HttpHeaders RequestHeaders { get; set; }
 
         /// <summary>The ID of the request. Request IDs are unique within a browser session. As a result, they could be used to relate different events of the same request.</summary>
+        [JsAccessPath("requestId")]
         [JsonPropertyName("requestId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string RequestId { get; set; }
 
         /// <summary>The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         public int TabId { get; set; }
 
         /// <summary>Indicates if this request and its content window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         public bool ThirdParty { get; set; }
 
         /// <summary>The time when this signal is triggered, in milliseconds since the epoch.</summary>
+        [JsAccessPath("timeStamp")]
         [JsonPropertyName("timeStamp")]
         public EpochTime TimeStamp { get; set; }
 
         /// <summary>How the requested resource will be used.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         public ResourceType Type { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Url { get; set; }
 
         /// <summary>Tracking classification if the request has been classified.</summary>
+        [JsAccessPath("urlClassification")]
         [JsonPropertyName("urlClassification")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassification UrlClassification { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/Options.cs b/src/WebExtensions.Net/Generated/WebRequest/Options.cs
index 0f77d50..bbf5ea8 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/Options.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/Options.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.WebRequest
     public partial class Options : BaseObject
     {
         /// <summary>Include the entire certificate chain.</summary>
+        [JsAccessPath("certificateChain")]
         [JsonPropertyName("certificateChain")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? CertificateChain { get; set; }
 
         /// <summary>Include raw certificate data for processing by the extension.</summary>
+        [JsAccessPath("rawDER")]
         [JsonPropertyName("rawDER")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? RawDER { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/RequestBody.cs b/src/WebExtensions.Net/Generated/WebRequest/RequestBody.cs
index 1c63f3d..16c9f09 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/RequestBody.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/RequestBody.cs
@@ -10,16 +10,19 @@ namespace WebExtensions.Net.WebRequest
     public partial class RequestBody : BaseObject
     {
         /// <summary>Errors when obtaining request body data.</summary>
+        [JsAccessPath("error")]
         [JsonPropertyName("error")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Error { get; set; }
 
         /// <summary>If the request method is POST and the body is a sequence of key-value pairs encoded in UTF8, encoded as either multipart/form-data, or application/x-www-form-urlencoded, this dictionary is present and for each key contains the list of all values for that key. If the data is of another media type, or if it is malformed, the dictionary is not present. An example value of this dictionary is {'key': ['value1', 'value2']}.</summary>
+        [JsAccessPath("formData")]
         [JsonPropertyName("formData")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object FormData { get; set; }
 
         /// <summary>If the request method is PUT or POST, and the body is not already parsed in formData, then the unparsed request body elements are contained in this array.</summary>
+        [JsAccessPath("raw")]
         [JsonPropertyName("raw")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<UploadData> Raw { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/RequestFilter.cs b/src/WebExtensions.Net/Generated/WebRequest/RequestFilter.cs
index db045dd..174005f 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/RequestFilter.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/RequestFilter.cs
@@ -10,26 +10,31 @@ namespace WebExtensions.Net.WebRequest
     public partial class RequestFilter : BaseObject
     {
         /// <summary>If provided, requests that do not match the incognito state will be filtered out.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>A list of request types. Requests that cannot match any of the types will be filtered out.</summary>
+        [JsAccessPath("types")]
         [JsonPropertyName("types")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<ResourceType> Types { get; set; }
 
         /// <summary>A list of URLs or URL patterns. Requests that cannot match any of the URLs will be filtered out.</summary>
+        [JsAccessPath("urls")]
         [JsonPropertyName("urls")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<string> Urls { get; set; }
 
         /// <summary></summary>
+        [JsAccessPath("windowId")]
         [JsonPropertyName("windowId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? WindowId { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/UploadData.cs b/src/WebExtensions.Net/Generated/WebRequest/UploadData.cs
index 71f14c4..ec89556 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/UploadData.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/UploadData.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.WebRequest
     public partial class UploadData : BaseObject
     {
         /// <summary>An ArrayBuffer with a copy of the data.</summary>
+        [JsAccessPath("bytes")]
         [JsonPropertyName("bytes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public object Bytes { get; set; }
 
         /// <summary>A string with the file's path and name.</summary>
+        [JsAccessPath("file")]
         [JsonPropertyName("file")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string File { get; set; }
diff --git a/src/WebExtensions.Net/Generated/WebRequest/UrlClassification.cs b/src/WebExtensions.Net/Generated/WebRequest/UrlClassification.cs
index cc6d58e..f28467c 100644
--- a/src/WebExtensions.Net/Generated/WebRequest/UrlClassification.cs
+++ b/src/WebExtensions.Net/Generated/WebRequest/UrlClassification.cs
@@ -9,11 +9,13 @@ namespace WebExtensions.Net.WebRequest
     public partial class UrlClassification : BaseObject
     {
         /// <summary>Classification flags if the request has been classified and it is first party.</summary>
+        [JsAccessPath("firstParty")]
         [JsonPropertyName("firstParty")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassificationParty FirstParty { get; set; }
 
         /// <summary>Classification flags if the request has been classified and it or its window hierarchy is third party.</summary>
+        [JsAccessPath("thirdParty")]
         [JsonPropertyName("thirdParty")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public UrlClassificationParty ThirdParty { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Windows/CreateData.cs b/src/WebExtensions.Net/Generated/Windows/CreateData.cs
index 63fbc5c..72e9e3b 100644
--- a/src/WebExtensions.Net/Generated/Windows/CreateData.cs
+++ b/src/WebExtensions.Net/Generated/Windows/CreateData.cs
@@ -9,66 +9,79 @@ namespace WebExtensions.Net.Windows
     public partial class CreateData : BaseObject
     {
         /// <summary>Allow scripts to close the window.</summary>
+        [JsAccessPath("allowScriptsToClose")]
         [JsonPropertyName("allowScriptsToClose")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? AllowScriptsToClose { get; set; }
 
         /// <summary>The CookieStoreId to use for all tabs that were created when the window is opened.</summary>
+        [JsAccessPath("cookieStoreId")]
         [JsonPropertyName("cookieStoreId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string CookieStoreId { get; set; }
 
         /// <summary>If true, opens an active window. If false, opens an inactive window.</summary>
+        [JsAccessPath("focused")]
         [JsonPropertyName("focused")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Focused { get; set; }
 
         /// <summary>The height in pixels of the new window, including the frame. If not specified defaults to a natural height.</summary>
+        [JsAccessPath("height")]
         [JsonPropertyName("height")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Height { get; set; }
 
         /// <summary>Whether the new window should be an incognito window.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Incognito { get; set; }
 
         /// <summary>The number of pixels to position the new window from the left edge of the screen. If not specified, the new window is offset naturally from the last focused window. This value is ignored for panels.</summary>
+        [JsAccessPath("left")]
         [JsonPropertyName("left")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Left { get; set; }
 
         /// <summary>The initial state of the window. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left', 'top', 'width' or 'height'.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public WindowState? State { get; set; }
 
         /// <summary>The id of the tab for which you want to adopt to the new window.</summary>
+        [JsAccessPath("tabId")]
         [JsonPropertyName("tabId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? TabId { get; set; }
 
         /// <summary>A string to add to the beginning of the window title.</summary>
+        [JsAccessPath("titlePreface")]
         [JsonPropertyName("titlePreface")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string TitlePreface { get; set; }
 
         /// <summary>The number of pixels to position the new window from the top edge of the screen. If not specified, the new window is offset naturally from the last focused window. This value is ignored for panels.</summary>
+        [JsAccessPath("top")]
         [JsonPropertyName("top")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Top { get; set; }
 
         /// <summary>Specifies what type of browser window to create. The 'panel' and 'detached_panel' types create a popup unless the '--enable-panels' flag is set.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public CreateType? Type { get; set; }
 
         /// <summary>A URL or array of URLs to open as tabs in the window. Fully-qualified URLs must include a scheme (i.e. 'http://www.google.com', not 'www.google.com'). Relative URLs will be relative to the current page within the extension. Defaults to the New Tab Page.</summary>
+        [JsAccessPath("url")]
         [JsonPropertyName("url")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public Url Url { get; set; }
 
         /// <summary>The width in pixels of the new window, including the frame. If not specified defaults to a natural width.</summary>
+        [JsAccessPath("width")]
         [JsonPropertyName("width")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Width { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Windows/GetAllGetInfo.cs b/src/WebExtensions.Net/Generated/Windows/GetAllGetInfo.cs
index d47590f..c76d57d 100644
--- a/src/WebExtensions.Net/Generated/Windows/GetAllGetInfo.cs
+++ b/src/WebExtensions.Net/Generated/Windows/GetAllGetInfo.cs
@@ -10,6 +10,7 @@ namespace WebExtensions.Net.Windows
     public partial class GetAllGetInfo : BaseObject
     {
         /// <summary>If set, the $(ref:windows.Window) returned will be filtered based on its type. If unset the default filter is set to <c>['app', 'normal', 'panel', 'popup']</c>, with <c>'app'</c> and <c>'panel'</c> window types limited to the extension's own windows.</summary>
+        [JsAccessPath("windowTypes")]
         [JsonPropertyName("windowTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<WindowType> WindowTypes { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Windows/GetInfo.cs b/src/WebExtensions.Net/Generated/Windows/GetInfo.cs
index c156f01..ca99130 100644
--- a/src/WebExtensions.Net/Generated/Windows/GetInfo.cs
+++ b/src/WebExtensions.Net/Generated/Windows/GetInfo.cs
@@ -11,12 +11,14 @@ namespace WebExtensions.Net.Windows
     public partial class GetInfo : BaseObject
     {
         /// <summary>If true, the $(ref:windows.Window) returned will have a <c>tabs</c> property that contains a list of the $(ref:tabs.Tab) objects. The <c>Tab</c> objects only contain the <c>url</c>, <c>title</c> and <c>favIconUrl</c> properties if the extension's manifest file includes the <c>"tabs"</c> permission.</summary>
+        [JsAccessPath("populate")]
         [JsonPropertyName("populate")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Populate { get; set; }
 
         /// <summary><c>windowTypes</c> is deprecated and ignored on Firefox.</summary>
         [Obsolete("This has been marked as deprecated without a description message. Please refer to the summary comment or the official API documentation.")]
+        [JsAccessPath("windowTypes")]
         [JsonPropertyName("windowTypes")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<WindowType> WindowTypes { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Windows/IWindowsApi.cs b/src/WebExtensions.Net/Generated/Windows/IWindowsApi.cs
index 9221d9e..4780526 100644
--- a/src/WebExtensions.Net/Generated/Windows/IWindowsApi.cs
+++ b/src/WebExtensions.Net/Generated/Windows/IWindowsApi.cs
@@ -1,60 +1,74 @@
+using JsBind.Net;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace WebExtensions.Net.Windows
 {
     /// <summary>Use the <c>browser.windows</c> API to interact with browser windows. You can use this API to create, modify, and rearrange windows in the browser.</summary>
+    [JsAccessPath("windows")]
     public partial interface IWindowsApi
     {
         /// <summary>Fired when a window is created.</summary>
+        [JsAccessPath("onCreated")]
         OnCreatedEvent OnCreated { get; }
 
         /// <summary>Fired when the currently focused window changes. Will be $(ref:windows.WINDOW_ID_NONE) if all browser windows have lost focus. Note: On some Linux window managers, WINDOW_ID_NONE will always be sent immediately preceding a switch from one browser window to another.</summary>
+        [JsAccessPath("onFocusChanged")]
         OnFocusChangedEvent OnFocusChanged { get; }
 
         /// <summary>Fired when a window is removed (closed).</summary>
+        [JsAccessPath("onRemoved")]
         OnRemovedEvent OnRemoved { get; }
 
         /// <summary>The windowId value that represents the $(topic:current-window)[current window].</summary>
+        [JsAccessPath("WINDOW_ID_CURRENT")]
         int WINDOW_ID_CURRENT { get; }
 
         /// <summary>The windowId value that represents the absence of a browser window.</summary>
+        [JsAccessPath("WINDOW_ID_NONE")]
         int WINDOW_ID_NONE { get; }
 
         /// <summary>Creates (opens) a new browser with any optional sizing, position or default URL provided.</summary>
         /// <param name="createData"></param>
         /// <returns>Contains details about the created window.</returns>
+        [JsAccessPath("create")]
         ValueTask<Window> Create(CreateData createData = null);
 
         /// <summary>Gets details about a window.</summary>
         /// <param name="windowId"></param>
         /// <param name="getInfo"></param>
         /// <returns></returns>
+        [JsAccessPath("get")]
         ValueTask<Window> Get(int windowId, GetInfo getInfo = null);
 
         /// <summary>Gets all windows.</summary>
         /// <param name="getInfo">Specifies properties used to filter the $(ref:windows.Window) returned and to determine whether they should contain a list of the $(ref:tabs.Tab) objects.</param>
         /// <returns></returns>
+        [JsAccessPath("getAll")]
         ValueTask<IEnumerable<Window>> GetAll(GetAllGetInfo getInfo = null);
 
         /// <summary>Gets the $(topic:current-window)[current window].</summary>
         /// <param name="getInfo"></param>
         /// <returns></returns>
+        [JsAccessPath("getCurrent")]
         ValueTask<Window> GetCurrent(GetInfo getInfo = null);
 
         /// <summary>Gets the window that was most recently focused - typically the window 'on top'.</summary>
         /// <param name="getInfo"></param>
         /// <returns></returns>
+        [JsAccessPath("getLastFocused")]
         ValueTask<Window> GetLastFocused(GetInfo getInfo = null);
 
         /// <summary>Removes (closes) a window, and all the tabs inside it.</summary>
         /// <param name="windowId"></param>
+        [JsAccessPath("remove")]
         ValueTask Remove(int windowId);
 
         /// <summary>Updates the properties of a window. Specify only the properties that you want to change; unspecified properties will be left unchanged.</summary>
         /// <param name="windowId"></param>
         /// <param name="updateInfo"></param>
         /// <returns></returns>
+        [JsAccessPath("update")]
         ValueTask<Window> Update(int windowId, UpdateInfo updateInfo);
     }
 }
diff --git a/src/WebExtensions.Net/Generated/Windows/OnCreatedEvent.cs b/src/WebExtensions.Net/Generated/Windows/OnCreatedEvent.cs
index 8ed6071..f569f15 100644
--- a/src/WebExtensions.Net/Generated/Windows/OnCreatedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Windows/OnCreatedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnCreatedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a window is created.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<Window> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<Window> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<Window> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<Window> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<Window> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Windows/OnFocusChangedEvent.cs b/src/WebExtensions.Net/Generated/Windows/OnFocusChangedEvent.cs
index cf5c170..0d6db14 100644
--- a/src/WebExtensions.Net/Generated/Windows/OnFocusChangedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Windows/OnFocusChangedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnFocusChangedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when the currently focused window changes. Will be $(ref:windows.WINDOW_ID_NONE) if all browser windows have lost focus. Note: On some Linux window managers, WINDOW_ID_NONE will always be sent immediately preceding a switch from one browser window to another.</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Windows/OnRemovedEvent.cs b/src/WebExtensions.Net/Generated/Windows/OnRemovedEvent.cs
index ad27051..5b59cc2 100644
--- a/src/WebExtensions.Net/Generated/Windows/OnRemovedEvent.cs
+++ b/src/WebExtensions.Net/Generated/Windows/OnRemovedEvent.cs
@@ -12,6 +12,7 @@ public partial class OnRemovedEvent : Event
     {
         /// <summary>Registers an event listener <em>callback</em> to an event.</summary>
         /// <param name="callback">Fired when a window is removed (closed).</param>
+        [JsAccessPath("addListener")]
         public virtual ValueTask AddListener(Action<int> callback)
         {
             return InvokeVoidAsync("addListener", callback);
@@ -20,6 +21,7 @@ public virtual ValueTask AddListener(Action<int> callback)
         /// <summary></summary>
         /// <param name="callback">Listener whose registration status shall be tested.</param>
         /// <returns>True if <em>callback</em> is registered to the event.</returns>
+        [JsAccessPath("hasListener")]
         public virtual ValueTask<bool> HasListener(Action<int> callback)
         {
             return InvokeAsync<bool>("hasListener", callback);
@@ -27,6 +29,7 @@ public virtual ValueTask<bool> HasListener(Action<int> callback)
 
         /// <summary>Deregisters an event listener <em>callback</em> from an event.</summary>
         /// <param name="callback">Listener that shall be unregistered.</param>
+        [JsAccessPath("removeListener")]
         public virtual ValueTask RemoveListener(Action<int> callback)
         {
             return InvokeVoidAsync("removeListener", callback);
diff --git a/src/WebExtensions.Net/Generated/Windows/UpdateInfo.cs b/src/WebExtensions.Net/Generated/Windows/UpdateInfo.cs
index 72d3ac4..5f7d4ca 100644
--- a/src/WebExtensions.Net/Generated/Windows/UpdateInfo.cs
+++ b/src/WebExtensions.Net/Generated/Windows/UpdateInfo.cs
@@ -9,41 +9,49 @@ namespace WebExtensions.Net.Windows
     public partial class UpdateInfo : BaseObject
     {
         /// <summary>If true, causes the window to be displayed in a manner that draws the user's attention to the window, without changing the focused window. The effect lasts until the user changes focus to the window. This option has no effect if the window already has focus. Set to false to cancel a previous draw attention request.</summary>
+        [JsAccessPath("drawAttention")]
         [JsonPropertyName("drawAttention")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? DrawAttention { get; set; }
 
         /// <summary>If true, brings the window to the front. If false, brings the next window in the z-order to the front.</summary>
+        [JsAccessPath("focused")]
         [JsonPropertyName("focused")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public bool? Focused { get; set; }
 
         /// <summary>The height to resize the window to in pixels. This value is ignored for panels.</summary>
+        [JsAccessPath("height")]
         [JsonPropertyName("height")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Height { get; set; }
 
         /// <summary>The offset from the left edge of the screen to move the window to in pixels. This value is ignored for panels.</summary>
+        [JsAccessPath("left")]
         [JsonPropertyName("left")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Left { get; set; }
 
         /// <summary>The new state of the window. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left', 'top', 'width' or 'height'.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public WindowState? State { get; set; }
 
         /// <summary>A string to add to the beginning of the window title.</summary>
+        [JsAccessPath("titlePreface")]
         [JsonPropertyName("titlePreface")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string TitlePreface { get; set; }
 
         /// <summary>The offset from the top edge of the screen to move the window to in pixels. This value is ignored for panels.</summary>
+        [JsAccessPath("top")]
         [JsonPropertyName("top")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Top { get; set; }
 
         /// <summary>The width to resize the window to in pixels. This value is ignored for panels.</summary>
+        [JsAccessPath("width")]
         [JsonPropertyName("width")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Width { get; set; }
diff --git a/src/WebExtensions.Net/Generated/Windows/Window.cs b/src/WebExtensions.Net/Generated/Windows/Window.cs
index 063ef62..8382078 100644
--- a/src/WebExtensions.Net/Generated/Windows/Window.cs
+++ b/src/WebExtensions.Net/Generated/Windows/Window.cs
@@ -11,63 +11,76 @@ namespace WebExtensions.Net.Windows
     public partial class Window : BaseObject
     {
         /// <summary>Whether the window is set to be always on top.</summary>
+        [JsAccessPath("alwaysOnTop")]
         [JsonPropertyName("alwaysOnTop")]
         public bool AlwaysOnTop { get; set; }
 
         /// <summary>Whether the window is currently the focused window.</summary>
+        [JsAccessPath("focused")]
         [JsonPropertyName("focused")]
         public bool Focused { get; set; }
 
         /// <summary>The height of the window, including the frame, in pixels. Under some circumstances a Window may not be assigned height property, for example when querying closed windows from the $(ref:sessions) API.</summary>
+        [JsAccessPath("height")]
         [JsonPropertyName("height")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Height { get; set; }
 
         /// <summary>The ID of the window. Window IDs are unique within a browser session. Under some circumstances a Window may not be assigned an ID, for example when querying windows using the $(ref:sessions) API, in which case a session ID may be present.</summary>
+        [JsAccessPath("id")]
         [JsonPropertyName("id")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Id { get; set; }
 
         /// <summary>Whether the window is incognito.</summary>
+        [JsAccessPath("incognito")]
         [JsonPropertyName("incognito")]
         public bool Incognito { get; set; }
 
         /// <summary>The offset of the window from the left edge of the screen in pixels. Under some circumstances a Window may not be assigned left property, for example when querying closed windows from the $(ref:sessions) API.</summary>
+        [JsAccessPath("left")]
         [JsonPropertyName("left")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Left { get; set; }
 
         /// <summary>The session ID used to uniquely identify a Window obtained from the $(ref:sessions) API.</summary>
+        [JsAccessPath("sessionId")]
         [JsonPropertyName("sessionId")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string SessionId { get; set; }
 
         /// <summary>The state of this browser window.</summary>
+        [JsAccessPath("state")]
         [JsonPropertyName("state")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public WindowState? State { get; set; }
 
         /// <summary>Array of $(ref:tabs.Tab) objects representing the current tabs in the window.</summary>
+        [JsAccessPath("tabs")]
         [JsonPropertyName("tabs")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IEnumerable<Tab> Tabs { get; set; }
 
         /// <summary>The title of the window. Read-only.</summary>
+        [JsAccessPath("title")]
         [JsonPropertyName("title")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public string Title { get; set; }
 
         /// <summary>The offset of the window from the top edge of the screen in pixels. Under some circumstances a Window may not be assigned top property, for example when querying closed windows from the $(ref:sessions) API.</summary>
+        [JsAccessPath("top")]
         [JsonPropertyName("top")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Top { get; set; }
 
         /// <summary>The type of browser window this is.</summary>
+        [JsAccessPath("type")]
         [JsonPropertyName("type")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public WindowType? Type { get; set; }
 
         /// <summary>The width of the window, including the frame, in pixels. Under some circumstances a Window may not be assigned width property, for example when querying closed windows from the $(ref:sessions) API.</summary>
+        [JsAccessPath("width")]
         [JsonPropertyName("width")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public int? Width { get; set; }
diff --git a/src/WebExtensions.Net/Generated/generated.txt b/src/WebExtensions.Net/Generated/generated.txt
index 15381ad..8be7f04 100644
--- a/src/WebExtensions.Net/Generated/generated.txt
+++ b/src/WebExtensions.Net/Generated/generated.txt
@@ -1 +1 @@
-This file is auto generated at 2024-05-12T08:22:02
\ No newline at end of file
+This file is auto generated at 2024-06-21T23:17:36
\ No newline at end of file