full reorg

1 files changed, 13955 insertions, 0 deletions

diff --git a/config/glide/glide.d.ts b/config/glide/glide.d.ts
new file mode 100644
index 0000000..db2d26f
--- /dev/null
+++ b/config/glide/glide.d.ts
@@ -0,0 +1,13955 @@
+/* ======================================================
+                Glide version: 0.1.52a
+   ====================================================== */
+
+declare const GLIDE_EXCOMMANDS: [
+	{
+		readonly name: "back";
+		readonly description: "Go back one page in history";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "forward";
+		readonly description: "Go forward one page in history";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "reload";
+		readonly description: "Reload the current page";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "reload_hard";
+		readonly description: "Reload the current page, bypassing the cache";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "quit";
+		readonly description: "Close all windows";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "clear";
+		readonly description: "Clear all notifications";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "set";
+		readonly description: "Set an option";
+		readonly args_schema: {
+			readonly name: {
+				readonly type: "string";
+				readonly position: 0;
+				readonly required: true;
+			};
+			readonly value: {
+				readonly type: "string";
+				readonly position: 1;
+				readonly required: true;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "profile_dir";
+		readonly description: "Show the current profile directory";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "config_edit";
+		readonly description: "Open the config file in the default editor";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "config_path";
+		readonly description: "Show the config file path";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "config_reload";
+		readonly description: "Reload the config file";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "config_init";
+		readonly description: "Initialise a config dir with all the necessary setup";
+		readonly args_schema: {
+			readonly location: {
+				readonly type: {
+					readonly enum: readonly [
+						"home",
+						"profile",
+						"cwd"
+					];
+				};
+				readonly required: false;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "css_edit";
+		readonly description: "Open the userChrome.css file in the default editor";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "repeat";
+		readonly description: "Repeat the last invoked command. In general only applies to \"mutative\" commands";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "map";
+		readonly description: "Show all mappings";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "unmap";
+		readonly description: "Remove a mapping from normal mode";
+		readonly args_schema: {
+			readonly lhs: {
+				readonly type: "string";
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "nunmap";
+		readonly description: "Remove a mapping from normal mode";
+		readonly args_schema: {
+			readonly lhs: {
+				readonly type: "string";
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "iunmap";
+		readonly description: "Remove a mapping from insert mode";
+		readonly args_schema: {
+			readonly lhs: {
+				readonly type: "string";
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "tab";
+		readonly description: "Switch to the given tab index";
+		readonly args_schema: {
+			readonly tab_index: {
+				readonly type: "integer";
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "tab_new";
+		readonly description: "Create a new tab with the given URL or the default new tab page if not provided";
+		readonly args_schema: {
+			readonly url: {
+				readonly type: "string";
+				readonly required: false;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "tab_close";
+		readonly description: "Close the current tab";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "tab_next";
+		readonly description: "Switch to the next tab, wrapping around if applicable";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "tab_prev";
+		readonly description: "Switch to the previous tab, wrapping around if applicable";
+		readonly content: false;
+		readonly repeatable: true;
+	},
+	{
+		readonly name: "commandline_show";
+		readonly description: "Show the commandline UI";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "commandline_toggle";
+		readonly description: "Toggle the commandline UI";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "commandline_focus_next";
+		readonly description: "Focus the next completion in the commandline";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "commandline_focus_back";
+		readonly description: "Focus the previous completion in the commandline";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "commandline_delete";
+		readonly description: "Delete the focused commandline completion";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "commandline_accept";
+		readonly description: "Accept the focused commandline completion";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "url_yank";
+		readonly description: "Yank the URL of the current tab to the clipboard";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "echo";
+		readonly description: "Log the given arguments to the console";
+		readonly content: false;
+		readonly args_schema: {};
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "mode_change";
+		readonly description: "Change the current mode";
+		readonly content: false;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly mode: {
+				readonly type: {
+					readonly enum: GlideMode[];
+				};
+				readonly required: true;
+				readonly position: 0;
+			};
+			readonly "--automove": {
+				readonly type: {
+					readonly enum: readonly [
+						"left",
+						"endline"
+					];
+				};
+				readonly required: false;
+			};
+			readonly "--operator": {
+				readonly type: {
+					readonly enum: readonly [
+						"d",
+						"c",
+						"r"
+					];
+				};
+				readonly required: false;
+				readonly description: "Only applicable for operator-pending mode";
+			};
+		};
+	},
+	{
+		readonly name: "caret_move";
+		readonly description: "Move the text caret";
+		readonly content: false;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly direction: {
+				readonly type: {
+					readonly enum: readonly [
+						"left",
+						"right",
+						"up",
+						"down"
+					];
+				};
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+	},
+	{
+		readonly name: "visual_selection_copy";
+		readonly description: "Copy the currently selected text to the clipboard & change to normal mode";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "help";
+		readonly description: "Open the docs";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "tutor";
+		readonly description: "Open the Glide tutorial";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "repl";
+		readonly description: "Start the config REPL";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "keys";
+		readonly description: "Synthesize the given key sequence as if they were actually pressed";
+		readonly args_schema: {
+			readonly keyseq: {
+				readonly type: "string";
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "r";
+		readonly description: "Replace the current character";
+		readonly content: false;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly character: {
+				readonly type: "string";
+				readonly required: false;
+				readonly position: 0;
+			};
+		};
+	},
+	{
+		readonly name: "scroll_top";
+		readonly description: "Scroll to the top of the window";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "scroll_page_down";
+		readonly description: "Scroll down by 1 page (the size of the viewport)";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "scroll_page_up";
+		readonly description: "Scroll up by 1 page (the size of the viewport)";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "scroll_bottom";
+		readonly description: "Scroll to the bottom of the window";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "blur";
+		readonly description: "Blur the active element";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "focusinput";
+		readonly description: "Focus an input element based on the given filter";
+		readonly content: true;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly filter: {
+				readonly type: {
+					readonly enum: readonly [
+						"last"
+					];
+				};
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+	},
+	{
+		readonly name: "hint";
+		readonly description: "Show hint labels for jumping to clickable elements";
+		readonly content: false;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly "-s": {
+				readonly type: "string";
+				readonly required: false;
+				readonly description: "*Only* show hints for all elements matching this CSS selector";
+			};
+			readonly "--include": {
+				readonly type: "string";
+				readonly required: false;
+				readonly description: "*Also* show hints for all elements matching this CSS selector";
+			};
+			readonly "-e": {
+				readonly type: "boolean";
+				readonly required: false;
+				readonly description: "*Only* show hints for all elements that are editable";
+			};
+			readonly "--auto": {
+				readonly type: "boolean";
+				readonly required: false;
+				readonly description: "If only one hint is generated, automatically activate it.";
+			};
+			readonly "--action": {
+				readonly type: {
+					readonly enum: readonly [
+						"click",
+						"newtab-click"
+					];
+				};
+				readonly required: false;
+			};
+			readonly "--location": {
+				readonly type: {
+					readonly enum: readonly [
+						"content",
+						"browser-ui"
+					];
+				};
+				readonly required: false;
+			};
+		};
+	},
+	{
+		readonly name: "hints_remove";
+		readonly description: "Remove all hint labels and exit hint mode";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "execute_motion";
+		readonly description: "Used from op-pending mode to execute a motion.";
+		readonly content: true;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "motion";
+		readonly description: "Execute a given motion (internal)";
+		readonly content: true;
+		readonly repeatable: false;
+		readonly args_schema: {
+			readonly keyseq: {
+				readonly type: {
+					readonly enum: readonly [
+						"w",
+						"W",
+						"e",
+						"b",
+						"B",
+						"0",
+						"$",
+						"{",
+						"}",
+						"s",
+						"v",
+						"vh",
+						"vl",
+						"vd",
+						"vc",
+						"x",
+						"X",
+						"o"
+					];
+				};
+				readonly required: true;
+				readonly position: 0;
+			};
+		};
+	},
+	{
+		readonly name: "undo";
+		readonly description: "Undo the most recent edit";
+		readonly content: false;
+		readonly repeatable: false;
+	},
+	{
+		readonly name: "redo";
+		readonly description: "Redo the most recent undo";
+		readonly content: false;
+		readonly repeatable: false;
+	}
+];
+export type GlideExcmdName = (typeof GLIDE_EXCOMMANDS)[number]["name"];
+export type GlideCommandString = GlideExcmdName | `${GlideExcmdName} ${string}`;
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+declare global {
+	var glide: {
+		ctx: {
+			/**
+			 * The currently active mode.
+			 */
+			mode: GlideMode;
+			/**
+			 * The URL of the currently focused tab.
+			 */
+			url: URL;
+			/**
+			 * The operating system Glide is running on.
+			 */
+			os: "linux" | "win" | "macosx" | "ios" | "android" | "other";
+			/**
+			 * Whether or not the currently focused element is editable.
+			 *
+			 * This includes but is not limited to `html:<textarea>`, `html:<input>`, `contenteditable=true`.
+			 */
+			is_editing(): Promise<boolean>;
+		};
+		/**
+		 * Set browser-wide options.
+		 */
+		/// @docs-expand-type-reference
+		o: glide.Options;
+		/**
+		 * Set buffer specific options.
+		 *
+		 * This has the exact same API as {@link glide.o}.
+		 */
+		bo: Partial<glide.Options>;
+		options: {
+			/**
+			 * Returns either a buffer-specific option, or the global version. In that order
+			 */
+			get<Name extends keyof glide.Options>(name: Name): glide.Options[Name];
+		};
+		env: {
+			/**
+			 * Get the value of an environment variable.
+			 *
+			 * If it does not exist `null` is returned.
+			 */
+			get(name: string): string | null;
+			/**
+			 * Set the value of an environment variable.
+			 */
+			set(name: string, value: string): void;
+			/**
+			 * Remove an environment variable.
+			 *
+			 * Does *not* error if the environment variable did not already exist.
+			 *
+			 * Returns the value of the deleted environment variable, if it did not exist `null` is returned.
+			 */
+			delete(name: string): string | null;
+		};
+		process: {
+			/**
+			 * Spawn a new process. The given `command` can either be the name of a binary in the `PATH`
+			 * or an absolute path to a binary file.
+			 *
+			 * If the process exits with a non-zero code, an error will be thrown, you can disable this check with `{ check_exit_code: false }`.
+			 *
+			 * ```ts
+			 * const proc = await glide.process.spawn('kitty', ['nvim', 'glide.ts'], { cwd: '~/.dotfiles/glide' });
+			 * console.log('opened kitty with pid', proc.pid);
+			 * ```
+			 */
+			spawn(command: string, args?: string[] | null | undefined, opts?: glide.SpawnOptions): Promise<glide.Process>;
+			/**
+			 * Spawn a new process and wait for it to exit.
+			 *
+			 * See {@link glide.process.spawn} for more information.
+			 */
+			execute(command: string, args?: string[] | null | undefined, opts?: glide.SpawnOptions): Promise<glide.CompletedProcess>;
+		};
+		autocmds: {
+			/**
+			 * Create an autocmd that will be invoked whenever the focused URL changes.
+			 *
+			 * This includes:
+			 *   1. URL changes within the same tab
+			 *   2. Switching tabs
+			 *   3. Navigating back and forth in history within the same tab
+			 */
+			create<const Event extends "UrlEnter">(event: Event, pattern: glide.AutocmdPatterns[Event], callback: (args: glide.AutocmdArgs[Event]) => void): void;
+			/**
+			 * Create an autocmd that will be invoked whenever the mode changes.
+			 *
+			 * The pattern is matched against `old_mode:new_mode`. You can also use `*` as a placeholder
+			 * to match *any* mode.
+			 *
+			 * for example, to define an autocmd that will be fired every time visual mode is entered:
+			 *
+			 * `*:visual`
+			 *
+			 * or when visual mode is left:
+			 *
+			 * `visual:*`
+			 *
+			 * or transitioning from visual to insert:
+			 *
+			 * `visual:insert`
+			 *
+			 * or for just any mode:
+			 *
+			 * `*`
+			 */
+			create<const Event extends "ModeChanged">(event: Event, pattern: glide.AutocmdPatterns[Event], callback: (args: glide.AutocmdArgs[Event]) => void): void;
+			/**
+			 * Create an autocmd that will be invoked whenever the key sequence changes.
+			 *
+			 * This will be fired under four circumstances:
+			 *
+			 * 1. A key is pressed that matches a key mapping.
+			 * 2. A key is pressed that is part of a key mapping.
+			 * 3. A key is pressed that cancels a previous partial key mapping sequence.
+			 * 4. A partial key mapping is cancelled (see {@link glide.o.mapping_timeout})
+			 *
+			 * For example, with
+			 * ```typescript
+			 * glide.keymaps.set('normal', 'gt', '...');
+			 * ```
+			 *
+			 * Pressing `g` will fire with `{ sequence: ["g"], partial: true }`, then either:
+			 * - Pressing `t` would fire `{ sequence: ["g", "t"], partial: false }`
+			 * - Pressing any other key would fire `{ sequence: [], partial: false }`
+			 *
+			 * Note that this is not fired for consecutive key presses for keys that don't correspond to mappings,
+			 * as the key state has not changed.
+			 */
+			create<const Event extends "KeyStateChanged">(event: Event, callback: (args: glide.AutocmdArgs[Event]) => void): void;
+			/**
+			 * Create an autocmd that will be invoked whenever the config is loaded.
+			 *
+			 * Called once on initial load and again every time the config is reloaded.
+			 */
+			create<const Event extends "ConfigLoaded">(event: Event, callback: (args: glide.AutocmdArgs[Event]) => void): void;
+			/**
+			 * Create an autocmd that will be invoked when the window is initially loaded.
+			 *
+			 * **note**: this is not invoked when the config is reloaded.
+			 */
+			create<const Event extends "WindowLoaded">(event: Event, callback: (args: glide.AutocmdArgs[Event]) => void): void;
+			create<const Event extends glide.AutocmdEvent>(event: Event, pattern: glide.AutocmdPatterns[Event] extends never ? (args: glide.AutocmdArgs[Event]) => void : glide.AutocmdPatterns[Event], callback?: (args: glide.AutocmdArgs[Event]) => void): void;
+		};
+		prefs: {
+			/**
+			 * Set a preference. This is an alternative to `prefs.js` / [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox) so
+			 * that all customisation can be represented in a single `glide.ts` file.
+			 *
+			 * **warning**: this function is expected to be called at the top-level of your config, there is no guarantee that calling {@link glide.prefs.set} in callbacks
+			 *              will result in the pref being properly applied everywhere.
+			 *
+			 * **warning**: there is also no guarantee that these settings will be applied when first loaded, sometimes a restart is required.
+			 */
+			set(name: string, value: string | number | boolean): void;
+			/**
+			 * Get the value of a pref.
+			 *
+			 * If the pref is not defined, then `undefined` is returned.
+			 */
+			get(name: string): string | number | boolean | undefined;
+			/**
+			 * Reset the pref value back to its default.
+			 */
+			clear(name: string): void;
+		};
+		/**
+		 * Equivalent to `vim.g`.
+		 *
+		 * You can also store arbitrary data here in a typesafe fashion with:
+		 * ```ts
+		 * declare global {
+		 *   interface GlideGlobals {
+		 *     my_prop?: boolean;
+		 *   }
+		 * }
+		 * glide.g.my_prop = true;
+		 * ```
+		 */
+		/// @docs-expand-type-reference
+		g: GlideGlobals;
+		tabs: {
+			/**
+			 * Returns the active tab for the currently focused window.
+			 *
+			 * This is equivalent to:
+			 * ```ts
+			 * const tab = await browser.tabs.query({ active: true, currentWindow: true })[0];
+			 * ```
+			 * But with additional error handling for invalid states.
+			 */
+			active(): Promise<glide.TabWithID>;
+			/**
+			 * Find the first tab matching the given query filter.
+			 *
+			 * This is the same API as [browser.tabs.get](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/get),
+			 * but returns the first tab instead of an Array.
+			 */
+			get_first(query: Browser.Tabs.QueryQueryInfoType): Promise<Browser.Tabs.Tab | undefined>;
+			/**
+			 * Gets all tabs that have the specified properties, or all tabs if no properties are specified.
+			 *
+			 * This is the same API as [browser.tabs.get](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query),
+			 */
+			query(query: Browser.Tabs.QueryQueryInfoType): Promise<Browser.Tabs.Tab[]>;
+		};
+		excmds: {
+			/**
+			 * Execute an excmd, this is the same as typing `:cmd --args`.
+			 */
+			execute(cmd: glide.ExcmdString): Promise<void>;
+			/**
+			 * Create a new excmd.
+			 *
+			 * e.g.
+			 * ```typescript
+			 * const cmd = glide.excmds.create(
+			 *   { name: "my_excmd", description: "..." },
+			 *   () => {
+			 *     // ...
+			 *   }
+			 * );
+			 * declare global {
+			 *   interface ExcmdRegistry {
+			 *     my_excmd: typeof cmd;
+			 *   }
+			 * }
+			 * ```
+			 */
+			create<const Excmd extends glide.ExcmdCreateProps>(info: Excmd, fn: (props: glide.ExcmdCallbackProps) => void | Promise<void>): Excmd;
+		};
+		content: {
+			/**
+			 * Execute a function in the content process for the given tab.
+			 *
+			 * The given function will be stringified before being sent across processes, which
+			 * means it **cannot** capture any outside variables.
+			 *
+			 * If you need to pass some context into the function, use `args`, e.g.
+			 *
+			 * ```ts
+			 * function set_body_border_style(css: string) {
+			 *  document.body.style.setProperty('border', css)
+			 * }
+			 * await glide.content.execute(set_body_border_style, { tab_id, args: ["20px dotted pink"] })
+			 * ```
+			 *
+			 * Note: all `args` must be JSON serialisable.
+			 */
+			execute<F extends (...args: any[]) => any>(func: F, opts: {
+				/**
+				 * The ID of the tab into which to inject.
+				 *
+				 * Or the tab object as returned by {@link glide.tabs.active}.
+				 */
+				tab_id: number | glide.TabWithID;
+			} & (Parameters<F> extends [
+			] ? {
+				/**
+				 * Note: the given function doesn't take any arguments but if
+				 *       it did, you could pass them here.
+				 */
+				args?: undefined;
+			} : {
+				/**
+				 * Arguments to pass to the given function.
+				 *
+				 * **Must** be JSON serialisable
+				 */
+				args: Parameters<F>;
+			})): Promise<ReturnType<F>>;
+		};
+		keymaps: {
+			set<const LHS>(modes: GlideMode | GlideMode[], lhs: $keymapcompletions.T<LHS>, rhs: glide.ExcmdString | glide.KeymapCallback, opts?: glide.KeymapOpts | undefined): void;
+			/**
+			 * Remove the mapping of {lhs} for the {modes} where the map command applies.
+			 *
+			 * The mapping may remain defined for other modes where it applies.
+			 */
+			del<const LHS>(modes: GlideMode | GlideMode[], lhs: $keymapcompletions.T<LHS>, opts?: glide.KeymapDeleteOpts): void;
+			/**
+			 * List all global key mappings.
+			 *
+			 * If a key mapping is defined for multiple modes, multiple entries
+			 * will be returned for each mode.
+			 */
+			list(modes?: GlideMode | GlideMode[]): glide.Keymap[];
+		};
+		hints: {
+			/**
+			 * Find and show hints for "clickable" elements in the content frame.
+			 *
+			 * An optional `action()` function can be passed that will be invoked when
+			 * a hint is selected.
+			 */
+			show(opts?: {
+				/**
+				 * *Only* show hints for all elements matching this [CSS selector](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors).
+				 *
+				 * @example "li, textarea"
+				 * @example "[id="my-element"]"
+				 */
+				selector?: string;
+				/**
+				 * *Also* show hints for all elements matching this [CSS selector](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors)
+				 * as well as the default set of [hintable elements](https://glide-browser.app/hints#hintable-elements).
+				 *
+				 * @example "li, textarea"
+				 * @example "[id="my-element"]"
+				 */
+				include?: string;
+				/**
+				 * *Only* show hints for elements that are editable.
+				 */
+				editable?: boolean;
+				/**
+				 * If only one hint is generated, automatically activate it.
+				 *
+				 * @default false
+				 */
+				auto_activate?: boolean;
+				/**
+				 * Callback invoked when the selected hint is chosen.
+				 *
+				 * This is executed in the content process.
+				 */
+				action?: "click" | "newtab-click" | ((target: HTMLElement) => Promise<void>);
+				/**
+				 * Which area to generate hints for.
+				 *
+				 * - `content` - Show hints for clickable elements within the web page (links, buttons, etc.)
+				 * - `chrome` - Show hints for browser interface elements (toolbar buttons, tabs, menus, etc.)
+				 *
+				 * @default "content"
+				 */
+				location?: glide.HintLocation;
+				/**
+				 * Define a callback to filter the resolved hints. It is called once with the resolved hints,
+				 * and must return an array of the hints you want to include.
+				 *
+				 * An empty array may be returned but will result in an error notification indicating that no
+				 * hints were found.
+				 *
+				 * @content this function is evaluated in the content process.
+				 */
+				pick?: (hints: glide.ContentHint[]) => glide.ContentHint[];
+			}): void;
+		};
+		buf: {
+			prefs: {
+				/**
+				 * Set a preference for the current buffer. When navigating to a new buffer, the pref will be reset
+				 * to the previous value.
+				 *
+				 * See {@link glide.prefs.set} for more information.
+				 */
+				set(name: string, value: string | number | boolean): void;
+			};
+			keymaps: {
+				set<const LHS>(modes: GlideMode | GlideMode[], lhs: $keymapcompletions.T<LHS>, rhs: glide.ExcmdString | glide.KeymapCallback, opts?: Omit<glide.KeymapOpts, "buffer"> | undefined): void;
+				/**
+				 * Remove the mapping of {lhs} for the {modes} where the map command applies.
+				 *
+				 * The mapping may remain defined for other modes where it applies.
+				 */
+				del(modes: GlideMode | GlideMode[], lhs: string, opts?: Omit<glide.KeymapDeleteOpts, "buffer"> | undefined): void;
+			};
+		};
+		keys: {
+			/**
+			 * Send a key sequence to the browser, simulating physical key presses.
+			 *
+			 * The key sequence can include multiple regular keys, special keys, and modifiers.
+			 *
+			 * For example:
+			 *
+			 * ```ts
+			 * // Send a simple key sequence, each char is sent separately
+			 * await glide.keys.send("hello");
+			 *
+			 * // Send with modifiers, results in two events
+			 * // - { ctrlKey: true, key: 'a' }
+			 * // - { ctrlKey: true, key: 'c' }
+			 * await glide.keys.send("<C-a><C-c>");
+			 * ```
+			 */
+			send<const Keys>(keyseq: $keymapcompletions.T<Keys> | {
+				glide_key: string;
+			}, opts?: glide.KeySendOptions): Promise<void>;
+			/**
+			 * Returns a `Promise` that resolves to a {@link glide.KeyEvent} when the next key is pressed.
+			 *
+			 * This also prevents the key input from being processed further and does *not* invoke any associated mappings.
+			 *
+			 * If you *want* to inspect keys without preventing any default behaviour, you can use {@link glide.keys.next_passthrough}.
+			 *
+			 * Note: there can only be one `Promise` registered at any given time.
+			 *
+			 * Note: this does not include modifier keys by themselves, e.g. just pressing ctrl will not resolve
+			 *       until another key is pressed, e.g. `<C-a>`.
+			 */
+			next(): Promise<glide.KeyEvent>;
+			/**
+			 * Returns a `Promise` that resolves to a {@link glide.KeyEvent} when the next key is pressed.
+			 *
+			 * Unlike {@link glide.keys.next}, this does not prevent key events from passing through into their original behaviour.
+			 *
+			 * Note: this does not include modifier keys by themselves, e.g. just pressing ctrl will not resolve
+			 *       until another key is pressed, e.g. `<C-a>`.
+			 */
+			next_passthrough(): Promise<glide.KeyEvent>;
+			/**
+			 * Returns a `Promise` that resolves to a string representation of the key, when the next key is pressed.
+			 *
+			 * This also prevents the key input from being processed further and does *not* invoke any associated mappings.
+			 *
+			 * If you *want* to inspect keys without preventing any default behaviour, you can use {@link glide.keys.next_passthrough}.
+			 *
+			 * Note: there can only be one `Promise` registered at any given time.
+			 *
+			 * Note: this does not include modifier keys by themselves, e.g. just pressing ctrl will not resolve
+			 *       until another key is pressed, e.g. `<C-a>`.
+			 *
+			 * @example 'd'
+			 * @example '<C-l>'
+			 */
+			next_str(): Promise<string>;
+			/**
+			 * Parse a single key notation into a structured object.
+			 *
+			 * This normalises special keys to be consistent but otherwise the
+			 * parsed object only containers modifiers that were in the input string.
+			 *
+			 * Shifted keys are *not* special cased, the returned key is whatever was given
+			 * in in the input.
+			 *
+			 * @example "<Space>" -> { key: "<Space>" }
+			 * @example "H" -> { key: "H" }
+			 * @example "<S-h>" -> { key: "h", shift: true }
+			 * @example "<S-H>" -> { key: "H", shift: true }
+			 * @example "<C-S-a>" -> { key: "A", shift: true, ctrl: true }
+			 * @example "<M-a>" -> { key: "a", meta: true }
+			 */
+			parse(key_notation: string): glide.KeyNotation;
+		};
+		unstable: {
+			/**
+			 * Include another file as part of your config. The given file is evluated as if it
+			 * was just another Glide config file.
+			 *
+			 * **note**: this only supports files that are directly relative to your config file,
+			 *           for example, `ts:"shared.glide.ts"` or `ts:"shared/glide.ts"` would work but
+			 *           `ts:"../shared/glide.ts"` will not.
+			 *
+			 * **note**: this function cannot be called from inside a file that has been included
+			 *           itself, i.e. nested {@link glide.unstable.include} calls are not supported.
+			 *
+			 * @example glide.unstable.include("shared.glide.ts")
+			 */
+			include(path: string): Promise<void>;
+		};
+		path: {
+			readonly cwd: string;
+			readonly home_dir: string;
+			readonly temp_dir: string;
+			readonly profile_dir: string;
+			/**
+			 * Join all arguments together and normalize the resulting path.
+			 *
+			 * Throws an error on non-relative paths.
+			 */
+			join(...parts: string[]): string;
+		};
+		fs: {
+			/**
+			 * Read the file at the given path.
+			 *
+			 * Relative paths are resolved relative to the config directory, if no config directory is defined then relative
+			 * paths are not allowed.
+			 *
+			 * The `encoding` must currently be set to `"utf8"` as that is the only supported encoding.
+			 *
+			 * @example await glide.fs.read("github.css", "utf8");
+			 */
+			read(path: string, encoding: "utf8"): Promise<string>;
+			/**
+			 * Write to the file at the given path.
+			 *
+			 * Relative paths are resolved relative to the config directory, if no config directory is defined then relative
+			 * paths are not allowed.
+			 *
+			 * If the path has parent directories that do not exist, they will be created.
+			 *
+			 * The `contents` are written in utf8.
+			 *
+			 * @example await glide.fs.write("github.css", ".copilot { display: none !important }");
+			 */
+			write(path: string, contents: string): Promise<void>;
+			/**
+			 * Determine if the given path exists.
+			 *
+			 * Relative paths are resolved relative to the config directory, if no config directory is defined then relative
+			 * paths are not allowed.
+			 *
+			 * @example await glide.fs.exists(`${glide.path.home_dir}/.config/foo`);
+			 */
+			exists(path: string): Promise<boolean>;
+			/**
+			 * Obtain information about a file, such as size, modification dates, etc.
+			 *
+			 * Relative paths are resolved relative to the config directory, if no config directory is defined then relative
+			 * paths are not allowed.
+			 *
+			 * ```ts
+			 * const stat = await glide.fs.stat('userChrome.css');
+			 * stat.last_modified // 1758835015092
+			 * stat.type // "file"
+			 * ```
+			 */
+			stat(path: string): Promise<glide.FileInfo>;
+		};
+		messengers: {
+			/**
+			 * Create a {@link glide.ParentMessenger} that can be used to communicate with the content process.
+			 *
+			 * Communication is currently uni-directional, the content process can communicate with the main
+			 * process, but not the other way around.
+			 *
+			 * Sending and receiving messages is type safe & determined from the type variable passed to this function.
+			 * e.g. in the example below, the only message that can be sent is `my_message`.
+			 *
+			 * ```typescript
+			 * // create a messenger and pass in the callback that will be invoked
+			 * // when `messenger.send()` is called below
+			 * const messenger = glide.messengers.create<{ my_message: null }>((message) => {
+			 *   switch (message.name) {
+			 *     case "my_message": {
+			 *       // ...
+			 *       break;
+			 *     }
+			 *   }
+			 * });
+			 *
+			 * glide.keymaps.set("normal", "gt", ({ tab_id }) => {
+			 *   // note the `messenger.content.execute()` function intead of
+			 *   // the typical `glide.content.execute()` function.
+			 *   messenger.content.execute((messenger) => {
+			 *     document.addEventListener('focusin', (event) => {
+			 *       if (event.target.id === 'my-element') {
+			 *         messenger.send('my_message');
+			 *       }
+			 *     })
+			 *   }, { tab_id });
+			 * });
+			 * ```
+			 */
+			create<Messages extends Record<string, any>>(receiver: (message: glide.Message<Messages>) => void): glide.ParentMessenger<Messages>;
+		};
+		modes: {
+			/**
+			 * Register a custom `mode`.
+			 *
+			 * **note**: you must *also* register it as a type like so:
+			 *
+			 * ```typescript
+			 * declare global {
+			 *   interface GlideModes {
+			 *     leap: "leap";
+			 *   }
+			 * }
+			 * glide.modes.register('leap', { caret: 'block' })
+			 * ```
+			 */
+			register<Mode extends keyof GlideModes>(mode: Mode, opts: {
+				caret: "block" | "line" | "underline";
+			}): void;
+		};
+	};
+	/**
+	 * Defines all the supported modes.
+	 *
+	 * **note**: the key is what defines the list of supported modes, currently the value is
+	 *           not used for anything.
+	 *
+	 * **note**: you must *also* register it at runtime like so:
+	 *
+	 * ```typescript
+	 * declare global {
+	 *   interface GlideModes {
+	 *     leap: "leap";
+	 *   }
+	 * }
+	 * glide.modes.register('leap', { caret: 'block' })
+	 * ```
+	 */
+	interface GlideModes {
+		normal: "normal";
+		insert: "insert";
+		visual: "visual";
+		ignore: "ignore";
+		command: "command";
+		"op-pending": "op-pending";
+	}
+	/**
+	 * All of the supported modes.
+	 *
+	 * See {@link GlideModes} for more information.
+	 */
+	type GlideMode = keyof GlideModes;
+	interface GlideGlobals {
+		/**
+		 * The key notation that any `<leader>` mapping matches against.
+		 *
+		 * For example, a mapping defined with `<leader>r` would be matched when Space + r is pressed.
+		 *
+		 * @default "<Space>"
+		 */
+		mapleader: string;
+	}
+	/**
+	 * Throws an error if the given value is not truthy.
+	 *
+	 * Returns the value if it is truthy.
+	 */
+	function ensure<T>(value: T, message?: string): T extends false | "" | 0 | 0n | null | undefined ? never : T;
+	/**
+	 * Assert an invariant. An \`AssertionError\` will be thrown if `value` is falsy.
+	 */
+	function assert(value: unknown, message?: string): asserts value;
+	/**
+	 * The inverse of `{@link assert}`, useful for blowing up when the condition becomes `truthy`.
+	 */
+	function todo_assert(value: unknown, message?: string): void;
+	/**
+	 * Helper function for asserting exhaustiveness checks.
+	 *
+	 * You can optionally pass a second argument which will be used as the error message,
+	 * if not given then the first argument will be stringified in the error message.
+	 *
+	 * ```typescript
+	 * switch (union.type) {
+	 *  case 'type1': ...
+	 *  case 'type2': ...
+	 *  default:
+	 *    throw assert_never(union.type);
+	 * }
+	 */
+	function assert_never(x: never, detail?: string | Error): never;
+	class FileNotFoundError extends Error {
+		path: string;
+		constructor(message: string, props: {
+			path: string;
+		});
+	}
+	class GlideProcessError extends Error {
+		process: glide.CompletedProcess;
+		exit_code: number;
+		constructor(message: string, process: glide.CompletedProcess);
+	}
+	/**
+	 * Interface used to define types for excmds, intended for declaration merging.
+	 *
+	 * e.g.
+	 * ```typescript
+	 * const cmd = glide.excmds.create(
+	 *   { name: "my_excmd", description: "..." },
+	 *   () => {
+	 *     // ...
+	 *   }
+	 * );
+	 * declare global {
+	 *   interface ExcmdRegistry {
+	 *     my_excmd: typeof cmd;
+	 *   }
+	 * }
+	 * ```
+	 */
+	export interface ExcmdRegistry {
+	}
+	namespace glide {
+		/**
+		 * Corresponds to {@link glide.o} or {@link glide.bo}.
+		 */
+		// note: this is skipped in docs generation because we expand `glide.o`, so rendering
+		//       the `Options` type as well would be redundant.
+		/// @docs-skip
+		export type Options = {
+			/**
+			 * How long to wait until cancelling a partial keymapping execution.
+			 *
+			 * For example, `glide.keymaps.set('insert', 'jj', 'mode_change normal')`, after
+			 * pressing `j` once, this option determines how long the delay should be until
+			 * the `j` key is considered fully pressed and the mapping sequence is reset.
+			 *
+			 * note: this only applies in insert mode.
+			 *
+			 * @default 200
+			 */
+			mapping_timeout: number;
+			/**
+			 * Color used to briefly highlight text when it's yanked.
+			 *
+			 * @example "#ff6b35" // Orange highlight
+			 * @default "#edc73b"
+			 */
+			yank_highlight: glide.RGBString;
+			/**
+			 * How long, in milliseconds, to highlight the selection for when it's yanked.
+			 *
+			 * @default 150
+			 */
+			yank_highlight_time: number;
+			/**
+			 * The delay, in milliseconds, before showing the which key UI.
+			 *
+			 * @default 300
+			 */
+			which_key_delay: number;
+			/**
+			 * The maximum number of entries to include in the jumplist, i.e.
+			 * how far back in history will the jumplist store.
+			 *
+			 * @default 100
+			 */
+			jumplist_max_entries: number;
+			/**
+			 * The font size of the hint label, directly corresponds to the
+			 * [font-size](https://developer.mozilla.org/en-US/docs/Web/CSS/font-size) property.
+			 *
+			 * @default "11px"
+			 */
+			hint_size: string;
+		};
+		export type SpawnOptions = {
+			cwd?: string;
+			env?: Record<string, string | null>;
+			extend_env?: boolean;
+			success_codes?: number[];
+			/**
+			 * If `false`, do not throw an error for non-zero exit codes.
+			 *
+			 * @default true
+			 */
+			check_exit_code?: boolean;
+			/**
+			 * Control where the stderr output is sent.
+			 *
+			 * If `"pipe"` then sterr is accessible through `process.stderr`.
+			 * If `"stdout"` then sterr is mixed with stdout and accessible through `process.stdout`.
+			 *
+			 * @default "pipe"
+			 */
+			stderr?: "pipe" | "stdout";
+		};
+		export type Process = {
+			pid: number;
+			/**
+			 * The process exit code.
+			 *
+			 * `null` if it has not exited yet.
+			 */
+			exit_code: number | null;
+			/**
+			 * A `ReadableStream` of `string`s from the stdout pipe.
+			 */
+			stdout: ReadableStream<string>;
+			/**
+			 * A `ReadableStream` of `string`s from the stderr pipe.
+			 *
+			 * This is `null` if the `stderr: 'stdout'` option was set as the pipe will be forwarded
+			 * to `stdout` instead.
+			 */
+			stderr: ReadableStream<string> | null;
+			/**
+			 * Wait for the process to exit.
+			 */
+			wait(): Promise<glide.CompletedProcess>;
+			/**
+			 * Kill the process.
+			 *
+			 * On platforms which support it, the process will be sent a `SIGTERM` signal immediately,
+			 * so that it has a chance to terminate gracefully, and a `SIGKILL` signal if it hasn't exited
+			 * within `timeout` milliseconds.
+			 *
+			 * @param {integer} [timeout=300]
+			 *        A timeout, in milliseconds, after which the process will be forcibly killed.
+			 */
+			kill(timeout?: number): Promise<glide.CompletedProcess>;
+		};
+		/**
+		 * Represents a process that has exited.
+		 */
+		export type CompletedProcess = glide.Process & {
+			exit_code: number;
+		};
+		export type RGBString = `#${string}`;
+		/** A web extension tab that is guaranteed to have the `ts:id` property present. */
+		export type TabWithID = Omit<Browser.Tabs.Tab, "id"> & {
+			id: number;
+		};
+		export type KeyEvent = KeyboardEvent & {
+			/**
+			 * The vim notation of the KeyEvent, e.g.
+			 *
+			 * `{ ctrlKey: true, key: 's' }` -> `'<C-s>'`
+			 */
+			glide_key: string;
+		};
+		export type KeySendOptions = {
+			/**
+			 * Send the key event(s) directly through to the builtin Firefox
+			 * input handler and skip all of the mappings defined in Glide.
+			 */
+			skip_mappings?: boolean;
+		};
+		export type KeymapCallback = (props: glide.KeymapCallbackProps) => void;
+		export type KeymapCallbackProps = {
+			/**
+			 * The tab that the callback is being executed in.
+			 */
+			tab_id: number;
+		};
+		/// @docs-skip
+		export type ExcmdCreateProps = {
+			name: string;
+			description?: string | undefined;
+		};
+		/// @docs-skip
+		export type ExcmdValue = glide.ExcmdString | glide.ExcmdCallback | glide.KeymapCallback;
+		/// @docs-skip
+		export type ExcmdCallback = (props: glide.ExcmdCallbackProps) => void;
+		/// @docs-skip
+		export type ExcmdCallbackProps = {
+			/**
+			 * The tab that the callback is being executed in.
+			 */
+			tab_id: number;
+			/**
+			 * The args passed to the excmd.
+			 *
+			 * @example "foo -r"                      -> ["-r"]
+			 * @example "foo -r 'string with spaces'" -> ["-r", "string with spaces"]
+			 */
+			args_arr: string[];
+		};
+		/// @docs-skip
+		export type ExcmdString = 
+		// builtin
+		GlideCommandString
+		// custom
+		 | keyof ExcmdRegistry | `${keyof ExcmdRegistry} ${string}`;
+		/// @docs-skip
+		export type ContentHint = {
+			id: number;
+			x: number;
+			y: number;
+			width: number;
+			height: number;
+			element: HTMLElement;
+		};
+		export type HintLocation = "content" | "browser-ui";
+		export type KeyNotation = {
+			/**
+			 * @example <leader>
+			 * @example h
+			 * @example j
+			 * @example K
+			 * @example L
+			 * @example <Tab>
+			 */
+			key: string;
+			// modifiers
+			alt: boolean;
+			ctrl: boolean;
+			meta: boolean;
+			shift: boolean;
+		};
+		export type Keymap = {
+			sequence: string[];
+			lhs: string;
+			rhs: glide.ExcmdValue;
+			description: string | undefined;
+			mode: GlideMode;
+		};
+		export type KeymapOpts = {
+			description?: string | undefined;
+			/**
+			 * If `true`, applies the mapping for the current buffer instead of globally.
+			 *
+			 * @default {false}
+			 */
+			buffer?: boolean;
+			/**
+			 * If true, the key sequence will be displayed even after the mapping is executed.
+			 *
+			 * This is useful for mappings that are conceptually chained but are not *actually*, e.g. `diw`.
+			 *
+			 * @default false
+			 */
+			retain_key_display?: boolean;
+		};
+		export type KeymapDeleteOpts = Pick<glide.KeymapOpts, "buffer">;
+		type AutocmdEvent = "UrlEnter" | "ModeChanged" | "ConfigLoaded" | "WindowLoaded" | "KeyStateChanged";
+		type AutocmdPatterns = {
+			UrlEnter: RegExp | {
+				hostname?: string;
+			};
+			ModeChanged: "*" | `${GlideMode | "*"}:${GlideMode | "*"}`;
+			ConfigLoaded: null;
+			WindowLoaded: null;
+			KeyStateChanged: null;
+		};
+		type AutocmdArgs = {
+			UrlEnter: {
+				readonly url: string;
+				readonly tab_id: number;
+			};
+			ModeChanged: {
+				/**
+				 * This may be `null` when first loading Glide or when reloading the config.
+				 */
+				readonly old_mode: GlideMode | null;
+				readonly new_mode: GlideMode;
+			};
+			ConfigLoaded: {};
+			WindowLoaded: {};
+			KeyStateChanged: {
+				readonly mode: GlideMode;
+				readonly sequence: string[];
+				readonly partial: boolean;
+			};
+		};
+		/// doesn't render properly right now
+		/// @docs-skip
+		type Message<Messages extends Record<string, any>> = {
+			[K in keyof Messages]: {
+				name: K;
+				data: Messages[K];
+			};
+		}[keyof Messages];
+		interface ParentMessenger<Messages extends Record<string, any>> {
+			content: {
+				/**
+				 * The given callback is executed in the content process and is given a
+				 * {@link glide.ContentMessenger} as the first argument.
+				 *
+				 * **note**: unlike {@link glide.content.execute} the callback cannot be passed custom arguments
+				 */
+				execute: (callback: (messenger: glide.ContentMessenger<Messages>) => void, opts: {
+					/**
+					 * The ID of the tab into which to inject.
+					 *
+					 * Or the tab object as returned by {@link glide.tabs.active}.
+					 */
+					tab_id: number | glide.TabWithID;
+				}) => void;
+			};
+		}
+		interface ContentMessenger<Messages extends Record<string, any>> {
+			/**
+			 * Send a message to the receiver in the parent process.
+			 */
+			send<MessageName extends keyof Messages>(name: MessageName): void;
+		}
+		export type FileInfo = {
+			type: "file" | "directory" | null;
+			permissions: number | undefined;
+			last_accessed: number | undefined;
+			last_modified: number | undefined;
+			creation_time: number | undefined;
+			path: string | undefined;
+			size: number | undefined;
+		};
+	}
+	/**
+	 * Dedent template function.
+	 *
+	 * Inspired by the https://www.npmjs.com/package/dedent package.
+	 */
+	function dedent(arg: string): string;
+	function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+	/**
+	 * Dedent template function for syntax highlighting.
+	 *
+	 * Inspired by the https://www.npmjs.com/package/dedent package.
+	 *
+	 * note: we don't support passing in arguments to these functions as we would have to
+	 *       support escaping them, to not make it easy to accidentally cause XSS
+	 */
+	function html(arg: TemplateStringsArray): string;
+	/**
+	 * Dedent template function for syntax highlighting.
+	 *
+	 * Inspired by the https://www.npmjs.com/package/dedent package.
+	 *
+	 * note: we don't support passing in arguments to these functions as we would have to
+	 *       support escaping them, to not make it easy to accidentally cause XSS
+	 */
+	function css(arg: TemplateStringsArray): string;
+	/**
+	 * Helper functions for interacting with the DOM.
+	 *
+	 * **note**: this is currently only available in the main process, for
+	 *           updating the browser UI itself. it is not available in
+	 *           content processes.
+	 */
+	var DOM: {
+		/**
+		 * Wrapper over `document.createElement()` providing a more ergonomic API.
+		 *
+		 * Element properties that can be assigned directly can be provided as props:
+		 *
+		 * ```ts
+		 * DOM.create_element('img', { src: '...' });
+		 * ```
+		 *
+		 * You can also pass a `children` property, which will use `.replaceChildren()`:
+		 *
+		 * ```ts
+		 * DOM.create_element("div", {
+		 *   children: ["text content", DOM.create_element("img", { alt: "hint" })],
+		 * });
+		 * ```
+		 */
+		create_element<TagName extends keyof HTMLElementTagNameMap | (string & {})>(tag_name: TagName, props?: DOM.CreateElementProps<TagName extends keyof HTMLElementTagNameMap ? TagName : "div">): TagName extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[TagName] : HTMLElement;
+	};
+	namespace DOM {
+		type Utils = typeof DOM;
+		type CreateElementProps<K extends keyof HTMLElementTagNameMap> = Omit<Partial<NonReadonly<HTMLElementTagNameMap[K]>>, "children"> & {
+			/**
+			 * Can be an individual child or an array of children.
+			 */
+			children?: (Node | string) | Array<Node | string>;
+			/**
+			 * Set arbitrary attributes on the element.
+			 */
+			attributes?: Record<string, string>;
+			/**
+			 * Set specific CSS style properties.
+			 *
+			 * This uses the JS style naming convention for properties, e.g. `zIndex`.
+			 */
+			style?: Partial<CSSStyleDeclaration>;
+		};
+	}
+	namespace $keymapcompletions {
+		/**
+		 * This type takes in a string literal type, e.g. `<C-`, `a`, `<leader>`
+		 * and resolves a new string literal type union type that represents as many
+		 * valid additional entries as possible.
+		 *
+		 * `<C-` -> `<C-a>` | `<C-D-` ...
+		 * `<leader>` -> `<leader>f` | `<leader><CR>` ...
+		 * `g` -> `gg` | `gj` ...
+		 */
+		type T<LHS> = LHS extends "" ? SingleKey : LHS extends "<" ? SpecialKey | `<${ModifierKey}-` : LHS extends `${infer S}<${infer M}-` ? `${S}<${M}-${Exclude<StripAngles<SingleKey>, ModifierKey>}>` | `${S}<${M}-${ModifierKey}-` | (S & {}) : LHS extends `${infer S}<` ? `${S}${SpecialKey}` | S : LHS extends `${infer S}` ? `${S}${SingleKey}` | S : LHS;
+		/**
+		 * e.g. a, b, <leader>
+		 */
+		type SingleKey = StringToUnion<"abcdefghijklmnoprstuvwxyz"> | StringToUnion<"ABCDEFGHIJKLMNOPRSTUVWXYZ"> | StringToUnion<"0123456789"> | SpecialKey;
+		type SpecialKey = "<space>" | "<tab>" | "<esc>" | "<escape>" | "<space>" | "<enter>" | "<backspace>" | "<BS>" | "<CR>" | "<leader>" | "<up>" | "<down>" | "<left>" | "<right>" | "<del>" | "<home>" | "<end>" | "<pageup>" | "<pagedown>" | "<F1>" | "<F2>" | "<F3>" | "<F4>" | "<F5>" | "<F6>" | "<F7>" | "<F8>" | "<F9>" | "<F10>" | "<F11>" | "<F12>" | "<lt>" | "<bar>" | "<bslash>";
+		type ModifierKey = "C" | "D" | "A" | "S";
+		type StringToUnion<S extends string> = S extends `${infer First}${infer Rest}` ? First | StringToUnion<Rest> : never;
+		/**
+		 * `<foo>` -> `foo`
+		 */
+		type StripAngles<K extends SingleKey> = K extends `<${infer Inner}>` ? Inner : K;
+	}
+}
+/// ----------------- util types -----------------
+/**
+ * Filter out `readonly` properties from the given object type.
+ */
+export type NonReadonly<T> = Pick<T, {
+	[K in keyof T]: T[K] extends Readonly<any> ? never : K;
+}[keyof T]>;
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//////////////////////////////////////////////////////
+// BEWARE: DO NOT EDIT MANUALLY! Changes will be lost!
+//////////////////////////////////////////////////////
+declare global {
+	const browser: Browser.Browser;
+	namespace Browser {
+		/**
+		 * Namespace: browser.activityLog
+		 */
+		namespace ActivityLog {
+			interface OnExtensionActivityDetailsType {
+				/**
+				 * The date string when this call is triggered.
+				 */
+				timeStamp: ExtensionTypes.DateType;
+				/**
+				 * The type of log entry.  api_call is a function call made by the extension and api_event is an event callback to the
+				 * extension.  content_script is logged when a content script is injected.
+				 */
+				type: OnExtensionActivityDetailsTypeTypeEnum;
+				/**
+				 * The type of view where the activity occurred.  Content scripts will not have a viewType.
+				 * Optional.
+				 */
+				viewType?: OnExtensionActivityDetailsTypeViewTypeEnum;
+				/**
+				 * The name of the api call or event, or the script url if this is a content or user script event.
+				 */
+				name: string;
+				data: OnExtensionActivityDetailsTypeDataType;
+			}
+			/**
+			 * The type of log entry.  api_call is a function call made by the extension and api_event is an event callback to the
+			 * extension.  content_script is logged when a content script is injected.
+			 */
+			type OnExtensionActivityDetailsTypeTypeEnum = "api_call" | "api_event" | "content_script" | "user_script";
+			/**
+			 * The type of view where the activity occurred.  Content scripts will not have a viewType.
+			 */
+			type OnExtensionActivityDetailsTypeViewTypeEnum = "background" | "popup" | "sidebar" | "tab" | "devtools_page" | "devtools_panel";
+			/**
+			 * The result of the call.
+			 */
+			interface OnExtensionActivityDetailsTypeDataResultType {
+				[s: string]: unknown;
+			}
+			interface OnExtensionActivityDetailsTypeDataType {
+				/**
+				 * A list of arguments passed to the call.
+				 * Optional.
+				 */
+				args?: unknown[];
+				/**
+				 * The result of the call.
+				 * Optional.
+				 */
+				result?: OnExtensionActivityDetailsTypeDataResultType;
+				/**
+				 * The tab associated with this event if it is a tab or content script.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * If the type is content_script, this is the url of the script that was injected.
+				 * Optional.
+				 */
+				url?: string;
+			}
+			/**
+			 * Receives an activityItem for each logging event.
+			 */
+			interface OnExtensionActivityEvent extends Events.Event<(details: OnExtensionActivityDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 */
+				addListener(callback: (details: OnExtensionActivityDetailsType) => void, id: string): void;
+			}
+			interface Static {
+				/**
+				 * Receives an activityItem for each logging event.
+				 */
+				onExtensionActivity: OnExtensionActivityEvent;
+			}
+		}
+		/**
+		 * Namespace: browser.alarms
+		 */
+		namespace Alarms {
+			interface Alarm {
+				/**
+				 * Name of this alarm.
+				 */
+				name: string;
+				/**
+				 * Time when the alarm is scheduled to fire, in milliseconds past the epoch.
+				 */
+				scheduledTime: number;
+				/**
+				 * When present, signals that the alarm triggers periodically after so many minutes.
+				 * Optional.
+				 */
+				periodInMinutes?: number;
+			}
+			/**
+			 * 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.
+			 */
+			interface CreateAlarmInfoType {
+				/**
+				 * Time when the alarm is scheduled to first fire, in milliseconds past the epoch.
+				 * Optional.
+				 */
+				when?: number;
+				/**
+				 * Number of minutes from the current time after which the alarm should first fire.
+				 * Optional.
+				 */
+				delayInMinutes?: number;
+				/**
+				 * Number of minutes after which the alarm should recur repeatedly.
+				 * Optional.
+				 */
+				periodInMinutes?: number;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 *
+				 * @param name Optional. Optional name to identify this alarm. Defaults to the empty string.
+				 * @param 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.
+				 */
+				create(name: string | undefined, alarmInfo: CreateAlarmInfoType): Promise<void>;
+				/**
+				 * 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.
+				 *
+				 * @param 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.
+				 */
+				create(alarmInfo: CreateAlarmInfoType): Promise<void>;
+				/**
+				 * Retrieves details about the specified alarm.
+				 *
+				 * @param name Optional. The name of the alarm to get. Defaults to the empty string.
+				 */
+				get(name?: string): Promise<Alarm | undefined>;
+				/**
+				 * Gets an array of all the alarms.
+				 */
+				getAll(): Promise<Alarm[]>;
+				/**
+				 * Clears the alarm with the given name.
+				 *
+				 * @param name Optional. The name of the alarm to clear. Defaults to the empty string.
+				 */
+				clear(name?: string): Promise<boolean>;
+				/**
+				 * Clears all alarms.
+				 */
+				clearAll(): Promise<boolean>;
+				/**
+				 * Fired when an alarm has expired. Useful for transient background pages.
+				 *
+				 * @param name The alarm that has expired.
+				 */
+				onAlarm: Events.Event<(name: Alarm) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.bookmarks
+		 */
+		namespace Bookmarks {
+			/**
+			 * Indicates the reason why this node is unmodifiable. The <var>managed</var> 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).
+			 */
+			type BookmarkTreeNodeUnmodifiable = "managed";
+			/**
+			 * Indicates the type of a BookmarkTreeNode, which can be one of bookmark, folder or separator.
+			 */
+			type BookmarkTreeNodeType = "bookmark" | "folder" | "separator";
+			/**
+			 * A node (either a bookmark or a folder) in the bookmark tree.  Child nodes are ordered within their parent folder.
+			 */
+			interface BookmarkTreeNode {
+				/**
+				 * The unique identifier for the node. IDs are unique within the current profile, and they remain valid even after the
+				 * browser is restarted.
+				 */
+				id: string;
+				/**
+				 * The <code>id</code> of the parent folder.  Omitted for the root node.
+				 * Optional.
+				 */
+				parentId?: string;
+				/**
+				 * The 0-based position of this node within its parent folder.
+				 * Optional.
+				 */
+				index?: number;
+				/**
+				 * The URL navigated to when a user clicks the bookmark. Omitted for folders.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * The text displayed for the node.
+				 */
+				title: string;
+				/**
+				 * When this node was created, in milliseconds since the epoch (<code>new Date(dateAdded)</code>).
+				 * Optional.
+				 */
+				dateAdded?: number;
+				/**
+				 * When the contents of this folder last changed, in milliseconds since the epoch.
+				 * Optional.
+				 */
+				dateGroupModified?: number;
+				/**
+				 * Indicates the reason why this node is unmodifiable. The <var>managed</var> 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).
+				 * Optional.
+				 */
+				unmodifiable?: BookmarkTreeNodeUnmodifiable;
+				/**
+				 * Indicates the type of the BookmarkTreeNode, which can be one of bookmark, folder or separator.
+				 * Optional.
+				 */
+				type?: BookmarkTreeNodeType;
+				/**
+				 * An ordered list of children of this node.
+				 * Optional.
+				 */
+				children?: BookmarkTreeNode[];
+			}
+			/**
+			 * Object passed to the create() function.
+			 */
+			interface CreateDetails {
+				/**
+				 * Defaults to the Other Bookmarks folder.
+				 * Optional.
+				 */
+				parentId?: string;
+				/**
+				 * Optional.
+				 */
+				index?: number;
+				/**
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * Indicates the type of BookmarkTreeNode to create, which can be one of bookmark, folder or separator.
+				 * Optional.
+				 */
+				type?: BookmarkTreeNodeType;
+			}
+			/**
+			 * An object specifying properties and values to match when searching. Produces bookmarks matching all properties.
+			 */
+			interface SearchQueryC2Type {
+				/**
+				 * A string of words that are matched against bookmark URLs and titles.
+				 * Optional.
+				 */
+				query?: string;
+				/**
+				 * The URL of the bookmark; matches verbatim. Note that folders have no URL.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * The title of the bookmark; matches verbatim.
+				 * Optional.
+				 */
+				title?: string;
+			}
+			interface MoveDestinationType {
+				/**
+				 * Optional.
+				 */
+				parentId?: string;
+				/**
+				 * Optional.
+				 */
+				index?: number;
+			}
+			interface UpdateChangesType {
+				/**
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Optional.
+				 */
+				url?: string;
+			}
+			interface OnRemovedRemoveInfoType {
+				parentId: string;
+				index: number;
+				node: BookmarkTreeNode;
+			}
+			interface OnChangedChangeInfoType {
+				title: string;
+				/**
+				 * Optional.
+				 */
+				url?: string;
+			}
+			interface OnMovedMoveInfoType {
+				parentId: string;
+				index: number;
+				oldParentId: string;
+				oldIndex: number;
+			}
+			interface Static {
+				/**
+				 * Retrieves the specified BookmarkTreeNode(s).
+				 *
+				 * @param idOrIdList A single string-valued id, or an array of string-valued ids
+				 */
+				get(idOrIdList: string | string[]): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Retrieves the children of the specified BookmarkTreeNode id.
+				 */
+				getChildren(id: string): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Retrieves the recently added bookmarks.
+				 *
+				 * @param numberOfItems The maximum number of items to return.
+				 */
+				getRecent(numberOfItems: number): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Retrieves the entire Bookmarks hierarchy.
+				 */
+				getTree(): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Retrieves part of the Bookmarks hierarchy, starting at the specified node.
+				 *
+				 * @param id The ID of the root of the subtree to retrieve.
+				 */
+				getSubTree(id: string): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Searches for BookmarkTreeNodes matching the given query. Queries specified with an object produce BookmarkTreeNodes
+				 * matching all specified properties.
+				 *
+				 * @param query Either a string of words that are matched against bookmark URLs and titles, or an object. If an object,
+				 * the properties <code>query</code>, <code>url</code>, and <code>title</code> may be specified and bookmarks matching all
+				 * specified properties will be produced.
+				 */
+				search(query: string | SearchQueryC2Type): Promise<BookmarkTreeNode[]>;
+				/**
+				 * Creates a bookmark or folder under the specified parentId.  If url is NULL or missing, it will be a folder.
+				 */
+				create(bookmark: CreateDetails): Promise<BookmarkTreeNode>;
+				/**
+				 * Moves the specified BookmarkTreeNode to the provided location.
+				 */
+				move(id: string, destination: MoveDestinationType): Promise<BookmarkTreeNode>;
+				/**
+				 * 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.
+				 */
+				update(id: string, changes: UpdateChangesType): Promise<BookmarkTreeNode>;
+				/**
+				 * Removes a bookmark or an empty bookmark folder.
+				 */
+				remove(id: string): Promise<void>;
+				/**
+				 * Recursively removes a bookmark folder.
+				 */
+				removeTree(id: string): Promise<void>;
+				/**
+				 * Fired when a bookmark or folder is created.
+				 */
+				onCreated: Events.Event<(id: string, bookmark: BookmarkTreeNode) => void>;
+				/**
+				 * 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.
+				 */
+				onRemoved: Events.Event<(id: string, removeInfo: OnRemovedRemoveInfoType) => void>;
+				/**
+				 * Fired when a bookmark or folder changes.  <b>Note:</b> Currently, only title and url changes trigger this.
+				 */
+				onChanged: Events.Event<(id: string, changeInfo: OnChangedChangeInfoType) => void>;
+				/**
+				 * Fired when a bookmark or folder is moved to a different parent folder.
+				 */
+				onMoved: Events.Event<(id: string, moveInfo: OnMovedMoveInfoType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.action
+		 */
+		namespace Action {
+			/**
+			 * Specifies to which tab or window the value should be set, or from which one it should be retrieved.
+			 * If no tab nor window is specified, the global value is set or retrieved.
+			 */
+			interface Details {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			type ColorArray = [
+				number,
+				number,
+				number,
+				number
+			];
+			/**
+			 * Pixel data for an image. Must be an ImageData object (for example, from a <code>canvas</code> element).
+			 */
+			interface ImageDataType extends ImageData {
+				[s: string]: unknown;
+			}
+			/**
+			 * An array of four integers in the range [0,255] that make up the RGBA color of the badge. For example,
+			 * opaque red is <code>[255, 0, 0, 255]</code>. Can also be a string with a CSS value, with opaque red being <code>
+			 * #FF0000</code> or <code>#F00</code>.
+			 */
+			type ColorValue = string | ColorArray | null;
+			/**
+			 * Information sent when a browser action is clicked.
+			 */
+			interface OnClickData {
+				/**
+				 * An array of keyboard modifiers that were held while the menu item was clicked.
+				 */
+				modifiers: OnClickDataModifiersItemEnum[];
+				/**
+				 * An integer value of button by which menu item was clicked.
+				 * Optional.
+				 */
+				button?: number;
+			}
+			interface SetTitleDetailsType extends Details {
+				/**
+				 * The string the browser action should display when moused over.
+				 */
+				title: string | null;
+			}
+			/**
+			 * The collection of user-specified settings relating to an extension's action.
+			 */
+			interface GetUserSettingsCallbackUserSettingsType {
+				/**
+				 * 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).
+				 * Optional.
+				 */
+				isOnToolbar?: boolean;
+			}
+			interface SetIconDetailsType extends Details {
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				imageData?: ImageDataType | Record<string, ImageDataType>;
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				path?: string | Record<string, string>;
+			}
+			interface SetPopupDetailsType extends Details {
+				/**
+				 * The html file to show in a popup.  If set to the empty string (''), no popup is shown.
+				 */
+				popup: string | null;
+			}
+			interface SetBadgeTextDetailsType extends Details {
+				/**
+				 * Any number of characters can be passed, but only about four can fit in the space.
+				 */
+				text: string | null;
+			}
+			interface SetBadgeBackgroundColorDetailsType extends Details {
+				color: ColorValue;
+			}
+			interface SetBadgeTextColorDetailsType extends Details {
+				color: ColorValue;
+			}
+			/**
+			 * An object with information about the popup to open.
+			 */
+			interface OpenPopupOptionsType {
+				/**
+				 * Defaults to the $(topic:current-window)[current window].
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			type OnClickDataModifiersItemEnum = "Shift" | "Alt" | "Command" | "Ctrl" | "MacCtrl";
+			interface Static {
+				/**
+				 * Sets the title of the browser action. This shows up in the tooltip.
+				 */
+				setTitle(details: SetTitleDetailsType): Promise<void>;
+				/**
+				 * Gets the title of the browser action.
+				 */
+				getTitle(details: Details): Promise<string>;
+				/**
+				 * Returns the user-specified settings relating to an extension's action.
+				 */
+				getUserSettings(): Promise<GetUserSettingsCallbackUserSettingsType>;
+				/**
+				 * 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.
+				 */
+				setIcon(details: SetIconDetailsType): Promise<void>;
+				/**
+				 * Sets the html document to be opened as a popup when the user clicks on the browser action's icon.
+				 */
+				setPopup(details: SetPopupDetailsType): Promise<void>;
+				/**
+				 * Gets the html document set as the popup for this browser action.
+				 */
+				getPopup(details: Details): Promise<string>;
+				/**
+				 * Sets the badge text for the browser action. The badge is displayed on top of the icon.
+				 */
+				setBadgeText(details: SetBadgeTextDetailsType): Promise<void>;
+				/**
+				 * Gets the badge text of the browser action. If no tab nor window is specified is specified,
+				 * the global badge text is returned.
+				 */
+				getBadgeText(details: Details): Promise<string>;
+				/**
+				 * Sets the background color for the badge.
+				 */
+				setBadgeBackgroundColor(details: SetBadgeBackgroundColorDetailsType): Promise<void>;
+				/**
+				 * Gets the background color of the browser action badge.
+				 */
+				getBadgeBackgroundColor(details: Details): Promise<ColorArray>;
+				/**
+				 * Sets the text color for the badge.
+				 */
+				setBadgeTextColor(details: SetBadgeTextColorDetailsType): Promise<void>;
+				/**
+				 * Gets the text color of the browser action badge.
+				 */
+				getBadgeTextColor(details: Details): Promise<ColorArray>;
+				/**
+				 * Enables the browser action for a tab. By default, browser actions are enabled.
+				 *
+				 * @param tabId Optional. The id of the tab for which you want to modify the browser action.
+				 */
+				enable(tabId?: number): Promise<void>;
+				/**
+				 * Disables the browser action for a tab.
+				 *
+				 * @param tabId Optional. The id of the tab for which you want to modify the browser action.
+				 */
+				disable(tabId?: number): Promise<void>;
+				/**
+				 * Checks whether the browser action is enabled.
+				 */
+				isEnabled(details: Details): Promise<boolean>;
+				/**
+				 * Opens the extension popup window in the specified window.
+				 *
+				 * @param options Optional. An object with information about the popup to open.
+				 */
+				openPopup(options?: OpenPopupOptionsType): Promise<void>;
+				/**
+				 * Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.
+				 *
+				 * @param info Optional.
+				 */
+				onClicked: Events.Event<(tab: Browser.Tabs.Tab, info: OnClickData | undefined) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.browserAction
+		 */
+		namespace BrowserAction {
+			interface Static extends Action.Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.browserSettings
+		 */
+		namespace BrowserSettings {
+			/**
+			 * How images should be animated in the browser.
+			 */
+			type ImageAnimationBehavior = "normal" | "none" | "once";
+			/**
+			 * After which mouse event context menus should popup.
+			 */
+			type ContextMenuMouseEvent = "mouseup" | "mousedown";
+			/**
+			 * Color management mode.
+			 */
+			type ColorManagementMode = "off" | "full" | "tagged_only";
+			interface Static {
+				/**
+				 * Allows or disallows pop-up windows from opening in response to user events.
+				 */
+				allowPopupsForUserEvents: Browser.Types.Setting;
+				/**
+				 * Enables or disables the browser cache.
+				 */
+				cacheEnabled: Browser.Types.Setting;
+				/**
+				 * This boolean setting controls whether the selected tab can be closed with a double click.
+				 */
+				closeTabsByDoubleClick: Browser.Types.Setting;
+				/**
+				 * Controls after which mouse event context menus popup. This setting's value is of type ContextMenuMouseEvent,
+				 * which has possible values of <code>mouseup</code> and <code>mousedown</code>.
+				 */
+				contextMenuShowEvent: Browser.Types.Setting;
+				/**
+				 * Returns the value of the overridden home page. Read-only.
+				 */
+				homepageOverride: Browser.Types.Setting;
+				/**
+				 * Controls the behaviour of image animation in the browser. This setting's value is of type ImageAnimationBehavior,
+				 * defaulting to <code>normal</code>.
+				 */
+				imageAnimationBehavior: Browser.Types.Setting;
+				/**
+				 * Returns the value of the overridden new tab page. Read-only.
+				 */
+				newTabPageOverride: Browser.Types.Setting;
+				/**
+				 * 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`.
+				 */
+				newTabPosition: Browser.Types.Setting;
+				/**
+				 * This boolean setting controls whether bookmarks are opened in the current tab or in a new tab.
+				 */
+				openBookmarksInNewTabs: Browser.Types.Setting;
+				/**
+				 * This boolean setting controls whether search results are opened in the current tab or in a new tab.
+				 */
+				openSearchResultsInNewTabs: Browser.Types.Setting;
+				/**
+				 * This boolean setting controls whether urlbar results are opened in the current tab or in a new tab.
+				 */
+				openUrlbarResultsInNewTabs: Browser.Types.Setting;
+				/**
+				 * Disables webAPI notifications.
+				 */
+				webNotificationsDisabled: Browser.Types.Setting;
+				/**
+				 * This setting controls whether the user-chosen colors override the page's colors.
+				 */
+				overrideDocumentColors: Browser.Types.Setting;
+				/**
+				 * This setting controls whether a light or dark color scheme overrides the page's preferred color scheme.
+				 */
+				overrideContentColorScheme: Browser.Types.Setting;
+				/**
+				 * This setting controls whether the document's fonts are used.
+				 */
+				useDocumentFonts: Browser.Types.Setting;
+				/**
+				 * This boolean setting controls whether zoom is applied to the full page or to text only.
+				 */
+				zoomFullPage: Browser.Types.Setting;
+				/**
+				 * 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.
+				 */
+				zoomSiteSpecific: Browser.Types.Setting;
+				colorManagement: ColorManagement.Static;
+			}
+		}
+		/**
+		 * Namespace: browser.browsingData
+		 */
+		namespace BrowsingData {
+			/**
+			 * Options that determine exactly what data will be removed.
+			 */
+			interface RemovalOptions {
+				/**
+				 * Remove data accumulated on or after this date, represented in milliseconds since the epoch (accessible via the <code>
+				 * getTime</code> method of the JavaScript <code>Date</code> object). If absent, defaults to 0 (which would remove all
+				 * browsing data).
+				 * Optional.
+				 */
+				since?: ExtensionTypes.DateType;
+				/**
+				 * Only remove data associated with these hostnames (only applies to cookies and localStorage).
+				 * Optional.
+				 */
+				hostnames?: string[];
+				/**
+				 * Only remove data associated with this specific cookieStoreId.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * 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'.
+				 * Optional.
+				 */
+				originTypes?: RemovalOptionsOriginTypesType;
+			}
+			/**
+			 * A set of data types. Missing data types are interpreted as <code>false</code>.
+			 */
+			interface DataTypeSet {
+				/**
+				 * The browser's cache. Note: when removing data, this clears the <em>entire</em> cache: it is not limited to the range you
+				 * specify.
+				 * Optional.
+				 */
+				cache?: boolean;
+				/**
+				 * The browser's cookies.
+				 * Optional.
+				 */
+				cookies?: boolean;
+				/**
+				 * The browser's download list.
+				 * Optional.
+				 */
+				downloads?: boolean;
+				/**
+				 * The browser's stored form data.
+				 * Optional.
+				 */
+				formData?: boolean;
+				/**
+				 * The browser's history.
+				 * Optional.
+				 */
+				history?: boolean;
+				/**
+				 * Websites' IndexedDB data.
+				 * Optional.
+				 */
+				indexedDB?: boolean;
+				/**
+				 * Websites' local storage data.
+				 * Optional.
+				 */
+				localStorage?: boolean;
+				/**
+				 * Server-bound certificates.
+				 * Optional.
+				 */
+				serverBoundCertificates?: boolean;
+				/**
+				 * Stored passwords.
+				 * Optional.
+				 */
+				passwords?: boolean;
+				/**
+				 * Plugins' data.
+				 * Optional.
+				 */
+				pluginData?: boolean;
+				/**
+				 * Service Workers.
+				 * Optional.
+				 */
+				serviceWorkers?: boolean;
+			}
+			interface SettingsCallbackResultType {
+				options: RemovalOptions;
+				/**
+				 * All of the types will be present in the result, with values of <code>true</code> if they are both selected to be removed
+				 * and permitted to be removed, otherwise <code>false</code>.
+				 */
+				dataToRemove: DataTypeSet;
+				/**
+				 * All of the types will be present in the result, with values of <code>true</code> if they are permitted to be removed (e.
+				 * g., by enterprise policy) and <code>false</code> if not.
+				 */
+				dataRemovalPermitted: DataTypeSet;
+			}
+			/**
+			 * 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'.
+			 */
+			interface RemovalOptionsOriginTypesType {
+				/**
+				 * Normal websites.
+				 * Optional.
+				 */
+				unprotectedWeb?: boolean;
+				/**
+				 * Websites that have been installed as hosted applications (be careful!).
+				 * Optional.
+				 */
+				protectedWeb?: boolean;
+				/**
+				 * Extensions and packaged applications a user has installed (be _really_ careful!).
+				 * Optional.
+				 */
+				extension?: boolean;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 */
+				settings(): Promise<SettingsCallbackResultType>;
+				/**
+				 * Clears various types of browsing data stored in a user's profile.
+				 *
+				 * @param dataToRemove The set of data types to remove.
+				 * @returns Called when deletion has completed.
+				 */
+				remove(options: RemovalOptions, dataToRemove: DataTypeSet): Promise<void>;
+				/**
+				 * Clears the browser's cache.
+				 *
+				 * @returns Called when the browser's cache has been cleared.
+				 */
+				removeCache(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears the browser's cookies and server-bound certificates modified within a particular timeframe.
+				 *
+				 * @returns Called when the browser's cookies and server-bound certificates have been cleared.
+				 */
+				removeCookies(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears the browser's list of downloaded files (<em>not</em> the downloaded files themselves).
+				 *
+				 * @returns Called when the browser's list of downloaded files has been cleared.
+				 */
+				removeDownloads(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears the browser's stored form data (autofill).
+				 *
+				 * @returns Called when the browser's form data has been cleared.
+				 */
+				removeFormData(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears the browser's history.
+				 *
+				 * @returns Called when the browser's history has cleared.
+				 */
+				removeHistory(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears websites' local storage data.
+				 *
+				 * @returns Called when websites' local storage has been cleared.
+				 */
+				removeLocalStorage(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears plugins' data.
+				 *
+				 * @returns Called when plugins' data has been cleared.
+				 */
+				removePluginData(options: RemovalOptions): Promise<void>;
+				/**
+				 * Clears the browser's stored passwords.
+				 *
+				 * @returns Called when the browser's passwords have been cleared.
+				 */
+				removePasswords(options: RemovalOptions): Promise<void>;
+			}
+		}
+		/**
+		 * Namespace: browser.captivePortal
+		 */
+		namespace CaptivePortal {
+			interface OnStateChangedDetailsType {
+				/**
+				 * The current captive portal state.
+				 */
+				state: OnStateChangedDetailsTypeStateEnum;
+			}
+			type OnConnectivityAvailableStatusEnum = "captive" | "clear";
+			/**
+			 * The current captive portal state.
+			 */
+			type OnStateChangedDetailsTypeStateEnum = "unknown" | "not_captive" | "unlocked_portal" | "locked_portal";
+			interface Static {
+				/**
+				 * Returns the current portal state, one of `unknown`, `not_captive`, `unlocked_portal`, `locked_portal`.
+				 */
+				getState(): Promise<"unknown" | "not_captive" | "unlocked_portal" | "locked_portal">;
+				/**
+				 * Returns the time difference between NOW and the last time a request was completed in milliseconds.
+				 */
+				getLastChecked(): Promise<number>;
+				/**
+				 * Fired when the captive portal state changes.
+				 */
+				onStateChanged: Events.Event<(details: OnStateChangedDetailsType) => void>;
+				/**
+				 * This notification will be emitted when the captive portal service has determined that we can connect to the internet.
+				 * The service will pass either `captive` if there is an unlocked captive portal present,
+				 * or `clear` if no captive portal was detected.
+				 */
+				onConnectivityAvailable: Events.Event<(status: OnConnectivityAvailableStatusEnum) => void>;
+				/**
+				 * Return the canonical captive-portal detection URL. Read-only.
+				 */
+				canonicalURL: Browser.Types.Setting;
+			}
+		}
+		/**
+		 * Namespace: browser.clipboard
+		 */
+		namespace Clipboard {
+			/**
+			 * The type of imageData.
+			 */
+			type SetImageDataImageTypeEnum = "jpeg" | "png";
+			interface Static {
+				/**
+				 * 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.
+				 *
+				 * @param imageData The image data to be copied.
+				 * @param imageType The type of imageData.
+				 */
+				setImageData(imageData: ArrayBuffer, imageType: SetImageDataImageTypeEnum): Promise<void>;
+			}
+		}
+		/**
+		 * Namespace: browser.commands
+		 */
+		namespace Commands {
+			interface Command {
+				/**
+				 * The name of the Extension Command
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * The Extension Command description
+				 * Optional.
+				 */
+				description?: string;
+				/**
+				 * The shortcut active for this command, or blank if not active.
+				 * Optional.
+				 */
+				shortcut?: string;
+			}
+			/**
+			 * The new description for the command.
+			 */
+			interface UpdateDetailType {
+				/**
+				 * The name of the command.
+				 */
+				name: string;
+				/**
+				 * The new description for the command.
+				 * Optional.
+				 */
+				description?: string;
+				/**
+				 * Optional.
+				 */
+				shortcut?: string;
+			}
+			interface OnChangedChangeInfoType {
+				/**
+				 * The name of the shortcut.
+				 */
+				name: string;
+				/**
+				 * The new shortcut active for this command, or blank if not active.
+				 */
+				newShortcut: string;
+				/**
+				 * The old shortcut which is no longer active for this command, or blank if the shortcut was previously inactive.
+				 */
+				oldShortcut: string;
+			}
+			interface Static {
+				/**
+				 * Update the details of an already defined command.
+				 *
+				 * @param detail The new description for the command.
+				 */
+				update(detail: UpdateDetailType): Promise<void>;
+				/**
+				 * Reset a command's details to what is specified in the manifest.
+				 *
+				 * @param name The name of the command.
+				 */
+				reset(name: string): Promise<void>;
+				/**
+				 * Returns all the registered extension commands for this extension and their shortcut (if active).
+				 *
+				 * @returns Called to return the registered commands.
+				 */
+				getAll(): Promise<Command[]>;
+				/**
+				 * Open extension shortcuts configuration page.
+				 */
+				openShortcutSettings(): void;
+				/**
+				 * Fired when a registered command is activated using a keyboard shortcut.
+				 *
+				 * @param tab Optional. Details of the $(ref:tabs.Tab) where the command was activated.
+				 */
+				onCommand: Events.Event<(command: string, tab: Browser.Tabs.Tab | undefined) => void>;
+				/**
+				 * Fired when a registered command's shortcut is changed.
+				 */
+				onChanged: Events.Event<(changeInfo: OnChangedChangeInfoType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.contentScripts
+		 */
+		namespace ContentScripts {
+			/**
+			 * Details of a content script registered programmatically
+			 */
+			interface RegisteredContentScriptOptions {
+				matches: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				excludeMatches?: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				includeGlobs?: string[];
+				/**
+				 * Optional.
+				 */
+				excludeGlobs?: string[];
+				/**
+				 * The list of CSS files to inject
+				 * Optional.
+				 */
+				css?: Browser.ExtensionTypes.ExtensionFileOrCode[];
+				/**
+				 * The list of JS files to inject
+				 * Optional.
+				 */
+				js?: Browser.ExtensionTypes.ExtensionFileOrCode[];
+				/**
+				 * If allFrames is <code>true</code>, implies that the JavaScript or CSS should be injected into all frames of current page.
+				 * By default, it's <code>false</code> and is only injected into the top frame.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * 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. Ignored if matchOriginAsFallback is specified. By default it is <code>false</code>.
+				 * Optional.
+				 */
+				matchAboutBlank?: boolean;
+				/**
+				 * If matchOriginAsFallback is true, then the code is also injected in about:, data:,
+				 * blob: when their origin matches the pattern in 'matches', even if the actual document origin is opaque (due to the use
+				 * of CSP sandbox or iframe sandbox). Match patterns in 'matches' must specify a wildcard path glob. By default it is <code>
+				 * false</code>.
+				 * Optional.
+				 */
+				matchOriginAsFallback?: boolean;
+				/**
+				 * The soonest that the JavaScript or CSS will be injected into the tab. Defaults to "document_idle".
+				 * Optional.
+				 */
+				runAt?: Browser.ExtensionTypes.RunAt;
+				/**
+				 * The JavaScript world for a script to execute within. Defaults to "ISOLATED".
+				 * Optional.
+				 */
+				world?: Browser.ExtensionTypes.ExecutionWorld;
+				/**
+				 * limit the set of matched tabs to those that belong to the given cookie store id
+				 * Optional.
+				 */
+				cookieStoreId?: string[] | string;
+			}
+			/**
+			 * An object that represents a content script registered programmatically
+			 */
+			interface RegisteredContentScript {
+				/**
+				 * Unregister a content script registered programmatically
+				 */
+				unregister(): Promise<void>;
+			}
+			interface Static {
+				/**
+				 * Register a content script programmatically
+				 */
+				register(contentScriptOptions: RegisteredContentScriptOptions): Promise<RegisteredContentScript>;
+			}
+		}
+		/**
+		 * Namespace: browser.contextualIdentities
+		 */
+		namespace ContextualIdentities {
+			/**
+			 * Represents information about a contextual identity.
+			 */
+			interface ContextualIdentity {
+				/**
+				 * The name of the contextual identity.
+				 */
+				name: string;
+				/**
+				 * The icon name of the contextual identity.
+				 */
+				icon: string;
+				/**
+				 * The icon url of the contextual identity.
+				 */
+				iconUrl: string;
+				/**
+				 * The color name of the contextual identity.
+				 */
+				color: string;
+				/**
+				 * The color hash of the contextual identity.
+				 */
+				colorCode: string;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 */
+				cookieStoreId: string;
+			}
+			/**
+			 * Information to filter the contextual identities being retrieved.
+			 */
+			interface QueryDetailsType {
+				/**
+				 * Filters the contextual identity by name.
+				 * Optional.
+				 */
+				name?: string;
+			}
+			/**
+			 * Details about the contextual identity being created.
+			 */
+			interface CreateDetailsType {
+				/**
+				 * The name of the contextual identity.
+				 */
+				name: string;
+				/**
+				 * The color of the contextual identity.
+				 */
+				color: string;
+				/**
+				 * The icon of the contextual identity.
+				 */
+				icon: string;
+			}
+			/**
+			 * Details about the contextual identity being created.
+			 */
+			interface UpdateDetailsType {
+				/**
+				 * The name of the contextual identity.
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * The color of the contextual identity.
+				 * Optional.
+				 */
+				color?: string;
+				/**
+				 * The icon of the contextual identity.
+				 * Optional.
+				 */
+				icon?: string;
+			}
+			interface OnUpdatedChangeInfoType {
+				/**
+				 * Contextual identity that has been updated
+				 */
+				contextualIdentity: ContextualIdentity;
+			}
+			interface OnCreatedChangeInfoType {
+				/**
+				 * Contextual identity that has been created
+				 */
+				contextualIdentity: ContextualIdentity;
+			}
+			interface OnRemovedChangeInfoType {
+				/**
+				 * Contextual identity that has been removed
+				 */
+				contextualIdentity: ContextualIdentity;
+			}
+			interface Static {
+				/**
+				 * Retrieves information about a single contextual identity.
+				 *
+				 * @param cookieStoreId The ID of the contextual identity cookie store.
+				 */
+				get(cookieStoreId: string): Promise<ContextualIdentity>;
+				/**
+				 * Retrieves all contextual identities
+				 *
+				 * @param details Information to filter the contextual identities being retrieved.
+				 */
+				query(details: QueryDetailsType): Promise<ContextualIdentity[]>;
+				/**
+				 * Creates a contextual identity with the given data.
+				 *
+				 * @param details Details about the contextual identity being created.
+				 */
+				create(details: CreateDetailsType): Promise<ContextualIdentity>;
+				/**
+				 * Updates a contextual identity with the given data.
+				 *
+				 * @param cookieStoreId The ID of the contextual identity cookie store.
+				 * @param details Details about the contextual identity being created.
+				 */
+				update(cookieStoreId: string, details: UpdateDetailsType): Promise<ContextualIdentity>;
+				/**
+				 * Reorder one or more contextual identities by their cookieStoreIDs to a given position.
+				 *
+				 * @param cookieStoreIds The ID or list of IDs of the contextual identity cookie stores.
+				 * @param position The position the contextual identity should move to.
+				 */
+				move(cookieStoreIds: string | string[], position: number): Promise<void>;
+				/**
+				 * Deletes a contextual identity by its cookie Store ID.
+				 *
+				 * @param cookieStoreId The ID of the contextual identity cookie store.
+				 */
+				remove(cookieStoreId: string): Promise<ContextualIdentity>;
+				/**
+				 * Fired when a container is updated.
+				 */
+				onUpdated: Events.Event<(changeInfo: OnUpdatedChangeInfoType) => void>;
+				/**
+				 * Fired when a new container is created.
+				 */
+				onCreated: Events.Event<(changeInfo: OnCreatedChangeInfoType) => void>;
+				/**
+				 * Fired when a container is removed.
+				 */
+				onRemoved: Events.Event<(changeInfo: OnRemovedChangeInfoType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.cookies
+		 */
+		namespace Cookies {
+			/**
+			 * A cookie's 'SameSite' state (https://tools.ietf.org/html/draft-west-first-party-cookies).
+			 * 'no_restriction' corresponds to a cookie set without a 'SameSite' attribute, 'lax' to 'SameSite=Lax',
+			 * and 'strict' to 'SameSite=Strict'.
+			 */
+			type SameSiteStatus = "unspecified" | "no_restriction" | "lax" | "strict";
+			/**
+			 * The description of the storage partition of a cookie. This object may be omitted (null) if a cookie is not partitioned.
+			 */
+			interface PartitionKey {
+				/**
+				 * The first-party URL of the cookie, if the cookie is in storage partitioned by the top-level site.
+				 * Optional.
+				 */
+				topLevelSite?: string;
+				/**
+				 * Whether or not the cookie is in a third-party context, respecting ancestor chains.
+				 * Optional.
+				 */
+				hasCrossSiteAncestor?: boolean;
+			}
+			/**
+			 * Represents information about an HTTP cookie.
+			 */
+			interface Cookie {
+				/**
+				 * The name of the cookie.
+				 */
+				name: string;
+				/**
+				 * The value of the cookie.
+				 */
+				value: string;
+				/**
+				 * The domain of the cookie (e.g. "www.google.com", "example.com").
+				 */
+				domain: string;
+				/**
+				 * True if the cookie is a host-only cookie (i.e. a request's host must exactly match the domain of the cookie).
+				 */
+				hostOnly: boolean;
+				/**
+				 * The path of the cookie.
+				 */
+				path: string;
+				/**
+				 * True if the cookie is marked as Secure (i.e. its scope is limited to secure channels, typically HTTPS).
+				 */
+				secure: boolean;
+				/**
+				 * True if the cookie is marked as HttpOnly (i.e. the cookie is inaccessible to client-side scripts).
+				 */
+				httpOnly: boolean;
+				/**
+				 * The cookie's same-site status (i.e. whether the cookie is sent with cross-site requests).
+				 */
+				sameSite: SameSiteStatus;
+				/**
+				 * True if the cookie is a session cookie, as opposed to a persistent cookie with an expiration date.
+				 */
+				session: boolean;
+				/**
+				 * The expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
+				 * Optional.
+				 */
+				expirationDate?: number;
+				/**
+				 * The ID of the cookie store containing this cookie, as provided in getAllCookieStores().
+				 */
+				storeId: string;
+				/**
+				 * The first-party domain of the cookie.
+				 */
+				firstPartyDomain: string;
+				/**
+				 * The cookie's storage partition, if any. null if not partitioned.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			/**
+			 * Represents a cookie store in the browser. An incognito mode window, for instance, uses a separate cookie store from a
+			 * non-incognito window.
+			 */
+			interface CookieStore {
+				/**
+				 * The unique identifier for the cookie store.
+				 */
+				id: string;
+				/**
+				 * Identifiers of all the browser tabs that share this cookie store.
+				 */
+				tabIds: number[];
+				/**
+				 * Indicates if this is an incognito cookie store
+				 */
+				incognito: boolean;
+			}
+			/**
+			 * The underlying reason behind the cookie's change. If a cookie was inserted, or removed via an explicit call to
+			 * $(ref:cookies.remove), "cause" will be "explicit". If a cookie was automatically removed due to expiry,
+			 * "cause" will be "expired". If a cookie was removed due to being overwritten with an already-expired expiration date,
+			 * "cause" will be set to "expired_overwrite".  If a cookie was automatically removed due to garbage collection,
+			 * "cause" will be "evicted".  If a cookie was automatically removed due to a "set" call that overwrote it,
+			 * "cause" will be "overwrite". Plan your response accordingly.
+			 */
+			type OnChangedCause = "evicted" | "expired" | "explicit" | "expired_overwrite" | "overwrite";
+			/**
+			 * Details to identify the cookie being retrieved.
+			 */
+			interface GetDetailsType {
+				/**
+				 * 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.
+				 */
+				url: string;
+				/**
+				 * The name of the cookie to retrieve.
+				 */
+				name: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				storeId?: string;
+				/**
+				 * The first-party domain which the cookie to retrieve is associated. This attribute is required if First-Party Isolation
+				 * is enabled.
+				 * Optional.
+				 */
+				firstPartyDomain?: string;
+				/**
+				 * The storage partition, if the cookie is part of partitioned storage. By default, only non-partitioned cookies are
+				 * returned.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			/**
+			 * Information to filter the cookies being retrieved.
+			 */
+			interface GetAllDetailsType {
+				/**
+				 * Restricts the retrieved cookies to those that would match the given URL.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * Filters the cookies by name.
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * Restricts the retrieved cookies to those whose domains match or are subdomains of this one.
+				 * Optional.
+				 */
+				domain?: string;
+				/**
+				 * Restricts the retrieved cookies to those whose path exactly matches this string.
+				 * Optional.
+				 */
+				path?: string;
+				/**
+				 * Filters the cookies by their Secure property.
+				 * Optional.
+				 */
+				secure?: boolean;
+				/**
+				 * Filters out session vs. persistent cookies.
+				 * Optional.
+				 */
+				session?: boolean;
+				/**
+				 * The cookie store to retrieve cookies from. If omitted, the current execution context's cookie store will be used.
+				 * Optional.
+				 */
+				storeId?: string;
+				/**
+				 * 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`.
+				 * Optional.
+				 */
+				firstPartyDomain?: string | null;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			/**
+			 * Details about the cookie being set.
+			 */
+			interface SetDetailsType {
+				/**
+				 * 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.
+				 */
+				url: string;
+				/**
+				 * The name of the cookie. Empty by default if omitted.
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * The value of the cookie. Empty by default if omitted.
+				 * Optional.
+				 */
+				value?: string;
+				/**
+				 * The domain of the cookie. If omitted, the cookie becomes a host-only cookie.
+				 * Optional.
+				 */
+				domain?: string;
+				/**
+				 * The path of the cookie. Defaults to the path portion of the url parameter.
+				 * Optional.
+				 */
+				path?: string;
+				/**
+				 * Whether the cookie should be marked as Secure. Defaults to false.
+				 * Optional.
+				 */
+				secure?: boolean;
+				/**
+				 * Whether the cookie should be marked as HttpOnly. Defaults to false.
+				 * Optional.
+				 */
+				httpOnly?: boolean;
+				/**
+				 * The cookie's same-site status.
+				 * Optional.
+				 */
+				sameSite?: SameSiteStatus;
+				/**
+				 * The expiration date of the cookie as the number of seconds since the UNIX epoch. If omitted,
+				 * the cookie becomes a session cookie.
+				 * Optional.
+				 */
+				expirationDate?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				storeId?: string;
+				/**
+				 * The first-party domain of the cookie. This attribute is required if First-Party Isolation is enabled.
+				 * Optional.
+				 */
+				firstPartyDomain?: string;
+				/**
+				 * The storage partition, if the cookie is part of partitioned storage. By default, non-partitioned storage is used.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			/**
+			 * Information to identify the cookie to remove.
+			 */
+			interface RemoveDetailsType {
+				/**
+				 * The URL associated with the cookie. If host permissions for this URL are not specified in the manifest file,
+				 * the API call will fail.
+				 */
+				url: string;
+				/**
+				 * The name of the cookie to remove.
+				 */
+				name: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				storeId?: string;
+				/**
+				 * The first-party domain associated with the cookie. This attribute is required if First-Party Isolation is enabled.
+				 * Optional.
+				 */
+				firstPartyDomain?: string;
+				/**
+				 * The storage partition, if the cookie is part of partitioned storage. By default, non-partitioned storage is used.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			/**
+			 * 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.
+			 */
+			interface RemoveCallbackDetailsType {
+				/**
+				 * The URL associated with the cookie that's been removed.
+				 */
+				url: string;
+				/**
+				 * The name of the cookie that's been removed.
+				 */
+				name: string;
+				/**
+				 * The ID of the cookie store from which the cookie was removed.
+				 */
+				storeId: string;
+				/**
+				 * The first-party domain associated with the cookie that's been removed.
+				 */
+				firstPartyDomain: string;
+				/**
+				 * The storage partition, if the cookie is part of partitioned storage. null if not partitioned.
+				 * Optional.
+				 */
+				partitionKey?: PartitionKey;
+			}
+			interface OnChangedChangeInfoType {
+				/**
+				 * True if a cookie was removed.
+				 */
+				removed: boolean;
+				/**
+				 * Information about the cookie that was set or removed.
+				 */
+				cookie: Cookie;
+				/**
+				 * The underlying reason behind the cookie's change.
+				 */
+				cause: OnChangedCause;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 *
+				 * @param details Details to identify the cookie being retrieved.
+				 */
+				get(details: GetDetailsType): Promise<Cookie | null>;
+				/**
+				 * 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.
+				 *
+				 * @param details Information to filter the cookies being retrieved.
+				 */
+				getAll(details: GetAllDetailsType): Promise<Cookie[]>;
+				/**
+				 * Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.
+				 *
+				 * @param details Details about the cookie being set.
+				 */
+				set(details: SetDetailsType): Promise<Cookie>;
+				/**
+				 * Deletes a cookie by name.
+				 *
+				 * @param details Information to identify the cookie to remove.
+				 */
+				remove(details: RemoveDetailsType): Promise<RemoveCallbackDetailsType | null>;
+				/**
+				 * Lists all existing cookie stores.
+				 */
+				getAllCookieStores(): Promise<CookieStore[]>;
+				/**
+				 * 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".
+				 */
+				onChanged: Events.Event<(changeInfo: OnChangedChangeInfoType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.declarativeContent
+		 */
+		namespace DeclarativeContent {
+			/**
+			 * See <a href="https://developer.mozilla.org/en-US/docs/Web/API/ImageData">https://developer.mozilla.
+			 * org/en-US/docs/Web/API/ImageData</a>.
+			 */
+			interface ImageDataType extends ImageData {
+				[s: string]: unknown;
+			}
+			/**
+			 * Matches the state of a web page based on various criteria.
+			 */
+			interface PageStateMatcher {
+				/**
+				 * Matches if the conditions of the <code>UrlFilter</code> are fulfilled for the top-level URL of the page.
+				 * Optional.
+				 */
+				pageUrl?: Browser.Events.UrlFilter;
+				/**
+				 * Matches if all of the CSS selectors in the array match displayed elements in a frame with the same origin as the page's
+				 * main frame. All selectors in this array must be <a href="http://www.w3.org/TR/selectors4/#compound">
+				 * compound selectors</a> to speed up matching. Note: Listing hundreds of CSS selectors or listing CSS selectors that match
+				 * hundreds of times per page can slow down web sites.
+				 * Optional.
+				 */
+				css?: string[];
+				/**
+				 * Matches if the bookmarked state of the page is equal to the specified value. Requres the <a
+				 * href='/docs/extensions/develop/concepts/declare-permissions'>bookmarks permission</a>.
+				 * Optional.
+				 */
+				isBookmarked?: boolean;
+			}
+			/**
+			 * Please use ShowAction.
+			 */
+			type ShowPageAction = never;
+			/**
+			 * A declarative event action that sets the extension's toolbar $(ref:action action) to an enabled state while the
+			 * corresponding conditions are met. This action can be used without <a
+			 * href="/docs/extensions/develop/concepts/declare-permissions#host-permissions">host permissions</a>.
+			 * If the extension has the <a href="/docs/extensions/develop/concepts/activeTab">activeTab</a> permission,
+			 * clicking the page action grants access to the active tab.<p>On pages where the conditions are not met the extension's
+			 * toolbar action will be grey-scale, and clicking it will open the context menu, instead of triggering the action.</p>
+			 */
+			interface ShowAction {
+				[s: string]: unknown;
+			}
+			/**
+			 * Declarative event action that sets the n-<abbr title="device-independent pixel">dip</abbr>
+			 * square icon for the extension's $(ref:pageAction page action) or $(ref:browserAction browser action)
+			 * while the corresponding conditions are met. This action can be used without <a
+			 * href="/docs/extensions/develop/concepts/declare-permissions#host-permissions">host permissions</a>,
+			 * but the extension must have a page or browser action.<p>Exactly one of <code>imageData</code> or <code>path</code>
+			 * must be specified. Both are dictionaries mapping a number of pixels to an image representation.
+			 * The image representation in <code>imageData</code> is an <a href="https://developer.mozilla.
+			 * org/en-US/docs/Web/API/ImageData">ImageData</a> object; for example, from a <code>canvas</code> element,
+			 * while the image representation in <code>path</code> is the path to an image file relative to the extension's manifest.
+			 * If <code>scale</code> screen pixels fit into a device-independent pixel, the <code>scale * n</code> icon is used.
+			 * If that scale is missing, another image is resized to the required size.</p>
+			 */
+			interface SetIcon {
+				/**
+				 * Either an <code>ImageData</code> object or a dictionary {size -> ImageData} representing an icon to be set.
+				 * If the icon is specified as a dictionary, the image used is chosen depending on the screen's pixel density.
+				 * If the number of image pixels that fit into one screen space unit equals <code>scale</code>,
+				 * then an image with size <code>scale * n</code> is selected, where <i>n</i> is the size of the icon in the UI.
+				 * At least one image must be specified. Note that <code>details.imageData = foo</code> is equivalent to <code>details.
+				 * imageData = {'16': foo}</code>.
+				 * Optional.
+				 */
+				imageData?: ImageDataType | SetIconImageDataC2Type;
+			}
+			/**
+			 * Declarative event action that injects a content script. <p><b>WARNING:</b> This action is still experimental and is not
+			 * supported on stable builds of Chrome.</p>
+			 */
+			interface RequestContentScript {
+				/**
+				 * Names of CSS files to be injected as a part of the content script.
+				 * Optional.
+				 */
+				css?: string[];
+				/**
+				 * Names of JavaScript files to be injected as a part of the content script.
+				 * Optional.
+				 */
+				js?: string[];
+				/**
+				 * Whether the content script runs in all frames of the matching page, or in only the top frame. Default is <code>
+				 * false</code>.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * Whether to insert the content script on <code>about:blank</code> and <code>about:srcdoc</code>. Default is <code>
+				 * false</code>.
+				 * Optional.
+				 */
+				matchAboutBlank?: boolean;
+			}
+			interface Rule<TCondition, TAction> {
+				/**
+				 * List of conditions that can trigger the actions.
+				 */
+				conditions: TCondition[];
+				/**
+				 * List of actions that are triggered if one of the conditions is fulfilled.
+				 */
+				actions: TAction[];
+			}
+			/**
+			 * An object which allows the addition and removal of rules for declarative content.
+			 */
+			interface RuleEvent<TCondition, TAction> {
+				/**
+				 * Registers rules to handle events.
+				 *
+				 * @param rules Rules to be registered. These do not replace previously registered rules.
+				 */
+				addRules(rules: Array<Rule<TCondition, TAction>>): void;
+				/**
+				 * Fetches currently registered rules.
+				 *
+				 * @param rules Optional. Rule ids to fetch.
+				 * @param callback Optional. Called when rules have been fetched.
+				 */
+				getRules(rules?: string[], callback?: (rules: Array<Rule<TCondition, TAction>>) => void): void;
+				/**
+				 * Unregisters currently registered rules.
+				 *
+				 * @param rules Optional. Rule ids to be unregistered.
+				 * @param callback Optional. Called when rules were unregistered.
+				 */
+				removeRules(rules?: string[], callback?: () => void): void;
+			}
+			interface SetIconImageDataC2Type {
+				[s: string]: unknown;
+			}
+			interface Static {
+				PageStateMatcher: {
+					new (options?: PageStateMatcher): PageStateMatcher;
+				};
+				ShowAction: {
+					new (options?: ShowAction): ShowAction;
+				};
+				SetIcon: {
+					new (options?: SetIcon): SetIcon;
+				};
+				RequestContentScript: {
+					new (options?: RequestContentScript): RequestContentScript;
+				};
+				onPageChanged: RuleEvent<PageStateMatcher, RequestContentScript | SetIcon | ShowPageAction | ShowAction>;
+			}
+		}
+		/**
+		 * Namespace: browser.declarativeNetRequest
+		 */
+		namespace DeclarativeNetRequest {
+			/**
+			 * How the requested resource will be used. Comparable to the webRequest.ResourceType type.
+			 * object_subrequest is unsupported.
+			 */
+			type ResourceType = "main_frame" | "sub_frame" | "stylesheet" | "script" | "image" | "object" | "object_subrequest" | "xmlhttprequest" | "xslt" | "ping" | "beacon" | "xml_dtd" | "font" | "media" | "websocket" | "csp_report" | "imageset" | "web_manifest" | "speculative" | "json" | "other";
+			/**
+			 * Describes the reason why a given regular expression isn't supported.
+			 */
+			type UnsupportedRegexReason = "syntaxError" | "memoryLimitExceeded";
+			interface MatchedRule {
+				/**
+				 * A matching rule's ID.
+				 */
+				ruleId: number;
+				/**
+				 * ID of the Ruleset this rule belongs to.
+				 */
+				rulesetId: string;
+				/**
+				 * ID of the extension, if this rule belongs to a different extension.
+				 * Optional.
+				 */
+				extensionId?: string;
+			}
+			/**
+			 * Describes the type of the Rule.action.redirect.transform property.
+			 */
+			interface URLTransform {
+				/**
+				 * The new scheme for the request.
+				 * Optional.
+				 */
+				scheme?: URLTransformSchemeEnum;
+				/**
+				 * The new username for the request.
+				 * Optional.
+				 */
+				username?: string;
+				/**
+				 * The new password for the request.
+				 * Optional.
+				 */
+				password?: string;
+				/**
+				 * The new host name for the request.
+				 * Optional.
+				 */
+				host?: string;
+				/**
+				 * The new port for the request. If empty, the existing port is cleared.
+				 * Optional.
+				 */
+				port?: string;
+				/**
+				 * The new path for the request. If empty, the existing path is cleared.
+				 * Optional.
+				 */
+				path?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				query?: string;
+				/**
+				 * Add, remove or replace query key-value pairs. Cannot be specified if 'query' is specified.
+				 * Optional.
+				 */
+				queryTransform?: URLTransformQueryTransformType;
+				/**
+				 * The new fragment for the request. Should be either empty, in which case the existing fragment is cleared; or should
+				 * begin with '#'.
+				 * Optional.
+				 */
+				fragment?: string;
+			}
+			interface Rule {
+				/**
+				 * An id which uniquely identifies a rule. Mandatory and should be >= 1.
+				 */
+				id: number;
+				/**
+				 * Rule priority. Defaults to 1. When specified, should be >= 1
+				 * Optional.
+				 */
+				priority?: number;
+				/**
+				 * The condition under which this rule is triggered.
+				 */
+				condition: RuleConditionType;
+				/**
+				 * The action to take if this rule is matched.
+				 */
+				action: RuleActionType;
+			}
+			interface GetRulesFilter {
+				/**
+				 * If specified, only rules with matching IDs are included.
+				 * Optional.
+				 */
+				ruleIds?: number[];
+			}
+			interface UpdateDynamicRulesOptionsType {
+				/**
+				 * IDs of the rules to remove. Any invalid IDs will be ignored.
+				 * Optional.
+				 */
+				removeRuleIds?: number[];
+				/**
+				 * Rules to add.
+				 * Optional.
+				 */
+				addRules?: Rule[];
+			}
+			interface UpdateSessionRulesOptionsType {
+				/**
+				 * IDs of the rules to remove. Any invalid IDs will be ignored.
+				 * Optional.
+				 */
+				removeRuleIds?: number[];
+				/**
+				 * Rules to add.
+				 * Optional.
+				 */
+				addRules?: Rule[];
+			}
+			interface UpdateEnabledRulesetsUpdateRulesetOptionsType {
+				/**
+				 * Optional.
+				 */
+				disableRulesetIds?: string[];
+				/**
+				 * Optional.
+				 */
+				enableRulesetIds?: string[];
+			}
+			interface UpdateStaticRulesOptionsType {
+				rulesetId: string;
+				/**
+				 * Optional.
+				 */
+				disableRuleIds?: number[];
+				/**
+				 * Optional.
+				 */
+				enableRuleIds?: number[];
+			}
+			interface GetDisabledRuleIdsOptionsType {
+				rulesetId: string;
+			}
+			interface IsRegexSupportedRegexOptionsType {
+				/**
+				 * The regular expresson to check.
+				 */
+				regex: string;
+				/**
+				 * Whether the 'regex' specified is case sensitive.
+				 * Optional.
+				 */
+				isCaseSensitive?: boolean;
+				/**
+				 * Whether the 'regex' specified requires capturing. Capturing is only required for redirect rules which specify a
+				 * 'regexSubstition' action.
+				 * Optional.
+				 */
+				requireCapturing?: boolean;
+			}
+			interface IsRegexSupportedCallbackResultType {
+				/**
+				 * Whether the given regex is supported
+				 */
+				isSupported: boolean;
+				/**
+				 * Specifies the reason why the regular expression is not supported. Only provided if 'isSupported' is false.
+				 * Optional.
+				 */
+				reason?: UnsupportedRegexReason;
+			}
+			/**
+			 * The details of the request to test.
+			 */
+			interface TestMatchOutcomeRequestType {
+				/**
+				 * The URL of the hypothetical request.
+				 */
+				url: string;
+				/**
+				 * The initiator URL (if any) for the hypothetical request.
+				 * Optional.
+				 */
+				initiator?: string;
+				/**
+				 * Standard HTTP method of the hypothetical request.
+				 * Optional.
+				 */
+				method?: string;
+				/**
+				 * The resource type of the hypothetical request.
+				 */
+				type: ResourceType;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				tabId?: number;
+			}
+			interface TestMatchOutcomeOptionsType {
+				/**
+				 * Whether to account for rules from other installed extensions during rule evaluation.
+				 * Optional.
+				 */
+				includeOtherExtensions?: boolean;
+			}
+			interface TestMatchOutcomeCallbackResultType {
+				/**
+				 * The rules (if any) that match the hypothetical request.
+				 */
+				matchedRules: MatchedRule[];
+			}
+			/**
+			 * The new scheme for the request.
+			 */
+			type URLTransformSchemeEnum = "http" | "https" | "moz-extension";
+			interface URLTransformQueryTransformAddOrReplaceParamsItemType {
+				key: string;
+				value: string;
+				/**
+				 * If true, the query key is replaced only if it's already present. Otherwise, the key is also added if it's missing.
+				 * Optional.
+				 */
+				replaceOnly?: boolean;
+			}
+			/**
+			 * Add, remove or replace query key-value pairs. Cannot be specified if 'query' is specified.
+			 */
+			interface URLTransformQueryTransformType {
+				/**
+				 * The list of query keys to be removed.
+				 * Optional.
+				 */
+				removeParams?: string[];
+				/**
+				 * The list of query key-value pairs to be added or replaced.
+				 * Optional.
+				 */
+				addOrReplaceParams?: URLTransformQueryTransformAddOrReplaceParamsItemType[];
+			}
+			/**
+			 * Specifies whether the network request is first-party or third-party to the domain from which it originated. If omitted,
+			 * all requests are matched.
+			 */
+			type RuleConditionDomainTypeEnum = "firstParty" | "thirdParty";
+			/**
+			 * The condition under which this rule is triggered.
+			 */
+			interface RuleConditionType {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				urlFilter?: string;
+				/**
+				 * Regular expression to match against the network request url. Only one of 'urlFilter' or 'regexFilter' can be specified.
+				 * Optional.
+				 */
+				regexFilter?: string;
+				/**
+				 * Whether 'urlFilter' or 'regexFilter' is case-sensitive.
+				 * Optional.
+				 */
+				isUrlFilterCaseSensitive?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				initiatorDomains?: string[];
+				/**
+				 * 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'.
+				 * Optional.
+				 */
+				excludedInitiatorDomains?: string[];
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				requestDomains?: string[];
+				/**
+				 * 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'.
+				 * Optional.
+				 */
+				excludedRequestDomains?: string[];
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				resourceTypes?: ResourceType[];
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				excludedResourceTypes?: ResourceType[];
+				/**
+				 * 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'.'
+				 * Optional.
+				 */
+				requestMethods?: string[];
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				excludedRequestMethods?: string[];
+				/**
+				 * Specifies whether the network request is first-party or third-party to the domain from which it originated. If omitted,
+				 * all requests are matched.
+				 * Optional.
+				 */
+				domainType?: RuleConditionDomainTypeEnum;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				tabIds?: number[];
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				excludedTabIds?: number[];
+			}
+			type RuleActionTypeEnum = "block" | "redirect" | "allow" | "upgradeScheme" | "modifyHeaders" | "allowAllRequests";
+			/**
+			 * Describes how the redirect should be performed. Only valid when type is 'redirect'.
+			 */
+			interface RuleActionRedirectType {
+				/**
+				 * Path relative to the extension directory. Should start with '/'.
+				 * Optional.
+				 */
+				extensionPath?: string;
+				/**
+				 * Url transformations to perform.
+				 * Optional.
+				 */
+				transform?: URLTransform;
+				/**
+				 * The redirect url. Redirects to JavaScript urls are not allowed.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				regexSubstitution?: string;
+			}
+			interface RuleActionRequestHeadersItemType {
+				/**
+				 * The name of the request header to be modified.
+				 */
+				header: string;
+				/**
+				 * The operation to be performed on a header.
+				 */
+				operation: "append" | "set" | "remove";
+				/**
+				 * The new value for the header. Must be specified for the 'append' and 'set' operations.
+				 * Optional.
+				 */
+				value?: string;
+			}
+			interface RuleActionResponseHeadersItemType {
+				/**
+				 * The name of the response header to be modified.
+				 */
+				header: string;
+				/**
+				 * The operation to be performed on a header.
+				 */
+				operation: "append" | "set" | "remove";
+				/**
+				 * The new value for the header. Must be specified for the 'append' and 'set' operations.
+				 * Optional.
+				 */
+				value?: string;
+			}
+			/**
+			 * The action to take if this rule is matched.
+			 */
+			interface RuleActionType {
+				type: RuleActionTypeEnum;
+				/**
+				 * Describes how the redirect should be performed. Only valid when type is 'redirect'.
+				 * Optional.
+				 */
+				redirect?: RuleActionRedirectType;
+				/**
+				 * The request headers to modify for the request. Only valid when type is 'modifyHeaders'.
+				 * Optional.
+				 */
+				requestHeaders?: RuleActionRequestHeadersItemType[];
+				/**
+				 * The response headers to modify for the request. Only valid when type is 'modifyHeaders'.
+				 * Optional.
+				 */
+				responseHeaders?: RuleActionResponseHeadersItemType[];
+			}
+			interface Static {
+				/**
+				 * 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.
+				 *
+				 * @returns Called when the dynamic rules have been updated
+				 */
+				updateDynamicRules(options: UpdateDynamicRulesOptionsType): Promise<void>;
+				/**
+				 * 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.
+				 *
+				 * @returns Called when the session rules have been updated
+				 */
+				updateSessionRules(options: UpdateSessionRulesOptionsType): Promise<void>;
+				/**
+				 * Returns the ids for the current set of enabled static rulesets.
+				 */
+				getEnabledRulesets(): Promise<string[]>;
+				/**
+				 * Modifies the static rulesets enabled/disabled state.
+				 */
+				updateEnabledRulesets(updateRulesetOptions: UpdateEnabledRulesetsUpdateRulesetOptionsType): Promise<void>;
+				/**
+				 * Modified individual static rules enabled/disabled state. Changes to rules belonging to a disabled ruleset will take
+				 * effect when the ruleset becomes enabled.
+				 */
+				updateStaticRules(options: UpdateStaticRulesOptionsType): Promise<void>;
+				/**
+				 * Returns the remaining number of static rules an extension can enable
+				 */
+				getAvailableStaticRuleCount(): Promise<number>;
+				/**
+				 * Returns the list of individual disabled static rules from a given static ruleset id.
+				 */
+				getDisabledRuleIds(options: GetDisabledRuleIdsOptionsType): Promise<number[]>;
+				/**
+				 * Returns the current set of dynamic rules for the extension.
+				 *
+				 * @param filter Optional. An object to filter the set of dynamic rules for the extension.
+				 */
+				getDynamicRules(filter?: GetRulesFilter): Promise<Rule[]>;
+				/**
+				 * Returns the current set of session scoped rules for the extension.
+				 *
+				 * @param filter Optional. An object to filter the set of session scoped rules for the extension.
+				 */
+				getSessionRules(filter?: GetRulesFilter): Promise<Rule[]>;
+				/**
+				 * Checks if the given regular expression will be supported as a 'regexFilter' rule condition.
+				 */
+				isRegexSupported(regexOptions: IsRegexSupportedRegexOptionsType): Promise<IsRegexSupportedCallbackResultType>;
+				/**
+				 * Checks if any of the extension's declarativeNetRequest rules would match a hypothetical request.
+				 *
+				 * @param request The details of the request to test.
+				 * @param options Optional.
+				 * @returns Called with the details of matched rules.
+				 */
+				testMatchOutcome(request: TestMatchOutcomeRequestType, options?: TestMatchOutcomeOptionsType): Promise<TestMatchOutcomeCallbackResultType>;
+				/**
+				 * Ruleset ID for the dynamic rules added by the extension.
+				 */
+				DYNAMIC_RULESET_ID: "_dynamic";
+				/**
+				 * 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.
+				 */
+				GUARANTEED_MINIMUM_STATIC_RULES: number;
+				/**
+				 * The maximum number of static Rulesets an extension can specify as part of the rule_resources manifest key.
+				 */
+				MAX_NUMBER_OF_STATIC_RULESETS: number;
+				/**
+				 * The maximum number of static rules that can be disabled on each static ruleset.
+				 */
+				MAX_NUMBER_OF_DISABLED_STATIC_RULES: number;
+				/**
+				 * The maximum number of static Rulesets an extension can enable at any one time.
+				 */
+				MAX_NUMBER_OF_ENABLED_STATIC_RULESETS: number;
+				/**
+				 * Deprecated property returning the maximum number of dynamic and session rules an extension can add,
+				 * replaced by MAX_NUMBER_OF_DYNAMIC_RULES/MAX_NUMBER_OF_SESSION_RULES.
+				 */
+				MAX_NUMBER_OF_DYNAMIC_AND_SESSION_RULES: number;
+				/**
+				 * The maximum number of dynamic session rules an extension can add.
+				 */
+				MAX_NUMBER_OF_DYNAMIC_RULES: number;
+				/**
+				 * The maximum number of dynamic session rules an extension can add.
+				 */
+				MAX_NUMBER_OF_SESSION_RULES: number;
+				/**
+				 * 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.
+				 */
+				MAX_NUMBER_OF_REGEX_RULES: number;
+				/**
+				 * Ruleset ID for the session-scoped rules added by the extension.
+				 */
+				SESSION_RULESET_ID: "_session";
+			}
+		}
+		/**
+		 * Namespace: browser.devtools
+		 */
+		namespace Devtools {
+			interface Static {
+				inspectedWindow: InspectedWindow.Static;
+				network: Network.Static;
+				panels: Panels.Static;
+			}
+		}
+		/**
+		 * Namespace: browser.dns
+		 */
+		namespace Dns {
+			/**
+			 * An object encapsulating a DNS Record.
+			 */
+			interface DNSRecord {
+				/**
+				 * The canonical hostname for this record.  this value is empty if the record was not fetched with the 'canonical_name'
+				 * flag.
+				 * Optional.
+				 */
+				canonicalName?: string;
+				/**
+				 * Record retreived with TRR.
+				 */
+				isTRR: string;
+				addresses: string[];
+			}
+			type ResolveFlags = ResolveFlagsItemEnum[];
+			type ResolveFlagsItemEnum = "allow_name_collisions" | "bypass_cache" | "canonical_name" | "disable_ipv4" | "disable_ipv6" | "disable_trr" | "offline" | "priority_low" | "priority_medium" | "speculate";
+			interface Static {
+				/**
+				 * Resolves a hostname to a DNS record.
+				 *
+				 * @param flags Optional.
+				 */
+				resolve(hostname: string, flags?: ResolveFlags): Promise<DNSRecord>;
+			}
+		}
+		/**
+		 * Namespace: browser.downloads
+		 */
+		namespace Downloads {
+			type FilenameConflictAction = "uniquify" | "overwrite" | "prompt";
+			type InterruptReason = "FILE_FAILED" | "FILE_ACCESS_DENIED" | "FILE_NO_SPACE" | "FILE_NAME_TOO_LONG" | "FILE_TOO_LARGE" | "FILE_VIRUS_INFECTED" | "FILE_TRANSIENT_ERROR" | "FILE_BLOCKED" | "FILE_SECURITY_CHECK_FAILED" | "FILE_TOO_SHORT" | "NETWORK_FAILED" | "NETWORK_TIMEOUT" | "NETWORK_DISCONNECTED" | "NETWORK_SERVER_DOWN" | "NETWORK_INVALID_REQUEST" | "SERVER_FAILED" | "SERVER_NO_RANGE" | "SERVER_BAD_CONTENT" | "SERVER_UNAUTHORIZED" | "SERVER_CERT_PROBLEM" | "SERVER_FORBIDDEN" | "USER_CANCELED" | "USER_SHUTDOWN" | "CRASH";
+			/**
+			 * <dl><dt>file</dt><dd>The download's filename is suspicious.</dd><dt>url</dt><dd>The download's URL is known to be
+			 * malicious.</dd><dt>content</dt><dd>The downloaded file is known to be malicious.</dd><dt>uncommon</dt><dd>
+			 * The download's URL is not commonly downloaded and could be dangerous.</dd><dt>safe</dt><dd>
+			 * The download presents no known danger to the user's computer.</dd></dl>These string constants will never change,
+			 * however the set of DangerTypes may change.
+			 */
+			type DangerType = "file" | "url" | "content" | "uncommon" | "host" | "unwanted" | "safe" | "accepted";
+			/**
+			 * <dl><dt>in_progress</dt><dd>The download is currently receiving data from the server.</dd><dt>interrupted</dt><dd>
+			 * An error broke the connection with the file host.</dd><dt>complete</dt><dd>The download completed successfully.</dd></dl>
+			 * These string constants will never change, however the set of States may change.
+			 */
+			type State = "in_progress" | "interrupted" | "complete";
+			interface DownloadItem {
+				/**
+				 * An identifier that is persistent across browser sessions.
+				 */
+				id: number;
+				/**
+				 * Absolute URL.
+				 */
+				url: string;
+				/**
+				 * Optional.
+				 */
+				referrer?: string;
+				/**
+				 * Absolute local path.
+				 */
+				filename: string;
+				/**
+				 * False if this download is recorded in the history, true if it is not recorded.
+				 */
+				incognito: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * Indication of whether this download is thought to be safe or known to be suspicious.
+				 */
+				danger: DangerType;
+				/**
+				 * The file's MIME type.
+				 * Optional.
+				 */
+				mime?: string;
+				/**
+				 * Number of milliseconds between the unix epoch and when this download began.
+				 */
+				startTime: string;
+				/**
+				 * Number of milliseconds between the unix epoch and when this download ended.
+				 * Optional.
+				 */
+				endTime?: string;
+				/**
+				 * Optional.
+				 */
+				estimatedEndTime?: string;
+				/**
+				 * Indicates whether the download is progressing, interrupted, or complete.
+				 */
+				state: State;
+				/**
+				 * True if the download has stopped reading data from the host, but kept the connection open.
+				 */
+				paused: boolean;
+				canResume: boolean;
+				/**
+				 * Number indicating why a download was interrupted.
+				 * Optional.
+				 */
+				error?: InterruptReason;
+				/**
+				 * Number of bytes received so far from the host, without considering file compression.
+				 */
+				bytesReceived: number;
+				/**
+				 * Number of bytes in the whole file, without considering file compression, or -1 if unknown.
+				 */
+				totalBytes: number;
+				/**
+				 * Number of bytes in the whole file post-decompression, or -1 if unknown.
+				 */
+				fileSize: number;
+				exists: boolean;
+				/**
+				 * Optional.
+				 */
+				byExtensionId?: string;
+				/**
+				 * Optional.
+				 */
+				byExtensionName?: string;
+			}
+			interface StringDelta {
+				/**
+				 * Optional.
+				 */
+				current?: string;
+				/**
+				 * Optional.
+				 */
+				previous?: string;
+			}
+			interface DoubleDelta {
+				/**
+				 * Optional.
+				 */
+				current?: number;
+				/**
+				 * Optional.
+				 */
+				previous?: number;
+			}
+			interface BooleanDelta {
+				/**
+				 * Optional.
+				 */
+				current?: boolean;
+				/**
+				 * Optional.
+				 */
+				previous?: boolean;
+			}
+			/**
+			 * A time specified as a Date object, a number or string representing milliseconds since the epoch, or an ISO 8601 string
+			 */
+			type DownloadTime = string | ExtensionTypes.DateType;
+			/**
+			 * Parameters that combine to specify a predicate that can be used to select a set of downloads.
+			 * Used for example in search() and erase()
+			 */
+			interface DownloadQuery {
+				/**
+				 * This array of search terms limits results to <a href='#type-DownloadItem'>DownloadItems</a> whose <code>filename</code>
+				 * or <code>url</code> 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.
+				 * Optional.
+				 */
+				query?: string[];
+				/**
+				 * Limits results to downloads that started before the given ms since the epoch.
+				 * Optional.
+				 */
+				startedBefore?: DownloadTime;
+				/**
+				 * Limits results to downloads that started after the given ms since the epoch.
+				 * Optional.
+				 */
+				startedAfter?: DownloadTime;
+				/**
+				 * Limits results to downloads that ended before the given ms since the epoch.
+				 * Optional.
+				 */
+				endedBefore?: DownloadTime;
+				/**
+				 * Limits results to downloads that ended after the given ms since the epoch.
+				 * Optional.
+				 */
+				endedAfter?: DownloadTime;
+				/**
+				 * Limits results to downloads whose totalBytes is greater than the given integer.
+				 * Optional.
+				 */
+				totalBytesGreater?: number;
+				/**
+				 * Limits results to downloads whose totalBytes is less than the given integer.
+				 * Optional.
+				 */
+				totalBytesLess?: number;
+				/**
+				 * Limits results to <a href='#type-DownloadItem'>DownloadItems</a> whose <code>filename</code>
+				 * matches the given regular expression.
+				 * Optional.
+				 */
+				filenameRegex?: string;
+				/**
+				 * Limits results to <a href='#type-DownloadItem'>DownloadItems</a> whose <code>url</code>
+				 * matches the given regular expression.
+				 * Optional.
+				 */
+				urlRegex?: string;
+				/**
+				 * Setting this integer limits the number of results. Otherwise, all matching <a href='#type-DownloadItem'>DownloadItems</a>
+				 * will be returned.
+				 * Optional.
+				 */
+				limit?: number;
+				/**
+				 * Setting elements of this array to <a href='#type-DownloadItem'>DownloadItem</a> properties in order to sort the search
+				 * results. For example, setting <code>orderBy='startTime'</code> sorts the <a href='#type-DownloadItem'>DownloadItems</a>
+				 * by their start time in ascending order. To specify descending order, prefix <code>orderBy</code>
+				 * with a hyphen: '-startTime'.
+				 * Optional.
+				 */
+				orderBy?: string[];
+				/**
+				 * Optional.
+				 */
+				id?: number;
+				/**
+				 * Absolute URL.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * Absolute local path.
+				 * Optional.
+				 */
+				filename?: string;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * Indication of whether this download is thought to be safe or known to be suspicious.
+				 * Optional.
+				 */
+				danger?: DangerType;
+				/**
+				 * The file's MIME type.
+				 * Optional.
+				 */
+				mime?: string;
+				/**
+				 * Optional.
+				 */
+				startTime?: string;
+				/**
+				 * Optional.
+				 */
+				endTime?: string;
+				/**
+				 * Indicates whether the download is progressing, interrupted, or complete.
+				 * Optional.
+				 */
+				state?: State;
+				/**
+				 * True if the download has stopped reading data from the host, but kept the connection open.
+				 * Optional.
+				 */
+				paused?: boolean;
+				/**
+				 * Why a download was interrupted.
+				 * Optional.
+				 */
+				error?: InterruptReason;
+				/**
+				 * Number of bytes received so far from the host, without considering file compression.
+				 * Optional.
+				 */
+				bytesReceived?: number;
+				/**
+				 * Number of bytes in the whole file, without considering file compression, or -1 if unknown.
+				 * Optional.
+				 */
+				totalBytes?: number;
+				/**
+				 * Number of bytes in the whole file post-decompression, or -1 if unknown.
+				 * Optional.
+				 */
+				fileSize?: number;
+				/**
+				 * Optional.
+				 */
+				exists?: boolean;
+			}
+			/**
+			 * What to download and how.
+			 */
+			interface DownloadOptionsType {
+				/**
+				 * The URL to download.
+				 */
+				url: string;
+				/**
+				 * A file path relative to the Downloads directory to contain the downloaded file.
+				 * Optional.
+				 */
+				filename?: string;
+				/**
+				 * Whether to associate the download with a private browsing session.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity; requires "cookies" permission.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * Optional.
+				 */
+				conflictAction?: FilenameConflictAction;
+				/**
+				 * 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 <code>browser.download.useDownloadDir</code> is set to <code>false</code>).
+				 * Optional.
+				 */
+				saveAs?: boolean;
+				/**
+				 * The HTTP method to use if the URL uses the HTTP[S] protocol.
+				 * Optional.
+				 */
+				method?: DownloadOptionsTypeMethodEnum;
+				/**
+				 * 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 <code>name</code> and either <code>value</code> or <code>binaryValue</code>,
+				 * restricted to those allowed by XMLHttpRequest.
+				 * Optional.
+				 */
+				headers?: DownloadOptionsTypeHeadersItemType[];
+				/**
+				 * Post body.
+				 * Optional.
+				 */
+				body?: string;
+				/**
+				 * When this flag is set to <code>true</code>, then the browser will allow downloads to proceed after encountering HTTP
+				 * errors such as <code>404 Not Found</code>.
+				 * Optional.
+				 */
+				allowHttpErrors?: boolean;
+			}
+			interface GetFileIconOptionsType {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				size?: number;
+			}
+			interface OnChangedDownloadDeltaType {
+				/**
+				 * The <code>id</code> of the <a href='#type-DownloadItem'>DownloadItem</a> that changed.
+				 */
+				id: number;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>url</code>.
+				 * Optional.
+				 */
+				url?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>filename</code>.
+				 * Optional.
+				 */
+				filename?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>danger</code>.
+				 * Optional.
+				 */
+				danger?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>mime</code>.
+				 * Optional.
+				 */
+				mime?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>startTime</code>.
+				 * Optional.
+				 */
+				startTime?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>endTime</code>.
+				 * Optional.
+				 */
+				endTime?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>state</code>.
+				 * Optional.
+				 */
+				state?: StringDelta;
+				/**
+				 * Optional.
+				 */
+				canResume?: BooleanDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>paused</code>.
+				 * Optional.
+				 */
+				paused?: BooleanDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>error</code>.
+				 * Optional.
+				 */
+				error?: StringDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>totalBytes</code>.
+				 * Optional.
+				 */
+				totalBytes?: DoubleDelta;
+				/**
+				 * Describes a change in a <a href='#type-DownloadItem'>DownloadItem</a>'s <code>fileSize</code>.
+				 * Optional.
+				 */
+				fileSize?: DoubleDelta;
+				/**
+				 * Optional.
+				 */
+				exists?: BooleanDelta;
+			}
+			/**
+			 * The HTTP method to use if the URL uses the HTTP[S] protocol.
+			 */
+			type DownloadOptionsTypeMethodEnum = "GET" | "POST";
+			interface DownloadOptionsTypeHeadersItemType {
+				/**
+				 * Name of the HTTP header.
+				 */
+				name: string;
+				/**
+				 * Value of the HTTP header.
+				 */
+				value: string;
+			}
+			interface Static {
+				/**
+				 * 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 <code>filename</code> and <code>saveAs</code> are specified, then the Save As dialog will be displayed,
+				 * pre-populated with the specified <code>filename</code>. If the download started successfully, <code>callback</code>
+				 * will be called with the new <a href='#type-DownloadItem'>DownloadItem</a>'s <code>downloadId</code>.
+				 * If there was an error starting the download, then <code>callback</code> will be called with <code>
+				 * downloadId=undefined</code> and <a href='extension.html#property-lastError'>chrome.extension.lastError</a>
+				 * will contain a descriptive string. The error strings are not guaranteed to remain backwards compatible between releases.
+				 * You must not parse it.
+				 *
+				 * @param options What to download and how.
+				 */
+				download(options: DownloadOptionsType): Promise<number>;
+				/**
+				 * Find <a href='#type-DownloadItem'>DownloadItems</a>. Set <code>query</code> to the empty object to get all <a
+				 * href='#type-DownloadItem'>DownloadItems</a>. To get a specific <a href='#type-DownloadItem'>DownloadItem</a>,
+				 * set only the <code>id</code> field.
+				 */
+				search(query: DownloadQuery): Promise<DownloadItem[]>;
+				/**
+				 * Pause the download. If the request was successful the download is in a paused state. Otherwise <a href='extension.
+				 * html#property-lastError'>chrome.extension.lastError</a> contains an error message.
+				 * The request will fail if the download is not active.
+				 *
+				 * @param downloadId The id of the download to pause.
+				 */
+				pause(downloadId: number): Promise<void>;
+				/**
+				 * Resume a paused download. If the request was successful the download is in progress and unpaused.
+				 * Otherwise <a href='extension.html#property-lastError'>chrome.extension.lastError</a> contains an error message.
+				 * The request will fail if the download is not active.
+				 *
+				 * @param downloadId The id of the download to resume.
+				 */
+				resume(downloadId: number): Promise<void>;
+				/**
+				 * Cancel a download. When <code>callback</code> is run, the download is cancelled, completed,
+				 * interrupted or doesn't exist anymore.
+				 *
+				 * @param downloadId The id of the download to cancel.
+				 */
+				cancel(downloadId: number): Promise<void>;
+				/**
+				 * Retrieve an icon for the specified download. For new downloads, file icons are available after the <a
+				 * href='#event-onCreated'>onCreated</a> 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, <a href='extension.
+				 * html#property-lastError'>chrome.extension.lastError</a> will contain an error message.
+				 *
+				 * @param downloadId The identifier for the download.
+				 * @param options Optional.
+				 */
+				getFileIcon(downloadId: number, options?: GetFileIconOptionsType): Promise<string>;
+				/**
+				 * Open the downloaded file.
+				 */
+				open(downloadId: number): Promise<void>;
+				/**
+				 * Show the downloaded file in its folder in a file manager.
+				 */
+				show(downloadId: number): Promise<boolean>;
+				showDefaultFolder(): void;
+				/**
+				 * Erase matching <a href='#type-DownloadItem'>DownloadItems</a> from history
+				 */
+				erase(query: DownloadQuery): Promise<number[]>;
+				removeFile(downloadId: number): Promise<void>;
+				/**
+				 * This event fires with the <a href='#type-DownloadItem'>DownloadItem</a> object when a download begins.
+				 */
+				onCreated: Events.Event<(downloadItem: DownloadItem) => void>;
+				/**
+				 * Fires with the <code>downloadId</code> when a download is erased from history.
+				 *
+				 * @param downloadId The <code>id</code> of the <a href='#type-DownloadItem'>DownloadItem</a> that was erased.
+				 */
+				onErased: Events.Event<(downloadId: number) => void>;
+				/**
+				 * When any of a <a href='#type-DownloadItem'>DownloadItem</a>'s properties except <code>bytesReceived</code> changes,
+				 * this event fires with the <code>downloadId</code> and an object containing the properties that changed.
+				 */
+				onChanged: Events.Event<(downloadDelta: OnChangedDownloadDeltaType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.events
+		 */
+		namespace Events {
+			/**
+			 * Description of a declarative rule for handling events.
+			 */
+			interface Rule {
+				/**
+				 * Optional identifier that allows referencing this rule.
+				 * Optional.
+				 */
+				id?: string;
+				/**
+				 * Tags can be used to annotate rules and perform operations on sets of rules.
+				 * Optional.
+				 */
+				tags?: string[];
+				/**
+				 * List of conditions that can trigger the actions.
+				 */
+				conditions: unknown[];
+				/**
+				 * List of actions that are triggered if one of the condtions is fulfilled.
+				 */
+				actions: unknown[];
+				/**
+				 * Optional priority of this rule. Defaults to 100.
+				 * Optional.
+				 */
+				priority?: number;
+			}
+			/**
+			 * An object which allows the addition and removal of listeners for a Chrome event.
+			 */
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			interface Event<T extends (...args: any[]) => any> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param ...params Further parameters, depending on the event.
+				 */
+				addListener(callback: T, ...params: unknown[]): void;
+				/**
+				 * Deregisters an event listener <em>callback</em> from an event.
+				 *
+				 * @param callback Listener that shall be unregistered.
+				 */
+				removeListener(callback: T): void;
+				/**
+				 * @param callback Listener whose registration status shall be tested.
+				 * @returns True if <em>callback</em> is registered to the event.
+				 */
+				hasListener(callback: T): boolean;
+			}
+			/**
+			 * Filters URLs for various criteria. See <a href='events#filtered'>event filtering</a>. All criteria are case sensitive.
+			 */
+			interface UrlFilter {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				hostContains?: string;
+				/**
+				 * Matches if the host name of the URL is equal to a specified string.
+				 * Optional.
+				 */
+				hostEquals?: string;
+				/**
+				 * Matches if the host name of the URL starts with a specified string.
+				 * Optional.
+				 */
+				hostPrefix?: string;
+				/**
+				 * Matches if the host name of the URL ends with a specified string.
+				 * Optional.
+				 */
+				hostSuffix?: string;
+				/**
+				 * Matches if the path segment of the URL contains a specified string.
+				 * Optional.
+				 */
+				pathContains?: string;
+				/**
+				 * Matches if the path segment of the URL is equal to a specified string.
+				 * Optional.
+				 */
+				pathEquals?: string;
+				/**
+				 * Matches if the path segment of the URL starts with a specified string.
+				 * Optional.
+				 */
+				pathPrefix?: string;
+				/**
+				 * Matches if the path segment of the URL ends with a specified string.
+				 * Optional.
+				 */
+				pathSuffix?: string;
+				/**
+				 * Matches if the query segment of the URL contains a specified string.
+				 * Optional.
+				 */
+				queryContains?: string;
+				/**
+				 * Matches if the query segment of the URL is equal to a specified string.
+				 * Optional.
+				 */
+				queryEquals?: string;
+				/**
+				 * Matches if the query segment of the URL starts with a specified string.
+				 * Optional.
+				 */
+				queryPrefix?: string;
+				/**
+				 * Matches if the query segment of the URL ends with a specified string.
+				 * Optional.
+				 */
+				querySuffix?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				urlContains?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				urlEquals?: string;
+				/**
+				 * 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 <a
+				 * href="https://github.com/google/re2/blob/master/doc/syntax.txt">RE2 syntax</a>.
+				 * Optional.
+				 */
+				urlMatches?: string;
+				/**
+				 * 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 <a
+				 * href="https://github.com/google/re2/blob/master/doc/syntax.txt">RE2 syntax</a>.
+				 * Optional.
+				 */
+				originAndPathMatches?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				urlPrefix?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				urlSuffix?: string;
+				/**
+				 * Matches if the scheme of the URL is equal to any of the schemes specified in the array.
+				 * Optional.
+				 */
+				schemes?: string[];
+				/**
+				 * Matches if the port of the URL is contained in any of the specified port lists. For example <code>[80, 443, [1000, 1200]]
+				 * </code> matches all requests on port 80, 443 and in the range 1000-1200.
+				 * Optional.
+				 */
+				ports?: Array<number | [
+					number,
+					number
+				]>;
+			}
+			interface Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.experiments
+		 */
+		namespace Experiments {
+			interface ExperimentAPI {
+				schema: ExperimentURL;
+				/**
+				 * Optional.
+				 */
+				parent?: ExperimentAPIParentType;
+				/**
+				 * Optional.
+				 */
+				child?: ExperimentAPIChildType;
+			}
+			type ExperimentURL = string;
+			type APIPaths = APIPath[];
+			type APIPath = string[];
+			type APIEvents = APIEvent[];
+			type APIEvent = "startup";
+			type APIParentScope = "addon_parent" | "content_parent" | "devtools_parent";
+			type APIChildScope = "addon_child" | "content_child" | "devtools_child";
+			interface ExperimentAPIParentType {
+				/**
+				 * Optional.
+				 */
+				events?: APIEvents;
+				/**
+				 * Optional.
+				 */
+				paths?: APIPaths;
+				script: ExperimentURL;
+				/**
+				 * Optional.
+				 */
+				scopes?: APIParentScope[];
+			}
+			interface ExperimentAPIChildType {
+				paths: APIPaths;
+				script: ExperimentURL;
+				scopes: APIChildScope[];
+			}
+			interface Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.extensionTypes
+		 */
+		namespace ExtensionTypes {
+			/**
+			 * The format of an image.
+			 */
+			type ImageFormat = "jpeg" | "png";
+			/**
+			 * Details about the format, quality, area and scale of the capture.
+			 */
+			interface ImageDetails {
+				/**
+				 * The format of the resulting image.  Default is <code>"jpeg"</code>.
+				 * Optional.
+				 */
+				format?: ImageFormat;
+				/**
+				 * When format is <code>"jpeg"</code>, 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.
+				 * Optional.
+				 */
+				quality?: number;
+				/**
+				 * The area of the document to capture, in CSS pixels, relative to the page.  If omitted, capture the visible viewport.
+				 * Optional.
+				 */
+				rect?: ImageDetailsRectType;
+				/**
+				 * The scale of the resulting image.  Defaults to <code>devicePixelRatio</code>.
+				 * Optional.
+				 */
+				scale?: number;
+				/**
+				 * If true, temporarily resets the scroll position of the document to 0. Only takes effect if rect is also specified.
+				 * Optional.
+				 */
+				resetScrollPosition?: boolean;
+			}
+			/**
+			 * The soonest that the JavaScript or CSS will be injected into the tab.
+			 */
+			type RunAt = "document_start" | "document_end" | "document_idle";
+			/**
+			 * The JavaScript world for a script to execute within. <code>ISOLATED</code> is the default execution environment of
+			 * content scripts, <code>MAIN</code> is the web page's execution environment.
+			 */
+			type ExecutionWorld = "ISOLATED" | "MAIN";
+			/**
+			 * The origin of the CSS to inject, this affects the cascading order (priority) of the stylesheet.
+			 */
+			type CSSOrigin = "user" | "author";
+			/**
+			 * Details of the script or CSS to inject. Either the code or the file property must be set,
+			 * but both may not be set at the same time.
+			 */
+			interface InjectDetails {
+				/**
+				 * JavaScript or CSS code to inject.<br><br><b>Warning:</b><br>Be careful using the <code>code</code> parameter.
+				 * Incorrect use of it may open your extension to <a href="https://en.wikipedia.org/wiki/Cross-site_scripting">
+				 * cross site scripting</a> attacks.
+				 * Optional.
+				 */
+				code?: string;
+				/**
+				 * JavaScript or CSS file to inject.
+				 * Optional.
+				 */
+				file?: string;
+				/**
+				 * If allFrames is <code>true</code>, implies that the JavaScript or CSS should be injected into all frames of current page.
+				 * By default, it's <code>false</code> and is only injected into the top frame.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * 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 <code>false</code>.
+				 * Optional.
+				 */
+				matchAboutBlank?: boolean;
+				/**
+				 * The ID of the frame to inject the script into. This may not be used in combination with <code>allFrames</code>.
+				 * Optional.
+				 */
+				frameId?: number;
+				/**
+				 * The soonest that the JavaScript or CSS will be injected into the tab. Defaults to "document_idle".
+				 * Optional.
+				 */
+				runAt?: RunAt;
+				/**
+				 * The css origin of the stylesheet to inject. Defaults to "author".
+				 * Optional.
+				 */
+				cssOrigin?: CSSOrigin;
+			}
+			type DateType = string | number | Date;
+			type ExtensionFileOrCode = ExtensionFileOrCodeC1Type | ExtensionFileOrCodeC2Type;
+			/**
+			 * A plain JSON value
+			 */
+			interface PlainJSONValue {
+				[s: string]: unknown;
+			}
+			/**
+			 * The area of the document to capture, in CSS pixels, relative to the page.  If omitted, capture the visible viewport.
+			 */
+			interface ImageDetailsRectType {
+				x: number;
+				y: number;
+				width: number;
+				height: number;
+			}
+			interface ExtensionFileOrCodeC1Type {
+				file: Browser.Manifest.ExtensionURL;
+			}
+			interface ExtensionFileOrCodeC2Type {
+				code: string;
+			}
+			interface Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.extension
+		 */
+		namespace Extension {
+			/**
+			 * The type of extension view.
+			 */
+			type ViewType = "tab" | "popup" | "sidebar";
+			interface GetViewsFetchPropertiesType {
+				/**
+				 * The type of view to get. If omitted, returns all views (including background pages and tabs). Valid values: 'tab',
+				 * 'popup', 'sidebar'.
+				 * Optional.
+				 */
+				type?: ViewType;
+				/**
+				 * The window to restrict the search to. If omitted, returns all views.
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * Find a view according to a tab id. If this field is omitted, returns all views.
+				 * Optional.
+				 */
+				tabId?: number;
+			}
+			interface Static {
+				/**
+				 * Returns an array of the JavaScript 'window' objects for each of the pages running inside the current extension.
+				 *
+				 * @param fetchProperties Optional.
+				 * @returns Array of global objects
+				 */
+				getViews(fetchProperties?: GetViewsFetchPropertiesType): Window[];
+				/**
+				 * Returns the JavaScript 'window' object for the background page running inside the current extension.
+				 * Returns null if the extension has no background page.
+				 */
+				getBackgroundPage(): Window;
+				/**
+				 * Retrieves the state of the extension's access to Incognito-mode (as determined by the user-controlled 'Allowed in
+				 * Incognito' checkbox.
+				 */
+				isAllowedIncognitoAccess(): Promise<boolean>;
+				/**
+				 * Retrieves the state of the extension's access to the 'file://' scheme (as determined by the user-controlled 'Allow
+				 * access to File URLs' checkbox.
+				 */
+				isAllowedFileSchemeAccess(): Promise<boolean>;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				inIncognitoContext?: boolean;
+			}
+		}
+		/**
+		 * Namespace: browser.find
+		 */
+		namespace Find {
+			interface RangeData {
+				/**
+				 * The index of the frame containing the match. 0 corresponds to the parent window. Note that the order of objects in the
+				 * rangeData array will sequentially line up with the order of frame indexes: for example,
+				 * framePos for the first sequence of rangeData objects will be 0, framePos for the next sequence will be 1, and so on.
+				 */
+				framePos: number;
+				/**
+				 * The ordinal position of the text node in which the match started.
+				 */
+				startTextNodePos: number;
+				/**
+				 * The ordinal position of the text node in which the match ended.
+				 */
+				endTextNodePos: number;
+				/**
+				 * The ordinal string position of the start of the matched word within start text node.
+				 * If match word include in single text node, Extension can get match word between startOffset and endOffset string index
+				 * in the single text node.
+				 */
+				startOffset: number;
+				/**
+				 * The ordinal string position of the end of the matched word within end text node.
+				 */
+				endOffset: number;
+			}
+			interface Rectangle {
+				/**
+				 * Pixels from the top.
+				 */
+				top: number;
+				/**
+				 * Pixels from the left.
+				 */
+				left: number;
+				/**
+				 * Pixels from the bottom.
+				 */
+				bottom: number;
+				/**
+				 * Pixels from the right.
+				 */
+				right: number;
+			}
+			interface RectsAndTexts {
+				/**
+				 * Rectangles relative to the top-left of the viewport.
+				 */
+				rectList: Rectangle[];
+				/**
+				 * an array of strings, corresponding to the rectList array. The entry at textList[i]
+				 * contains the part of the match bounded by the rectangle at rectList[i].
+				 */
+				textList: string[];
+			}
+			interface RectData {
+				/**
+				 * The index of the frame containing the match. 0 corresponds to the parent window. Note that the order of objects in the
+				 * rangeData array will sequentially line up with the order of frame indexes: for example,
+				 * framePos for the first sequence of rangeData objects will be 0, framePos for the next sequence will be 1, and so on.
+				 */
+				rectsAndTexts: RectsAndTexts;
+				/**
+				 * The complete text of the match.
+				 */
+				text: string;
+			}
+			interface FindResult {
+				/**
+				 * The number of results found.
+				 */
+				count: number;
+				/**
+				 * If includeRangeData was given in the options parameter, then this property will be included.
+				 * It is provided as an array of RangeData objects, one for each match. Each RangeData object describes where in the DOM
+				 * tree the match was found. This would enable, for example, an extension to get the text surrounding each match,
+				 * so as to display context for the matches. The items correspond to the items given in rectData, so rangeData[i]
+				 * describes the same match as rectData[i].
+				 * Optional.
+				 */
+				rangeData?: RangeData[];
+				/**
+				 * If includeRectData was given in the options parameter, then this property will be included.
+				 * It is an array of RectData objects. It contains client rectangles for all the text matched in the search,
+				 * relative to the top-left of the viewport. Extensions can use this to provide custom highlighting of the results.
+				 * Optional.
+				 */
+				rectData?: RectData[];
+			}
+			/**
+			 * Search parameters.
+			 */
+			interface FindParamsType {
+				/**
+				 * Tab to query. Defaults to the active tab.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Find only ranges with case sensitive match.
+				 * Optional.
+				 */
+				caseSensitive?: boolean;
+				/**
+				 * Find only ranges with diacritic sensitive match.
+				 * Optional.
+				 */
+				matchDiacritics?: boolean;
+				/**
+				 * Find only ranges that match entire word.
+				 * Optional.
+				 */
+				entireWord?: boolean;
+				/**
+				 * Return rectangle data which describes visual position of search results.
+				 * Optional.
+				 */
+				includeRectData?: boolean;
+				/**
+				 * Return range data which provides range data in a serializable form.
+				 * Optional.
+				 */
+				includeRangeData?: boolean;
+			}
+			/**
+			 * highlightResults parameters
+			 */
+			interface HighlightResultsParamsType {
+				/**
+				 * Found range to be highlighted. Default highlights all ranges.
+				 * Optional.
+				 */
+				rangeIndex?: number;
+				/**
+				 * Tab to highlight. Defaults to the active tab.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Don't scroll to highlighted item.
+				 * Optional.
+				 */
+				noScroll?: boolean;
+			}
+			interface Static {
+				/**
+				 * Search for text in document and store found ranges in array, in document order.
+				 *
+				 * @param queryphrase The string to search for.
+				 * @param params Optional. Search parameters.
+				 */
+				find(queryphrase: string, params?: FindParamsType): Promise<FindResult>;
+				/**
+				 * Highlight a range
+				 *
+				 * @param params Optional. highlightResults parameters
+				 */
+				highlightResults(params?: HighlightResultsParamsType): Promise<void>;
+				/**
+				 * Remove all highlighting from previous searches.
+				 *
+				 * @param tabId Optional. Tab to highlight. Defaults to the active tab.
+				 */
+				removeHighlighting(tabId?: number): Promise<void>;
+			}
+		}
+		/**
+		 * Namespace: browser.geckoProfiler
+		 */
+		namespace GeckoProfiler {
+			type ProfilerFeature = "java" | "js" | "mainthreadio" | "fileio" | "fileioall" | "nomarkerstacks" | "screenshots" | "seqstyle" | "stackwalk" | "jsallocations" | "nostacksampling" | "nativeallocations" | "ipcmessages" | "audiocallbacktracing" | "cpu" | "notimerresolutionchange" | "cpuallthreads" | "samplingallthreads" | "markersallthreads" | "unregisteredthreads" | "processcpu" | "power" | "responsiveness" | "cpufreq" | "bandwidth" | "memory" | "tracing" | "sandbox" | "flows";
+			type supports = "windowLength";
+			interface StartSettingsType {
+				/**
+				 * The maximum size in bytes of the buffer used to store profiling data. A larger value allows capturing a profile that
+				 * covers a greater amount of time.
+				 */
+				bufferSize: number;
+				/**
+				 * The length of the window of time that's kept in the buffer. Any collected samples are discarded as soon as they are
+				 * older than the number of seconds specified in this setting. Zero means no duration restriction.
+				 * Optional.
+				 */
+				windowLength?: number;
+				/**
+				 * Interval in milliseconds between samples of profiling data. A smaller value will increase the detail of the profiles
+				 * captured.
+				 */
+				interval: number;
+				/**
+				 * A list of active features for the profiler.
+				 */
+				features: ProfilerFeature[];
+				/**
+				 * A list of thread names for which to capture profiles.
+				 * Optional.
+				 */
+				threads?: string[];
+			}
+			interface Static {
+				/**
+				 * Starts the profiler with the specified settings.
+				 */
+				start(settings: StartSettingsType): void;
+				/**
+				 * Stops the profiler and discards any captured profile data.
+				 */
+				stop(): void;
+				/**
+				 * Pauses the profiler, keeping any profile data that is already written.
+				 */
+				pause(): void;
+				/**
+				 * Resumes the profiler with the settings that were initially used to start it.
+				 */
+				resume(): void;
+				/**
+				 * Gathers the profile data from the current profiling session, and writes it to disk.
+				 * The returned promise resolves to a path that locates the created file.
+				 *
+				 * @param fileName The name of the file inside the profile/profiler directory
+				 */
+				dumpProfileToFile(fileName: string): void;
+				/**
+				 * Gathers the profile data from the current profiling session.
+				 */
+				getProfile(): void;
+				/**
+				 * Gathers the profile data from the current profiling session. The returned promise resolves to an array buffer that
+				 * contains a JSON string.
+				 */
+				getProfileAsArrayBuffer(): void;
+				/**
+				 * Gathers the profile data from the current profiling session. The returned promise resolves to an array buffer that
+				 * contains a gzipped JSON string.
+				 */
+				getProfileAsGzippedArrayBuffer(): void;
+				/**
+				 * Gets the debug symbols for a particular library.
+				 *
+				 * @param debugName The name of the library's debug file. For example, 'xul.pdb
+				 * @param breakpadId The Breakpad ID of the library
+				 */
+				getSymbols(debugName: string, breakpadId: string): void;
+				/**
+				 * Fires when the profiler starts/stops running.
+				 *
+				 * @param isRunning Whether the profiler is running or not. Pausing the profiler will not affect this value.
+				 */
+				onRunning: Events.Event<(isRunning: boolean) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.history
+		 */
+		namespace History {
+			/**
+			 * The $(topic:transition-types)[transition type] for this visit from its referrer.
+			 */
+			type TransitionType = "link" | "typed" | "auto_bookmark" | "auto_subframe" | "manual_subframe" | "generated" | "auto_toplevel" | "form_submit" | "reload" | "keyword" | "keyword_generated";
+			/**
+			 * An object encapsulating one result of a history query.
+			 */
+			interface HistoryItem {
+				/**
+				 * The unique identifier for the item.
+				 */
+				id: string;
+				/**
+				 * The URL navigated to by a user.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * The title of the page when it was last loaded.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * When this page was last loaded, represented in milliseconds since the epoch.
+				 * Optional.
+				 */
+				lastVisitTime?: number;
+				/**
+				 * The number of times the user has navigated to this page.
+				 * Optional.
+				 */
+				visitCount?: number;
+				/**
+				 * The number of times the user has navigated to this page by typing in the address.
+				 * Optional.
+				 */
+				typedCount?: number;
+			}
+			/**
+			 * An object encapsulating one visit to a URL.
+			 */
+			interface VisitItem {
+				/**
+				 * The unique identifier for the item.
+				 */
+				id: string;
+				/**
+				 * The unique identifier for this visit.
+				 */
+				visitId: string;
+				/**
+				 * When this visit occurred, represented in milliseconds since the epoch.
+				 * Optional.
+				 */
+				visitTime?: number;
+				/**
+				 * The visit ID of the referrer.
+				 */
+				referringVisitId: string;
+				/**
+				 * The $(topic:transition-types)[transition type] for this visit from its referrer.
+				 */
+				transition: TransitionType;
+			}
+			interface SearchQueryType {
+				/**
+				 * A free-text query to the history service.  Leave empty to retrieve all pages.
+				 */
+				text: string;
+				/**
+				 * Limit results to those visited after this date. If not specified, this defaults to 24 hours in the past.
+				 * Optional.
+				 */
+				startTime?: ExtensionTypes.DateType;
+				/**
+				 * Limit results to those visited before this date.
+				 * Optional.
+				 */
+				endTime?: ExtensionTypes.DateType;
+				/**
+				 * The maximum number of results to retrieve.  Defaults to 100.
+				 * Optional.
+				 */
+				maxResults?: number;
+			}
+			interface GetVisitsDetailsType {
+				/**
+				 * The URL for which to retrieve visit information.  It must be in the format as returned from a call to history.search.
+				 */
+				url: string;
+			}
+			interface AddUrlDetailsType {
+				/**
+				 * The URL to add. Must be a valid URL that can be added to history.
+				 */
+				url: string;
+				/**
+				 * The title of the page.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * The $(topic:transition-types)[transition type] for this visit from its referrer.
+				 * Optional.
+				 */
+				transition?: TransitionType;
+				/**
+				 * The date when this visit occurred.
+				 * Optional.
+				 */
+				visitTime?: ExtensionTypes.DateType;
+			}
+			interface DeleteUrlDetailsType {
+				/**
+				 * The URL to remove.
+				 */
+				url: string;
+			}
+			interface DeleteRangeRangeType {
+				/**
+				 * Items added to history after this date.
+				 */
+				startTime: ExtensionTypes.DateType;
+				/**
+				 * Items added to history before this date.
+				 */
+				endTime: ExtensionTypes.DateType;
+			}
+			interface OnVisitRemovedRemovedType {
+				/**
+				 * True if all history was removed.  If true, then urls will be empty.
+				 */
+				allHistory: boolean;
+				urls: string[];
+			}
+			interface OnTitleChangedChangedType {
+				/**
+				 * The URL for which the title has changed
+				 */
+				url: string;
+				/**
+				 * The new title for the URL.
+				 */
+				title: string;
+			}
+			interface Static {
+				/**
+				 * Searches the history for the last visit time of each page matching the query.
+				 */
+				search(query: SearchQueryType): Promise<HistoryItem[]>;
+				/**
+				 * Retrieves information about visits to a URL.
+				 */
+				getVisits(details: GetVisitsDetailsType): Promise<VisitItem[]>;
+				/**
+				 * Adds a URL to the history with a default visitTime of the current time and a default $(topic:transition-types)
+				 * [transition type] of "link".
+				 */
+				addUrl(details: AddUrlDetailsType): Promise<void>;
+				/**
+				 * Removes all occurrences of the given URL from the history.
+				 */
+				deleteUrl(details: DeleteUrlDetailsType): Promise<void>;
+				/**
+				 * 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.
+				 */
+				deleteRange(range: DeleteRangeRangeType): Promise<void>;
+				/**
+				 * Deletes all items from the history.
+				 */
+				deleteAll(): Promise<void>;
+				/**
+				 * Fired when a URL is visited, providing the HistoryItem data for that URL.  This event fires before the page has loaded.
+				 */
+				onVisited: Events.Event<(result: HistoryItem) => void>;
+				/**
+				 * Fired when one or more URLs are removed from the history service.  When all visits have been removed the URL is purged
+				 * from history.
+				 */
+				onVisitRemoved: Events.Event<(removed: OnVisitRemovedRemovedType) => void>;
+				/**
+				 * Fired when the title of a URL is changed in the browser history.
+				 */
+				onTitleChanged: Events.Event<(changed: OnTitleChangedChangedType) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.i18n
+		 */
+		namespace I18n {
+			/**
+			 * An ISO language code such as <code>en</code> or <code>fr</code>. For a complete list of languages supported by this
+			 * method, see <a href='http://src.chromium.org/viewvc/chrome/trunk/src/third_party/cld/languages/internal/languages.cc'>
+			 * kLanguageInfoTable</a>. For an unknown language, <code>und</code> will be returned, which means that [percentage]
+			 * of the text is unknown to CLD
+			 */
+			type LanguageCode = string;
+			/**
+			 * LanguageDetectionResult object that holds detected langugae reliability and array of DetectedLanguage
+			 */
+			interface DetectLanguageCallbackResultType {
+				/**
+				 * CLD detected language reliability
+				 */
+				isReliable: boolean;
+				/**
+				 * array of detectedLanguage
+				 */
+				languages: DetectLanguageCallbackResultTypeLanguagesItemType[];
+			}
+			/**
+			 * DetectedLanguage object that holds detected ISO language code and its percentage in the input string
+			 */
+			interface DetectLanguageCallbackResultTypeLanguagesItemType {
+				language: LanguageCode;
+				/**
+				 * The percentage of the detected language
+				 */
+				percentage: number;
+			}
+			interface Static {
+				/**
+				 * 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).
+				 */
+				getAcceptLanguages(): Promise<LanguageCode[]>;
+				/**
+				 * Gets the localized string for the specified message. If the message is missing, this method returns an empty string ('').
+				 * If the format of the <code>getMessage()</code> call is wrong &mdash; for example, <em>messageName</em>
+				 * is not a string or the <em>substitutions</em> array has more than 9 elements &mdash; this method returns <code>
+				 * undefined</code>.
+				 *
+				 * @param messageName The name of the message, as specified in the <code>$(topic:i18n-messages)[messages.json]</code> file.
+				 * @param substitutions Optional. Substitution strings, if the message requires any.
+				 * @returns Message localized for current locale.
+				 */
+				getMessage(messageName: string, substitutions?: string[] | string): Promise<string>;
+				/**
+				 * Gets the browser UI language of the browser. This is different from $(ref:i18n.getAcceptLanguages)
+				 * which returns the preferred user languages.
+				 *
+				 * @returns The browser UI language code such as en-US or fr-FR.
+				 */
+				getUILanguage(): string;
+				/**
+				 * Detects the language of the provided text using CLD.
+				 *
+				 * @param text User input string to be translated.
+				 */
+				detectLanguage(text: string): Promise<DetectLanguageCallbackResultType>;
+			}
+		}
+		/**
+		 * Namespace: browser.identity
+		 */
+		namespace Identity {
+			/**
+			 * An object encapsulating an OAuth account id.
+			 */
+			interface AccountInfo {
+				/**
+				 * A unique identifier for the account. This ID will not change for the lifetime of the account.
+				 */
+				id: string;
+			}
+			interface LaunchWebAuthFlowDetailsType {
+				url: Browser.Manifest.HttpURL;
+				/**
+				 * Optional.
+				 */
+				interactive?: boolean;
+			}
+			interface Static {
+				/**
+				 * Starts an auth flow at the specified URL.
+				 */
+				launchWebAuthFlow(details: LaunchWebAuthFlowDetailsType): Promise<string>;
+				/**
+				 * Generates a redirect URL to be used in |launchWebAuthFlow|.
+				 *
+				 * @param path Optional. The path appended to the end of the generated URL.
+				 */
+				getRedirectURL(path?: string): Promise<string>;
+			}
+		}
+		/**
+		 * Namespace: browser.idle
+		 */
+		namespace Idle {
+			type IdleState = "active" | "idle" | "locked";
+			interface Static {
+				/**
+				 * Returns "idle" if the user has not generated any input for a specified number of seconds, or "active" otherwise.
+				 *
+				 * @param detectionIntervalInSeconds The system is considered idle if detectionIntervalInSeconds seconds have elapsed since
+				 * the last user input detected.
+				 */
+				queryState(detectionIntervalInSeconds: number): Promise<IdleState>;
+				/**
+				 * 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.
+				 *
+				 * @param intervalInSeconds Threshold, in seconds, used to determine when the system is in an idle state.
+				 */
+				setDetectionInterval(intervalInSeconds: number): void;
+				/**
+				 * 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.
+				 */
+				onStateChanged: Events.Event<(newState: IdleState) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.management
+		 */
+		namespace Management {
+			/**
+			 * Information about an icon belonging to an extension.
+			 */
+			interface IconInfo {
+				/**
+				 * A number representing the width and height of the icon. Likely values include (but are not limited to) 128, 48, 24,
+				 * and 16.
+				 */
+				size: number;
+				/**
+				 * The URL for this icon image. To display a grayscale version of the icon (to indicate that an extension is disabled,
+				 * for example), append <code>?grayscale=true</code> to the URL.
+				 */
+				url: string;
+			}
+			/**
+			 * A reason the item is disabled.
+			 */
+			type ExtensionDisabledReason = "unknown" | "permissions_increase";
+			/**
+			 * The type of this extension, 'extension' or 'theme'.
+			 */
+			type ExtensionType = "extension" | "theme";
+			/**
+			 * How the extension was installed. One of<br><var>development</var>: The extension was loaded unpacked in developer mode,
+			 * <br><var>normal</var>: The extension was installed normally via an .xpi file,<br><var>sideload</var>
+			 * : The extension was installed by other software on the machine,<br><var>admin</var>
+			 * : The extension was installed by policy,<br><var>other</var>: The extension was installed by other means.
+			 */
+			type ExtensionInstallType = "development" | "normal" | "sideload" | "admin" | "other";
+			/**
+			 * Information about an installed extension.
+			 */
+			interface ExtensionInfo {
+				/**
+				 * The extension's unique identifier.
+				 */
+				id: string;
+				/**
+				 * The name of this extension.
+				 */
+				name: string;
+				/**
+				 * A short version of the name of this extension.
+				 * Optional.
+				 */
+				shortName?: string;
+				/**
+				 * The description of this extension.
+				 */
+				description: string;
+				/**
+				 * The <a href='manifest/version'>version</a> of this extension.
+				 */
+				version: string;
+				/**
+				 * The <a href='manifest/version#version_name'>version name</a> of this extension if the manifest specified one.
+				 * Optional.
+				 */
+				versionName?: string;
+				/**
+				 * Whether this extension can be disabled or uninstalled by the user.
+				 */
+				mayDisable: boolean;
+				/**
+				 * Whether it is currently enabled or disabled.
+				 */
+				enabled: boolean;
+				/**
+				 * A reason the item is disabled.
+				 * Optional.
+				 */
+				disabledReason?: ExtensionDisabledReason;
+				/**
+				 * The type of this extension, 'extension' or 'theme'.
+				 */
+				type: ExtensionType;
+				/**
+				 * The URL of the homepage of this extension.
+				 * Optional.
+				 */
+				homepageUrl?: string;
+				/**
+				 * The update URL of this extension.
+				 * Optional.
+				 */
+				updateUrl?: string;
+				/**
+				 * The url for the item's options page, if it has one.
+				 */
+				optionsUrl: string;
+				/**
+				 * 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 <a href='manifest/icons'>manifest documentation on icons</a> for more details.
+				 * Optional.
+				 */
+				icons?: IconInfo[];
+				/**
+				 * Returns a list of API based permissions.
+				 * Optional.
+				 */
+				permissions?: string[];
+				/**
+				 * Returns a list of host based permissions.
+				 * Optional.
+				 */
+				hostPermissions?: string[];
+				/**
+				 * How the extension was installed.
+				 */
+				installType: ExtensionInstallType;
+			}
+			interface InstallOptionsType {
+				/**
+				 * URL pointing to the XPI file on addons.mozilla.org or similar.
+				 */
+				url: Browser.Manifest.HttpURL;
+				/**
+				 * A hash of the XPI file, using sha256 or stronger.
+				 * Optional.
+				 */
+				hash?: string;
+			}
+			interface InstallCallbackResultType {
+				id: Browser.Manifest.ExtensionID;
+			}
+			interface UninstallSelfOptionsType {
+				/**
+				 * Whether or not a confirm-uninstall dialog should prompt the user. Defaults to false.
+				 * Optional.
+				 */
+				showConfirmDialog?: boolean;
+				/**
+				 * The message to display to a user when being asked to confirm removal of the extension.
+				 * Optional.
+				 */
+				dialogMessage?: string;
+			}
+			interface Static {
+				/**
+				 * Returns a list of information about installed extensions.
+				 */
+				getAll(): Promise<ExtensionInfo[]>;
+				/**
+				 * Returns information about the installed extension that has the given ID.
+				 *
+				 * @param id The ID from an item of $(ref:management.ExtensionInfo).
+				 */
+				get(id: Browser.Manifest.ExtensionID): Promise<ExtensionInfo>;
+				/**
+				 * Installs and enables a theme extension from the given url.
+				 */
+				install(options: InstallOptionsType): Promise<InstallCallbackResultType>;
+				/**
+				 * Returns information about the calling extension. Note: This function can be used without requesting the 'management'
+				 * permission in the manifest.
+				 */
+				getSelf(): Promise<ExtensionInfo>;
+				/**
+				 * Uninstalls the calling extension. Note: This function can be used without requesting the 'management' permission in the
+				 * manifest.
+				 *
+				 * @param options Optional.
+				 */
+				uninstallSelf(options?: UninstallSelfOptionsType): Promise<void>;
+				/**
+				 * Enables or disables the given add-on.
+				 *
+				 * @param id ID of the add-on to enable/disable.
+				 * @param enabled Whether to enable or disable the add-on.
+				 */
+				setEnabled(id: string, enabled: boolean): Promise<void>;
+				/**
+				 * Fired when an addon has been disabled.
+				 */
+				onDisabled: Events.Event<(info: ExtensionInfo) => void>;
+				/**
+				 * Fired when an addon has been enabled.
+				 */
+				onEnabled: Events.Event<(info: ExtensionInfo) => void>;
+				/**
+				 * Fired when an addon has been installed.
+				 */
+				onInstalled: Events.Event<(info: ExtensionInfo) => void>;
+				/**
+				 * Fired when an addon has been uninstalled.
+				 */
+				onUninstalled: Events.Event<(info: ExtensionInfo) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.manifest
+		 */
+		namespace Manifest {
+			/**
+			 * Common properties for all manifest.json files
+			 */
+			interface ManifestBase {
+				manifest_version: number;
+				/**
+				 * The applications property is deprecated, please use 'browser_specific_settings'
+				 * Optional.
+				 */
+				applications?: DeprecatedApplications;
+				/**
+				 * Optional.
+				 */
+				browser_specific_settings?: BrowserSpecificSettings;
+				/**
+				 * Name must be at least 2, and should be at most 75 characters
+				 */
+				name: string;
+				/**
+				 * Optional.
+				 */
+				short_name?: string;
+				/**
+				 * Optional.
+				 */
+				description?: string;
+				/**
+				 * Optional.
+				 */
+				author?: string;
+				version: string;
+				/**
+				 * Optional.
+				 */
+				homepage_url?: string;
+				/**
+				 * Optional.
+				 */
+				install_origins?: string[];
+				/**
+				 * Optional.
+				 */
+				developer?: ManifestBaseDeveloperType;
+				/**
+				 * In addition to the version field, which is used for update purposes, version_name can be set to a descriptive version
+				 * string and will be used for display purposes if present. If no version_name is present,
+				 * the version field will be used for display purposes as well.
+				 * Optional.
+				 */
+				version_name?: string;
+			}
+			/**
+			 * Represents a WebExtension manifest.json file
+			 */
+			interface WebExtensionManifest extends ManifestBase {
+				/**
+				 * Optional.
+				 */
+				minimum_chrome_version?: string;
+				/**
+				 * Optional.
+				 */
+				minimum_opera_version?: string;
+				/**
+				 * Optional.
+				 */
+				icons?: Record<string, ExtensionFileUrl>;
+				/**
+				 * The 'split' value is not supported.
+				 * Optional.
+				 */
+				incognito?: WebExtensionManifestIncognitoEnum;
+				/**
+				 * Optional.
+				 */
+				background?: WebExtensionManifestBackgroundType;
+				/**
+				 * Alias property for options_ui.page, ignored when options_ui.page is set. When using this property the options page is
+				 * always opened in a new tab.
+				 * Optional.
+				 */
+				options_page?: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				options_ui?: WebExtensionManifestOptionsUiType;
+				/**
+				 * Optional.
+				 */
+				content_scripts?: ContentScript[];
+				/**
+				 * Optional.
+				 */
+				content_security_policy?: string | WebExtensionManifestContentSecurityPolicyC2Type;
+				/**
+				 * Optional.
+				 */
+				permissions?: PermissionOrOrigin[] | Permission[];
+				/**
+				 * Optional.
+				 */
+				granted_host_permissions?: boolean;
+				/**
+				 * Optional.
+				 */
+				host_permissions?: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				optional_host_permissions?: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				optional_permissions?: OptionalPermissionOrOrigin[];
+				/**
+				 * Optional.
+				 */
+				web_accessible_resources?: string[] | WebExtensionManifestWebAccessibleResourcesC2ItemType[];
+				/**
+				 * Optional.
+				 */
+				hidden?: boolean;
+				/**
+				 * Optional.
+				 */
+				action?: ActionManifest;
+				/**
+				 * Optional.
+				 */
+				browser_action?: ActionManifest;
+				/**
+				 * Optional.
+				 */
+				chrome_settings_overrides?: WebExtensionManifestChromeSettingsOverridesType;
+				/**
+				 * Optional.
+				 */
+				commands?: Record<string, WebExtensionManifestCommandsType>;
+				/**
+				 * Optional.
+				 */
+				declarative_net_request?: WebExtensionManifestDeclarativeNetRequestType;
+				/**
+				 * Optional.
+				 */
+				devtools_page?: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				experiment_apis?: WebExtensionManifestExperimentApisType;
+				/**
+				 * A list of protocol handler definitions.
+				 * Optional.
+				 */
+				protocol_handlers?: ProtocolHandler[];
+				/**
+				 * Optional.
+				 */
+				default_locale?: string;
+				/**
+				 * Optional.
+				 */
+				l10n_resources?: string[];
+				/**
+				 * Optional.
+				 */
+				omnibox?: WebExtensionManifestOmniboxType;
+				/**
+				 * Optional.
+				 */
+				page_action?: WebExtensionManifestPageActionType;
+				/**
+				 * Optional.
+				 */
+				sidebar_action?: WebExtensionManifestSidebarActionType;
+				/**
+				 * Optional.
+				 */
+				theme_experiment?: ThemeExperiment;
+				/**
+				 * Optional.
+				 */
+				chrome_url_overrides?: WebExtensionManifestChromeUrlOverridesType;
+				/**
+				 * Optional.
+				 */
+				user_scripts?: WebExtensionManifestUserScriptsType;
+			}
+			/**
+			 * Represents a WebExtension language pack manifest.json file
+			 */
+			interface WebExtensionLangpackManifest extends ManifestBase {
+				langpack_id: string;
+				languages: Record<string, WebExtensionLangpackManifestLanguagesPatternType>;
+				/**
+				 * Optional.
+				 */
+				sources?: Record<string, WebExtensionLangpackManifestSourcesPatternType>;
+			}
+			/**
+			 * Represents a WebExtension dictionary manifest.json file
+			 */
+			interface WebExtensionDictionaryManifest extends ManifestBase {
+				dictionaries: Record<string, string>;
+			}
+			interface ThemeIcons {
+				/**
+				 * A light icon to use for dark themes
+				 */
+				light: ExtensionURL;
+				/**
+				 * The dark icon to use for light themes
+				 */
+				dark: ExtensionURL;
+				/**
+				 * The size of the icons
+				 */
+				size: number;
+			}
+			type OptionalOnlyPermission = "trialML" | "userScripts";
+			type OptionalPermissionNoPrompt = "idle" | "cookies" | "menus.overrideContext" | "scripting" | "search" | "tabGroups" | "activeTab" | "webRequest" | "webRequestAuthProvider" | "webRequestBlocking" | "webRequestFilterResponse" | "webRequestFilterResponse.serviceWorkerScript";
+			type OptionalPermission = OptionalPermissionNoPrompt | "clipboardRead" | "clipboardWrite" | "geolocation" | "notifications" | "bookmarks" | "browserSettings" | "browsingData" | "declarativeNetRequestFeedback" | "devtools" | "downloads" | "downloads.open" | "find" | "history" | "management" | "pkcs11" | "privacy" | "proxy" | "nativeMessaging" | "sessions" | "tabs" | "tabHide" | "topSites" | "webNavigation" | "identity.email";
+			type OptionalPermissionOrOrigin = OptionalPermission | OptionalOnlyPermission | MatchPattern;
+			type PermissionPrivileged = "mozillaAddons" | "activityLog" | "networkStatus" | "normandyAddonStudy";
+			type CommonDataCollectionPermission = "authenticationInfo" | "bookmarksInfo" | "browsingActivity" | "financialAndPaymentInfo" | "healthInfo" | "locationInfo" | "personalCommunications" | "personallyIdentifyingInfo" | "searchTerms" | "websiteActivity" | "websiteContent";
+			type DataCollectionPermission = CommonDataCollectionPermission | "none";
+			type OptionalDataCollectionPermission = CommonDataCollectionPermission | "technicalAndInteraction";
+			type PermissionNoPrompt = OptionalPermissionNoPrompt | PermissionPrivileged | "alarms" | "storage" | "unlimitedStorage" | "captivePortal" | "contextualIdentities" | "declarativeNetRequestWithHostAccess" | "dns" | "geckoProfiler" | "identity" | "menus" | "contextMenus" | "theme";
+			type Permission = PermissionNoPrompt | OptionalPermission | "declarativeNetRequest" | string;
+			type PermissionOrOrigin = Permission | MatchPattern;
+			type HttpURL = string;
+			type ExtensionURL = string;
+			type ExtensionFileUrl = string;
+			type ImageDataOrExtensionURL = string;
+			type ExtensionID = string;
+			interface FirefoxSpecificProperties {
+				/**
+				 * Optional.
+				 */
+				id?: ExtensionID;
+				/**
+				 * Optional.
+				 */
+				update_url?: string;
+				/**
+				 * Optional.
+				 */
+				strict_min_version?: string;
+				/**
+				 * Optional.
+				 */
+				strict_max_version?: string;
+				/**
+				 * Optional.
+				 */
+				admin_install_only?: boolean;
+				/**
+				 * Optional.
+				 */
+				data_collection_permissions?: FirefoxSpecificPropertiesDataCollectionPermissionsType;
+			}
+			interface GeckoAndroidSpecificProperties {
+				/**
+				 * Optional.
+				 */
+				strict_min_version?: string;
+				/**
+				 * Optional.
+				 */
+				strict_max_version?: string;
+			}
+			interface DeprecatedApplications {
+				/**
+				 * Optional.
+				 */
+				gecko?: FirefoxSpecificProperties;
+			}
+			interface BrowserSpecificSettings {
+				/**
+				 * Optional.
+				 */
+				gecko?: FirefoxSpecificProperties;
+				/**
+				 * Optional.
+				 */
+				gecko_android?: GeckoAndroidSpecificProperties;
+			}
+			type MatchPattern = "<all_urls>" | MatchPatternRestricted | MatchPatternUnestricted;
+			/**
+			 * Same as MatchPattern above, but excludes <all_urls>
+			 */
+			type MatchPatternRestricted = string;
+			/**
+			 * Mostly unrestricted match patterns for privileged add-ons. This should technically be rejected for unprivileged add-ons,
+			 * but, reasons. The MatchPattern class will still refuse privileged schemes for those extensions.
+			 */
+			type MatchPatternUnestricted = string;
+			/**
+			 * Details of the script or CSS to inject. Either the code or the file property must be set,
+			 * but both may not be set at the same time. Based on InjectDetails, but using underscore rather than camel case naming
+			 * conventions.
+			 */
+			interface ContentScript {
+				matches: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				exclude_matches?: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				include_globs?: string[];
+				/**
+				 * Optional.
+				 */
+				exclude_globs?: string[];
+				/**
+				 * The list of CSS files to inject
+				 * Optional.
+				 */
+				css?: ExtensionURL[];
+				/**
+				 * The list of JS files to inject
+				 * Optional.
+				 */
+				js?: ExtensionURL[];
+				/**
+				 * If allFrames is <code>true</code>, implies that the JavaScript or CSS should be injected into all frames of current page.
+				 * By default, it's <code>false</code> and is only injected into the top frame.
+				 * Optional.
+				 */
+				all_frames?: boolean;
+				/**
+				 * If match_about_blank is true, then the code is also injected in about:blank and about:srcdoc frames if your extension
+				 * has access to its parent document. Ignored if match_origin_as_fallback is specified. By default it is <code>false</code>.
+				 * Optional.
+				 */
+				match_about_blank?: boolean;
+				/**
+				 * If match_origin_as_fallback is true, then the code is also injected in about:, data:,
+				 * blob: when their origin matches the pattern in 'matches', even if the actual document origin is opaque (due to the use
+				 * of CSP sandbox or iframe sandbox). Match patterns in 'matches' must specify a wildcard path glob. By default it is <code>
+				 * false</code>.
+				 * Optional.
+				 */
+				match_origin_as_fallback?: boolean;
+				/**
+				 * The soonest that the JavaScript or CSS will be injected into the tab. Defaults to "document_idle".
+				 * Optional.
+				 */
+				run_at?: Browser.ExtensionTypes.RunAt;
+				/**
+				 * The JavaScript world for a script to execute within. Defaults to "ISOLATED".
+				 * Optional.
+				 */
+				world?: Browser.ExtensionTypes.ExecutionWorld;
+			}
+			type IconPath = Record<string, ExtensionFileUrl> | ExtensionFileUrl;
+			type IconImageData = Record<string, ImageData> | ImageData;
+			interface ActionManifest {
+				/**
+				 * Optional.
+				 */
+				default_title?: string;
+				/**
+				 * Optional.
+				 */
+				default_icon?: IconPath;
+				/**
+				 * Specifies icons to use for dark and light themes
+				 * Optional.
+				 */
+				theme_icons?: ThemeIcons[];
+				/**
+				 * Optional.
+				 */
+				default_popup?: string;
+				/**
+				 * Deprecated in Manifest V3.
+				 * Optional.
+				 */
+				browser_style?: boolean;
+				/**
+				 * Defines the location the browserAction will appear by default.  The default location is navbar.
+				 * Optional.
+				 */
+				default_area?: ActionManifestDefaultAreaEnum;
+			}
+			type KeyName = string;
+			/**
+			 * Represents a protocol handler definition.
+			 */
+			interface ProtocolHandler {
+				/**
+				 * A user-readable title string for the protocol handler. This will be displayed to the user in interface objects as needed.
+				 */
+				name: string;
+				/**
+				 * The protocol the site wishes to handle, specified as a string. For example, you can register to handle SMS text message
+				 * links by registering to handle the "sms" scheme.
+				 */
+				protocol: "bitcoin" | "dat" | "dweb" | "ftp" | "geo" | "gopher" | "im" | "ipfs" | "ipns" | "irc" | "ircs" | "magnet" | "mailto" | "matrix" | "mms" | "news" | "nntp" | "sip" | "sms" | "smsto" | "ssb" | "ssh" | "tel" | "urn" | "webcal" | "wtai" | "xmpp" | string;
+				/**
+				 * The URL of the handler, as a string. This string should include "%s" as a placeholder which will be replaced with the
+				 * escaped URL of the document to be handled. This URL might be a true URL, or it could be a phone number, email address,
+				 * or so forth.
+				 */
+				uriTemplate: ExtensionURL | HttpURL;
+			}
+			type ThemeColor = string | [
+				number,
+				number,
+				number
+			] | [
+				number,
+				number,
+				number,
+				number
+			];
+			interface ThemeExperiment {
+				/**
+				 * Optional.
+				 */
+				stylesheet?: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				images?: ThemeExperimentImagesType;
+				/**
+				 * Optional.
+				 */
+				colors?: ThemeExperimentColorsType;
+				/**
+				 * Optional.
+				 */
+				properties?: ThemeExperimentPropertiesType;
+			}
+			interface ThemeType {
+				/**
+				 * Optional.
+				 */
+				images?: ThemeTypeImagesType;
+				/**
+				 * Optional.
+				 */
+				colors?: ThemeTypeColorsType;
+				/**
+				 * Optional.
+				 */
+				properties?: ThemeTypePropertiesType;
+			}
+			/**
+			 * Contents of manifest.json for a static theme
+			 */
+			interface ThemeManifest extends Browser.Manifest.ManifestBase {
+				theme: ThemeType;
+				/**
+				 * Optional.
+				 */
+				dark_theme?: ThemeType;
+				/**
+				 * Optional.
+				 */
+				default_locale?: string;
+				/**
+				 * Optional.
+				 */
+				theme_experiment?: ThemeExperiment;
+				/**
+				 * Optional.
+				 */
+				icons?: Record<string, string>;
+			}
+			interface ManifestBaseDeveloperType {
+				/**
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * Optional.
+				 */
+				url?: string;
+			}
+			/**
+			 * The 'split' value is not supported.
+			 */
+			type WebExtensionManifestIncognitoEnum = "not_allowed" | "spanning" | "split";
+			/**
+			 * Only supported for page/scripts; not for service_worker yet, see bug 1775574
+			 */
+			type WebExtensionManifestBackgroundTypeEnum = "module" | "classic";
+			type WebExtensionManifestBackgroundPreferredEnvironmentItemEnum = "service_worker" | "document";
+			interface WebExtensionManifestBackgroundType {
+				/**
+				 * Optional.
+				 */
+				service_worker?: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				page?: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				scripts?: ExtensionURL[];
+				/**
+				 * Only supported for page/scripts; not for service_worker yet, see bug 1775574
+				 * Optional.
+				 */
+				type?: WebExtensionManifestBackgroundTypeEnum;
+				/**
+				 * Optional.
+				 */
+				persistent?: boolean;
+				/**
+				 * Optional.
+				 */
+				preferred_environment?: WebExtensionManifestBackgroundPreferredEnvironmentItemEnum[];
+			}
+			interface WebExtensionManifestOptionsUiType {
+				page: ExtensionURL;
+				/**
+				 * Defaults to true in Manifest V2; Deprecated in Manifest V3.
+				 * Optional.
+				 */
+				browser_style?: boolean;
+				/**
+				 * chrome_style is ignored in Firefox. Its replacement (browser_style) has been deprecated.
+				 * Optional.
+				 */
+				chrome_style?: boolean;
+				/**
+				 * Optional.
+				 */
+				open_in_tab?: boolean;
+			}
+			interface WebExtensionManifestContentSecurityPolicyC2Type {
+				/**
+				 * The Content Security Policy used for extension pages.
+				 * Optional.
+				 */
+				extension_pages?: string;
+				/**
+				 * In addition, Manifest V3 disallows certain CSP modifications for `extension_pages` that were permitted in Manifest V2.
+				 * The `script-src`, `object-src`, and `worker-src` directives may only have the following values:
+				 * - `self`
+				 * - `none` - Any localhost source, (`http://localhost`, `http://127.0.0.1`, or any port on those domains)
+				 * Optional.
+				 */
+				sandbox?: string;
+			}
+			interface WebExtensionManifestWebAccessibleResourcesC2ItemType {
+				resources: string[];
+				/**
+				 * Optional.
+				 */
+				matches?: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				extension_ids?: Array<ExtensionID | "*">;
+			}
+			interface WebExtensionManifestChromeSettingsOverridesSearchProviderType {
+				name: string;
+				/**
+				 * Optional.
+				 */
+				keyword?: string | string[];
+				search_url: string;
+				/**
+				 * Optional.
+				 */
+				favicon_url?: string;
+				/**
+				 * Optional.
+				 */
+				suggest_url?: string;
+				/**
+				 * GET parameters to the search_url as a query string.
+				 * Optional.
+				 */
+				search_url_get_params?: string;
+				/**
+				 * POST parameters to the search_url as a query string.
+				 * Optional.
+				 */
+				search_url_post_params?: string;
+				/**
+				 * GET parameters to the suggest_url as a query string.
+				 * Optional.
+				 */
+				suggest_url_get_params?: string;
+				/**
+				 * POST parameters to the suggest_url as a query string.
+				 * Optional.
+				 */
+				suggest_url_post_params?: string;
+				/**
+				 * Encoding of the search term.
+				 * Optional.
+				 */
+				encoding?: string;
+				/**
+				 * Sets the default engine to a built-in engine only.
+				 * Optional.
+				 */
+				is_default?: boolean;
+			}
+			interface WebExtensionManifestChromeSettingsOverridesType {
+				/**
+				 * Optional.
+				 */
+				homepage?: string;
+				/**
+				 * Optional.
+				 */
+				search_provider?: WebExtensionManifestChromeSettingsOverridesSearchProviderType;
+			}
+			interface WebExtensionManifestCommandsSuggestedKeyType {
+				/**
+				 * Optional.
+				 */
+				default?: KeyName;
+				/**
+				 * Optional.
+				 */
+				mac?: KeyName;
+				/**
+				 * Optional.
+				 */
+				linux?: KeyName;
+				/**
+				 * Optional.
+				 */
+				windows?: KeyName;
+				/**
+				 * Optional.
+				 */
+				chromeos?: string;
+				/**
+				 * Optional.
+				 */
+				android?: string;
+				/**
+				 * Optional.
+				 */
+				ios?: string;
+			}
+			interface WebExtensionManifestCommandsType {
+				/**
+				 * Optional.
+				 */
+				suggested_key?: WebExtensionManifestCommandsSuggestedKeyType;
+				/**
+				 * Optional.
+				 */
+				description?: string;
+			}
+			interface WebExtensionManifestDeclarativeNetRequestRuleResourcesItemType {
+				/**
+				 * A non-empty string uniquely identifying the ruleset. IDs beginning with '_' are reserved for internal use.
+				 */
+				id: string;
+				/**
+				 * Whether the ruleset is enabled by default.
+				 */
+				enabled: boolean;
+				/**
+				 * The path of the JSON ruleset relative to the extension directory.
+				 */
+				path: Browser.Manifest.ExtensionURL;
+			}
+			interface WebExtensionManifestDeclarativeNetRequestType {
+				rule_resources: WebExtensionManifestDeclarativeNetRequestRuleResourcesItemType[];
+			}
+			interface WebExtensionManifestExperimentApisType {
+				[s: string]: Browser.Experiments.ExperimentAPI;
+			}
+			interface WebExtensionManifestOmniboxType {
+				keyword: string;
+			}
+			interface WebExtensionManifestPageActionType {
+				/**
+				 * Optional.
+				 */
+				default_title?: string;
+				/**
+				 * Optional.
+				 */
+				default_icon?: IconPath;
+				/**
+				 * Optional.
+				 */
+				default_popup?: string;
+				/**
+				 * Deprecated in Manifest V3.
+				 * Optional.
+				 */
+				browser_style?: boolean;
+				/**
+				 * Optional.
+				 */
+				show_matches?: MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				hide_matches?: MatchPatternRestricted[];
+				/**
+				 * Optional.
+				 */
+				pinned?: boolean;
+			}
+			interface WebExtensionManifestSidebarActionType {
+				/**
+				 * Optional.
+				 */
+				default_title?: string;
+				/**
+				 * Optional.
+				 */
+				default_icon?: IconPath;
+				/**
+				 * Defaults to true in Manifest V2; Deprecated in Manifest V3.
+				 * Optional.
+				 */
+				browser_style?: boolean;
+				default_panel: string;
+				/**
+				 * Whether or not the sidebar is opened at install. Default is <code>true</code>.
+				 * Optional.
+				 */
+				open_at_install?: boolean;
+			}
+			interface WebExtensionManifestChromeUrlOverridesType {
+				/**
+				 * Optional.
+				 */
+				newtab?: ExtensionURL;
+			}
+			interface WebExtensionManifestUserScriptsType {
+				/**
+				 * Optional.
+				 */
+				api_script?: Browser.Manifest.ExtensionURL;
+			}
+			interface WebExtensionLangpackManifestLanguagesPatternType {
+				chrome_resources: Record<string, ExtensionURL | Record<string, ExtensionURL>>;
+				version: string;
+			}
+			interface WebExtensionLangpackManifestSourcesPatternType {
+				base_path: ExtensionURL;
+				/**
+				 * Optional.
+				 */
+				paths?: string[];
+			}
+			interface FirefoxSpecificPropertiesDataCollectionPermissionsType {
+				/**
+				 * Optional.
+				 */
+				required?: DataCollectionPermission[];
+				/**
+				 * Optional.
+				 */
+				optional?: OptionalDataCollectionPermission[];
+			}
+			/**
+			 * Defines the location the browserAction will appear by default.  The default location is navbar.
+			 */
+			type ActionManifestDefaultAreaEnum = "navbar" | "menupanel" | "tabstrip" | "personaltoolbar";
+			interface ThemeExperimentImagesType {
+				[s: string]: unknown;
+			}
+			interface ThemeExperimentColorsType {
+				[s: string]: unknown;
+			}
+			interface ThemeExperimentPropertiesType {
+				[s: string]: unknown;
+			}
+			interface ThemeTypeImagesType {
+				/**
+				 * Optional.
+				 */
+				additional_backgrounds?: ImageDataOrExtensionURL[];
+				/**
+				 * Optional.
+				 */
+				theme_frame?: ImageDataOrExtensionURL;
+			}
+			interface ThemeTypeColorsType {
+				/**
+				 * Optional.
+				 */
+				tab_selected?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				frame?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				frame_inactive?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				tab_background_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				tab_background_separator?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				tab_loading?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				tab_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				tab_line?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar?: ThemeColor;
+				/**
+				 * This color property is an alias of 'bookmark_text'.
+				 * Optional.
+				 */
+				toolbar_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				bookmark_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_border?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_top_separator?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_bottom_separator?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_vertical_separator?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				icons?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				icons_attention?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				button_background_hover?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				button_background_active?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				popup?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				popup_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				popup_border?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_focus?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_text_focus?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_border_focus?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				popup_highlight?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				popup_highlight_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				ntp_background?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				ntp_card_background?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				ntp_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				sidebar?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				sidebar_border?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				sidebar_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				sidebar_highlight?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				sidebar_highlight_text?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_highlight?: ThemeColor;
+				/**
+				 * Optional.
+				 */
+				toolbar_field_highlight_text?: ThemeColor;
+			}
+			type ThemeTypePropertiesAdditionalBackgroundsAlignmentItemEnum = "bottom" | "center" | "left" | "right" | "top" | "center bottom" | "center center" | "center top" | "left bottom" | "left center" | "left top" | "right bottom" | "right center" | "right top";
+			type ThemeTypePropertiesAdditionalBackgroundsTilingItemEnum = "no-repeat" | "repeat" | "repeat-x" | "repeat-y";
+			type ThemeTypePropertiesColorSchemeEnum = "auto" | "light" | "dark" | "system";
+			type ThemeTypePropertiesContentColorSchemeEnum = "auto" | "light" | "dark" | "system";
+			interface ThemeTypePropertiesType {
+				/**
+				 * Optional.
+				 */
+				additional_backgrounds_alignment?: ThemeTypePropertiesAdditionalBackgroundsAlignmentItemEnum[];
+				/**
+				 * Optional.
+				 */
+				additional_backgrounds_tiling?: ThemeTypePropertiesAdditionalBackgroundsTilingItemEnum[];
+				/**
+				 * Optional.
+				 */
+				color_scheme?: ThemeTypePropertiesColorSchemeEnum;
+				/**
+				 * Optional.
+				 */
+				content_color_scheme?: ThemeTypePropertiesContentColorSchemeEnum;
+			}
+			interface Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.contextMenus
+		 */
+		namespace ContextMenus {
+			interface Static extends Menus.Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.menus
+		 */
+		namespace Menus {
+			/**
+			 * The different contexts a menu can appear in. Specifying 'all' is equivalent to the combination of all other contexts
+			 * except for 'tab' and 'tools_menu'.
+			 */
+			type ContextType = "all" | "page" | "frame" | "selection" | "link" | "editable" | "password" | "image" | "video" | "audio" | "launcher" | "bookmark" | "page_action" | "tab" | "tools_menu" | "browser_action" | "action";
+			/**
+			 * The type of menu item.
+			 */
+			type ItemType = "normal" | "checkbox" | "radio" | "separator";
+			/**
+			 * Information sent when a context menu item is clicked.
+			 */
+			interface OnClickData {
+				/**
+				 * The ID of the menu item that was clicked.
+				 */
+				menuItemId: number | string;
+				/**
+				 * The parent ID, if any, for the item clicked.
+				 * Optional.
+				 */
+				parentMenuItemId?: number | string;
+				/**
+				 * The type of view where the menu is clicked. May be unset if the menu is not associated with a view.
+				 * Optional.
+				 */
+				viewType?: Browser.Extension.ViewType;
+				/**
+				 * One of 'image', 'video', or 'audio' if the context menu was activated on one of these types of elements.
+				 * Optional.
+				 */
+				mediaType?: string;
+				/**
+				 * If the element is a link, the text of that link.
+				 * Optional.
+				 */
+				linkText?: string;
+				/**
+				 * If the element is a link, the URL it points to.
+				 * Optional.
+				 */
+				linkUrl?: string;
+				/**
+				 * Will be present for elements with a 'src' URL.
+				 * Optional.
+				 */
+				srcUrl?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				pageUrl?: string;
+				/**
+				 * The id of the frame of the element where the context menu was clicked.
+				 * Optional.
+				 */
+				frameId?: number;
+				/**
+				 * The URL of the frame of the element where the context menu was clicked, if it was in a frame.
+				 * Optional.
+				 */
+				frameUrl?: string;
+				/**
+				 * The text for the context selection, if any.
+				 * Optional.
+				 */
+				selectionText?: string;
+				/**
+				 * A flag indicating whether the element is editable (text input, textarea, etc.).
+				 */
+				editable: boolean;
+				/**
+				 * A flag indicating the state of a checkbox or radio item before it was clicked.
+				 * Optional.
+				 */
+				wasChecked?: boolean;
+				/**
+				 * A flag indicating the state of a checkbox or radio item after it is clicked.
+				 * Optional.
+				 */
+				checked?: boolean;
+				/**
+				 * The id of the bookmark where the context menu was clicked, if it was on a bookmark.
+				 * Optional.
+				 */
+				bookmarkId?: string;
+				/**
+				 * An array of keyboard modifiers that were held while the menu item was clicked.
+				 */
+				modifiers: OnClickDataModifiersItemEnum[];
+				/**
+				 * An integer value of button by which menu item was clicked.
+				 * Optional.
+				 */
+				button?: number;
+				/**
+				 * An identifier of the clicked element, if any. Use menus.getTargetElement in the page to find the corresponding element.
+				 * Optional.
+				 */
+				targetElementId?: number;
+			}
+			interface CreateCreatePropertiesType {
+				/**
+				 * The type of menu item. Defaults to 'normal' if not specified.
+				 * Optional.
+				 */
+				type?: ItemType;
+				/**
+				 * The unique ID to assign to this item. Mandatory for event pages. Cannot be the same as another ID for this extension.
+				 * Optional.
+				 */
+				id?: string;
+				/**
+				 * Optional.
+				 */
+				icons?: Record<string, string>;
+				/**
+				 * The text to be displayed in the item; this is <em>required</em> unless <code>type</code> is 'separator'.
+				 * When the context is 'selection', you can use <code>%s</code> 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".
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				checked?: boolean;
+				/**
+				 * List of contexts this menu item will appear in. Defaults to ['page'] if not specified.
+				 * Optional.
+				 */
+				contexts?: ContextType[];
+				/**
+				 * List of view types where the menu item will be shown. Defaults to any view, including those without a viewType.
+				 * Optional.
+				 */
+				viewTypes?: Browser.Extension.ViewType[];
+				/**
+				 * Whether the item is visible in the menu.
+				 * Optional.
+				 */
+				visible?: boolean;
+				/**
+				 * 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).
+				 *
+				 * @param info Information about the item clicked and the context where the click happened.
+				 * @param tab The details of the tab where the click took place. Note: this parameter only present for extensions.
+				 */
+				onclick?(info: OnClickData, tab: Browser.Tabs.Tab): void;
+				/**
+				 * The ID of a parent menu item; this makes the item a child of a previously added item.
+				 * Optional.
+				 */
+				parentId?: number | string;
+				/**
+				 * 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].
+				 * Optional.
+				 */
+				documentUrlPatterns?: string[];
+				/**
+				 * Similar to documentUrlPatterns, but lets you filter based on the src attribute of img/audio/video tags and the href of
+				 * anchor tags.
+				 * Optional.
+				 */
+				targetUrlPatterns?: string[];
+				/**
+				 * Whether this context menu item is enabled or disabled. Defaults to true.
+				 * Optional.
+				 */
+				enabled?: boolean;
+				/**
+				 * Specifies a command to issue for the context click.
+				 * Optional.
+				 */
+				command?: string | "_execute_browser_action" | "_execute_page_action" | "_execute_sidebar_action" | "_execute_action" | "_execute_page_action" | "_execute_sidebar_action";
+			}
+			/**
+			 * The properties to update. Accepts the same values as the create function.
+			 */
+			interface UpdateUpdatePropertiesType {
+				/**
+				 * Optional.
+				 */
+				type?: ItemType;
+				/**
+				 * Optional.
+				 */
+				icons?: Record<string, string>;
+				/**
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Optional.
+				 */
+				checked?: boolean;
+				/**
+				 * Optional.
+				 */
+				contexts?: ContextType[];
+				/**
+				 * Optional.
+				 */
+				viewTypes?: Browser.Extension.ViewType[];
+				/**
+				 * Whether the item is visible in the menu.
+				 * Optional.
+				 */
+				visible?: boolean;
+				/**
+				 * @param tab The details of the tab where the click took place. Note: this parameter only present for extensions.
+				 */
+				onclick?(info: OnClickData, tab: Browser.Tabs.Tab): void;
+				/**
+				 * Note: You cannot change an item to be a child of one of its own descendants.
+				 * Optional.
+				 */
+				parentId?: number | string;
+				/**
+				 * Optional.
+				 */
+				documentUrlPatterns?: string[];
+				/**
+				 * Optional.
+				 */
+				targetUrlPatterns?: string[];
+				/**
+				 * Optional.
+				 */
+				enabled?: boolean;
+			}
+			interface OverrideContextContextOptionsType {
+				/**
+				 * Whether to also include default menu items in the menu.
+				 * Optional.
+				 */
+				showDefaults?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				context?: OverrideContextContextOptionsTypeContextEnum;
+				/**
+				 * Required when context is 'bookmark'. Requires 'bookmark' permission.
+				 * Optional.
+				 */
+				bookmarkId?: string;
+				/**
+				 * Required when context is 'tab'. Requires 'tabs' permission.
+				 * Optional.
+				 */
+				tabId?: number;
+			}
+			/**
+			 * Information about the context of the menu action and the created menu items. For more information about each property,
+			 * see OnClickData. The following properties are only set if the extension has host permissions for the given context:
+			 * linkUrl, linkText, srcUrl, pageUrl, frameUrl, selectionText.
+			 */
+			interface OnShownInfoType {
+				/**
+				 * A list of IDs of the menu items that were shown.
+				 */
+				menuIds: Array<number | string>;
+				/**
+				 * A list of all contexts that apply to the menu.
+				 */
+				contexts: ContextType[];
+				/**
+				 * Optional.
+				 */
+				viewType?: Browser.Extension.ViewType;
+				editable: boolean;
+				/**
+				 * Optional.
+				 */
+				mediaType?: string;
+				/**
+				 * Optional.
+				 */
+				linkUrl?: string;
+				/**
+				 * Optional.
+				 */
+				linkText?: string;
+				/**
+				 * Optional.
+				 */
+				srcUrl?: string;
+				/**
+				 * Optional.
+				 */
+				pageUrl?: string;
+				/**
+				 * Optional.
+				 */
+				frameUrl?: string;
+				/**
+				 * Optional.
+				 */
+				selectionText?: string;
+				/**
+				 * Optional.
+				 */
+				targetElementId?: number;
+			}
+			type OnClickDataModifiersItemEnum = "Shift" | "Alt" | "Command" | "Ctrl" | "MacCtrl";
+			/**
+			 * 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.
+			 */
+			type OverrideContextContextOptionsTypeContextEnum = "bookmark" | "tab";
+			interface Static {
+				/**
+				 * 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)).
+				 *
+				 * @param callback Optional. 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).
+				 * @returns The ID of the newly created item.
+				 */
+				create(createProperties: CreateCreatePropertiesType, callback?: () => void): number | string;
+				/**
+				 * Updates a previously created context menu item.
+				 *
+				 * @param id The ID of the item to update.
+				 * @param updateProperties The properties to update. Accepts the same values as the create function.
+				 * @returns Called when the context menu has been updated.
+				 */
+				update(id: number | string, updateProperties: UpdateUpdatePropertiesType): Promise<void>;
+				/**
+				 * Removes a context menu item.
+				 *
+				 * @param menuItemId The ID of the context menu item to remove.
+				 * @returns Called when the context menu has been removed.
+				 */
+				remove(menuItemId: number | string): Promise<void>;
+				/**
+				 * Removes all context menu items added by this extension.
+				 *
+				 * @returns Called when removal is complete.
+				 */
+				removeAll(): Promise<void>;
+				/**
+				 * 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.
+				 */
+				overrideContext(contextOptions: OverrideContextContextOptionsType): void;
+				/**
+				 * 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.
+				 */
+				refresh(): Promise<void>;
+				/**
+				 * Retrieve the element that was associated with a recent contextmenu event.
+				 *
+				 * @param targetElementId The identifier of the clicked element, available as info.targetElementId in the menus.onShown,
+				 * onClicked or onclick event.
+				 */
+				getTargetElement(targetElementId: number): Element;
+				/**
+				 * Fired when a context menu item is clicked.
+				 *
+				 * @param info Information about the item clicked and the context where the click happened.
+				 * @param tab Optional. The details of the tab where the click took place. If the click did not take place in a tab,
+				 * this parameter will be missing.
+				 */
+				onClicked: Events.Event<(info: OnClickData, tab: Browser.Tabs.Tab | undefined) => void>;
+				/**
+				 * Fired when a menu is shown. The extension can add, modify or remove menu items and call menus.refresh()
+				 * to update the menu.
+				 *
+				 * @param info Information about the context of the menu action and the created menu items.
+				 * For more information about each property, see OnClickData. The following properties are only set if the extension has
+				 * host permissions for the given context: linkUrl, linkText, srcUrl, pageUrl, frameUrl, selectionText.
+				 * @param tab The details of the tab where the menu was opened.
+				 */
+				onShown: Events.Event<(info: OnShownInfoType, tab: Browser.Tabs.Tab) => void>;
+				/**
+				 * Fired when a menu is hidden. This event is only fired if onShown has fired before.
+				 */
+				onHidden: Events.Event<() => void>;
+				/**
+				 * 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.
+				 */
+				ACTION_MENU_TOP_LEVEL_LIMIT: 6;
+			}
+		}
+		/**
+		 * Namespace: browser.networkStatus
+		 */
+		namespace NetworkStatus {
+			interface NetworkLinkInfo {
+				/**
+				 * Status of the network link, if "unknown" then link is usually assumed to be "up"
+				 */
+				status: NetworkLinkInfoStatusEnum;
+				/**
+				 * If known, the type of network connection that is avialable.
+				 */
+				type: NetworkLinkInfoTypeEnum;
+				/**
+				 * If known, the network id or name.
+				 * Optional.
+				 */
+				id?: string;
+			}
+			/**
+			 * Status of the network link, if "unknown" then link is usually assumed to be "up"
+			 */
+			type NetworkLinkInfoStatusEnum = "unknown" | "up" | "down";
+			/**
+			 * If known, the type of network connection that is avialable.
+			 */
+			type NetworkLinkInfoTypeEnum = "unknown" | "ethernet" | "usb" | "wifi" | "wimax" | "mobile";
+			interface Static {
+				/**
+				 * Returns the $(ref:NetworkLinkInfo) of the current network connection.
+				 */
+				getLinkInfo(): void;
+				/**
+				 * Fired when the network connection state changes.
+				 */
+				onConnectionChanged: Events.Event<(details: NetworkLinkInfo) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.normandyAddonStudy
+		 */
+		namespace NormandyAddonStudy {
+			interface Study {
+				/**
+				 * The ID of the recipe for the study.
+				 */
+				recipeId: number;
+				/**
+				 * A slug to identify the study.
+				 */
+				slug: string;
+				/**
+				 * The name presented on about:studies.
+				 */
+				userFacingName: string;
+				/**
+				 * The description presented on about:studies.
+				 */
+				userFacingDescription: string;
+				/**
+				 * The study branch in which the user is enrolled.
+				 */
+				branch: string;
+				/**
+				 * The state of the study.
+				 */
+				active: boolean;
+				/**
+				 * The ID of the extension installed by the study.
+				 */
+				addonId: string;
+				/**
+				 * The URL of the XPI that was downloaded and installed by the study.
+				 */
+				addonUrl: string;
+				/**
+				 * The version of the extension installed by the study.
+				 */
+				addonVersion: string;
+				/**
+				 * The start date for the study.
+				 */
+				studyStartDate: ExtensionTypes.DateType;
+				/**
+				 * The end date for the study.
+				 */
+				studyEndDate: ExtensionTypes.DateType;
+				/**
+				 * The record ID for the extension in Normandy server's database.
+				 */
+				extensionApiId: number;
+				/**
+				 * A hash of the extension XPI file.
+				 */
+				extensionHash: string;
+				/**
+				 * The algorithm used to hash the extension XPI file.
+				 */
+				extensionHashAlgorithm: string;
+			}
+			interface Static {
+				/**
+				 * Returns a study object for the current study.
+				 */
+				getStudy(): void;
+				/**
+				 * Marks the study as ended and then uninstalls the addon.
+				 *
+				 * @param reason The reason why the study is ending.
+				 */
+				endStudy(reason: string): void;
+				/**
+				 * Returns an object with metadata about the client which may be required for constructing survey URLs.
+				 */
+				getClientMetadata(): void;
+				/**
+				 * Fired when a user unenrolls from a study but before the addon is uninstalled.
+				 *
+				 * @param reason The reason why the study is ending.
+				 */
+				onUnenroll: Events.Event<(reason: string) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.notifications
+		 */
+		namespace Notifications {
+			type TemplateType = "basic" | "image" | "list" | "progress";
+			type PermissionLevel = "granted" | "denied";
+			interface NotificationItem {
+				/**
+				 * Title of one item of a list notification.
+				 */
+				title: string;
+				/**
+				 * Additional details about this item.
+				 */
+				message: string;
+			}
+			interface CreateNotificationOptions {
+				/**
+				 * Which type of notification to display.
+				 */
+				type: TemplateType;
+				/**
+				 * A URL to the sender's avatar, app icon, or a thumbnail for image notifications.
+				 * Optional.
+				 */
+				iconUrl?: string;
+				/**
+				 * A URL to the app icon mask.
+				 * Optional.
+				 */
+				appIconMaskUrl?: string;
+				/**
+				 * Title of the notification (e.g. sender name for email).
+				 */
+				title: string;
+				/**
+				 * Main notification content.
+				 */
+				message: string;
+				/**
+				 * Alternate notification content with a lower-weight font.
+				 * Optional.
+				 */
+				contextMessage?: string;
+				/**
+				 * Priority ranges from -2 to 2. -2 is lowest priority. 2 is highest. Zero is default.
+				 * Optional.
+				 */
+				priority?: number;
+				/**
+				 * A timestamp associated with the notification, in milliseconds past the epoch.
+				 * Optional.
+				 */
+				eventTime?: number;
+				/**
+				 * A URL to the image thumbnail for image-type notifications.
+				 * Optional.
+				 */
+				imageUrl?: string;
+				/**
+				 * Items for multi-item notifications.
+				 * Optional.
+				 */
+				items?: NotificationItem[];
+				/**
+				 * Current progress ranges from 0 to 100.
+				 * Optional.
+				 */
+				progress?: number;
+				/**
+				 * Whether to show UI indicating that the app will visibly respond to clicks on the body of a notification.
+				 * Optional.
+				 */
+				isClickable?: boolean;
+			}
+			interface UpdateNotificationOptions {
+				/**
+				 * Which type of notification to display.
+				 * Optional.
+				 */
+				type?: TemplateType;
+				/**
+				 * A URL to the sender's avatar, app icon, or a thumbnail for image notifications.
+				 * Optional.
+				 */
+				iconUrl?: string;
+				/**
+				 * A URL to the app icon mask.
+				 * Optional.
+				 */
+				appIconMaskUrl?: string;
+				/**
+				 * Title of the notification (e.g. sender name for email).
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Main notification content.
+				 * Optional.
+				 */
+				message?: string;
+				/**
+				 * Alternate notification content with a lower-weight font.
+				 * Optional.
+				 */
+				contextMessage?: string;
+				/**
+				 * Priority ranges from -2 to 2. -2 is lowest priority. 2 is highest. Zero is default.
+				 * Optional.
+				 */
+				priority?: number;
+				/**
+				 * A timestamp associated with the notification, in milliseconds past the epoch.
+				 * Optional.
+				 */
+				eventTime?: number;
+				/**
+				 * A URL to the image thumbnail for image-type notifications.
+				 * Optional.
+				 */
+				imageUrl?: string;
+				/**
+				 * Items for multi-item notifications.
+				 * Optional.
+				 */
+				items?: NotificationItem[];
+				/**
+				 * Current progress ranges from 0 to 100.
+				 * Optional.
+				 */
+				progress?: number;
+				/**
+				 * Whether to show UI indicating that the app will visibly respond to clicks on the body of a notification.
+				 * Optional.
+				 */
+				isClickable?: boolean;
+			}
+			interface Static {
+				/**
+				 * Creates and displays a notification.
+				 *
+				 * @param notificationId Optional. 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 options Contents of the notification.
+				 */
+				create(notificationId: string | undefined, options: CreateNotificationOptions): Promise<string>;
+				/**
+				 * Creates and displays a notification.
+				 *
+				 * @param options Contents of the notification.
+				 */
+				create(options: CreateNotificationOptions): Promise<string>;
+				/**
+				 * Clears an existing notification.
+				 *
+				 * @param notificationId The id of the notification to be updated.
+				 */
+				clear(notificationId: string): Promise<boolean>;
+				/**
+				 * Retrieves all the notifications.
+				 */
+				getAll(): Promise<Record<string, CreateNotificationOptions>>;
+				/**
+				 * Fired when the notification closed, either by the system or by user action.
+				 *
+				 * @param notificationId The notificationId of the closed notification.
+				 * @param byUser True if the notification was closed by the user.
+				 */
+				onClosed: Events.Event<(notificationId: string, byUser: boolean) => void>;
+				/**
+				 * Fired when the user clicked in a non-button area of the notification.
+				 *
+				 * @param notificationId The notificationId of the clicked notification.
+				 */
+				onClicked: Events.Event<(notificationId: string) => void>;
+				/**
+				 * Fired when the  user pressed a button in the notification.
+				 *
+				 * @param notificationId The notificationId of the clicked notification.
+				 * @param buttonIndex The index of the button clicked by the user.
+				 */
+				onButtonClicked: Events.Event<(notificationId: string, buttonIndex: number) => void>;
+				/**
+				 * Fired when the notification is shown.
+				 *
+				 * @param notificationId The notificationId of the shown notification.
+				 */
+				onShown: Events.Event<(notificationId: string) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.omnibox
+		 */
+		namespace Omnibox {
+			/**
+			 * The style type.
+			 */
+			type DescriptionStyleType = "url" | "match" | "dim";
+			/**
+			 * The window disposition for the omnibox query. This is the recommended context to display results. For example,
+			 * if the omnibox command is to navigate to a certain URL, a disposition of 'newForegroundTab' means the navigation should
+			 * take place in a new selected tab.
+			 */
+			type OnInputEnteredDisposition = "currentTab" | "newForegroundTab" | "newBackgroundTab";
+			/**
+			 * A suggest result.
+			 */
+			interface SuggestResult {
+				/**
+				 * The text that is put into the URL bar, and that is sent to the extension when the user chooses this entry.
+				 */
+				content: string;
+				/**
+				 * 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
+				 */
+				description: string;
+				/**
+				 * Whether the suggest result can be deleted by the user.
+				 * Optional.
+				 */
+				deletable?: boolean;
+			}
+			/**
+			 * A suggest result.
+			 */
+			interface DefaultSuggestResult {
+				/**
+				 * The text that is displayed in the URL dropdown.
+				 */
+				description: string;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 *
+				 * @param suggestion A partial SuggestResult object, without the 'content' parameter.
+				 */
+				setDefaultSuggestion(suggestion: DefaultSuggestResult): void;
+				/**
+				 * 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.
+				 */
+				onInputStarted: Events.Event<() => void>;
+				/**
+				 * User has changed what is typed into the omnibox.
+				 *
+				 * @param suggest A callback passed to the onInputChanged event used for sending suggestions back to the browser.
+				 */
+				onInputChanged: Events.Event<(text: string, suggest: (suggestResults: SuggestResult[]) => void) => void>;
+				/**
+				 * User has accepted what is typed into the omnibox.
+				 */
+				onInputEntered: Events.Event<(text: string, disposition: OnInputEnteredDisposition) => void>;
+				/**
+				 * User has ended the keyword input session without accepting the input.
+				 */
+				onInputCancelled: Events.Event<() => void>;
+				/**
+				 * User has deleted a suggested result.
+				 */
+				onDeleteSuggestion: Events.Event<(text: string) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.pageAction
+		 */
+		namespace PageAction {
+			/**
+			 * Pixel data for an image. Must be an ImageData object (for example, from a <code>canvas</code> element).
+			 */
+			interface ImageDataType extends ImageData {
+				[s: string]: unknown;
+			}
+			/**
+			 * Information sent when a page action is clicked.
+			 */
+			interface OnClickData {
+				/**
+				 * An array of keyboard modifiers that were held while the menu item was clicked.
+				 */
+				modifiers: OnClickDataModifiersItemEnum[];
+				/**
+				 * An integer value of button by which menu item was clicked.
+				 * Optional.
+				 */
+				button?: number;
+			}
+			interface IsShownDetailsType {
+				/**
+				 * Specify the tab to get the shownness from.
+				 */
+				tabId: number;
+			}
+			interface SetTitleDetailsType {
+				/**
+				 * The id of the tab for which you want to modify the page action.
+				 */
+				tabId: number;
+				/**
+				 * The tooltip string.
+				 */
+				title: string | null;
+			}
+			interface GetTitleDetailsType {
+				/**
+				 * Specify the tab to get the title from.
+				 */
+				tabId: number;
+			}
+			interface SetIconDetailsType {
+				/**
+				 * The id of the tab for which you want to modify the page action.
+				 */
+				tabId: number;
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				imageData?: ImageDataType | Record<string, ImageDataType>;
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				path?: string | Record<string, string>;
+			}
+			interface SetPopupDetailsType {
+				/**
+				 * The id of the tab for which you want to modify the page action.
+				 */
+				tabId: number;
+				/**
+				 * The html file to show in a popup.  If set to the empty string (''), no popup is shown.
+				 */
+				popup: string | null;
+			}
+			interface GetPopupDetailsType {
+				/**
+				 * Specify the tab to get the popup from.
+				 */
+				tabId: number;
+			}
+			type OnClickDataModifiersItemEnum = "Shift" | "Alt" | "Command" | "Ctrl" | "MacCtrl";
+			interface Static {
+				/**
+				 * Shows the page action. The page action is shown whenever the tab is selected.
+				 *
+				 * @param tabId The id of the tab for which you want to modify the page action.
+				 */
+				show(tabId: number): Promise<void>;
+				/**
+				 * Hides the page action.
+				 *
+				 * @param tabId The id of the tab for which you want to modify the page action.
+				 */
+				hide(tabId: number): Promise<void>;
+				/**
+				 * Checks whether the page action is shown.
+				 */
+				isShown(details: IsShownDetailsType): Promise<boolean>;
+				/**
+				 * Sets the title of the page action. This is displayed in a tooltip over the page action.
+				 */
+				setTitle(details: SetTitleDetailsType): void;
+				/**
+				 * Gets the title of the page action.
+				 */
+				getTitle(details: GetTitleDetailsType): Promise<string>;
+				/**
+				 * 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.
+				 */
+				setIcon(details: SetIconDetailsType): Promise<void>;
+				/**
+				 * Sets the html document to be opened as a popup when the user clicks on the page action's icon.
+				 */
+				setPopup(details: SetPopupDetailsType): Promise<void>;
+				/**
+				 * Gets the html document set as the popup for this page action.
+				 */
+				getPopup(details: GetPopupDetailsType): Promise<string>;
+				/**
+				 * Opens the extension page action in the active window.
+				 */
+				openPopup(): Promise<void>;
+				/**
+				 * Fired when a page action icon is clicked.  This event will not fire if the page action has a popup.
+				 *
+				 * @param info Optional.
+				 */
+				onClicked: Events.Event<(tab: Browser.Tabs.Tab, info: OnClickData | undefined) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.permissions
+		 */
+		namespace Permissions {
+			interface Permissions {
+				/**
+				 * Optional.
+				 */
+				permissions?: Array<Browser.Manifest.OptionalPermission | Browser.Manifest.OptionalOnlyPermission>;
+				/**
+				 * Optional.
+				 */
+				origins?: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				data_collection?: Browser.Manifest.OptionalDataCollectionPermission[];
+			}
+			interface AnyPermissions {
+				/**
+				 * Optional.
+				 */
+				permissions?: Array<Browser.Manifest.Permission | Browser.Manifest.OptionalOnlyPermission>;
+				/**
+				 * Optional.
+				 */
+				origins?: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				data_collection?: Browser.Manifest.OptionalDataCollectionPermission[];
+			}
+			interface Static {
+				/**
+				 * Get a list of all the extension's permissions.
+				 */
+				getAll(): Promise<AnyPermissions>;
+				/**
+				 * Check if the extension has the given permissions.
+				 */
+				contains(permissions: AnyPermissions): Promise<boolean>;
+				/**
+				 * Request the given permissions.
+				 */
+				request(permissions: Permissions): Promise<boolean>;
+				/**
+				 * Relinquish the given permissions.
+				 */
+				remove(permissions: Permissions): Promise<boolean>;
+				/**
+				 * Fired when the extension acquires new permissions.
+				 */
+				onAdded: Events.Event<(permissions: Permissions) => void>;
+				/**
+				 * Fired when permissions are removed from the extension.
+				 */
+				onRemoved: Events.Event<(permissions: Permissions) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.pkcs11
+		 */
+		namespace Pkcs11 {
+			interface Token {
+				/**
+				 * Name of the token.
+				 */
+				name: string;
+				/**
+				 * Name of the token's manufacturer.
+				 */
+				manufacturer: string;
+				/**
+				 * Hardware version, as a PKCS #11 version number (two 32-bit integers separated with a dot, like "1.0".
+				 */
+				HWVersion: string;
+				/**
+				 * Firmware version, as a PKCS #11 version number (two 32-bit integers separated with a dot, like "1.0".
+				 */
+				FWVersion: string;
+				/**
+				 * Serial number, whose format is defined by the token specification.
+				 */
+				serial: string;
+				/**
+				 * true if the token is logged on already, false otherwise.
+				 */
+				isLoggedIn: boolean;
+			}
+			interface ModuleSlot {
+				/**
+				 * The name of the slot.
+				 */
+				name: string;
+				/**
+				 * The token of the slot.
+				 */
+				token: Token | null;
+			}
+			interface Static {
+				/**
+				 * checks whether a PKCS#11 module, given by name, is installed
+				 */
+				isModuleInstalled(name: string): Promise<boolean>;
+				/**
+				 * Install a PKCS#11 module with a given name
+				 *
+				 * @param flags Optional.
+				 */
+				installModule(name: string, flags?: number): Promise<void>;
+				/**
+				 * Remove an installed PKCS#11 module from firefox
+				 */
+				uninstallModule(name: string): Promise<void>;
+				/**
+				 * Enumerate a module's slots, each with their name and whether a token is present
+				 */
+				getModuleSlots(name: string): Promise<undefined>;
+			}
+		}
+		/**
+		 * Namespace: browser.privacy
+		 */
+		namespace Privacy {
+			interface Static {
+				network: Network.Static;
+				services: Services.Static;
+				websites: Websites.Static;
+			}
+		}
+		/**
+		 * Namespace: browser.proxy
+		 */
+		namespace Proxy {
+			/**
+			 * An object which describes proxy settings.
+			 */
+			interface ProxyConfig {
+				/**
+				 * The type of proxy to use.
+				 * Optional.
+				 */
+				proxyType?: ProxyConfigProxyTypeEnum;
+				/**
+				 * The address of the http proxy, can include a port.
+				 * Optional.
+				 */
+				http?: string;
+				/**
+				 * Use the http proxy server for all protocols.
+				 * Optional.
+				 */
+				httpProxyAll?: boolean;
+				/**
+				 * The address of the ssl proxy, can include a port.
+				 * Optional.
+				 */
+				ssl?: string;
+				/**
+				 * The address of the socks proxy, can include a port.
+				 * Optional.
+				 */
+				socks?: string;
+				/**
+				 * The version of the socks proxy.
+				 * Optional.
+				 */
+				socksVersion?: number;
+				/**
+				 * A list of hosts which should not be proxied.
+				 * Optional.
+				 */
+				passthrough?: string;
+				/**
+				 * A URL to use to configure the proxy.
+				 * Optional.
+				 */
+				autoConfigUrl?: string;
+				/**
+				 * Do not prompt for authentication if password is saved.
+				 * Optional.
+				 */
+				autoLogin?: boolean;
+				/**
+				 * Proxy DNS when using SOCKS. DNS queries get leaked to the network when set to false. True by default for SOCKS v5.
+				 * False by default for SOCKS v4.
+				 * Optional.
+				 */
+				proxyDNS?: boolean;
+				/**
+				 * If true (the default value), do not use newer TLS protocol features that might have interoperability problems on the
+				 * Internet. This is intended only for use with critical infrastructure like the updates,
+				 * and is only available to privileged addons.
+				 * Optional.
+				 */
+				respectBeConservative?: boolean;
+			}
+			interface OnRequestDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: Browser.WebRequest.ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * Indicates if this response was fetched from disk cache.
+				 */
+				fromCache: boolean;
+				/**
+				 * The HTTP request headers that are going to be sent out with this request.
+				 * Optional.
+				 */
+				requestHeaders?: Browser.WebRequest.HttpHeaders;
+				/**
+				 * Url classification if the request has been classified.
+				 */
+				urlClassification: Browser.WebRequest.UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+			}
+			interface OnErrorErrorType {
+				[s: string]: unknown;
+			}
+			/**
+			 * The type of proxy to use.
+			 */
+			type ProxyConfigProxyTypeEnum = "none" | "autoDetect" | "system" | "manual" | "autoConfig";
+			/**
+			 * Fired when proxy data is needed for a request.
+			 */
+			interface OnRequestEvent extends Events.Event<(details: OnRequestDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnRequestDetailsType) => void, filter: Browser.WebRequest.RequestFilter, extraInfoSpec?: string[]): void;
+			}
+			interface Static {
+				/**
+				 * Fired when proxy data is needed for a request.
+				 */
+				onRequest: OnRequestEvent;
+				/**
+				 * Notifies about errors caused by the invalid use of the proxy API.
+				 */
+				onError: Events.Event<(error: OnErrorErrorType) => void>;
+				/**
+				 * Configures proxy settings. This setting's value is an object of type ProxyConfig.
+				 */
+				settings: Browser.Types.Setting;
+			}
+		}
+		/**
+		 * Namespace: browser.runtime
+		 */
+		namespace Runtime {
+			/**
+			 * A filter to match against existing extension context. Matching contexts must match all specified filters.
+			 */
+			interface ContextFilter {
+				/**
+				 * Optional.
+				 */
+				contextIds?: string[];
+				/**
+				 * Optional.
+				 */
+				contextTypes?: ContextType[];
+				/**
+				 * Optional.
+				 */
+				documentIds?: string[];
+				/**
+				 * Optional.
+				 */
+				documentOrigins?: string[];
+				/**
+				 * Optional.
+				 */
+				documentUrls?: string[];
+				/**
+				 * Optional.
+				 */
+				frameIds?: number[];
+				/**
+				 * Optional.
+				 */
+				tabIds?: number[];
+				/**
+				 * Optional.
+				 */
+				windowIds?: number[];
+				/**
+				 * Optional.
+				 */
+				incognito?: boolean;
+			}
+			/**
+			 * The type of extension view.
+			 */
+			type ContextType = "BACKGROUND" | "POPUP" | "SIDE_PANEL" | "TAB";
+			/**
+			 * A context hosting extension content
+			 */
+			interface ExtensionContext {
+				/**
+				 * An unique identifier associated to this context
+				 */
+				contextId: string;
+				/**
+				 * The type of the context
+				 */
+				contextType: ContextType;
+				/**
+				 * The origin of the document associated with this context, or undefined if it is not hosted in a document
+				 * Optional.
+				 */
+				documentOrigin?: string;
+				/**
+				 * The URL of the document associated with this context, or undefined if it is not hosted in a document
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * Whether the context is associated with an private browsing context.
+				 */
+				incognito: boolean;
+				/**
+				 * The frame ID for this context, or -1 if it is not hosted in a frame.
+				 */
+				frameId: number;
+				/**
+				 * The tab ID for this context, or -1 if it is not hosted in a tab.
+				 */
+				tabId: number;
+				/**
+				 * The window ID for this context, or -1 if it is not hosted in a window.
+				 */
+				windowId: number;
+			}
+			/**
+			 * An object which allows two way communication with other pages.
+			 */
+			interface Port {
+				name: string;
+				disconnect(): void;
+				onDisconnect: Events.Event<(port: Port) => void>;
+				onMessage: Events.Event<(message: unknown, port: Port) => void>;
+				/**
+				 * Send a message to the other end. This takes one argument, which is a JSON object representing the message to send.
+				 * It will be delivered to any script listening to the port's onMessage event, or to the native application if this port
+				 * is connected to a native application.
+				 */
+				postMessage(message: unknown): void;
+				/**
+				 * This property will <b>only</b> be present on ports passed to onConnect/onConnectExternal listeners.
+				 * Optional.
+				 */
+				sender?: MessageSender;
+				/**
+				 * If the port was disconnected due to an error, this will be set to an object with a string property message,
+				 * giving you more information about the error. See onDisconnect.
+				 * Optional.
+				 */
+				error?: PortErrorType;
+			}
+			/**
+			 * An object containing information about the script context that sent a message or request.
+			 */
+			interface MessageSender {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				tab?: Browser.Tabs.Tab;
+				/**
+				 * The $(topic:frame_ids)[frame] that opened the connection. 0 for top-level frames, positive for child frames.
+				 * This will only be set when <code>tab</code> is set.
+				 * Optional.
+				 */
+				frameId?: number;
+				/**
+				 * The ID of the extension or app that opened the connection, if any.
+				 * Optional.
+				 */
+				id?: string;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * The worldId of the USER_SCRIPT world that sent the message. Only present on onUserScriptMessage and onUserScriptConnect
+				 * (in port.sender) events.
+				 * Optional.
+				 */
+				userScriptWorldId?: string;
+			}
+			/**
+			 * The operating system the browser is running on.
+			 */
+			type PlatformOs = "mac" | "win" | "android" | "cros" | "linux" | "openbsd";
+			/**
+			 * The machine's processor architecture.
+			 */
+			type PlatformArch = "aarch64" | "arm" | "ppc64" | "s390x" | "sparc64" | "x86-32" | "x86-64" | "noarch";
+			/**
+			 * An object containing information about the current platform.
+			 */
+			interface PlatformInfo {
+				/**
+				 * The operating system the browser is running on.
+				 */
+				os: PlatformOs;
+				/**
+				 * The machine's processor architecture.
+				 */
+				arch: PlatformArch;
+			}
+			/**
+			 * An object containing information about the current browser.
+			 */
+			interface BrowserInfo {
+				/**
+				 * The name of the browser, for example 'Firefox'.
+				 */
+				name: string;
+				/**
+				 * The name of the browser vendor, for example 'Mozilla'.
+				 */
+				vendor: string;
+				/**
+				 * The browser's version, for example '42.0.0' or '0.8.1pre'.
+				 */
+				version: string;
+				/**
+				 * The browser's build ID/date, for example '20160101'.
+				 */
+				buildID: string;
+			}
+			/**
+			 * Result of the update check.
+			 */
+			type RequestUpdateCheckStatus = "throttled" | "no_update" | "update_available";
+			/**
+			 * The reason that this event is being dispatched.
+			 */
+			type OnInstalledReason = "install" | "update" | "browser_update";
+			/**
+			 * The reason that the event is being dispatched. 'app_update' is used when the restart is needed because the application
+			 * is updated to a newer version. 'os_update' is used when the restart is needed because the browser/OS is updated to a
+			 * newer version. 'periodic' is used when the system runs for more than the permitted uptime set in the enterprise policy.
+			 */
+			type OnRestartRequiredReason = "app_update" | "os_update" | "periodic";
+			/**
+			 * The performance warning event category, e.g. 'content_script'.
+			 */
+			type OnPerformanceWarningCategory = "content_script";
+			/**
+			 * The performance warning event severity. Will be 'high' for serious and user-visible issues.
+			 */
+			type OnPerformanceWarningSeverity = "low" | "medium" | "high";
+			/**
+			 * The third parameter is a function to call (at most once) when you have a response.
+			 * The argument should be any JSON-ifiable object. If you have more than one <code>onMessage</code>
+			 * listener in the same document, then only one may send a response. <code>sendResponse</code>
+			 * becomes invalid when the event listener returns, unless you return true from the event listener to indicate you wish to
+			 * send a response asynchronously (this will keep the message channel open to the other end until <code>sendResponse</code>
+			 * is called).
+			 */
+			type OnMessageListenerCallback = (message: unknown, sender: MessageSender, sendResponse: (response: unknown) => void) => true;
+			/**
+			 * The return value should be a promise of any JSON-ifiable object. If you have more than one <code>onMessage</code>
+			 * listener in the same document, then only one may send a response.
+			 */
+			type OnMessageListenerAsync = (message: unknown, sender: MessageSender) => Promise<unknown>;
+			type OnMessageListenerNoResponse = (message: unknown, sender: MessageSender) => void;
+			type OnMessageListener = OnMessageListenerCallback | OnMessageListenerAsync | OnMessageListenerNoResponse;
+			/**
+			 * If an update is available, this contains more information about the available update.
+			 */
+			interface RequestUpdateCheckCallbackDetailsType {
+				/**
+				 * The version of the available update.
+				 */
+				version: string;
+			}
+			interface ConnectConnectInfoType {
+				/**
+				 * Will be passed into onConnect for processes that are listening for the connection event.
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * Whether the TLS channel ID will be passed into onConnectExternal for processes that are listening for the connection
+				 * event.
+				 * Optional.
+				 */
+				includeTlsChannelId?: boolean;
+			}
+			interface SendMessageOptionsType {
+				[s: string]: unknown;
+			}
+			interface OnInstalledDetailsType {
+				/**
+				 * The reason that this event is being dispatched.
+				 */
+				reason: OnInstalledReason;
+				/**
+				 * Indicates the previous version of the extension, which has just been updated. This is present only if 'reason' is
+				 * 'update'.
+				 * Optional.
+				 */
+				previousVersion?: string;
+				/**
+				 * Indicates whether the addon is installed as a temporary extension.
+				 */
+				temporary: boolean;
+			}
+			/**
+			 * The manifest details of the available update.
+			 */
+			interface OnUpdateAvailableDetailsType {
+				/**
+				 * The version number of the available update.
+				 */
+				version: string;
+			}
+			interface OnPerformanceWarningDetailsType {
+				/**
+				 * The performance warning event category, e.g. 'content_script'.
+				 */
+				category: OnPerformanceWarningCategory;
+				/**
+				 * The performance warning event severity, e.g. 'high'.
+				 */
+				severity: OnPerformanceWarningSeverity;
+				/**
+				 * The $(ref:tabs.Tab) that the performance warning relates to, if any.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * An explanation of what the warning means, and hopefully how to address it.
+				 */
+				description: string;
+			}
+			/**
+			 * This will be defined during an API method callback if there was an error
+			 */
+			interface PropertyLastErrorType {
+				/**
+				 * Details about the error which occurred.
+				 * Optional.
+				 */
+				message?: string;
+			}
+			/**
+			 * If the port was disconnected due to an error, this will be set to an object with a string property message,
+			 * giving you more information about the error. See onDisconnect.
+			 */
+			interface PortErrorType {
+				message: string;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 */
+				getBackgroundPage(): Promise<Window>;
+				/**
+				 * Fetches information about active contexts associated with this extension
+				 *
+				 * @param filter A filter to find matching context.
+				 */
+				getContexts(filter: ContextFilter): Promise<ExtensionContext[]>;
+				/**
+				 * <p>Open your Extension's options page, if possible.</p><p>The precise behavior may depend on your manifest's <code>
+				 * $(topic:optionsV2)[options_ui]</code> or <code>$(topic:options)[options_page]</code> key,
+				 * or what the browser happens to support at the time.</p><p>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).</p>
+				 */
+				openOptionsPage(): Promise<void>;
+				/**
+				 * Returns details about the app or extension from the manifest. The object returned is a serialization of the full
+				 * $(topic:manifest)[manifest file].
+				 *
+				 * @returns The manifest details.
+				 */
+				getManifest(): Promise<Manifest.WebExtensionManifest>;
+				/**
+				 * Converts a relative path within an app/extension install directory to a fully-qualified URL.
+				 *
+				 * @param path A path to a resource within an app/extension expressed relative to its install directory.
+				 * @returns The fully-qualified URL to the resource.
+				 */
+				getURL(path: string): Promise<string>;
+				/**
+				 * Get the frameId of any window global or frame element.
+				 *
+				 * @param target A WindowProxy or a Browsing Context container element (IFrame, Frame, Embed, Object) for the target frame.
+				 * @returns The frameId of the target frame, or -1 if it doesn't exist.
+				 */
+				getFrameId(target: unknown): number;
+				/**
+				 * 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.
+				 *
+				 * @param url Optional. 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.
+				 * @returns Called when the uninstall URL is set. If the given URL is invalid, $(ref:runtime.lastError) will be set.
+				 */
+				setUninstallURL(url?: string): Promise<void>;
+				/**
+				 * Reloads the app or extension.
+				 */
+				reload(): void;
+				/**
+				 * Requests an update check for this app/extension.
+				 */
+				requestUpdateCheck(): Promise<[
+					RequestUpdateCheckStatus,
+					RequestUpdateCheckCallbackDetailsType
+				]>;
+				/**
+				 * 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).
+				 *
+				 * @param extensionId Optional. 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 connectInfo Optional.
+				 * @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.
+				 */
+				connect(extensionId?: string, connectInfo?: ConnectConnectInfoType): Port;
+				/**
+				 * 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).
+				 *
+				 * @param connectInfo Optional.
+				 * @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.
+				 */
+				connect(connectInfo?: ConnectConnectInfoType): Port;
+				/**
+				 * Connects to a native application in the host machine.
+				 *
+				 * @param application The name of the registered application to connect to.
+				 * @returns Port through which messages can be sent and received with the application
+				 */
+				connectNative(application: string): Port;
+				/**
+				 * 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).
+				 *
+				 * @param extensionId Optional. The ID of the extension/app to send the message to. If omitted,
+				 * the message will be sent to your own extension/app. Required if sending messages from a web page for
+				 * $(topic:manifest/externally_connectable)[web messaging].
+				 * @param options Optional.
+				 */
+				// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+				sendMessage<TMessage = unknown, TResponse = unknown>(extensionId: string | undefined, message: TMessage, options?: SendMessageOptionsType): Promise<TResponse>;
+				/**
+				 * 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).
+				 *
+				 * @param options Optional.
+				 */
+				// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+				sendMessage<TMessage = unknown, TResponse = unknown>(message: TMessage, options?: SendMessageOptionsType): Promise<TResponse>;
+				/**
+				 * Send a single message to a native application.
+				 *
+				 * @param application The name of the native messaging host.
+				 * @param message The message that will be passed to the native messaging host.
+				 */
+				// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+				sendNativeMessage<TMessage = unknown, TResponse = unknown>(application: string, message: TMessage): Promise<TResponse>;
+				/**
+				 * Returns information about the current browser.
+				 *
+				 * @returns Called with results
+				 */
+				getBrowserInfo(): Promise<BrowserInfo>;
+				/**
+				 * Returns information about the current platform.
+				 *
+				 * @returns Called with results
+				 */
+				getPlatformInfo(): Promise<PlatformInfo>;
+				/**
+				 * Fired when a profile that has this extension installed first starts up. This event is not fired for incognito profiles.
+				 */
+				onStartup: Events.Event<() => void>;
+				/**
+				 * 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.
+				 */
+				onInstalled: Events.Event<(details: OnInstalledDetailsType) => void>;
+				/**
+				 * 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.
+				 */
+				onSuspend: Events.Event<() => void>;
+				/**
+				 * Sent after onSuspend to indicate that the app won't be unloaded after all.
+				 */
+				onSuspendCanceled: Events.Event<() => void>;
+				/**
+				 * 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 details The manifest details of the available update.
+				 */
+				onUpdateAvailable: Events.Event<(details: OnUpdateAvailableDetailsType) => void>;
+				/**
+				 * Fired when a connection is made from either an extension process or a content script.
+				 */
+				onConnect: Events.Event<(port: Port) => void>;
+				/**
+				 * Fired when a connection is made from a USER_SCRIPT world registered through the userScripts API.
+				 */
+				onUserScriptConnect: Events.Event<(port: Port) => void>;
+				/**
+				 * Fired when a connection is made from another extension.
+				 */
+				onConnectExternal: Events.Event<(port: Port) => void>;
+				/**
+				 * Fired when a message is sent from either an extension process or a content script.
+				 */
+				onMessage: Events.Event<OnMessageListener>;
+				/**
+				 * Fired when a message is sent from another extension/app. Cannot be used in a content script.
+				 */
+				onMessageExternal: Events.Event<OnMessageListener>;
+				/**
+				 * Fired when a message is sent from a USER_SCRIPT world registered through the userScripts API.
+				 */
+				onUserScriptMessage: Events.Event<OnMessageListener>;
+				/**
+				 * Fired when a runtime performance issue is detected with the extension. Observe this event to be proactively notified of
+				 * runtime performance problems with the extension.
+				 */
+				onPerformanceWarning: Events.Event<(details: OnPerformanceWarningDetailsType) => void>;
+				/**
+				 * This will be defined during an API method callback if there was an error
+				 * Optional.
+				 */
+				lastError?: PropertyLastErrorType;
+				/**
+				 * The ID of the extension/app.
+				 */
+				id: string;
+			}
+		}
+		/**
+		 * Namespace: browser.scripting
+		 */
+		namespace Scripting {
+			/**
+			 * Details of a script injection
+			 */
+			interface ScriptInjection {
+				/**
+				 * The arguments to curry into a provided function. This is only valid if the <code>func</code> parameter is specified.
+				 * These arguments must be JSON-serializable.
+				 * Optional.
+				 */
+				args?: unknown[];
+				/**
+				 * The path of the JS files to inject, relative to the extension's root directory. Exactly one of <code>files</code>
+				 * and <code>func</code> must be specified.
+				 * Optional.
+				 */
+				files?: string[];
+				/**
+				 * 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 <code>files</code> and <code>
+				 * func</code> must be specified.
+				 *
+				 * @param ...args The arguments
+				 * @returns The return value
+				 */
+				func?(...args: unknown[]): unknown;
+				/**
+				 * Details specifying the target into which to inject the script.
+				 */
+				target: InjectionTarget;
+				/**
+				 * Optional.
+				 */
+				world?: ExecutionWorld;
+				/**
+				 * Whether the injection should be triggered in the target as soon as possible (but not necessarily prior to page load).
+				 * Optional.
+				 */
+				injectImmediately?: boolean;
+			}
+			/**
+			 * Result of a script injection.
+			 */
+			interface InjectionResult {
+				/**
+				 * The frame ID associated with the injection.
+				 */
+				frameId: number;
+				/**
+				 * The result of the script execution.
+				 * Optional.
+				 */
+				result?: unknown;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				error?: unknown;
+				/**
+				 * Whether the script should inject into all frames within the tab. Defaults to false.
+				 * This must not be true if frameIds is specified.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+			}
+			/**
+			 * Details of the script to insert.
+			 */
+			interface InjectionTarget {
+				/**
+				 * The IDs of specific frames to inject into.
+				 * Optional.
+				 */
+				frameIds?: number[];
+				/**
+				 * Whether the script should inject into all frames within the tab. Defaults to false.
+				 * This must not be true if frameIds is specified.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * The ID of the tab into which to inject.
+				 */
+				tabId: number;
+			}
+			interface CSSInjection {
+				/**
+				 * A string containing the CSS to inject. Exactly one of <code>files</code> and <code>css</code> must be specified.
+				 * Optional.
+				 */
+				css?: string;
+				/**
+				 * The path of the CSS files to inject, relative to the extension's root directory. Exactly one of <code>files</code>
+				 * and <code>css</code> must be specified.
+				 * Optional.
+				 */
+				files?: string[];
+				/**
+				 * The style origin for the injection. Defaults to <code>'AUTHOR'</code>.
+				 * Optional.
+				 */
+				origin?: CSSInjectionOriginEnum;
+				/**
+				 * Details specifying the target into which to inject the CSS.
+				 */
+				target: InjectionTarget;
+			}
+			interface ContentScriptFilter {
+				/**
+				 * The IDs of specific scripts to retrieve with <code>getRegisteredContentScripts()</code> or to unregister with <code>
+				 * unregisterContentScripts()</code>.
+				 * Optional.
+				 */
+				ids?: string[];
+			}
+			/**
+			 * The JavaScript world for a script to execute within. <code>ISOLATED</code> is the default execution environment of
+			 * content scripts, <code>MAIN</code> is the web page's execution environment.
+			 */
+			type ExecutionWorld = "ISOLATED" | "MAIN";
+			interface RegisteredContentScript {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * Excludes pages that this content script would otherwise be injected into.
+				 * Optional.
+				 */
+				excludeMatches?: string[];
+				/**
+				 * The id of the content script, specified in the API call.
+				 */
+				id: string;
+				/**
+				 * The list of JavaScript files to be injected into matching pages. These are injected in the order they appear in this
+				 * array.
+				 * Optional.
+				 */
+				js?: Browser.Manifest.ExtensionURL[];
+				/**
+				 * Specifies which pages this content script will be injected into. Must be specified for <code>registerContentScripts()
+				 * </code>.
+				 * Optional.
+				 */
+				matches?: string[];
+				/**
+				 * If matchOriginAsFallback is true, then the code is also injected in about:, data:,
+				 * blob: when their origin matches the pattern in 'matches', even if the actual document origin is opaque (due to the use
+				 * of CSP sandbox or iframe sandbox). Match patterns in 'matches' must specify a wildcard path glob. By default it is <code>
+				 * false</code>.
+				 * Optional.
+				 */
+				matchOriginAsFallback?: boolean;
+				/**
+				 * Specifies when JavaScript files are injected into the web page. The preferred and default value is <code>
+				 * document_idle</code>.
+				 * Optional.
+				 */
+				runAt?: Browser.ExtensionTypes.RunAt;
+				/**
+				 * The JavaScript world for a script to execute within. Defaults to "ISOLATED".
+				 * Optional.
+				 */
+				world?: ExecutionWorld;
+				/**
+				 * Specifies if this content script will persist into future sessions. This is currently NOT supported.
+				 * Optional.
+				 */
+				persistAcrossSessions?: boolean;
+				/**
+				 * The list of CSS files to be injected into matching pages. These are injected in the order they appear in this array.
+				 * Optional.
+				 */
+				css?: Browser.Manifest.ExtensionURL[];
+			}
+			/**
+			 * The origin for a style change. See style origins for more info.
+			 *
+			 * "AUTHOR": The author origin is the style origin which contains all of the styles which are part of the document,
+			 * whether embedded within the HTML or loaded from an external stylesheet file.
+			 * "USER": The user origin is the style origin containing any CSS that the user of the web browser has added.
+			 * These may be from adding styles using a developer tool or from a browser extension that automatically applies custom
+			 * styles to content, such as Stylus or Stylish.
+			 */
+			type StyleOrigin = "AUTHOR" | "USER";
+			/**
+			 * Details of the css to insert.
+			 */
+			interface CSSInjection {
+				/**
+				 * A string containing the CSS to inject. Exactly one of files and css must be specified.
+				 * Optional.
+				 */
+				css?: string;
+				/**
+				 * The path of the CSS files to inject, relative to the extension's root directory. NOTE: Currently a maximum of one file
+				 * is supported. Exactly one of files and css must be specified.
+				 * Optional.
+				 */
+				files?: string[];
+				/**
+				 * The style origin for the injection. Defaults to 'AUTHOR'.
+				 * Optional.
+				 */
+				origin?: StyleOrigin;
+				/**
+				 * Details specifying the target into which to insert the CSS.
+				 */
+				target: InjectionTarget;
+			}
+			interface UpdateContentScriptsScriptsItemType extends RegisteredContentScript {
+				/**
+				 * Specifies if this content script will persist into future sessions.
+				 * Optional.
+				 */
+				persistAcrossSessions?: boolean;
+			}
+			/**
+			 * The style origin for the injection. Defaults to <code>'AUTHOR'</code>.
+			 */
+			type CSSInjectionOriginEnum = "USER" | "AUTHOR";
+			interface Static {
+				/**
+				 * Injects a script into a target context. The script will be run at <code>document_idle</code>.
+				 *
+				 * @param injection The details of the script which to inject.
+				 * @returns Invoked upon completion of the injection. The resulting array contains the result of execution for each frame
+				 * where the injection succeeded.
+				 */
+				executeScript(injection: ScriptInjection): Promise<InjectionResult[]>;
+				/**
+				 * Inserts a CSS stylesheet into a target context. If multiple frames are specified, unsuccessful injections are ignored.
+				 *
+				 * @param injection The details of the styles to insert.
+				 * @returns Invoked upon completion of the injection.
+				 */
+				insertCSS(injection: CSSInjection): Promise<void>;
+				/**
+				 * Removes a CSS stylesheet that was previously inserted by this extension from a target context.
+				 *
+				 * @param injection The details of the styles to remove. Note that the <code>css</code>, <code>files</code>, and <code>
+				 * origin</code> properties must exactly match the stylesheet inserted through <code>insertCSS</code>.
+				 * Attempting to remove a non-existent stylesheet is a no-op.
+				 * @returns Invoked upon completion of the injection.
+				 */
+				removeCSS(injection: CSSInjection): Promise<void>;
+				/**
+				 * Registers one or more content scripts for this extension.
+				 *
+				 * @param 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.
+				 * @returns Invoked upon completion of the registration.
+				 */
+				registerContentScripts(scripts: RegisteredContentScript[]): Promise<void>;
+				/**
+				 * Returns all dynamically registered content scripts for this extension that match the given filter.
+				 *
+				 * @param filter Optional. An object to filter the extension's dynamically registered scripts.
+				 * @returns The resulting array contains the registered content scripts.
+				 */
+				getRegisteredContentScripts(filter?: ContentScriptFilter): Promise<RegisteredContentScript[]>;
+				/**
+				 * Unregisters one or more content scripts for this extension.
+				 *
+				 * @param filter Optional. If specified, only unregisters dynamic content scripts which match the filter. Otherwise,
+				 * all of the extension's dynamic content scripts are unregistered.
+				 * @returns Invoked upon completion of the unregistration.
+				 */
+				unregisterContentScripts(filter?: ContentScriptFilter): Promise<void>;
+				/**
+				 * Updates one or more content scripts for this extension.
+				 *
+				 * @param 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.
+				 * @returns Invoked when scripts have been updated.
+				 */
+				updateContentScripts(scripts: UpdateContentScriptsScriptsItemType[]): Promise<void>;
+			}
+		}
+		/**
+		 * Namespace: browser.search
+		 */
+		namespace Search {
+			/**
+			 * An object encapsulating a search engine
+			 */
+			interface SearchEngine {
+				name: string;
+				isDefault: boolean;
+				/**
+				 * Optional.
+				 */
+				alias?: string;
+				/**
+				 * Optional.
+				 */
+				favIconUrl?: string;
+			}
+			/**
+			 * Location where search results should be displayed.
+			 */
+			type Disposition = "CURRENT_TAB" | "NEW_TAB" | "NEW_WINDOW";
+			interface SearchSearchPropertiesType {
+				/**
+				 * Terms to search for.
+				 */
+				query: string;
+				/**
+				 * Search engine to use. Uses the default if not specified.
+				 * Optional.
+				 */
+				engine?: string;
+				/**
+				 * Location where search results should be displayed. NEW_TAB is the default.
+				 * Optional.
+				 */
+				disposition?: Disposition;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				tabId?: number;
+			}
+			interface QueryQueryInfoType {
+				/**
+				 * String to query with the default search provider.
+				 */
+				text: string;
+				/**
+				 * Location where search results should be displayed. CURRENT_TAB is the default.
+				 * Optional.
+				 */
+				disposition?: Disposition;
+				/**
+				 * Location where search results should be displayed. tabId cannot be used with disposition.
+				 * Optional.
+				 */
+				tabId?: number;
+			}
+			interface Static {
+				/**
+				 * Gets a list of search engines.
+				 *
+				 * @returns A Promise that will be fulfilled with an array of search engine objects.
+				 */
+				get(): Promise<SearchEngine[]>;
+				/**
+				 * Perform a search.
+				 */
+				search(searchProperties: SearchSearchPropertiesType): Promise<void>;
+				/**
+				 * Use the chrome.search API to search via the default provider.
+				 */
+				query(queryInfo: QueryQueryInfoType): Promise<void>;
+			}
+		}
+		/**
+		 * Namespace: browser.sessions
+		 */
+		namespace Sessions {
+			interface Filter {
+				/**
+				 * 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)).
+				 * Optional.
+				 */
+				maxResults?: number;
+			}
+			interface Session {
+				/**
+				 * The time when the window or tab was closed or modified, represented in milliseconds since the epoch.
+				 */
+				lastModified: number;
+				/**
+				 * The $(ref:tabs.Tab), if this entry describes a tab. Either this or $(ref:sessions.Session.window) will be set.
+				 * Optional.
+				 */
+				tab?: Browser.Tabs.Tab;
+				/**
+				 * The $(ref:windows.Window), if this entry describes a window. Either this or $(ref:sessions.Session.tab) will be set.
+				 * Optional.
+				 */
+				window?: Browser.Windows.Window;
+			}
+			interface Device {
+				info: string;
+				/**
+				 * The name of the foreign device.
+				 */
+				deviceName: string;
+				/**
+				 * A list of open window sessions for the foreign device, sorted from most recently to least recently modified session.
+				 */
+				sessions: Session[];
+			}
+			interface Static {
+				/**
+				 * Forget a recently closed tab.
+				 *
+				 * @param windowId The windowId of the window to which the recently closed tab to be forgotten belongs.
+				 * @param sessionId The sessionId (closedId) of the recently closed tab to be forgotten.
+				 */
+				forgetClosedTab(windowId: number, sessionId: string): Promise<void>;
+				/**
+				 * Forget a recently closed window.
+				 *
+				 * @param sessionId The sessionId (closedId) of the recently closed window to be forgotten.
+				 */
+				forgetClosedWindow(sessionId: string): Promise<void>;
+				/**
+				 * Gets the list of recently closed tabs and/or windows.
+				 *
+				 * @param filter Optional.
+				 */
+				getRecentlyClosed(filter?: Filter): Promise<Session[]>;
+				/**
+				 * Reopens a $(ref:windows.Window) or $(ref:tabs.Tab), with an optional callback to run when the entry has been restored.
+				 *
+				 * @param sessionId Optional. 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.
+				 */
+				restore(sessionId?: string): Promise<Session>;
+				/**
+				 * Set a key/value pair on a given tab.
+				 *
+				 * @param tabId The id of the tab that the key/value pair is being set on.
+				 * @param key The key which corresponds to the value being set.
+				 * @param value The value being set.
+				 */
+				setTabValue(tabId: number, key: string, value: unknown): Promise<void>;
+				/**
+				 * Retrieve a value that was set for a given key on a given tab.
+				 *
+				 * @param tabId The id of the tab whose value is being retrieved from.
+				 * @param key The key which corresponds to the value.
+				 */
+				getTabValue(tabId: number, key: string): Promise<unknown>;
+				/**
+				 * Remove a key/value pair that was set on a given tab.
+				 *
+				 * @param tabId The id of the tab whose key/value pair is being removed.
+				 * @param key The key which corresponds to the value.
+				 */
+				removeTabValue(tabId: number, key: string): Promise<void>;
+				/**
+				 * Set a key/value pair on a given window.
+				 *
+				 * @param windowId The id of the window that the key/value pair is being set on.
+				 * @param key The key which corresponds to the value being set.
+				 * @param value The value being set.
+				 */
+				setWindowValue(windowId: number, key: string, value: unknown): Promise<void>;
+				/**
+				 * Retrieve a value that was set for a given key on a given window.
+				 *
+				 * @param windowId The id of the window whose value is being retrieved from.
+				 * @param key The key which corresponds to the value.
+				 */
+				getWindowValue(windowId: number, key: string): Promise<unknown>;
+				/**
+				 * Remove a key/value pair that was set on a given window.
+				 *
+				 * @param windowId The id of the window whose key/value pair is being removed.
+				 * @param key The key which corresponds to the value.
+				 */
+				removeWindowValue(windowId: number, key: string): Promise<void>;
+				/**
+				 * Fired when recently closed tabs and/or windows are changed. This event does not monitor synced sessions changes.
+				 */
+				onChanged: Events.Event<() => void>;
+				/**
+				 * The maximum number of $(ref:sessions.Session) that will be included in a requested list.
+				 */
+				MAX_SESSION_RESULTS: 25;
+			}
+		}
+		/**
+		 * Namespace: browser.sidebarAction
+		 */
+		namespace SidebarAction {
+			/**
+			 * Pixel data for an image. Must be an ImageData object (for example, from a <code>canvas</code> element).
+			 */
+			interface ImageDataType extends ImageData {
+				[s: string]: unknown;
+			}
+			interface SetTitleDetailsType {
+				/**
+				 * The string the sidebar action should display when moused over.
+				 */
+				title: string | null;
+				/**
+				 * Sets the sidebar title for the tab specified by tabId. Automatically resets when the tab is closed.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Sets the sidebar title for the window specified by windowId.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface GetTitleDetailsType {
+				/**
+				 * Specify the tab to get the title from. If no tab nor window is specified, the global title is returned.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Specify the window to get the title from. If no tab nor window is specified, the global title is returned.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface SetIconDetailsType {
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				imageData?: ImageDataType | Record<string, ImageDataType>;
+				/**
+				 * 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 <code>scale</code>, then image with size <code>
+				 * scale</code> * 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}'
+				 * Optional.
+				 */
+				path?: string | SetIconDetailsTypePathC2Type;
+				/**
+				 * Sets the sidebar icon for the tab specified by tabId. Automatically resets when the tab is closed.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Sets the sidebar icon for the window specified by windowId.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface SetPanelDetailsType {
+				/**
+				 * Sets the sidebar url for the tab specified by tabId. Automatically resets when the tab is closed.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Sets the sidebar url for the window specified by windowId.
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * The url to the html file to show in a sidebar.  If set to the empty string (''), no sidebar is shown.
+				 */
+				panel: string | null;
+			}
+			interface GetPanelDetailsType {
+				/**
+				 * Specify the tab to get the panel from. If no tab nor window is specified, the global panel is returned.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Specify the window to get the panel from. If no tab nor window is specified, the global panel is returned.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface IsOpenDetailsType {
+				/**
+				 * Specify the window to get the openness from.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface SetIconDetailsTypePathC2Type {
+				[s: string]: unknown;
+			}
+			interface Static {
+				/**
+				 * Sets the title of the sidebar action. This shows up in the tooltip.
+				 */
+				setTitle(details: SetTitleDetailsType): Promise<void>;
+				/**
+				 * Gets the title of the sidebar action.
+				 */
+				getTitle(details: GetTitleDetailsType): Promise<string>;
+				/**
+				 * Sets the icon for the sidebar 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 <strong>path</strong> or the <strong>
+				 * imageData</strong> property must be specified.
+				 */
+				setIcon(details: SetIconDetailsType): Promise<void>;
+				/**
+				 * Sets the url to the html document to be opened in the sidebar when the user clicks on the sidebar action's icon.
+				 */
+				setPanel(details: SetPanelDetailsType): Promise<void>;
+				/**
+				 * Gets the url to the html document set as the panel for this sidebar action.
+				 */
+				getPanel(details: GetPanelDetailsType): Promise<string>;
+				/**
+				 * Opens the extension sidebar in the active window.
+				 */
+				open(): Promise<void>;
+				/**
+				 * Closes the extension sidebar in the active window if the sidebar belongs to the extension.
+				 */
+				close(): Promise<void>;
+				/**
+				 * Toggles the extension sidebar in the active window.
+				 */
+				toggle(): Promise<void>;
+				/**
+				 * Checks whether the sidebar action is open.
+				 */
+				isOpen(details: IsOpenDetailsType): Promise<boolean>;
+			}
+		}
+		/**
+		 * Namespace: browser.storage
+		 */
+		namespace Storage {
+			interface StorageChange {
+				/**
+				 * The old value of the item, if there was an old value.
+				 * Optional.
+				 */
+				oldValue?: unknown;
+				/**
+				 * The new value of the item, if there is a new value.
+				 * Optional.
+				 */
+				newValue?: unknown;
+			}
+			interface StorageArea {
+				/**
+				 * Gets one or more items from storage.
+				 *
+				 * @param keys Optional. 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 <code>null</code>
+				 * to get the entire contents of storage.
+				 * @returns Callback with storage items, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				get(keys?: null | string | string[] | Record<string, unknown>): Promise<Record<string, unknown>>;
+				/**
+				 * Sets multiple items.
+				 *
+				 * @param items <p>An object which gives each key/value pair to update storage with. Any other key/value pairs in storage
+				 * will not be affected.</p><p>Primitive values such as numbers will serialize as expected. Values with a <code>
+				 * typeof</code> <code>"object"</code> and <code>"function"</code> will typically serialize to <code>{}</code>,
+				 * with the exception of <code>Array</code> (serializes as expected), <code>Date</code>, and <code>Regex</code>
+				 * (serialize using their <code>String</code> representation).</p>
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				set(items: Record<string, unknown>): Promise<void>;
+				/**
+				 * Removes one or more items from storage.
+				 *
+				 * @param keys A single key or a list of keys for items to remove.
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				remove(keys: string | string[]): Promise<void>;
+				/**
+				 * Removes all items from storage.
+				 *
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				clear(): Promise<void>;
+				/**
+				 * Fired when one or more items change.
+				 *
+				 * @param changes Object mapping each key that changed to its corresponding $(ref:storage.StorageChange) for that item.
+				 */
+				onChanged: Events.Event<(changes: StorageAreaOnChangedChangesType) => void>;
+			}
+			interface StorageAreaWithUsage {
+				/**
+				 * Gets one or more items from storage.
+				 *
+				 * @param keys Optional. 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 <code>null</code>
+				 * to get the entire contents of storage.
+				 * @returns Callback with storage items, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				get(keys?: null | string | string[] | Record<string, unknown>): Promise<Record<string, unknown>>;
+				/**
+				 * Gets the amount of space (in bytes) being used by one or more items.
+				 *
+				 * @param keys Optional. A single key or list of keys to get the total usage for. An empty list will return 0.
+				 * Pass in <code>null</code> to get the total usage of all of storage.
+				 * @returns Callback with the amount of space being used by storage, or on failure (in which case $(ref:runtime.lastError)
+				 * will be set).
+				 */
+				getBytesInUse(keys?: null | string | string[]): Promise<number>;
+				/**
+				 * Sets multiple items.
+				 *
+				 * @param items <p>An object which gives each key/value pair to update storage with. Any other key/value pairs in storage
+				 * will not be affected.</p><p>Primitive values such as numbers will serialize as expected. Values with a <code>
+				 * typeof</code> <code>"object"</code> and <code>"function"</code> will typically serialize to <code>{}</code>,
+				 * with the exception of <code>Array</code> (serializes as expected), <code>Date</code>, and <code>Regex</code>
+				 * (serialize using their <code>String</code> representation).</p>
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				set(items: Record<string, unknown>): Promise<void>;
+				/**
+				 * Removes one or more items from storage.
+				 *
+				 * @param keys A single key or a list of keys for items to remove.
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				remove(keys: string | string[]): Promise<void>;
+				/**
+				 * Removes all items from storage.
+				 *
+				 * @returns Callback on success, or on failure (in which case $(ref:runtime.lastError) will be set).
+				 */
+				clear(): Promise<void>;
+				/**
+				 * Fired when one or more items change.
+				 *
+				 * @param changes Object mapping each key that changed to its corresponding $(ref:storage.StorageChange) for that item.
+				 */
+				onChanged: Events.Event<(changes: StorageAreaWithUsageOnChangedChangesType) => void>;
+			}
+			/**
+			 * Object mapping each key that changed to its corresponding $(ref:storage.StorageChange) for that item.
+			 */
+			interface StorageAreaOnChangedChangesType {
+				[s: string]: StorageChange;
+			}
+			/**
+			 * Object mapping each key that changed to its corresponding $(ref:storage.StorageChange) for that item.
+			 */
+			interface StorageAreaWithUsageOnChangedChangesType {
+				[s: string]: StorageChange;
+			}
+			interface Static {
+				/**
+				 * Fired when one or more items change.
+				 *
+				 * @param changes Object mapping each key that changed to its corresponding $(ref:storage.StorageChange) for that item.
+				 * @param areaName The name of the storage area (<code>"sync"</code>, <code>"local"</code> or <code>"managed"</code>)
+				 * the changes are for.
+				 */
+				onChanged: Events.Event<(changes: Record<string, StorageChange>, areaName: string) => void>;
+				/**
+				 * Items in the <code>sync</code> storage area are synced by the browser.
+				 */
+				sync: StorageAreaWithUsage;
+				/**
+				 * Items in the <code>local</code> storage area are local to each machine.
+				 */
+				local: StorageArea;
+				/**
+				 * Items in the <code>managed</code> 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.
+				 */
+				managed: StorageArea;
+				/**
+				 * Items in the <code>session</code> storage area are kept in memory, and only until the either browser or extension is
+				 * closed or reloaded.
+				 */
+				session: StorageAreaWithUsage;
+			}
+		}
+		/**
+		 * Namespace: browser.tabGroups
+		 */
+		namespace TabGroups {
+			/**
+			 * The group's color, using 'grey' spelling for compatibility with Chromium.
+			 */
+			type Color = "blue" | "cyan" | "grey" | "green" | "orange" | "pink" | "purple" | "red" | "yellow";
+			/**
+			 * State of a tab group inside of an open window.
+			 */
+			interface TabGroup {
+				/**
+				 * Whether the tab group is collapsed or expanded in the tab strip.
+				 */
+				collapsed: boolean;
+				/**
+				 * User-selected color name for the tab group's label/icons.
+				 */
+				color: Color;
+				/**
+				 * Unique ID of the tab group.
+				 */
+				id: number;
+				/**
+				 * User-defined name of the tab group.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Window that the tab group is in.
+				 */
+				windowId: number;
+			}
+			interface MoveMovePropertiesType {
+				index: number;
+				/**
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface QueryQueryInfoType {
+				/**
+				 * Optional.
+				 */
+				collapsed?: boolean;
+				/**
+				 * Optional.
+				 */
+				color?: Color;
+				/**
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface UpdateUpdatePropertiesType {
+				/**
+				 * Optional.
+				 */
+				collapsed?: boolean;
+				/**
+				 * Optional.
+				 */
+				color?: Color;
+				/**
+				 * Optional.
+				 */
+				title?: string;
+			}
+			interface OnRemovedRemoveInfoType {
+				/**
+				 * True when the tab group is being closed because its window is being closed.
+				 */
+				isWindowClosing: boolean;
+			}
+			interface Static {
+				/**
+				 * Retrieves details about the specified group.
+				 */
+				get(groupId: number): Promise<TabGroup>;
+				/**
+				 * Move a group within, or to another window.
+				 */
+				move(groupId: number, moveProperties: MoveMovePropertiesType): Promise<TabGroup>;
+				/**
+				 * Return all grups, or find groups with specified properties.
+				 */
+				query(queryInfo: QueryQueryInfoType): Promise<TabGroup[]>;
+				/**
+				 * Modifies state of a specified group.
+				 */
+				update(groupId: number, updateProperties: UpdateUpdatePropertiesType): Promise<TabGroup>;
+				/**
+				 * Fired when a tab group is created.
+				 */
+				onCreated: Events.Event<(group: TabGroup) => void>;
+				/**
+				 * Fired when a tab group is moved, within a window or to another window.
+				 */
+				onMoved: Events.Event<(group: TabGroup) => void>;
+				/**
+				 * Fired when a tab group is removed.
+				 */
+				onRemoved: Events.Event<(group: TabGroup, removeInfo: OnRemovedRemoveInfoType) => void>;
+				/**
+				 * Fired when a tab group is updated.
+				 */
+				onUpdated: Events.Event<(group: TabGroup) => void>;
+				/**
+				 * An ID that represents the absence of a group.
+				 */
+				TAB_GROUP_ID_NONE: -1;
+			}
+		}
+		/**
+		 * Namespace: browser.tabs
+		 */
+		namespace Tabs {
+			/**
+			 * An event that caused a muted state change.
+			 *
+			 * "user": A user input action has set/overridden the muted state.
+			 * "capture": Tab capture started, forcing a muted state change.
+			 * "extension": An extension, identified by the extensionId field, set the muted state.
+			 */
+			type MutedInfoReason = "user" | "capture" | "extension";
+			/**
+			 * Tab muted state and the reason for the last state change.
+			 */
+			interface MutedInfo {
+				/**
+				 * Whether the tab is prevented from playing sound (but hasn't necessarily recently produced sound).
+				 * Equivalent to whether the muted audio indicator is showing.
+				 */
+				muted: boolean;
+				/**
+				 * The reason the tab was muted or unmuted. Not set if the tab's mute state has never been changed.
+				 * Optional.
+				 */
+				reason?: MutedInfoReason;
+				/**
+				 * The ID of the extension that changed the muted state. Not set if an extension was not the reason the muted state last
+				 * changed.
+				 * Optional.
+				 */
+				extensionId?: string;
+			}
+			/**
+			 * Tab sharing state for screen, microphone and camera.
+			 */
+			interface SharingState {
+				/**
+				 * If the tab is sharing the screen the value will be one of "Screen", "Window", or "Application",
+				 * or undefined if not screen sharing.
+				 * Optional.
+				 */
+				screen?: string;
+				/**
+				 * True if the tab is using the camera.
+				 */
+				camera: boolean;
+				/**
+				 * True if the tab is using the microphone.
+				 */
+				microphone: boolean;
+			}
+			interface Tab {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				id?: number;
+				/**
+				 * The zero-based index of the tab within its window.
+				 */
+				index: number;
+				/**
+				 * The ID of the window the tab is contained within.
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * The ID of the tab that opened this tab, if any. This property is only present if the opener tab still exists.
+				 * Optional.
+				 */
+				openerTabId?: number;
+				/**
+				 * Whether the tab is highlighted. Works as an alias of active
+				 */
+				highlighted: boolean;
+				/**
+				 * Whether the tab is active in its window. (Does not necessarily mean the window is focused.)
+				 */
+				active: boolean;
+				/**
+				 * Whether the tab is pinned.
+				 */
+				pinned: boolean;
+				/**
+				 * The last time the tab was accessed as the number of milliseconds since epoch.
+				 * Optional.
+				 */
+				lastAccessed?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				audible?: boolean;
+				/**
+				 * Whether the tab can be discarded automatically by the browser when resources are low.
+				 * Optional.
+				 */
+				autoDiscardable?: boolean;
+				/**
+				 * Current tab muted state and the reason for the last state change.
+				 * Optional.
+				 */
+				mutedInfo?: MutedInfo;
+				/**
+				 * The URL the tab is displaying. This property is only present if the extension's manifest includes the <code>"tabs"</code>
+				 * permission.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * The title of the tab. This property is only present if the extension's manifest includes the <code>"tabs"</code>
+				 * permission.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * The URL of the tab's favicon. This property is only present if the extension's manifest includes the <code>"tabs"</code>
+				 * permission. It may also be an empty string if the tab is loading.
+				 * Optional.
+				 */
+				favIconUrl?: string;
+				/**
+				 * Either <em>loading</em> or <em>complete</em>.
+				 * Optional.
+				 */
+				status?: string;
+				/**
+				 * True while the tab is not loaded with content.
+				 * Optional.
+				 */
+				discarded?: boolean;
+				/**
+				 * Whether the tab is in an incognito window.
+				 */
+				incognito: boolean;
+				/**
+				 * The width of the tab in pixels.
+				 * Optional.
+				 */
+				width?: number;
+				/**
+				 * The height of the tab in pixels.
+				 * Optional.
+				 */
+				height?: number;
+				/**
+				 * True if the tab is hidden.
+				 * Optional.
+				 */
+				hidden?: boolean;
+				/**
+				 * The session ID used to uniquely identify a Tab obtained from the $(ref:sessions) API.
+				 * Optional.
+				 */
+				sessionId?: string;
+				/**
+				 * The CookieStoreId used for the tab.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * Whether the document in the tab can be rendered in reader mode.
+				 * Optional.
+				 */
+				isArticle?: boolean;
+				/**
+				 * Whether the document in the tab is being rendered in reader mode.
+				 * Optional.
+				 */
+				isInReaderMode?: boolean;
+				/**
+				 * Current tab sharing state for screen, microphone and camera.
+				 * Optional.
+				 */
+				sharingState?: SharingState;
+				/**
+				 * Whether the tab is drawing attention.
+				 * Optional.
+				 */
+				attention?: boolean;
+				/**
+				 * The ID of this tab's successor, if any; $(ref:tabs.TAB_ID_NONE) otherwise.
+				 * Optional.
+				 */
+				successorTabId?: number;
+				/**
+				 * The ID of the group that the tab belongs to.
+				 * Optional.
+				 */
+				groupId?: number;
+				/**
+				 * The URL the tab is navigating to, before it has committed. This property is only present if the extension's manifest
+				 * includes the "tabs" permission and there is a pending navigation.
+				 * Optional.
+				 */
+				pendingUrl?: string;
+			}
+			/**
+			 * Defines how zoom changes are handled, i.e. which entity is responsible for the actual scaling of the page; defaults to
+			 * <code>automatic</code>.
+			 *
+			 * "automatic": Zoom changes are handled automatically by the browser.
+			 * "manual": Overrides the automatic handling of zoom changes. The <code>onZoomChange</code> event will still be dispatched,
+			 * and it is the responsibility of the extension to listen for this event and manually scale the page.
+			 * This mode does not support <code>per-origin</code> zooming, and will thus ignore the <code>scope</code>
+			 * zoom setting and assume <code>per-tab</code>.
+			 * "disabled": Disables all zooming in the tab. The tab will revert to the default zoom level,
+			 * and all attempted zoom changes will be ignored.
+			 */
+			type ZoomSettingsMode = "automatic" | "manual" | "disabled";
+			/**
+			 * Defines whether zoom changes will persist for the page's origin, or only take effect in this tab; defaults to <code>
+			 * per-origin</code> when in <code>automatic</code> mode, and <code>per-tab</code> otherwise.
+			 *
+			 * "per-origin": Zoom changes will persist in the zoomed page's origin, i.e. all other tabs navigated to that same origin
+			 * will be zoomed as well. Moreover, <code>per-origin</code> zoom changes are saved with the origin,
+			 * meaning that when navigating to other pages in the same origin, they will all be zoomed to the same zoom factor.
+			 * The <code>per-origin</code> scope is only available in the <code>automatic</code> mode.
+			 * "per-tab": Zoom changes only take effect in this tab, and zoom changes in other tabs will not affect the zooming of this
+			 * tab. Also, <code>per-tab</code> zoom changes are reset on navigation; navigating a tab will always load pages with their
+			 * <code>per-origin</code> zoom factors.
+			 */
+			type ZoomSettingsScope = "per-origin" | "per-tab";
+			/**
+			 * Defines how zoom changes in a tab are handled and at what scope.
+			 */
+			interface ZoomSettings {
+				/**
+				 * Defines how zoom changes are handled, i.e. which entity is responsible for the actual scaling of the page; defaults to
+				 * <code>automatic</code>.
+				 * Optional.
+				 */
+				mode?: ZoomSettingsMode;
+				/**
+				 * Defines whether zoom changes will persist for the page's origin, or only take effect in this tab; defaults to <code>
+				 * per-origin</code> when in <code>automatic</code> mode, and <code>per-tab</code> otherwise.
+				 * Optional.
+				 */
+				scope?: ZoomSettingsScope;
+				/**
+				 * Used to return the default zoom level for the current tab in calls to tabs.getZoomSettings.
+				 * Optional.
+				 */
+				defaultZoomFactor?: number;
+			}
+			/**
+			 * Defines the page settings to be used when saving a page as a pdf file.
+			 */
+			interface PageSettings {
+				/**
+				 * The name of the file. May include optional .pdf extension.
+				 * Optional.
+				 */
+				toFileName?: string;
+				/**
+				 * The page size unit: 0 = inches, 1 = millimeters. Default: 0.
+				 * Optional.
+				 */
+				paperSizeUnit?: number;
+				/**
+				 * The paper width in paper size units. Default: 8.5.
+				 * Optional.
+				 */
+				paperWidth?: number;
+				/**
+				 * The paper height in paper size units. Default: 11.0.
+				 * Optional.
+				 */
+				paperHeight?: number;
+				/**
+				 * The page content orientation: 0 = portrait, 1 = landscape. Default: 0.
+				 * Optional.
+				 */
+				orientation?: number;
+				/**
+				 * The page content scaling factor: 1.0 = 100% = normal size. Default: 1.0.
+				 * Optional.
+				 */
+				scaling?: number;
+				/**
+				 * Whether the page content should shrink to fit the page width (overrides scaling). Default: true.
+				 * Optional.
+				 */
+				shrinkToFit?: boolean;
+				/**
+				 * Whether the page background colors should be shown. Default: false.
+				 * Optional.
+				 */
+				showBackgroundColors?: boolean;
+				/**
+				 * Whether the page background images should be shown. Default: false.
+				 * Optional.
+				 */
+				showBackgroundImages?: boolean;
+				/**
+				 * The spacing between the left header/footer and the left edge of the paper (inches). Default: 0.
+				 * Optional.
+				 */
+				edgeLeft?: number;
+				/**
+				 * The spacing between the right header/footer and the right edge of the paper (inches). Default: 0.
+				 * Optional.
+				 */
+				edgeRight?: number;
+				/**
+				 * The spacing between the top of the headers and the top edge of the paper (inches). Default: 0
+				 * Optional.
+				 */
+				edgeTop?: number;
+				/**
+				 * The spacing between the bottom of the footers and the bottom edge of the paper (inches). Default: 0.
+				 * Optional.
+				 */
+				edgeBottom?: number;
+				/**
+				 * The margin between the page content and the left edge of the paper (inches). Default: 0.5.
+				 * Optional.
+				 */
+				marginLeft?: number;
+				/**
+				 * The margin between the page content and the right edge of the paper (inches). Default: 0.5.
+				 * Optional.
+				 */
+				marginRight?: number;
+				/**
+				 * The margin between the page content and the top edge of the paper (inches). Default: 0.5.
+				 * Optional.
+				 */
+				marginTop?: number;
+				/**
+				 * The margin between the page content and the bottom edge of the paper (inches). Default: 0.5.
+				 * Optional.
+				 */
+				marginBottom?: number;
+				/**
+				 * The text for the page's left header. Default: '&T'.
+				 * Optional.
+				 */
+				headerLeft?: string;
+				/**
+				 * The text for the page's center header. Default: ''.
+				 * Optional.
+				 */
+				headerCenter?: string;
+				/**
+				 * The text for the page's right header. Default: '&U'.
+				 * Optional.
+				 */
+				headerRight?: string;
+				/**
+				 * The text for the page's left footer. Default: '&PT'.
+				 * Optional.
+				 */
+				footerLeft?: string;
+				/**
+				 * The text for the page's center footer. Default: ''.
+				 * Optional.
+				 */
+				footerCenter?: string;
+				/**
+				 * The text for the page's right footer. Default: '&D'.
+				 * Optional.
+				 */
+				footerRight?: string;
+			}
+			/**
+			 * Whether the tabs have completed loading.
+			 */
+			type TabStatus = "loading" | "complete";
+			/**
+			 * The type of window.
+			 */
+			type WindowType = "normal" | "popup" | "panel" | "app" | "devtools";
+			/**
+			 * Event names supported in onUpdated.
+			 */
+			type UpdatePropertyName = "attention" | "audible" | "autoDiscardable" | "discarded" | "favIconUrl" | "groupId" | "hidden" | "isArticle" | "mutedInfo" | "pinned" | "sharingState" | "status" | "title" | "url";
+			/**
+			 * An object describing filters to apply to tabs.onUpdated events.
+			 */
+			interface UpdateFilter {
+				/**
+				 * A list of URLs or URL patterns. Events that cannot match any of the URLs will be filtered out.
+				 * Filtering with urls requires the <code>"tabs"</code> or  <code>"activeTab"</code> permission.
+				 * Optional.
+				 */
+				urls?: string[];
+				/**
+				 * A list of property names. Events that do not match any of the names will be filtered out.
+				 * Optional.
+				 */
+				properties?: UpdatePropertyName[];
+				/**
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			interface ConnectConnectInfoType {
+				/**
+				 * Will be passed into onConnect for content scripts that are listening for the connection event.
+				 * Optional.
+				 */
+				name?: string;
+				/**
+				 * Open a port to a specific $(topic:frame_ids)[frame] identified by <code>frameId</code> instead of all frames in the tab.
+				 * Optional.
+				 */
+				frameId?: number;
+			}
+			interface SendMessageOptionsType {
+				/**
+				 * Send a message to a specific $(topic:frame_ids)[frame] identified by <code>frameId</code>
+				 * instead of all frames in the tab.
+				 * Optional.
+				 */
+				frameId?: number;
+			}
+			interface CreateCreatePropertiesType {
+				/**
+				 * The window to create the new tab in. Defaults to the $(topic:current-window)[current window].
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				index?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * 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 <var>true</var>.
+				 * Optional.
+				 */
+				active?: boolean;
+				/**
+				 * Whether the tab should be pinned. Defaults to <var>false</var>
+				 * Optional.
+				 */
+				pinned?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				openerTabId?: number;
+				/**
+				 * The CookieStoreId for the tab that opened this tab.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * Whether the document in the tab should be opened in reader mode.
+				 * Optional.
+				 */
+				openInReaderMode?: boolean;
+				/**
+				 * Whether the tab is marked as 'discarded' when created.
+				 * Optional.
+				 */
+				discarded?: boolean;
+				/**
+				 * The title used for display if the tab is created in discarded mode.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Whether the tab should be muted when created.
+				 * Optional.
+				 */
+				muted?: boolean;
+			}
+			interface DuplicateDuplicatePropertiesType {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				index?: number;
+				/**
+				 * 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 <var>true</var>.
+				 * Optional.
+				 */
+				active?: boolean;
+			}
+			interface QueryQueryInfoType {
+				/**
+				 * Whether the tabs are active in their windows.
+				 * Optional.
+				 */
+				active?: boolean;
+				/**
+				 * Whether the tabs are drawing attention.
+				 * Optional.
+				 */
+				attention?: boolean;
+				/**
+				 * Whether the tabs are pinned.
+				 * Optional.
+				 */
+				pinned?: boolean;
+				/**
+				 * Whether the tabs are audible.
+				 * Optional.
+				 */
+				audible?: boolean;
+				/**
+				 * Whether the tabs can be discarded automatically by the browser when resources are low.
+				 * Optional.
+				 */
+				autoDiscardable?: boolean;
+				/**
+				 * Whether the tabs are muted.
+				 * Optional.
+				 */
+				muted?: boolean;
+				/**
+				 * Whether the tabs are highlighted.  Works as an alias of active.
+				 * Optional.
+				 */
+				highlighted?: boolean;
+				/**
+				 * Whether the tabs are in the $(topic:current-window)[current window].
+				 * Optional.
+				 */
+				currentWindow?: boolean;
+				/**
+				 * Whether the tabs are in the last focused window.
+				 * Optional.
+				 */
+				lastFocusedWindow?: boolean;
+				/**
+				 * Whether the tabs have completed loading.
+				 * Optional.
+				 */
+				status?: TabStatus;
+				/**
+				 * True while the tabs are not loaded with content.
+				 * Optional.
+				 */
+				discarded?: boolean;
+				/**
+				 * True while the tabs are hidden.
+				 * Optional.
+				 */
+				hidden?: boolean;
+				/**
+				 * Match page titles against a pattern.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Match tabs against one or more $(topic:match_patterns)[URL patterns]. Note that fragment identifiers are not matched.
+				 * Optional.
+				 */
+				url?: string | string[];
+				/**
+				 * The ID of the parent window, or $(ref:windows.WINDOW_ID_CURRENT) for the $(topic:current-window)[current window].
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * The type of window the tabs are in.
+				 * Optional.
+				 */
+				windowType?: WindowType;
+				/**
+				 * The position of the tabs within their windows.
+				 * Optional.
+				 */
+				index?: number;
+				/**
+				 * The CookieStoreId used for the tab.
+				 * Optional.
+				 */
+				cookieStoreId?: string[] | string;
+				/**
+				 * The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.
+				 * Optional.
+				 */
+				openerTabId?: number;
+				/**
+				 * The ID of the group that the tabs are in, or $(ref:tabGroups.TAB_GROUP_ID_NONE) (-1) for ungrouped tabs.
+				 * Optional.
+				 */
+				groupId?: number;
+				/**
+				 * True for any screen sharing, or a string to specify type of screen sharing.
+				 * Optional.
+				 */
+				screen?: "Screen" | "Window" | "Application" | boolean;
+				/**
+				 * True if the tab is using the camera.
+				 * Optional.
+				 */
+				camera?: boolean;
+				/**
+				 * True if the tab is using the microphone.
+				 * Optional.
+				 */
+				microphone?: boolean;
+			}
+			interface HighlightHighlightInfoType {
+				/**
+				 * The window that contains the tabs.
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * If true, the $(ref:windows.Window) returned will have a <var>tabs</var> property that contains a list of the $(ref:tabs.
+				 * Tab) objects. The <code>Tab</code> objects only contain the <code>url</code>, <code>title</code> and <code>
+				 * favIconUrl</code> properties if the extension's manifest file includes the <code>"tabs"</code> permission. If false,
+				 * the $(ref:windows.Window) won't have the <var>tabs</var> property.
+				 * Optional.
+				 */
+				populate?: boolean;
+				/**
+				 * One or more tab indices to highlight.
+				 */
+				tabs: number[] | number;
+			}
+			interface UpdateUpdatePropertiesType {
+				/**
+				 * A URL to navigate the tab to.
+				 * Optional.
+				 */
+				url?: string;
+				/**
+				 * Whether the tab should be active. Does not affect whether the window is focused (see $(ref:windows.update)).
+				 * Optional.
+				 */
+				active?: boolean;
+				/**
+				 * Whether the tab should be discarded automatically by the browser when resources are low.
+				 * Optional.
+				 */
+				autoDiscardable?: boolean;
+				/**
+				 * Adds or removes the tab from the current selection.
+				 * Optional.
+				 */
+				highlighted?: boolean;
+				/**
+				 * Whether the tab should be pinned.
+				 * Optional.
+				 */
+				pinned?: boolean;
+				/**
+				 * Whether the tab should be muted.
+				 * Optional.
+				 */
+				muted?: boolean;
+				/**
+				 * The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as this tab.
+				 * Optional.
+				 */
+				openerTabId?: number;
+				/**
+				 * Whether the load should replace the current history entry for the tab.
+				 * Optional.
+				 */
+				loadReplace?: boolean;
+				/**
+				 * The ID of this tab's successor. If specified, the successor tab must be in the same window as this tab.
+				 * Optional.
+				 */
+				successorTabId?: number;
+			}
+			interface MoveMovePropertiesType {
+				/**
+				 * Defaults to the window the tab is currently in.
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * The position to move the window to. -1 will place the tab at the end of the window.
+				 */
+				index: number;
+			}
+			interface ReloadReloadPropertiesType {
+				/**
+				 * Whether using any local cache. Default is false.
+				 * Optional.
+				 */
+				bypassCache?: boolean;
+			}
+			interface MoveInSuccessionOptionsType {
+				/**
+				 * Whether to move the tabs before (false) or after (true) tabId in the succession. Defaults to false.
+				 * Optional.
+				 */
+				append?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				insert?: boolean;
+			}
+			interface GroupOptionsType {
+				/**
+				 * The tab ID or list of tab IDs to add to the specified group.
+				 */
+				tabIds: number | number[];
+				/**
+				 * The ID of the group to add the tabs to. If not specified, a new group will be created.
+				 * Optional.
+				 */
+				groupId?: number;
+				/**
+				 * Configurations for creating a group. Cannot be used if groupId is already specified.
+				 * Optional.
+				 */
+				createProperties?: GroupOptionsTypeCreatePropertiesType;
+			}
+			/**
+			 * Lists the changes to the state of the tab that was updated.
+			 */
+			interface OnUpdatedChangeInfoType {
+				/**
+				 * The tab's new attention state.
+				 * Optional.
+				 */
+				attention?: boolean;
+				/**
+				 * The tab's new audible state.
+				 * Optional.
+				 */
+				audible?: boolean;
+				/**
+				 * The tab's new autoDiscardable state.
+				 * Optional.
+				 */
+				autoDiscardable?: boolean;
+				/**
+				 * True while the tab is not loaded with content.
+				 * Optional.
+				 */
+				discarded?: boolean;
+				/**
+				 * The tab's new favicon URL. This property is only present if the extension's manifest includes the <code>"tabs"</code>
+				 * permission.
+				 * Optional.
+				 */
+				favIconUrl?: string;
+				/**
+				 * The tab's new hidden state.
+				 * Optional.
+				 */
+				hidden?: boolean;
+				/**
+				 * Whether the document in the tab can be rendered in reader mode.
+				 * Optional.
+				 */
+				isArticle?: boolean;
+				/**
+				 * The tab's new muted state and the reason for the change.
+				 * Optional.
+				 */
+				mutedInfo?: MutedInfo;
+				/**
+				 * The tab's new pinned state.
+				 * Optional.
+				 */
+				pinned?: boolean;
+				/**
+				 * The tab's new sharing state for screen, microphone and camera.
+				 * Optional.
+				 */
+				sharingState?: SharingState;
+				/**
+				 * The status of the tab. Can be either <em>loading</em> or <em>complete</em>.
+				 * Optional.
+				 */
+				status?: string;
+				/**
+				 * The title of the tab if it has changed. This property is only present if the extension's manifest includes the <code>
+				 * "tabs"</code> permission.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * The tab's URL if it has changed. This property is only present if the extension's manifest includes the <code>
+				 * "tabs"</code> permission.
+				 * Optional.
+				 */
+				url?: string;
+			}
+			interface OnMovedMoveInfoType {
+				windowId: number;
+				fromIndex: number;
+				toIndex: number;
+			}
+			interface OnActivatedActiveInfoType {
+				/**
+				 * The ID of the tab that has become active.
+				 */
+				tabId: number;
+				/**
+				 * The ID of the tab that was previously active, if that tab is still open.
+				 * Optional.
+				 */
+				previousTabId?: number;
+				/**
+				 * The ID of the window the active tab changed inside of.
+				 */
+				windowId: number;
+			}
+			interface OnHighlightedHighlightInfoType {
+				/**
+				 * The window whose tabs changed.
+				 */
+				windowId: number;
+				/**
+				 * All highlighted tabs in the window.
+				 */
+				tabIds: number[];
+			}
+			interface OnDetachedDetachInfoType {
+				oldWindowId: number;
+				oldPosition: number;
+			}
+			interface OnAttachedAttachInfoType {
+				newWindowId: number;
+				newPosition: number;
+			}
+			interface OnRemovedRemoveInfoType {
+				/**
+				 * The window whose tab is closed.
+				 */
+				windowId: number;
+				/**
+				 * True when the tab is being closed because its window is being closed.
+				 */
+				isWindowClosing: boolean;
+			}
+			interface OnZoomChangeZoomChangeInfoType {
+				tabId: number;
+				oldZoomFactor: number;
+				newZoomFactor: number;
+				zoomSettings: ZoomSettings;
+			}
+			/**
+			 * Configurations for creating a group. Cannot be used if groupId is already specified.
+			 */
+			interface GroupOptionsTypeCreatePropertiesType {
+				/**
+				 * The window of the new group. Defaults to the current window.
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			/**
+			 * Fired when a tab is updated.
+			 */
+			interface OnUpdatedEvent extends Events.Event<(tabId: number, changeInfo: OnUpdatedChangeInfoType, tab: Tab) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter Optional. A set of filters that restricts the events that will be sent to this listener.
+				 */
+				addListener(callback: (tabId: number, changeInfo: OnUpdatedChangeInfoType, tab: Tab) => void, filter?: UpdateFilter): void;
+			}
+			interface Static {
+				/**
+				 * Retrieves details about the specified tab.
+				 */
+				get(tabId: number): Promise<Tab>;
+				/**
+				 * 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).
+				 */
+				getCurrent(): Promise<Tab>;
+				/**
+				 * 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].
+				 *
+				 * @param connectInfo Optional.
+				 * @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.
+				 */
+				connect(tabId: number, connectInfo?: ConnectConnectInfoType): Browser.Runtime.Port;
+				/**
+				 * 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.
+				 *
+				 * @param options Optional.
+				 */
+				// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+				sendMessage<TMessage = unknown, TResponse = unknown>(tabId: number, message: TMessage, options?: SendMessageOptionsType): Promise<TResponse>;
+				/**
+				 * Creates a new tab.
+				 */
+				create(createProperties: CreateCreatePropertiesType): Promise<Tab>;
+				/**
+				 * Duplicates a tab.
+				 *
+				 * @param tabId The ID of the tab which is to be duplicated.
+				 * @param duplicateProperties Optional.
+				 */
+				duplicate(tabId: number, duplicateProperties?: DuplicateDuplicatePropertiesType): Promise<Tab>;
+				/**
+				 * Gets all tabs that have the specified properties, or all tabs if no properties are specified.
+				 */
+				query(queryInfo: QueryQueryInfoType): Promise<Tab[]>;
+				/**
+				 * Highlights the given tabs.
+				 */
+				highlight(highlightInfo: HighlightHighlightInfoType): Promise<Browser.Windows.Window>;
+				/**
+				 * Modifies the properties of a tab. Properties that are not specified in <var>updateProperties</var> are not modified.
+				 *
+				 * @param tabId Optional. Defaults to the selected tab of the $(topic:current-window)[current window].
+				 */
+				update(tabId: number | undefined, updateProperties: UpdateUpdatePropertiesType): Promise<Tab>;
+				/**
+				 * Modifies the properties of a tab. Properties that are not specified in <var>updateProperties</var> are not modified.
+				 */
+				update(updateProperties: UpdateUpdatePropertiesType): Promise<Tab>;
+				/**
+				 * 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.
+				 *
+				 * @param tabIds The tab or list of tabs to move.
+				 */
+				move(tabIds: number | number[], moveProperties: MoveMovePropertiesType): Promise<Tab | Tab[]>;
+				/**
+				 * Reload a tab.
+				 *
+				 * @param tabId Optional. The ID of the tab to reload; defaults to the selected tab of the current window.
+				 * @param reloadProperties Optional.
+				 */
+				reload(tabId?: number, reloadProperties?: ReloadReloadPropertiesType): Promise<void>;
+				/**
+				 * Warm up a tab
+				 *
+				 * @param tabId The ID of the tab to warm up.
+				 */
+				warmup(tabId: number): Promise<void>;
+				/**
+				 * Closes one or more tabs.
+				 *
+				 * @param tabIds The tab or list of tabs to close.
+				 */
+				remove(tabIds: number | number[]): Promise<void>;
+				/**
+				 * discards one or more tabs.
+				 *
+				 * @param tabIds The tab or list of tabs to discard.
+				 */
+				discard(tabIds: number | number[]): Promise<void>;
+				/**
+				 * Detects the primary language of the content in a tab.
+				 *
+				 * @param tabId Optional. Defaults to the active tab of the $(topic:current-window)[current window].
+				 */
+				detectLanguage(tabId?: number): Promise<string>;
+				/**
+				 * Toggles reader mode for the document in the tab.
+				 *
+				 * @param tabId Optional. Defaults to the active tab of the $(topic:current-window)[current window].
+				 */
+				toggleReaderMode(tabId?: number): Promise<void>;
+				/**
+				 * Captures an area of a specified tab. You must have $(topic:declare_permissions)[&lt;all_urls&gt;]
+				 * permission to use this method.
+				 *
+				 * @param tabId Optional. The tab to capture. Defaults to the active tab of the current window.
+				 * @param options Optional.
+				 */
+				captureTab(tabId?: number, options?: Browser.ExtensionTypes.ImageDetails): Promise<string>;
+				/**
+				 * Captures an area of the currently active tab in the specified window. You must have &lt;all_urls&gt; or activeTab
+				 * permission to use this method.
+				 *
+				 * @param windowId Optional. The target window. Defaults to the $(topic:current-window)[current window].
+				 * @param options Optional.
+				 */
+				captureVisibleTab(windowId?: number, options?: Browser.ExtensionTypes.ImageDetails): Promise<string>;
+				/**
+				 * Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param tabId Optional. The ID of the tab in which to run the script; defaults to the active tab of the current window.
+				 * @param details Details of the script to run.
+				 * @returns Called after all the JavaScript has been executed.
+				 */
+				executeScript(tabId: number | undefined, details: Browser.ExtensionTypes.InjectDetails): Promise<unknown[]>;
+				/**
+				 * Injects JavaScript code into a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param details Details of the script to run.
+				 * @returns Called after all the JavaScript has been executed.
+				 */
+				executeScript(details: Browser.ExtensionTypes.InjectDetails): Promise<unknown[]>;
+				/**
+				 * Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param tabId Optional. The ID of the tab in which to insert the CSS; defaults to the active tab of the current window.
+				 * @param details Details of the CSS text to insert.
+				 * @returns Called when all the CSS has been inserted.
+				 */
+				insertCSS(tabId: number | undefined, details: Browser.ExtensionTypes.InjectDetails): Promise<void>;
+				/**
+				 * Injects CSS into a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param details Details of the CSS text to insert.
+				 * @returns Called when all the CSS has been inserted.
+				 */
+				insertCSS(details: Browser.ExtensionTypes.InjectDetails): Promise<void>;
+				/**
+				 * Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param tabId Optional. The ID of the tab from which to remove the injected CSS; defaults to the active tab of the
+				 * current window.
+				 * @param details Details of the CSS text to remove.
+				 * @returns Called when all the CSS has been removed.
+				 */
+				removeCSS(tabId: number | undefined, details: Browser.ExtensionTypes.InjectDetails): Promise<void>;
+				/**
+				 * Removes injected CSS from a page. For details, see the $(topic:content_scripts)[programmatic injection]
+				 * section of the content scripts doc.
+				 *
+				 * @param details Details of the CSS text to remove.
+				 * @returns Called when all the CSS has been removed.
+				 */
+				removeCSS(details: Browser.ExtensionTypes.InjectDetails): Promise<void>;
+				/**
+				 * Zooms a specified tab.
+				 *
+				 * @param tabId Optional. The ID of the tab to zoom; defaults to the active tab of the current window.
+				 * @param 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.
+				 * @returns Called after the zoom factor has been changed.
+				 */
+				setZoom(tabId: number | undefined, zoomFactor: number): Promise<void>;
+				/**
+				 * Zooms a specified tab.
+				 *
+				 * @param 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.
+				 * @returns Called after the zoom factor has been changed.
+				 */
+				setZoom(zoomFactor: number): Promise<void>;
+				/**
+				 * Gets the current zoom factor of a specified tab.
+				 *
+				 * @param tabId Optional. The ID of the tab to get the current zoom factor from; defaults to the active tab of the current
+				 * window.
+				 * @returns Called with the tab's current zoom factor after it has been fetched.
+				 */
+				getZoom(tabId?: number): Promise<number>;
+				/**
+				 * 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.
+				 *
+				 * @param tabId Optional. The ID of the tab to change the zoom settings for; defaults to the active tab of the current
+				 * window.
+				 * @param zoomSettings Defines how zoom changes are handled and at what scope.
+				 * @returns Called after the zoom settings have been changed.
+				 */
+				setZoomSettings(tabId: number | undefined, zoomSettings: ZoomSettings): Promise<void>;
+				/**
+				 * 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.
+				 *
+				 * @param zoomSettings Defines how zoom changes are handled and at what scope.
+				 * @returns Called after the zoom settings have been changed.
+				 */
+				setZoomSettings(zoomSettings: ZoomSettings): Promise<void>;
+				/**
+				 * Gets the current zoom settings of a specified tab.
+				 *
+				 * @param tabId Optional. The ID of the tab to get the current zoom settings from; defaults to the active tab of the
+				 * current window.
+				 * @returns Called with the tab's current zoom settings.
+				 */
+				getZoomSettings(tabId?: number): Promise<ZoomSettings>;
+				/**
+				 * Prints page in active tab.
+				 */
+				print(): void;
+				/**
+				 * Shows print preview for page in active tab.
+				 *
+				 * @returns Called after print preview entered.
+				 */
+				printPreview(): Promise<void>;
+				/**
+				 * Saves page in active tab as a PDF file.
+				 *
+				 * @param pageSettings The page settings used to save the PDF file.
+				 * @returns Called after save as dialog closed.
+				 */
+				saveAsPDF(pageSettings: PageSettings): Promise<string>;
+				/**
+				 * Shows one or more tabs.
+				 *
+				 * @param tabIds The TAB ID or list of TAB IDs to show.
+				 */
+				show(tabIds: number | number[]): Promise<void>;
+				/**
+				 * Hides one or more tabs. The <code>"tabHide"</code> permission is required to hide tabs.  Not all tabs are hidable.
+				 * Returns an array of hidden tabs.
+				 *
+				 * @param tabIds The TAB ID or list of TAB IDs to hide.
+				 */
+				hide(tabIds: number | number[]): Promise<number[]>;
+				/**
+				 * Removes an array of tabs from their lines of succession and prepends or appends them in a chain to another tab.
+				 *
+				 * @param 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 tabId Optional. 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 options Optional.
+				 */
+				moveInSuccession(tabIds: number[], tabId?: number, options?: MoveInSuccessionOptionsType): Promise<void>;
+				/**
+				 * Navigate to next page in tab's history, if available
+				 *
+				 * @param tabId Optional. The ID of the tab to navigate forward.
+				 */
+				goForward(tabId?: number): Promise<void>;
+				/**
+				 * Navigate to previous page in tab's history, if available.
+				 *
+				 * @param tabId Optional. The ID of the tab to navigate backward.
+				 */
+				goBack(tabId?: number): Promise<void>;
+				/**
+				 * Adds one or more tabs to a specified group, or if no group is specified, adds the given tabs to a newly created group.
+				 */
+				group(options: GroupOptionsType): Promise<number>;
+				/**
+				 * Removes one or more tabs from their respective groups. If any groups become empty, they are deleted.
+				 *
+				 * @param tabIds The tab ID or list of tab IDs to remove from their respective groups.
+				 */
+				ungroup(tabIds: number | number[]): Promise<void>;
+				/**
+				 * 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 tab Details of the tab that was created.
+				 */
+				onCreated: Events.Event<(tab: Tab) => void>;
+				/**
+				 * Fired when a tab is updated.
+				 */
+				onUpdated: OnUpdatedEvent;
+				/**
+				 * 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).
+				 */
+				onMoved: Events.Event<(tabId: number, moveInfo: OnMovedMoveInfoType) => void>;
+				/**
+				 * 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.
+				 */
+				onActivated: Events.Event<(activeInfo: OnActivatedActiveInfoType) => void>;
+				/**
+				 * Fired when the highlighted or selected tabs in a window changes.
+				 */
+				onHighlighted: Events.Event<(highlightInfo: OnHighlightedHighlightInfoType) => void>;
+				/**
+				 * Fired when a tab is detached from a window, for example because it is being moved between windows.
+				 */
+				onDetached: Events.Event<(tabId: number, detachInfo: OnDetachedDetachInfoType) => void>;
+				/**
+				 * Fired when a tab is attached to a window, for example because it was moved between windows.
+				 */
+				onAttached: Events.Event<(tabId: number, attachInfo: OnAttachedAttachInfoType) => void>;
+				/**
+				 * Fired when a tab is closed.
+				 */
+				onRemoved: Events.Event<(tabId: number, removeInfo: OnRemovedRemoveInfoType) => void>;
+				/**
+				 * Fired when a tab is replaced with another tab due to prerendering or instant.
+				 */
+				onReplaced: Events.Event<(addedTabId: number, removedTabId: number) => void>;
+				/**
+				 * Fired when a tab is zoomed.
+				 */
+				onZoomChange: Events.Event<(ZoomChangeInfo: OnZoomChangeZoomChangeInfoType) => void>;
+				/**
+				 * An ID which represents the absence of a browser tab.
+				 */
+				TAB_ID_NONE: -1;
+			}
+		}
+		/**
+		 * Namespace: browser.theme
+		 */
+		namespace Theme {
+			/**
+			 * Info provided in the onUpdated listener.
+			 */
+			interface ThemeUpdateInfo {
+				/**
+				 * The new theme after update
+				 */
+				theme: ThemeUpdateInfoThemeType;
+				/**
+				 * The id of the window the theme has been applied to
+				 * Optional.
+				 */
+				windowId?: number;
+			}
+			/**
+			 * The new theme after update
+			 */
+			interface ThemeUpdateInfoThemeType {
+				[s: string]: unknown;
+			}
+			interface Static {
+				/**
+				 * Returns the current theme for the specified window or the last focused window.
+				 *
+				 * @param windowId Optional. The window for which we want the theme.
+				 */
+				getCurrent(windowId?: number): Promise<Manifest.ThemeType>;
+				/**
+				 * Make complete updates to the theme. Resolves when the update has completed.
+				 *
+				 * @param windowId Optional. The id of the window to update. No id updates all windows.
+				 * @param details The properties of the theme to update.
+				 */
+				update(windowId: number | undefined, details: Browser.Manifest.ThemeType): Promise<void>;
+				/**
+				 * Make complete updates to the theme. Resolves when the update has completed.
+				 *
+				 * @param details The properties of the theme to update.
+				 */
+				update(details: Browser.Manifest.ThemeType): Promise<void>;
+				/**
+				 * Removes the updates made to the theme.
+				 *
+				 * @param windowId Optional. The id of the window to reset. No id resets all windows.
+				 */
+				reset(windowId?: number): Promise<void>;
+				/**
+				 * Fired when a new theme has been applied
+				 *
+				 * @param updateInfo Details of the theme update
+				 */
+				onUpdated: Events.Event<(updateInfo: ThemeUpdateInfo) => void>;
+			}
+		}
+		/**
+		 * Namespace: browser.topSites
+		 */
+		namespace TopSites {
+			/**
+			 * An object encapsulating a most visited URL, such as the URLs on the new tab page.
+			 */
+			interface MostVisitedURL {
+				/**
+				 * The most visited URL.
+				 */
+				url: string;
+				/**
+				 * The title of the page.
+				 * Optional.
+				 */
+				title?: string;
+				/**
+				 * Data URL for the favicon, if available.
+				 * Optional.
+				 */
+				favicon?: string;
+				/**
+				 * The entry type, either <code>url</code> for a normal page link, or <code>search</code> for a search shortcut.
+				 * Optional.
+				 */
+				type?: MostVisitedURLTypeEnum;
+			}
+			interface GetOptionsType {
+				/**
+				 * The number of top sites to return, defaults to the value used by Firefox
+				 * Optional.
+				 */
+				limit?: number;
+				/**
+				 * Limit the result to a single top site link per domain
+				 * Optional.
+				 */
+				onePerDomain?: boolean;
+				/**
+				 * Include sites that the user has blocked from appearing on the Firefox new tab.
+				 * Optional.
+				 */
+				includeBlocked?: boolean;
+				/**
+				 * Include sites favicon if available.
+				 * Optional.
+				 */
+				includeFavicon?: boolean;
+				/**
+				 * Include sites that the user has pinned on the Firefox new tab.
+				 * Optional.
+				 */
+				includePinned?: boolean;
+				/**
+				 * Include search shortcuts appearing on the Firefox new tab.
+				 * Optional.
+				 */
+				includeSearchShortcuts?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				newtab?: boolean;
+			}
+			/**
+			 * The entry type, either <code>url</code> for a normal page link, or <code>search</code> for a search shortcut.
+			 */
+			type MostVisitedURLTypeEnum = "url" | "search";
+			interface Static {
+				/**
+				 * Gets a list of top sites.
+				 *
+				 * @param options Optional.
+				 */
+				get(options?: GetOptionsType): Promise<MostVisitedURL[]>;
+			}
+		}
+		/**
+		 * Namespace: browser.trial
+		 */
+		namespace Trial {
+			interface Static {
+				ml: Ml.Static;
+			}
+		}
+		/**
+		 * Namespace: browser.types
+		 */
+		namespace Types {
+			/**
+			 * The scope of the Setting. One of<ul><li><var>regular</var>: setting for the regular profile (which is inherited by the
+			 * incognito profile if not overridden elsewhere),</li><li><var>regular_only</var>: setting for the regular profile only
+			 * (not inherited by the incognito profile),</li><li><var>incognito_persistent</var>: setting for the incognito profile
+			 * that survives browser restarts (overrides regular preferences),</li><li><var>incognito_session_only</var>
+			 * : setting for the incognito profile that can only be set during an incognito session and is deleted when the incognito
+			 * session ends (overrides regular and incognito_persistent preferences).</li></ul> Only <var>regular</var>
+			 * is supported by Firefox at this time.
+			 */
+			type SettingScope = "regular" | "regular_only" | "incognito_persistent" | "incognito_session_only";
+			/**
+			 * One of<ul><li><var>not_controllable</var>: cannot be controlled by any extension</li><li><var>
+			 * controlled_by_other_extensions</var>: controlled by extensions with higher precedence</li><li><var>
+			 * controllable_by_this_extension</var>: can be controlled by this extension</li><li><var>controlled_by_this_extension</var>
+			 * : controlled by this extension</li></ul>
+			 */
+			type LevelOfControl = "not_controllable" | "controlled_by_other_extensions" | "controllable_by_this_extension" | "controlled_by_this_extension";
+			interface Setting {
+				/**
+				 * Gets the value of a setting.
+				 *
+				 * @param details Which setting to consider.
+				 */
+				get(details: SettingGetDetailsType): Promise<SettingGetCallbackDetailsType>;
+				/**
+				 * Sets the value of a setting.
+				 *
+				 * @param details Which setting to change.
+				 * @returns Called at the completion of the set operation.
+				 */
+				set(details: SettingSetDetailsType): Promise<void>;
+				/**
+				 * Clears the setting, restoring any default value.
+				 *
+				 * @param details Which setting to clear.
+				 * @returns Called at the completion of the clear operation.
+				 */
+				clear(details: SettingClearDetailsType): Promise<void>;
+				/**
+				 * Fired after the setting changes.
+				 */
+				onChange: Events.Event<(details: SettingOnChangeDetailsType) => void>;
+			}
+			interface SettingOnChangeDetailsType {
+				/**
+				 * The value of the setting after the change.
+				 */
+				value: unknown;
+				/**
+				 * The level of control of the setting.
+				 */
+				levelOfControl: Browser.Types.LevelOfControl;
+				/**
+				 * Whether the value that has changed is specific to the incognito session.<br/>This property will <em>only</em>
+				 * be present if the user has enabled the extension in incognito mode.
+				 * Optional.
+				 */
+				incognitoSpecific?: boolean;
+			}
+			/**
+			 * Which setting to consider.
+			 */
+			interface SettingGetDetailsType {
+				/**
+				 * Whether to return the value that applies to the incognito session (default false).
+				 * Optional.
+				 */
+				incognito?: boolean;
+			}
+			/**
+			 * Details of the currently effective value.
+			 */
+			interface SettingGetCallbackDetailsType {
+				/**
+				 * The value of the setting.
+				 */
+				value: unknown;
+				/**
+				 * The level of control of the setting.
+				 */
+				levelOfControl: Browser.Types.LevelOfControl;
+				/**
+				 * Whether the effective value is specific to the incognito session.<br/>This property will <em>only</em>
+				 * be present if the <var>incognito</var> property in the <var>details</var> parameter of <code>get()</code> was true.
+				 * Optional.
+				 */
+				incognitoSpecific?: boolean;
+			}
+			/**
+			 * Which setting to change.
+			 */
+			interface SettingSetDetailsType {
+				/**
+				 * 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.
+				 */
+				value: unknown;
+				/**
+				 * Where to set the setting (default: regular).
+				 * Optional.
+				 */
+				scope?: Browser.Types.SettingScope;
+			}
+			/**
+			 * Which setting to clear.
+			 */
+			interface SettingClearDetailsType {
+				/**
+				 * Where to clear the setting (default: regular).
+				 * Optional.
+				 */
+				scope?: Browser.Types.SettingScope;
+			}
+			interface Static {
+				[s: string]: unknown;
+			}
+		}
+		/**
+		 * Namespace: browser.userScripts
+		 */
+		namespace UserScripts {
+			/**
+			 * Details of a user script
+			 */
+			interface UserScriptOptions {
+				/**
+				 * The list of JS files to inject
+				 */
+				js: Browser.ExtensionTypes.ExtensionFileOrCode[];
+				/**
+				 * An opaque user script metadata value
+				 * Optional.
+				 */
+				scriptMetadata?: Browser.ExtensionTypes.PlainJSONValue;
+				matches: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				excludeMatches?: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				includeGlobs?: string[];
+				/**
+				 * Optional.
+				 */
+				excludeGlobs?: string[];
+				/**
+				 * If allFrames is <code>true</code>, implies that the JavaScript should be injected into all frames of current page.
+				 * By default, it's <code>false</code> and is only injected into the top frame.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * 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 <code>false</code>.
+				 * Optional.
+				 */
+				matchAboutBlank?: boolean;
+				/**
+				 * The soonest that the JavaScript will be injected into the tab. Defaults to "document_idle".
+				 * Optional.
+				 */
+				runAt?: Browser.ExtensionTypes.RunAt;
+				/**
+				 * limit the set of matched tabs to those that belong to the given cookie store id
+				 * Optional.
+				 */
+				cookieStoreId?: string[] | string;
+			}
+			/**
+			 * An object that represents a user script registered programmatically
+			 */
+			interface RegisteredUserScript {
+				/**
+				 * The ID of the user script specified in the API call. This property must not start with a '_' as it's reserved as a
+				 * prefix for generated script IDs.
+				 */
+				id: string;
+				/**
+				 * If allFrames is <code>true</code>, implies that the JavaScript should be injected into all frames of current page.
+				 * By default, it's <code>false</code> and is only injected into the top frame.
+				 * Optional.
+				 */
+				allFrames?: boolean;
+				/**
+				 * The list of ScriptSource objects defining sources of scripts to be injected into matching pages.
+				 */
+				js: ScriptSource[];
+				/**
+				 * At least one of matches or includeGlobs should be non-empty. The script runs in documents whose URL match either pattern.
+				 * Optional.
+				 */
+				matches?: Browser.Manifest.MatchPattern[];
+				/**
+				 * Optional.
+				 */
+				excludeMatches?: Browser.Manifest.MatchPattern[];
+				/**
+				 * At least one of matches or includeGlobs should be non-empty. The script runs in documents whose URL match either pattern.
+				 * Optional.
+				 */
+				includeGlobs?: string[];
+				/**
+				 * Optional.
+				 */
+				excludeGlobs?: string[];
+				/**
+				 * The soonest that the JavaScript will be injected into the tab. Defaults to "document_idle".
+				 * Optional.
+				 */
+				runAt?: Browser.ExtensionTypes.RunAt;
+				/**
+				 * The JavaScript script for a script to execute within. Defaults to "USER_SCRIPT".
+				 * Optional.
+				 */
+				world?: ExecutionWorld;
+				/**
+				 * If specified, specifies a specific user script world ID to execute in. Only valid if `world` is omitted or is
+				 * `USER_SCRIPT`. If `worldId` is omitted, the script will execute in the default user script world ("").
+				 * Values with leading underscores (`_`) are reserved. The maximum length is 256.
+				 * Optional.
+				 */
+				worldId?: string;
+			}
+			/**
+			 * The JavaScript world for a script to execute within. <code>USER_SCRIPT</code> is the default execution environment of
+			 * user scripts, <code>MAIN</code> is the web page's execution environment.
+			 */
+			type ExecutionWorld = "MAIN" | "USER_SCRIPT";
+			/**
+			 * Optional filter to use with getScripts() and unregister().
+			 */
+			interface UserScriptFilter {
+				/**
+				 * Optional.
+				 */
+				ids?: string[];
+			}
+			/**
+			 * Object with file xor code property. Equivalent to the ExtensionFileOrCode, except the file remains a relative URL.
+			 */
+			type ScriptSource = ScriptSourceC1Type | ScriptSourceC2Type;
+			/**
+			 * The configuration of a USER_SCRIPT world.
+			 */
+			interface WorldProperties {
+				/**
+				 * The identifier of the world. Values with leading underscores (`_`) are reserved. The maximum length is 256.
+				 * Defaults to the default USER_SCRIPT world ("").
+				 * Optional.
+				 */
+				worldId?: string;
+				/**
+				 * The world's Content Security Policy. Defaults to the CSP of regular content scripts,
+				 * which prohibits dynamic code execution such as eval.
+				 * Optional.
+				 */
+				csp?: string;
+				/**
+				 * Whether the runtime.sendMessage and runtime.connect methods are exposed. Defaults to not exposing these messaging APIs.
+				 * Optional.
+				 */
+				messaging?: boolean;
+			}
+			/**
+			 * An object that represents a user script registered programmatically
+			 */
+			interface RegisterCallbackLegacyRegisteredUserScriptType {
+				/**
+				 * Unregister a user script registered programmatically
+				 */
+				unregister(): Promise<void>;
+			}
+			interface UpdateScriptsItemType extends Omit<RegisteredUserScript, "js"> {
+				/**
+				 * Optional.
+				 */
+				js?: ScriptSource[];
+			}
+			interface ScriptSourceC1Type {
+				/**
+				 * The path of the JavaScript file to inject relative to the extension's root directory.
+				 */
+				file: string;
+			}
+			interface ScriptSourceC2Type {
+				code: string;
+			}
+			interface Static {
+				/**
+				 * Register a user script programmatically given its $(ref:userScripts.UserScriptOptions),
+				 * and resolves to an object with the unregister() function
+				 */
+				register(userScriptOptions: UserScriptOptions): Promise<RegisterCallbackLegacyRegisteredUserScriptType>;
+				/**
+				 * Registers one or more user scripts for this extension.
+				 *
+				 * @param scripts List of user scripts to be registered.
+				 */
+				register(scripts: RegisteredUserScript[]): void;
+				/**
+				 * Updates one or more user scripts for this extension.
+				 *
+				 * @param scripts List of user scripts to be updated.
+				 */
+				update(scripts: UpdateScriptsItemType[]): void;
+				/**
+				 * Unregisters all dynamically-registered user scripts for this extension.
+				 *
+				 * @param filter Optional. If specified, this method unregisters only the user scripts that match it.
+				 */
+				unregister(filter?: UserScriptFilter): void;
+				/**
+				 * Returns all dynamically-registered user scripts for this extension.
+				 *
+				 * @param filter Optional. If specified, this method returns only the user scripts that match it.
+				 */
+				getScripts(filter?: UserScriptFilter): Promise<RegisteredUserScript[]>;
+				/**
+				 * Configures the environment for scripts running in a USER_SCRIPT world.
+				 *
+				 * @param properties The desired configuration for a USER_SCRIPT world.
+				 */
+				configureWorld(properties: WorldProperties): void;
+				/**
+				 * Resets the configuration for a given world. That world will fall back to the default world's configuration.
+				 *
+				 * @param worldId Optional. The ID of the USER_SCRIPT world to reset. If omitted or empty,
+				 * resets the default world's configuration.
+				 */
+				resetWorldConfiguration(worldId?: string): void;
+				/**
+				 * Returns all registered USER_SCRIPT world configurations.
+				 */
+				getWorldConfigurations(): Promise<WorldProperties[]>;
+			}
+		}
+		/**
+		 * Namespace: browser.webNavigation
+		 */
+		namespace WebNavigation {
+			/**
+			 * Cause of the navigation. The same transition types as defined in the history API are used.
+			 * These are the same transition types as defined in the $(topic:transition_types)[history API] except with <code>
+			 * "start_page"</code> in place of <code>"auto_toplevel"</code> (for backwards compatibility).
+			 */
+			type TransitionType = "link" | "typed" | "auto_bookmark" | "auto_subframe" | "manual_subframe" | "generated" | "start_page" | "form_submit" | "reload" | "keyword" | "keyword_generated";
+			type TransitionQualifier = "client_redirect" | "server_redirect" | "forward_back" | "from_address_bar";
+			interface EventUrlFilters {
+				url: Browser.Events.UrlFilter[];
+			}
+			/**
+			 * Information about the frame to retrieve information about.
+			 */
+			interface GetFrameDetailsType {
+				/**
+				 * The ID of the tab in which the frame is.
+				 */
+				tabId: number;
+				/**
+				 * The ID of the process runs the renderer for this tab.
+				 * Optional.
+				 */
+				processId?: number;
+				/**
+				 * The ID of the frame in the given tab.
+				 */
+				frameId: number;
+			}
+			/**
+			 * Information about the requested frame, null if the specified frame ID and/or tab ID are invalid.
+			 */
+			interface GetFrameCallbackDetailsType {
+				/**
+				 * True if the last navigation in this frame was interrupted by an error, i.e. the onErrorOccurred event fired.
+				 * Optional.
+				 */
+				errorOccurred?: boolean;
+				/**
+				 * 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.
+				 */
+				url: string;
+				/**
+				 * The ID of the tab in which the frame is.
+				 */
+				tabId: number;
+				/**
+				 * The ID of the frame. 0 indicates that this is the main frame; a positive value indicates the ID of a subframe.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame. Set to -1 of no parent frame exists.
+				 */
+				parentFrameId: number;
+			}
+			/**
+			 * Information about the tab to retrieve all frames from.
+			 */
+			interface GetAllFramesDetailsType {
+				/**
+				 * The ID of the tab.
+				 */
+				tabId: number;
+			}
+			interface GetAllFramesCallbackDetailsItemType {
+				/**
+				 * True if the last navigation in this frame was interrupted by an error, i.e. the onErrorOccurred event fired.
+				 * Optional.
+				 */
+				errorOccurred?: boolean;
+				/**
+				 * The ID of the tab in which the frame is.
+				 */
+				tabId: number;
+				/**
+				 * The ID of the frame. 0 indicates that this is the main frame; a positive value indicates the ID of a subframe.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame. Set to -1 of no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * The URL currently associated with this frame.
+				 */
+				url: string;
+			}
+			interface OnBeforeNavigateDetailsType {
+				/**
+				 * The ID of the tab in which the navigation is about to occur.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame. Set to -1 of no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * The time when the browser was about to start the navigation, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnCommittedDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * Cause of the navigation.
+				 */
+				transitionType: TransitionType;
+				/**
+				 * A list of transition qualifiers.
+				 */
+				transitionQualifiers: TransitionQualifier[];
+				/**
+				 * The time when the navigation was committed, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnDOMContentLoadedDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * The time when the page's DOM was fully constructed, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnCompletedDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * The time when the document finished loading, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnErrorOccurredDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * The time when the error occurred, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnCreatedNavigationTargetDetailsType {
+				/**
+				 * The ID of the tab in which the navigation is triggered.
+				 */
+				sourceTabId: number;
+				/**
+				 * The ID of the process runs the renderer for the source tab.
+				 */
+				sourceProcessId: number;
+				/**
+				 * The ID of the frame with sourceTabId in which the navigation is triggered. 0 indicates the main frame.
+				 */
+				sourceFrameId: number;
+				/**
+				 * The URL to be opened in the new window.
+				 */
+				url: string;
+				/**
+				 * The ID of the tab in which the url is opened
+				 */
+				tabId: number;
+				/**
+				 * The time when the browser was about to create a new view, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnReferenceFragmentUpdatedDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * Cause of the navigation.
+				 */
+				transitionType: TransitionType;
+				/**
+				 * A list of transition qualifiers.
+				 */
+				transitionQualifiers: TransitionQualifier[];
+				/**
+				 * The time when the navigation was committed, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnTabReplacedDetailsType {
+				/**
+				 * The ID of the tab that was replaced.
+				 */
+				replacedTabId: number;
+				/**
+				 * The ID of the tab that replaced the old tab.
+				 */
+				tabId: number;
+				/**
+				 * The time when the replacement happened, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			interface OnHistoryStateUpdatedDetailsType {
+				/**
+				 * The ID of the tab in which the navigation occurs.
+				 */
+				tabId: number;
+				url: string;
+				/**
+				 * 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.
+				 */
+				frameId: number;
+				/**
+				 * Cause of the navigation.
+				 */
+				transitionType: TransitionType;
+				/**
+				 * A list of transition qualifiers.
+				 */
+				transitionQualifiers: TransitionQualifier[];
+				/**
+				 * The time when the navigation was committed, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+			}
+			/**
+			 * Fired when a navigation is about to occur.
+			 */
+			interface OnBeforeNavigateEvent extends Events.Event<(details: OnBeforeNavigateDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnBeforeNavigateDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * 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.
+			 */
+			interface OnCommittedEvent extends Events.Event<(details: OnCommittedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnCommittedDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * Fired when the page's DOM is fully constructed, but the referenced resources may not finish loading.
+			 */
+			interface OnDOMContentLoadedEvent extends Events.Event<(details: OnDOMContentLoadedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnDOMContentLoadedDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * Fired when a document, including the resources it refers to, is completely loaded and initialized.
+			 */
+			interface OnCompletedEvent extends Events.Event<(details: OnCompletedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnCompletedDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * 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.
+			 */
+			interface OnErrorOccurredEvent extends Events.Event<(details: OnErrorOccurredDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnErrorOccurredDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * Fired when a new window, or a new tab in an existing window, is created to host a navigation.
+			 */
+			interface OnCreatedNavigationTargetEvent extends Events.Event<(details: OnCreatedNavigationTargetDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnCreatedNavigationTargetDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * Fired when the reference fragment of a frame was updated. All future events for that frame will use the updated URL.
+			 */
+			interface OnReferenceFragmentUpdatedEvent extends Events.Event<(details: OnReferenceFragmentUpdatedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnReferenceFragmentUpdatedDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			/**
+			 * Fired when the frame's history was updated to a new URL. All future events for that frame will use the updated URL.
+			 */
+			interface OnHistoryStateUpdatedEvent extends Events.Event<(details: OnHistoryStateUpdatedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filters Optional. Conditions that the URL being navigated to must satisfy. The 'schemes' and 'ports' fields of
+				 * UrlFilter are ignored for this event.
+				 */
+				addListener(callback: (details: OnHistoryStateUpdatedDetailsType) => void, filters?: EventUrlFilters): void;
+			}
+			interface Static {
+				/**
+				 * Retrieves information about the given frame. A frame refers to an &lt;iframe&gt; or a &lt;frame&gt; of a web page and is
+				 * identified by a tab ID and a frame ID.
+				 *
+				 * @param details Information about the frame to retrieve information about.
+				 */
+				getFrame(details: GetFrameDetailsType): Promise<GetFrameCallbackDetailsType | null>;
+				/**
+				 * Retrieves information about all frames of a given tab.
+				 *
+				 * @param details Information about the tab to retrieve all frames from.
+				 */
+				getAllFrames(details: GetAllFramesDetailsType): Promise<GetAllFramesCallbackDetailsItemType[] | null>;
+				/**
+				 * Fired when a navigation is about to occur.
+				 */
+				onBeforeNavigate: OnBeforeNavigateEvent;
+				/**
+				 * 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.
+				 */
+				onCommitted: OnCommittedEvent;
+				/**
+				 * Fired when the page's DOM is fully constructed, but the referenced resources may not finish loading.
+				 */
+				onDOMContentLoaded: OnDOMContentLoadedEvent;
+				/**
+				 * Fired when a document, including the resources it refers to, is completely loaded and initialized.
+				 */
+				onCompleted: OnCompletedEvent;
+				/**
+				 * 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.
+				 */
+				onErrorOccurred: OnErrorOccurredEvent;
+				/**
+				 * Fired when a new window, or a new tab in an existing window, is created to host a navigation.
+				 */
+				onCreatedNavigationTarget: OnCreatedNavigationTargetEvent;
+				/**
+				 * Fired when the reference fragment of a frame was updated. All future events for that frame will use the updated URL.
+				 */
+				onReferenceFragmentUpdated: OnReferenceFragmentUpdatedEvent;
+				/**
+				 * Fired when the contents of the tab is replaced by a different (usually previously pre-rendered) tab.
+				 */
+				onTabReplaced: Events.Event<(details: OnTabReplacedDetailsType) => void>;
+				/**
+				 * Fired when the frame's history was updated to a new URL. All future events for that frame will use the updated URL.
+				 */
+				onHistoryStateUpdated: OnHistoryStateUpdatedEvent;
+			}
+		}
+		/**
+		 * Namespace: browser.webRequest
+		 */
+		namespace WebRequest {
+			type ResourceType = "main_frame" | "sub_frame" | "stylesheet" | "script" | "image" | "object" | "xmlhttprequest" | "xslt" | "ping" | "beacon" | "xml_dtd" | "font" | "media" | "websocket" | "csp_report" | "imageset" | "web_manifest" | "speculative" | "json" | "other";
+			type OnBeforeRequestOptions = "blocking" | "requestBody" | "extraHeaders";
+			type OnBeforeSendHeadersOptions = "requestHeaders" | "blocking" | "extraHeaders";
+			type OnSendHeadersOptions = "requestHeaders" | "extraHeaders";
+			type OnHeadersReceivedOptions = "blocking" | "responseHeaders" | "extraHeaders";
+			type OnAuthRequiredOptions = "responseHeaders" | "blocking" | "asyncBlocking" | "extraHeaders";
+			type OnResponseStartedOptions = "responseHeaders" | "extraHeaders";
+			type OnBeforeRedirectOptions = "responseHeaders" | "extraHeaders";
+			type OnCompletedOptions = "responseHeaders" | "extraHeaders";
+			/**
+			 * An object describing filters to apply to webRequest events.
+			 */
+			interface RequestFilter {
+				/**
+				 * A list of URLs or URL patterns. Requests that cannot match any of the URLs will be filtered out.
+				 */
+				urls: string[];
+				/**
+				 * A list of request types. Requests that cannot match any of the types will be filtered out.
+				 * Optional.
+				 */
+				types?: ResourceType[];
+				/**
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * Optional.
+				 */
+				windowId?: number;
+				/**
+				 * If provided, requests that do not match the incognito state will be filtered out.
+				 * Optional.
+				 */
+				incognito?: boolean;
+			}
+			/**
+			 * An array of HTTP headers. Each header is represented as a dictionary containing the keys <code>name</code>
+			 * and either <code>value</code> or <code>binaryValue</code>.
+			 */
+			type HttpHeaders = HttpHeadersItemType[];
+			/**
+			 * Returns value for event handlers that have the 'blocking' extraInfoSpec applied. Allows the event handler to modify
+			 * network requests.
+			 */
+			interface BlockingResponse {
+				/**
+				 * If true, the request is cancelled. Used in onBeforeRequest, this prevents the request from being sent.
+				 * Optional.
+				 */
+				cancel?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				redirectUrl?: string;
+				/**
+				 * 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 <code>redirectUrl</code>
+				 * during onBeforeRequest, <code>upgradeToSecure</code> will have no affect.
+				 * Optional.
+				 */
+				upgradeToSecure?: boolean;
+				/**
+				 * Only used as a response to the onBeforeSendHeaders event. If set, the request is made with these request headers instead.
+				 * Optional.
+				 */
+				requestHeaders?: HttpHeaders;
+				/**
+				 * 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 <code>responseHeaders</code> if you really want to modify the headers in order to
+				 * limit the number of conflicts (only one extension may modify <code>responseHeaders</code> for each request).
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * Only used as a response to the onAuthRequired event. If set, the request is made using the supplied credentials.
+				 * Optional.
+				 */
+				authCredentials?: BlockingResponseAuthCredentialsType;
+			}
+			/**
+			 * Contains the certificate properties of the request if it is a secure request.
+			 */
+			interface CertificateInfo {
+				subject: string;
+				issuer: string;
+				/**
+				 * Contains start and end timestamps.
+				 */
+				validity: CertificateInfoValidityType;
+				fingerprint: CertificateInfoFingerprintType;
+				serialNumber: string;
+				isBuiltInRoot: boolean;
+				subjectPublicKeyInfoDigest: CertificateInfoSubjectPublicKeyInfoDigestType;
+				/**
+				 * Optional.
+				 */
+				rawDER?: number[];
+			}
+			type CertificateTransparencyStatus = "not_applicable" | "policy_compliant" | "policy_not_enough_scts" | "policy_not_diverse_scts";
+			type TransportWeaknessReasons = "cipher";
+			/**
+			 * Contains the security properties of the request (ie. SSL/TLS information).
+			 */
+			interface SecurityInfo {
+				state: SecurityInfoStateEnum;
+				/**
+				 * Error message if state is "broken"
+				 * Optional.
+				 */
+				errorMessage?: string;
+				/**
+				 * Protocol version if state is "secure"
+				 * Optional.
+				 */
+				protocolVersion?: SecurityInfoProtocolVersionEnum;
+				/**
+				 * The cipher suite used in this request if state is "secure".
+				 * Optional.
+				 */
+				cipherSuite?: string;
+				/**
+				 * The key exchange algorithm used in this request if state is "secure".
+				 * Optional.
+				 */
+				keaGroupName?: string;
+				/**
+				 * The length (in bits) of the secret key.
+				 * Optional.
+				 */
+				secretKeyLength?: number;
+				/**
+				 * The signature scheme used in this request if state is "secure".
+				 * Optional.
+				 */
+				signatureSchemeName?: string;
+				/**
+				 * Certificate data if state is "secure".  Will only contain one entry unless <code>certificateChain</code>
+				 * is passed as an option.
+				 */
+				certificates: CertificateInfo[];
+				/**
+				 * The type of certificate error that was overridden for this connection, if any.
+				 * Optional.
+				 */
+				overridableErrorCategory?: SecurityInfoOverridableErrorCategoryEnum;
+				/**
+				 * Optional.
+				 */
+				isExtendedValidation?: boolean;
+				/**
+				 * Certificate transparency compliance per RFC 6962.  See <code>https://www.certificate-transparency.org/what-is-ct</code>
+				 * for more information.
+				 * Optional.
+				 */
+				certificateTransparencyStatus?: CertificateTransparencyStatus;
+				/**
+				 * True if host uses Strict Transport Security and state is "secure".
+				 * Optional.
+				 */
+				hsts?: boolean;
+				/**
+				 * True if host uses Public Key Pinning and state is "secure".
+				 * Optional.
+				 */
+				hpkp?: string;
+				/**
+				 * list of reasons that cause the request to be considered weak, if state is "weak"
+				 * Optional.
+				 */
+				weaknessReasons?: TransportWeaknessReasons[];
+				/**
+				 * True if the TLS connection used Encrypted Client Hello.
+				 * Optional.
+				 */
+				usedEch?: boolean;
+				/**
+				 * True if the TLS connection used Delegated Credentials.
+				 * Optional.
+				 */
+				usedDelegatedCredentials?: boolean;
+				/**
+				 * True if the TLS connection made OCSP requests.
+				 * Optional.
+				 */
+				usedOcsp?: boolean;
+				/**
+				 * True if the TLS connection used a privacy-preserving DNS transport like DNS-over-HTTPS.
+				 * Optional.
+				 */
+				usedPrivateDns?: boolean;
+			}
+			/**
+			 * Contains data uploaded in a URL request.
+			 */
+			interface UploadData {
+				/**
+				 * An ArrayBuffer with a copy of the data.
+				 * Optional.
+				 */
+				bytes?: unknown;
+				/**
+				 * A string with the file's path and name.
+				 * Optional.
+				 */
+				file?: string;
+			}
+			/**
+			 * Tracking flags that match our internal tracking classification
+			 */
+			type UrlClassificationFlags = "fingerprinting" | "fingerprinting_content" | "cryptomining" | "cryptomining_content" | "emailtracking" | "emailtracking_content" | "consentmanager" | "tracking" | "tracking_ad" | "tracking_analytics" | "tracking_social" | "tracking_content" | "any_basic_tracking" | "any_strict_tracking" | "any_social_tracking";
+			/**
+			 * If the request has been classified this is an array of $(ref:UrlClassificationFlags).
+			 */
+			type UrlClassificationParty = UrlClassificationFlags[];
+			interface UrlClassification {
+				/**
+				 * Classification flags if the request has been classified and it is first party.
+				 */
+				firstParty: UrlClassificationParty;
+				/**
+				 * Classification flags if the request has been classified and it or its window hierarchy is third party.
+				 */
+				thirdParty: UrlClassificationParty;
+			}
+			type OnErrorOccurredOptions = "extraHeaders";
+			/**
+			 * A BlockingResponse or a Promise<BlockingResponse>
+			 */
+			// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+			type BlockingResponseOrPromiseOrVoid = BlockingResponse | Promise<BlockingResponse> | void;
+			/**
+			 * "uninitialized": The StreamFilter is not fully initialized. No methods may be called until a "start" event has been
+			 * received.
+			 * "transferringdata": The underlying channel is currently transferring data, which will be dispatched via "data" events.
+			 * "finishedtransferringdata": The underlying channel has finished transferring data. Data may still be written via write()
+			 * calls at this point.
+			 * "suspended": Data transfer is currently suspended. It may be resumed by a call to resume().
+			 * Data may still be written via write() calls in this state.
+			 * "closed": The channel has been closed by a call to close(). No further data wlil be delivered via "data" events,
+			 * and no further data may be written via write() calls.
+			 * "disconnected": The channel has been disconnected by a call to disconnect(). All further data will be delivered directly,
+			 * without passing through the filter. No further events will be dispatched, and no further data may be written by write()
+			 * calls.
+			 * "failed": An error has occurred and the channel is disconnected. The `error`, property contains the details of the error.
+			 */
+			type StreamFilterStatus = "uninitialized" | "transferringdata" | "finishedtransferringdata" | "suspended" | "closed" | "disconnected" | "failed";
+			/**
+			 * An interface which allows an extension to intercept, and optionally modify, response data from an HTTP request.
+			 */
+			interface StreamFilter {
+				/**
+				 * Returns the current status of the stream.
+				 */
+				status: StreamFilterStatus;
+				/**
+				 * After an "error" event has been dispatched, this contains a message describing the error.
+				 */
+				error: string;
+				/**
+				 * Creates a stream filter for the given add-on and the given extension ID.
+				 */
+				create(requestId: number, addonId: string): void;
+				/**
+				 * Suspends processing of the request. After this is called, no further data will be delivered until the request is resumed.
+				 */
+				suspend(): void;
+				/**
+				 * Resumes delivery of data for a suspended request.
+				 */
+				resume(): void;
+				/**
+				 * Closes the request. After this is called, no more data may be written to the stream,
+				 * and no further data will be delivered. This *must* be called after the consumer is finished writing data,
+				 * unless disconnect() has already been called.
+				 */
+				close(): void;
+				/**
+				 * Disconnects the stream filter from the request. After this is called, no further data will be delivered to the filter,
+				 * and any unprocessed data will be written directly to the output stream.
+				 */
+				disconnect(): void;
+				/**
+				 * Writes a chunk of data to the output stream. This may not be called before the "start" event has been received.
+				 */
+				write(data: ArrayBuffer | Uint8Array): void;
+				/**
+				 * Dispatched with a StreamFilterDataEvent whenever incoming data is available on the stream.
+				 * This data will not be delivered to the output stream unless it is explicitly written via a write() call.
+				 */
+				ondata?: (data: StreamFilterEventData) => void;
+				/**
+				 * Dispatched when the stream is opened, and is about to begin delivering data.
+				 */
+				onstart?: (data: StreamFilterEventData) => void;
+				/**
+				 * Dispatched when the stream has closed, and has no more data to deliver. The output stream remains open and writable
+				 * until close() is called.
+				 */
+				onstop?: (data: StreamFilterEventData) => void;
+				/**
+				 * Dispatched when an error has occurred. No further data may be read or written after this point.
+				 */
+				onerror?: (data: StreamFilterEventData) => void;
+			}
+			interface StreamFilterEventData {
+				/**
+				 * Contains a chunk of data read from the input stream.
+				 */
+				data: ArrayBuffer;
+			}
+			interface GetSecurityInfoOptionsType {
+				/**
+				 * Include the entire certificate chain.
+				 * Optional.
+				 */
+				certificateChain?: boolean;
+				/**
+				 * Include raw certificate data for processing by the extension.
+				 * Optional.
+				 */
+				rawDER?: boolean;
+			}
+			interface OnBeforeRequestDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * Contains the HTTP request body data. Only provided if extraInfoSpec contains 'requestBody'.
+				 * Optional.
+				 */
+				requestBody?: OnBeforeRequestDetailsTypeRequestBodyType;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnBeforeSendHeadersDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The HTTP request headers that are going to be sent out with this request.
+				 * Optional.
+				 */
+				requestHeaders?: HttpHeaders;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnSendHeadersDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The HTTP request headers that have been sent out with this request.
+				 * Optional.
+				 */
+				requestHeaders?: HttpHeaders;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnHeadersReceivedDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * 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).
+				 */
+				statusLine: string;
+				/**
+				 * The HTTP response headers that have been received with this response.
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * Standard HTTP status code returned by the server.
+				 */
+				statusCode: number;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnAuthRequiredDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The authentication scheme, e.g. Basic or Digest.
+				 */
+				scheme: string;
+				/**
+				 * The authentication realm provided by the server, if there is one.
+				 * Optional.
+				 */
+				realm?: string;
+				/**
+				 * The server requesting authentication.
+				 */
+				challenger: OnAuthRequiredDetailsTypeChallengerType;
+				/**
+				 * True for Proxy-Authenticate, false for WWW-Authenticate.
+				 */
+				isProxy: boolean;
+				/**
+				 * The HTTP response headers that were received along with this response.
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * 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.
+				 */
+				statusLine: string;
+				/**
+				 * Standard HTTP status code returned by the server.
+				 */
+				statusCode: number;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnResponseStartedDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.
+				 * Optional.
+				 */
+				ip?: string;
+				/**
+				 * Indicates if this response was fetched from disk cache.
+				 */
+				fromCache: boolean;
+				/**
+				 * Standard HTTP status code returned by the server.
+				 */
+				statusCode: number;
+				/**
+				 * The HTTP response headers that were received along with this response.
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * 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.
+				 */
+				statusLine: string;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnBeforeRedirectDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.
+				 * Optional.
+				 */
+				ip?: string;
+				/**
+				 * Indicates if this response was fetched from disk cache.
+				 */
+				fromCache: boolean;
+				/**
+				 * Standard HTTP status code returned by the server.
+				 */
+				statusCode: number;
+				/**
+				 * The new URL.
+				 */
+				redirectUrl: string;
+				/**
+				 * The HTTP response headers that were received along with this redirect.
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * 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.
+				 */
+				statusLine: string;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnCompletedDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.
+				 * Optional.
+				 */
+				ip?: string;
+				/**
+				 * Indicates if this response was fetched from disk cache.
+				 */
+				fromCache: boolean;
+				/**
+				 * Standard HTTP status code returned by the server.
+				 */
+				statusCode: number;
+				/**
+				 * The HTTP response headers that were received along with this response.
+				 * Optional.
+				 */
+				responseHeaders?: HttpHeaders;
+				/**
+				 * 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.
+				 */
+				statusLine: string;
+				/**
+				 * Tracking classification if the request has been classified.
+				 */
+				urlClassification: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * For http requests, the bytes transferred in the request. Only available in onCompleted.
+				 */
+				requestSize: number;
+				/**
+				 * For http requests, the bytes received in the request. Only available in onCompleted.
+				 */
+				responseSize: number;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface OnErrorOccurredDetailsType {
+				/**
+				 * 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.
+				 */
+				requestId: string;
+				url: string;
+				/**
+				 * Standard HTTP method.
+				 */
+				method: string;
+				/**
+				 * 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 (<code>type</code> is <code>main_frame</code>
+				 * or <code>sub_frame</code>), <code>frameId</code> indicates the ID of this frame, not the ID of the outer frame.
+				 * Frame IDs are unique within a tab.
+				 */
+				frameId: number;
+				/**
+				 * ID of frame that wraps the frame which sent the request. Set to -1 if no parent frame exists.
+				 */
+				parentFrameId: number;
+				/**
+				 * True for private browsing requests.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * The cookie store ID of the contextual identity.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * URL of the resource that triggered this request.
+				 * Optional.
+				 */
+				originUrl?: string;
+				/**
+				 * URL of the page into which the requested resource will be loaded.
+				 * Optional.
+				 */
+				documentUrl?: string;
+				/**
+				 * The ID of the tab in which the request takes place. Set to -1 if the request isn't related to a tab.
+				 */
+				tabId: number;
+				/**
+				 * How the requested resource will be used.
+				 */
+				type: ResourceType;
+				/**
+				 * The time when this signal is triggered, in milliseconds since the epoch.
+				 */
+				timeStamp: number;
+				/**
+				 * The server IP address that the request was actually sent to. Note that it may be a literal IPv6 address.
+				 * Optional.
+				 */
+				ip?: string;
+				/**
+				 * Indicates if this response was fetched from disk cache.
+				 */
+				fromCache: boolean;
+				/**
+				 * 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.
+				 */
+				error: string;
+				/**
+				 * Tracking classification if the request has been classified.
+				 * Optional.
+				 */
+				urlClassification?: UrlClassification;
+				/**
+				 * Indicates if this request and its content window hierarchy is third party.
+				 */
+				thirdParty: boolean;
+				/**
+				 * URL of the resource that triggered this request (on chrome).
+				 * Optional.
+				 */
+				initiator?: string;
+			}
+			interface HttpHeadersItemType {
+				/**
+				 * Name of the HTTP header.
+				 */
+				name: string;
+				/**
+				 * Value of the HTTP header if it can be represented by UTF-8.
+				 * Optional.
+				 */
+				value?: string;
+				/**
+				 * Value of the HTTP header if it cannot be represented by UTF-8, stored as individual byte values (0..255).
+				 * Optional.
+				 */
+				binaryValue?: number[];
+			}
+			/**
+			 * Only used as a response to the onAuthRequired event. If set, the request is made using the supplied credentials.
+			 */
+			interface BlockingResponseAuthCredentialsType {
+				username: string;
+				password: string;
+			}
+			/**
+			 * Contains start and end timestamps.
+			 */
+			interface CertificateInfoValidityType {
+				start: number;
+				end: number;
+			}
+			interface CertificateInfoFingerprintType {
+				sha1: string;
+				sha256: string;
+			}
+			interface CertificateInfoSubjectPublicKeyInfoDigestType {
+				sha256: string;
+			}
+			type SecurityInfoStateEnum = "insecure" | "weak" | "broken" | "secure";
+			/**
+			 * Protocol version if state is "secure"
+			 */
+			type SecurityInfoProtocolVersionEnum = "TLSv1" | "TLSv1.1" | "TLSv1.2" | "TLSv1.3" | "unknown";
+			/**
+			 * The type of certificate error that was overridden for this connection, if any.
+			 */
+			type SecurityInfoOverridableErrorCategoryEnum = "trust_error" | "domain_mismatch" | "expired_or_not_yet_valid";
+			/**
+			 * Contains the HTTP request body data. Only provided if extraInfoSpec contains 'requestBody'.
+			 */
+			interface OnBeforeRequestDetailsTypeRequestBodyType {
+				/**
+				 * Errors when obtaining request body data.
+				 * Optional.
+				 */
+				error?: string;
+				/**
+				 * 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']}.
+				 * Optional.
+				 */
+				formData?: Record<string, string>;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				raw?: UploadData[];
+			}
+			/**
+			 * The server requesting authentication.
+			 */
+			interface OnAuthRequiredDetailsTypeChallengerType {
+				host: string;
+				port: number;
+			}
+			/**
+			 * Fired when a request is about to occur.
+			 */
+			interface OnBeforeRequestEvent extends Events.Event<(details: OnBeforeRequestDetailsType) => BlockingResponseOrPromiseOrVoid> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnBeforeRequestDetailsType) => BlockingResponseOrPromiseOrVoid, filter: RequestFilter, extraInfoSpec?: OnBeforeRequestOptions[]): void;
+			}
+			/**
+			 * 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.
+			 */
+			interface OnBeforeSendHeadersEvent extends Events.Event<(details: OnBeforeSendHeadersDetailsType) => BlockingResponseOrPromiseOrVoid> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnBeforeSendHeadersDetailsType) => BlockingResponseOrPromiseOrVoid, filter: RequestFilter, extraInfoSpec?: OnBeforeSendHeadersOptions[]): void;
+			}
+			/**
+			 * 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).
+			 */
+			interface OnSendHeadersEvent extends Events.Event<(details: OnSendHeadersDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnSendHeadersDetailsType) => void, filter: RequestFilter, extraInfoSpec?: OnSendHeadersOptions[]): void;
+			}
+			/**
+			 * Fired when HTTP response headers of a request have been received.
+			 */
+			interface OnHeadersReceivedEvent extends Events.Event<(details: OnHeadersReceivedDetailsType) => BlockingResponseOrPromiseOrVoid> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnHeadersReceivedDetailsType) => BlockingResponseOrPromiseOrVoid, filter: RequestFilter, extraInfoSpec?: OnHeadersReceivedOptions[]): void;
+			}
+			/**
+			 * 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.
+			 */
+			interface OnAuthRequiredEvent extends Events.Event<(details: OnAuthRequiredDetailsType) => BlockingResponseOrPromiseOrVoid> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnAuthRequiredDetailsType) => BlockingResponseOrPromiseOrVoid, filter: RequestFilter, extraInfoSpec?: OnAuthRequiredOptions[]): void;
+			}
+			/**
+			 * 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.
+			 */
+			interface OnResponseStartedEvent extends Events.Event<(details: OnResponseStartedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnResponseStartedDetailsType) => void, filter: RequestFilter, extraInfoSpec?: OnResponseStartedOptions[]): void;
+			}
+			/**
+			 * Fired when a server-initiated redirect is about to occur.
+			 */
+			interface OnBeforeRedirectEvent extends Events.Event<(details: OnBeforeRedirectDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnBeforeRedirectDetailsType) => void, filter: RequestFilter, extraInfoSpec?: OnBeforeRedirectOptions[]): void;
+			}
+			/**
+			 * Fired when a request is completed.
+			 */
+			interface OnCompletedEvent extends Events.Event<(details: OnCompletedDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnCompletedDetailsType) => void, filter: RequestFilter, extraInfoSpec?: OnCompletedOptions[]): void;
+			}
+			/**
+			 * Fired when an error occurs.
+			 */
+			interface OnErrorOccurredEvent extends Events.Event<(details: OnErrorOccurredDetailsType) => void> {
+				/**
+				 * Registers an event listener <em>callback</em> to an event.
+				 *
+				 * @param callback Called when an event occurs. The parameters of this function depend on the type of event.
+				 * @param filter A set of filters that restricts the events that will be sent to this listener.
+				 * @param extraInfoSpec Optional. Array of extra information that should be passed to the listener function.
+				 */
+				addListener(callback: (details: OnErrorOccurredDetailsType) => void, filter: RequestFilter, extraInfoSpec?: OnErrorOccurredOptions[]): void;
+			}
+			interface Static {
+				/**
+				 * 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.
+				 */
+				handlerBehaviorChanged(): Promise<void>;
+				/**
+				 * ...
+				 */
+				filterResponseData(requestId: string): StreamFilter;
+				/**
+				 * Retrieves the security information for the request.  Returns a promise that will resolve to a SecurityInfo object.
+				 *
+				 * @param options Optional.
+				 */
+				getSecurityInfo(requestId: string, options?: GetSecurityInfoOptionsType): Promise<SecurityInfo>;
+				/**
+				 * Fired when a request is about to occur.
+				 */
+				onBeforeRequest: OnBeforeRequestEvent;
+				/**
+				 * 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.
+				 */
+				onBeforeSendHeaders: OnBeforeSendHeadersEvent;
+				/**
+				 * 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).
+				 */
+				onSendHeaders: OnSendHeadersEvent;
+				/**
+				 * Fired when HTTP response headers of a request have been received.
+				 */
+				onHeadersReceived: OnHeadersReceivedEvent;
+				/**
+				 * 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.
+				 */
+				onAuthRequired: OnAuthRequiredEvent;
+				/**
+				 * 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.
+				 */
+				onResponseStarted: OnResponseStartedEvent;
+				/**
+				 * Fired when a server-initiated redirect is about to occur.
+				 */
+				onBeforeRedirect: OnBeforeRedirectEvent;
+				/**
+				 * Fired when a request is completed.
+				 */
+				onCompleted: OnCompletedEvent;
+				/**
+				 * Fired when an error occurs.
+				 */
+				onErrorOccurred: OnErrorOccurredEvent;
+				/**
+				 * The maximum number of times that <code>handlerBehaviorChanged</code> can be called per 10 minute sustained interval.
+				 * <code>handlerBehaviorChanged</code> is an expensive function call that shouldn't be called often.
+				 */
+				MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES: 20;
+			}
+		}
+		/**
+		 * Namespace: browser.windows
+		 */
+		namespace Windows {
+			/**
+			 * The type of browser window this is. Under some circumstances a Window may not be assigned type property,
+			 * for example when querying closed windows from the $(ref:sessions) API.
+			 */
+			type WindowType = "normal" | "popup" | "panel" | "app" | "devtools";
+			/**
+			 * The state of this browser window. Under some circumstances a Window may not be assigned state property,
+			 * for example when querying closed windows from the $(ref:sessions) API.
+			 */
+			type WindowState = "normal" | "minimized" | "maximized" | "fullscreen" | "docked";
+			interface Window {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				id?: number;
+				/**
+				 * Whether the window is currently the focused window.
+				 */
+				focused: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				top?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				left?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				width?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				height?: number;
+				/**
+				 * Array of $(ref:tabs.Tab) objects representing the current tabs in the window.
+				 * Optional.
+				 */
+				tabs?: Browser.Tabs.Tab[];
+				/**
+				 * Whether the window is incognito.
+				 */
+				incognito: boolean;
+				/**
+				 * The type of browser window this is.
+				 * Optional.
+				 */
+				type?: WindowType;
+				/**
+				 * The state of this browser window.
+				 * Optional.
+				 */
+				state?: WindowState;
+				/**
+				 * Whether the window is set to be always on top.
+				 */
+				alwaysOnTop: boolean;
+				/**
+				 * The session ID used to uniquely identify a Window obtained from the $(ref:sessions) API.
+				 * Optional.
+				 */
+				sessionId?: string;
+				/**
+				 * The title of the window. Read-only.
+				 * Optional.
+				 */
+				title?: string;
+			}
+			/**
+			 * Specifies what type of browser window to create. The 'panel' and 'detached_panel' types create a popup unless the
+			 * '--enable-panels' flag is set.
+			 */
+			type CreateType = "normal" | "popup" | "panel" | "detached_panel";
+			/**
+			 * Specifies whether the $(ref:windows.Window) returned should contain a list of the $(ref:tabs.Tab) objects.
+			 */
+			interface GetInfo {
+				/**
+				 * If true, the $(ref:windows.Window) returned will have a <var>tabs</var> property that contains a list of the $(ref:tabs.
+				 * Tab) objects. The <code>Tab</code> objects only contain the <code>url</code>, <code>title</code> and <code>
+				 * favIconUrl</code> properties if the extension's manifest file includes the <code>"tabs"</code> permission.
+				 * Optional.
+				 */
+				populate?: boolean;
+			}
+			/**
+			 * 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.
+			 */
+			interface GetAllGetInfoType extends GetInfo {
+				/**
+				 * If set, the $(ref:windows.Window) returned will be filtered based on its type. If unset the default filter is set to
+				 * <code>['app', 'normal', 'panel', 'popup']</code>, with <code>'app'</code> and <code>'panel'</code>
+				 * window types limited to the extension's own windows.
+				 * Optional.
+				 */
+				windowTypes?: WindowType[];
+			}
+			interface CreateCreateDataType {
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				url?: string | string[];
+				/**
+				 * The id of the tab for which you want to adopt to the new window.
+				 * Optional.
+				 */
+				tabId?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				left?: number;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				top?: number;
+				/**
+				 * The width in pixels of the new window, including the frame. If not specified defaults to a natural width.
+				 * Optional.
+				 */
+				width?: number;
+				/**
+				 * The height in pixels of the new window, including the frame. If not specified defaults to a natural height.
+				 * Optional.
+				 */
+				height?: number;
+				/**
+				 * If true, the new window will be focused. If false, the new window will be opened in the background and the currently
+				 * focused window will stay focused. Defaults to true.
+				 * Optional.
+				 */
+				focused?: boolean;
+				/**
+				 * Whether the new window should be an incognito window.
+				 * Optional.
+				 */
+				incognito?: boolean;
+				/**
+				 * Specifies what type of browser window to create. The 'panel' and 'detached_panel' types create a popup unless the
+				 * '--enable-panels' flag is set.
+				 * Optional.
+				 */
+				type?: CreateType;
+				/**
+				 * The initial state of the window. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left',
+				 * 'top', 'width' or 'height'.
+				 * Optional.
+				 */
+				state?: WindowState;
+				/**
+				 * Allow scripts to close the window.
+				 * Optional.
+				 */
+				allowScriptsToClose?: boolean;
+				/**
+				 * The CookieStoreId to use for all tabs that were created when the window is opened.
+				 * Optional.
+				 */
+				cookieStoreId?: string;
+				/**
+				 * A string to add to the beginning of the window title.
+				 * Optional.
+				 */
+				titlePreface?: string;
+			}
+			interface UpdateUpdateInfoType {
+				/**
+				 * The offset from the left edge of the screen to move the window to in pixels. This value is ignored for panels.
+				 * Optional.
+				 */
+				left?: number;
+				/**
+				 * The offset from the top edge of the screen to move the window to in pixels. This value is ignored for panels.
+				 * Optional.
+				 */
+				top?: number;
+				/**
+				 * The width to resize the window to in pixels. This value is ignored for panels.
+				 * Optional.
+				 */
+				width?: number;
+				/**
+				 * The height to resize the window to in pixels. This value is ignored for panels.
+				 * Optional.
+				 */
+				height?: number;
+				/**
+				 * If true, brings the window to the front. If false, brings the next window in the z-order to the front.
+				 * Optional.
+				 */
+				focused?: boolean;
+				/**
+				 * 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.
+				 * Optional.
+				 */
+				drawAttention?: boolean;
+				/**
+				 * The new state of the window. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left', 'top',
+				 * 'width' or 'height'.
+				 * Optional.
+				 */
+				state?: WindowState;
+				/**
+				 * A string to add to the beginning of the window title.
+				 * Optional.
+				 */
+				titlePreface?: string;
+			}
+			interface Static {
+				/**
+				 * Gets details about a window.
+				 *
+				 * @param getInfo Optional.
+				 */
+				get(windowId: number, getInfo?: GetInfo): Promise<Window>;
+				/**
+				 * Gets the $(topic:current-window)[current window].
+				 *
+				 * @param getInfo Optional.
+				 */
+				getCurrent(getInfo?: GetInfo): Promise<Window>;
+				/**
+				 * Gets the window that was most recently focused &mdash; typically the window 'on top'.
+				 *
+				 * @param getInfo Optional.
+				 */
+				getLastFocused(getInfo?: GetInfo): Promise<Window>;
+				/**
+				 * Gets all windows.
+				 *
+				 * @param getInfo Optional. 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.
+				 */
+				getAll(getInfo?: GetAllGetInfoType): Promise<Window[]>;
+				/**
+				 * Creates (opens) a new browser with any optional sizing, position or default URL provided.
+				 *
+				 * @param createData Optional.
+				 */
+				create(createData?: CreateCreateDataType): Promise<Window>;
+				/**
+				 * Updates the properties of a window. Specify only the properties that you want to change; unspecified properties will be
+				 * left unchanged.
+				 */
+				update(windowId: number, updateInfo: UpdateUpdateInfoType): Promise<Window>;
+				/**
+				 * Removes (closes) a window, and all the tabs inside it.
+				 */
+				remove(windowId: number): Promise<void>;
+				/**
+				 * Fired when a window is created.
+				 *
+				 * @param window Details of the window that was created.
+				 */
+				onCreated: Events.Event<(window: Window) => void>;
+				/**
+				 * Fired when a window is removed (closed).
+				 *
+				 * @param windowId ID of the removed window.
+				 */
+				onRemoved: Events.Event<(windowId: number) => void>;
+				/**
+				 * 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 windowId ID of the newly focused window.
+				 */
+				onFocusChanged: Events.Event<(windowId: number) => void>;
+				/**
+				 * The windowId value that represents the absence of a browser window.
+				 */
+				WINDOW_ID_NONE: -1;
+				/**
+				 * The windowId value that represents the $(topic:current-window)[current window].
+				 */
+				WINDOW_ID_CURRENT: -2;
+			}
+		}
+		namespace BrowserSettings {
+			namespace ColorManagement {
+				interface Static {
+					/**
+					 * This setting controls the mode used for color management and must be a string from $(ref:browserSettings.
+					 * ColorManagementMode)
+					 */
+					mode: Browser.Types.Setting;
+					/**
+					 * This boolean setting controls whether or not native sRGB color management is used.
+					 */
+					useNativeSRGB: Browser.Types.Setting;
+					/**
+					 * This boolean setting controls whether or not the WebRender compositor is used.
+					 */
+					useWebRenderCompositor: Browser.Types.Setting;
+				}
+			}
+		}
+		namespace Devtools {
+			namespace InspectedWindow {
+				/**
+				 * A resource within the inspected page, such as a document, a script, or an image.
+				 */
+				interface Resource {
+					/**
+					 * The URL of the resource.
+					 */
+					url: string;
+				}
+				/**
+				 * The options parameter can contain one or more options.
+				 */
+				interface EvalOptionsType {
+					[s: string]: unknown;
+				}
+				/**
+				 * An object providing details if an exception occurred while evaluating the expression.
+				 */
+				interface EvalCallbackExceptionInfoType {
+					/**
+					 * Set if the error occurred on the DevTools side before the expression is evaluated.
+					 */
+					isError: boolean;
+					/**
+					 * Set if the error occurred on the DevTools side before the expression is evaluated.
+					 */
+					code: string;
+					/**
+					 * Set if the error occurred on the DevTools side before the expression is evaluated.
+					 */
+					description: string;
+					/**
+					 * 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.
+					 */
+					details: unknown[];
+					/**
+					 * Set if the evaluated code produces an unhandled exception.
+					 */
+					isException: boolean;
+					/**
+					 * Set if the evaluated code produces an unhandled exception.
+					 */
+					value: string;
+				}
+				interface ReloadReloadOptionsType {
+					/**
+					 * When true, the loader will bypass the cache for all inspected page resources loaded before the <code>load</code>
+					 * event is fired. The effect is similar to pressing Ctrl+Shift+R in the inspected window or within the Developer Tools
+					 * window.
+					 * Optional.
+					 */
+					ignoreCache?: boolean;
+					/**
+					 * If specified, the string will override the value of the <code>User-Agent</code> HTTP header that's sent while loading
+					 * the resources of the inspected page. The string will also override the value of the <code>navigator.userAgent</code>
+					 * property that's returned to any scripts that are running within the inspected page.
+					 * Optional.
+					 */
+					userAgent?: string;
+					/**
+					 * 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&mdash;for example,
+					 * if the user presses Ctrl+R.
+					 * Optional.
+					 */
+					injectedScript?: string;
+				}
+				interface Static {
+					/**
+					 * 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 <code>result</code> parameter of the callback is <code>undefined</code>.
+					 * In the case of a DevTools-side error, the <code>isException</code> parameter is non-null and has <code>isError</code>
+					 * set to true and <code>code</code> set to an error code. In the case of a JavaScript error, <code>isException</code>
+					 * is set to true and <code>value</code> is set to the string value of thrown object.
+					 *
+					 * @param expression An expression to evaluate.
+					 * @param options Optional. The options parameter can contain one or more options.
+					 * @returns A function called when evaluation completes.
+					 */
+					eval(expression: string, options?: EvalOptionsType): Promise<[
+						unknown,
+						EvalCallbackExceptionInfoType
+					]>;
+					/**
+					 * Reloads the inspected page.
+					 *
+					 * @param reloadOptions Optional.
+					 */
+					reload(reloadOptions?: ReloadReloadOptionsType): void;
+					/**
+					 * The ID of the tab being inspected. This ID may be used with chrome.tabs.* API.
+					 */
+					tabId: number;
+				}
+			}
+		}
+		namespace Devtools {
+			namespace Network {
+				/**
+				 * Represents a network request for a document resource (script, image and so on). See HAR Specification for reference.
+				 */
+				interface Request {
+					/**
+					 * Returns content of the response body.
+					 *
+					 * @returns A function that receives the response body when the request completes.
+					 */
+					getContent(): Promise<[
+						string,
+						string
+					]>;
+				}
+				/**
+				 * A HAR log. See HAR specification for details.
+				 */
+				interface GetHARCallbackHarLogType {
+					[s: string]: unknown;
+				}
+				interface Static {
+					/**
+					 * Returns HAR log that contains all known network requests.
+					 *
+					 * @returns A function that receives the HAR log when the request completes.
+					 */
+					getHAR(): Promise<GetHARCallbackHarLogType>;
+					/**
+					 * Fired when a network request is finished and all request data are available.
+					 *
+					 * @param request Description of a network request in the form of a HAR entry. See HAR specification for details.
+					 */
+					onRequestFinished: Events.Event<(request: Request) => void>;
+					/**
+					 * Fired when the inspected window navigates to a new page.
+					 *
+					 * @param url URL of the new page.
+					 */
+					onNavigated: Events.Event<(url: string) => void>;
+				}
+			}
+		}
+		namespace Devtools {
+			namespace Panels {
+				/**
+				 * Represents the Elements panel.
+				 */
+				interface ElementsPanel {
+					/**
+					 * Creates a pane within panel's sidebar.
+					 *
+					 * @param title Text that is displayed in sidebar caption.
+					 * @returns A callback invoked when the sidebar is created.
+					 */
+					createSidebarPane(title: string): Promise<ExtensionSidebarPane>;
+					/**
+					 * Fired when an object is selected in the panel.
+					 */
+					onSelectionChanged: Events.Event<() => void>;
+				}
+				/**
+				 * Represents the Sources panel.
+				 */
+				interface SourcesPanel {
+					[s: string]: unknown;
+				}
+				/**
+				 * Represents a panel created by extension.
+				 */
+				interface ExtensionPanel {
+					/**
+					 * Fired when the user switches to the panel.
+					 *
+					 * @param window The JavaScript <code>window</code> object of panel's page.
+					 */
+					onShown: Events.Event<(window: Window) => void>;
+					/**
+					 * Fired when the user switches away from the panel.
+					 */
+					onHidden: Events.Event<() => void>;
+				}
+				/**
+				 * A sidebar created by the extension.
+				 */
+				interface ExtensionSidebarPane {
+					/**
+					 * Sets an expression that is evaluated within the inspected page. The result is displayed in the sidebar pane.
+					 *
+					 * @param 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 rootTitle Optional. An optional title for the root of the expression tree.
+					 * @returns A callback invoked after the sidebar pane is updated with the expression evaluation results.
+					 */
+					setExpression(expression: string, rootTitle?: string): Promise<void>;
+					/**
+					 * Sets a JSON-compliant object to be displayed in the sidebar pane.
+					 *
+					 * @param jsonObject An object to be displayed in context of the inspected page. Evaluated in the context of the caller
+					 * (API client).
+					 * @param rootTitle Optional. An optional title for the root of the expression tree.
+					 * @returns A callback invoked after the sidebar is updated with the object.
+					 */
+					setObject(jsonObject: string | unknown[] | Record<string, unknown>, rootTitle?: string): Promise<void>;
+					/**
+					 * Sets an HTML page to be displayed in the sidebar pane.
+					 *
+					 * @param path Relative path of an extension page to display within the sidebar.
+					 */
+					setPage(path: Browser.Manifest.ExtensionURL): Promise<void>;
+					/**
+					 * Fired when the sidebar pane becomes visible as a result of user switching to the panel that hosts it.
+					 *
+					 * @param window The JavaScript <code>window</code> object of the sidebar page, if one was set with the <code>setPage()
+					 * </code> method.
+					 */
+					onShown: Events.Event<(window: Window) => void>;
+					/**
+					 * Fired when the sidebar pane becomes hidden as a result of the user switching away from the panel that hosts the sidebar
+					 * pane.
+					 */
+					onHidden: Events.Event<() => void>;
+				}
+				/**
+				 * A button created by the extension.
+				 */
+				interface Button {
+					[s: string]: unknown;
+				}
+				interface Static {
+					/**
+					 * Creates an extension panel.
+					 *
+					 * @param title Title that is displayed next to the extension icon in the Developer Tools toolbar.
+					 * @param 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 pagePath Path of the panel's HTML page relative to the extension directory.
+					 * @returns A function that is called when the panel is created.
+					 */
+					create(title: string, iconPath: "" | Browser.Manifest.ExtensionURL, pagePath: Browser.Manifest.ExtensionURL): Promise<ExtensionPanel>;
+					/**
+					 * Fired when the devtools theme changes.
+					 *
+					 * @param themeName The name of the current devtools theme.
+					 */
+					onThemeChanged: Events.Event<(themeName: string) => void>;
+					/**
+					 * Elements panel.
+					 */
+					elements: ElementsPanel;
+					/**
+					 * Sources panel.
+					 */
+					sources: SourcesPanel;
+					/**
+					 * The name of the current devtools theme.
+					 */
+					themeName: string;
+				}
+			}
+		}
+		namespace Privacy {
+			namespace Network {
+				/**
+				 * The IP handling policy of WebRTC.
+				 */
+				type IPHandlingPolicy = "default" | "default_public_and_private_interfaces" | "default_public_interface_only" | "disable_non_proxied_udp" | "proxy_only";
+				/**
+				 * An object which describes TLS minimum and maximum versions.
+				 */
+				interface tlsVersionRestrictionConfig {
+					/**
+					 * The minimum TLS version supported.
+					 * Optional.
+					 */
+					minimum?: TlsVersionRestrictionConfigMinimumEnum;
+					/**
+					 * The maximum TLS version supported.
+					 * Optional.
+					 */
+					maximum?: TlsVersionRestrictionConfigMaximumEnum;
+				}
+				/**
+				 * The mode for https-only mode.
+				 */
+				type HTTPSOnlyModeOption = "always" | "private_browsing" | "never";
+				/**
+				 * The minimum TLS version supported.
+				 */
+				type TlsVersionRestrictionConfigMinimumEnum = "TLSv1" | "TLSv1.1" | "TLSv1.2" | "TLSv1.3" | "unknown";
+				/**
+				 * The maximum TLS version supported.
+				 */
+				type TlsVersionRestrictionConfigMaximumEnum = "TLSv1" | "TLSv1.1" | "TLSv1.2" | "TLSv1.3" | "unknown";
+				interface Static {
+					/**
+					 * If enabled, the browser attempts to speed up your web browsing experience by pre-resolving DNS entries,
+					 * prerendering sites (<code>&lt;link rel='prefetch' ...&gt;</code>), and preemptively opening TCP and SSL connections to
+					 * servers.  This preference's value is a boolean, defaulting to <code>true</code>.
+					 */
+					networkPredictionEnabled: Browser.Types.Setting;
+					/**
+					 * Allow users to enable and disable RTCPeerConnections (aka WebRTC).
+					 */
+					peerConnectionEnabled: Browser.Types.Setting;
+					/**
+					 * 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 <code>
+					 * default</code>.
+					 */
+					webRTCIPHandlingPolicy: Browser.Types.Setting;
+					/**
+					 * This property controls the minimum and maximum TLS versions. This setting's value is an object of
+					 * $(ref:tlsVersionRestrictionConfig).
+					 */
+					tlsVersionRestriction: Browser.Types.Setting;
+					/**
+					 * Allow users to query the mode for 'HTTPS-Only Mode'. This setting's value is of type HTTPSOnlyModeOption,
+					 * defaulting to <code>never</code>.
+					 */
+					httpsOnlyMode: Browser.Types.Setting;
+					/**
+					 * Allow users to query the status of 'Global Privacy Control'. This setting's value is of type boolean,
+					 * defaulting to <code>false</code>.
+					 */
+					globalPrivacyControl: Browser.Types.Setting;
+				}
+			}
+		}
+		namespace Privacy {
+			namespace Services {
+				interface Static {
+					/**
+					 * If enabled, the password manager will ask if you want to save passwords. This preference's value is a boolean,
+					 * defaulting to <code>true</code>.
+					 */
+					passwordSavingEnabled: Browser.Types.Setting;
+				}
+			}
+		}
+		namespace Privacy {
+			namespace Websites {
+				/**
+				 * The mode for tracking protection.
+				 */
+				type TrackingProtectionModeOption = "always" | "never" | "private_browsing";
+				/**
+				 * The settings for cookies.
+				 */
+				interface CookieConfig {
+					/**
+					 * The type of cookies to allow.
+					 * Optional.
+					 */
+					behavior?: CookieConfigBehaviorEnum;
+				}
+				/**
+				 * The type of cookies to allow.
+				 */
+				type CookieConfigBehaviorEnum = "allow_all" | "reject_all" | "reject_third_party" | "allow_visited" | "reject_trackers" | "reject_trackers_and_partition_foreign";
+				interface Static {
+					/**
+					 * If enabled, the browser sends auditing pings when requested by a website (<code>&lt;a ping&gt;</code>).
+					 * The value of this preference is of type boolean, and the default value is <code>true</code>.
+					 */
+					hyperlinkAuditingEnabled: Browser.Types.Setting;
+					/**
+					 * If enabled, the browser sends <code>referer</code> 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 <code>true</code>.
+					 */
+					referrersEnabled: Browser.Types.Setting;
+					/**
+					 * 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 <code>
+					 * false</code>.
+					 */
+					resistFingerprinting: Browser.Types.Setting;
+					/**
+					 * 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 <code>false</code>.
+					 */
+					firstPartyIsolate: Browser.Types.Setting;
+					/**
+					 * Allow users to specify the mode for tracking protection. This setting's value is of type TrackingProtectionModeOption,
+					 * defaulting to <code>private_browsing_only</code>.
+					 */
+					trackingProtectionMode: Browser.Types.Setting;
+					/**
+					 * 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.
+					 */
+					cookieConfig: Browser.Types.Setting;
+				}
+			}
+		}
+		namespace Trial {
+			namespace Ml {
+				interface CreateEngineRequest {
+					[s: string]: unknown;
+				}
+				interface RunEngineRequest {
+					[s: string]: unknown;
+				}
+				/**
+				 * Object containing the data, see https://firefox-source-docs.mozilla.org/toolkit/components/ml/notifications.html
+				 */
+				interface OnProgressProgressDataType {
+					[s: string]: unknown;
+				}
+				interface Static {
+					/**
+					 * Prepare the inference engine
+					 */
+					createEngine(CreateEngineRequest: CreateEngineRequest): void;
+					/**
+					 * Call the inference engine
+					 */
+					runEngine(RunEngineRequest: RunEngineRequest): void;
+					/**
+					 * Delete the models the extension downloaded.
+					 */
+					deleteCachedModels(): void;
+					/**
+					 * Events from the inference engine.
+					 *
+					 * @param progressData Object containing the data, see https://firefox-source-docs.mozilla.
+					 * org/toolkit/components/ml/notifications.html
+					 */
+					onProgress: Events.Event<(progressData: OnProgressProgressDataType) => void>;
+				}
+			}
+		}
+		interface Browser {
+			/**
+			 * Monitor extension activity
+			 *
+			 * Permissions: "activityLog"
+			 */
+			activityLog: ActivityLog.Static;
+			/**
+			 * Permissions: "alarms"
+			 */
+			alarms: Alarms.Static;
+			/**
+			 * Use the <code>browser.bookmarks</code> 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.
+			 *
+			 * Permissions: "bookmarks"
+			 */
+			bookmarks: Bookmarks.Static;
+			/**
+			 * 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.
+			 *
+			 * Permissions: "manifest:action", "manifest:browser_action"
+			 */
+			action: Action.Static;
+			/**
+			 * Permissions: "manifest:action", "manifest:browser_action"
+			 */
+			browserAction: BrowserAction.Static;
+			/**
+			 * Use the <code>browser.browserSettings</code> API to control global settings of the browser.
+			 *
+			 * Permissions: "browserSettings"
+			 */
+			browserSettings: BrowserSettings.Static;
+			/**
+			 * Use the <code>chrome.browsingData</code> API to remove browsing data from a user's local profile.
+			 *
+			 * Permissions: "browsingData"
+			 */
+			browsingData: BrowsingData.Static;
+			/**
+			 * This API provides the ability detect the captive portal state of the users connection.
+			 *
+			 * Permissions: "captivePortal"
+			 */
+			captivePortal: CaptivePortal.Static;
+			/**
+			 * 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.
+			 *
+			 * Permissions: "clipboardWrite"
+			 */
+			clipboard: Clipboard.Static;
+			/**
+			 * 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.
+			 *
+			 * Permissions: "manifest:commands"
+			 */
+			commands: Commands.Static;
+			contentScripts: ContentScripts.Static;
+			/**
+			 * Use the <code>browser.contextualIdentities</code> API to query and modify contextual identity, also called as containers.
+			 *
+			 * Permissions: "contextualIdentities"
+			 */
+			contextualIdentities: ContextualIdentities.Static;
+			/**
+			 * Use the <code>browser.cookies</code> API to query and modify cookies, and to be notified when they change.
+			 *
+			 * Permissions: "cookies"
+			 */
+			cookies: Cookies.Static;
+			/**
+			 * Use the <code>chrome.declarativeContent</code> API to take actions depending on the content of a page,
+			 * without requiring permission to read the page's content.
+			 */
+			declarativeContent: DeclarativeContent.Static;
+			/**
+			 * Use the declarativeNetRequest API to block or modify network requests by specifying declarative rules.
+			 *
+			 * Permissions: "declarativeNetRequest", "declarativeNetRequestWithHostAccess"
+			 */
+			declarativeNetRequest: DeclarativeNetRequest.Static;
+			/**
+			 * Permissions: "manifest:devtools_page"
+			 */
+			devtools: Devtools.Static;
+			/**
+			 * Asynchronous DNS API
+			 *
+			 * Permissions: "dns"
+			 */
+			dns: Dns.Static;
+			/**
+			 * Permissions: "downloads"
+			 */
+			downloads: Downloads.Static;
+			/**
+			 * The <code>chrome.events</code> namespace contains common types used by APIs dispatching events to notify you when
+			 * something interesting happens.
+			 */
+			events: Events.Static;
+			experiments: Experiments.Static;
+			/**
+			 * The <code>browser.extensionTypes</code> API contains type declarations for WebExtensions.
+			 */
+			extensionTypes: ExtensionTypes.Static;
+			/**
+			 * The <code>browser.extension</code> 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].
+			 */
+			extension: Extension.Static;
+			/**
+			 * Use the <code>browser.find</code> API to interact with the browser's <code>Find</code> interface.
+			 *
+			 * Permissions: "find"
+			 */
+			find: Find.Static;
+			/**
+			 * Exposes the browser's profiler.
+			 *
+			 * Permissions: "geckoProfiler"
+			 */
+			geckoProfiler: GeckoProfiler.Static;
+			/**
+			 * Use the <code>browser.history</code> 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].
+			 *
+			 * Permissions: "history"
+			 */
+			history: History.Static;
+			/**
+			 * Use the <code>browser.i18n</code> infrastructure to implement internationalization across your whole app or extension.
+			 */
+			i18n: I18n.Static;
+			/**
+			 * Use the chrome.identity API to get OAuth2 access tokens.
+			 *
+			 * Permissions: "identity"
+			 */
+			identity: Identity.Static;
+			/**
+			 * Use the <code>browser.idle</code> API to detect when the machine's idle state changes.
+			 *
+			 * Permissions: "idle"
+			 */
+			idle: Idle.Static;
+			/**
+			 * The <code>browser.management</code> API provides ways to manage the list of extensions that are installed and running.
+			 */
+			management: Management.Static;
+			/**
+			 * Permissions: -
+			 */
+			manifest: Manifest.Static;
+			/**
+			 * Use the browser.contextMenus API to add items to the browser's context menu. You can choose what types of objects your
+			 * context menu additions apply to, such as images, hyperlinks, and pages.
+			 *
+			 * Permissions: "contextMenus"
+			 */
+			contextMenus: ContextMenus.Static;
+			/**
+			 * 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.
+			 *
+			 * Permissions: "menus"
+			 */
+			menus: Menus.Static;
+			/**
+			 * This API provides the ability to determine the status of and detect changes in the network connection.
+			 * This API can only be used in privileged extensions.
+			 *
+			 * Permissions: "networkStatus"
+			 */
+			networkStatus: NetworkStatus.Static;
+			/**
+			 * Normandy Study API
+			 *
+			 * Permissions: "normandyAddonStudy"
+			 */
+			normandyAddonStudy: NormandyAddonStudy.Static;
+			/**
+			 * Permissions: "notifications"
+			 */
+			notifications: Notifications.Static;
+			/**
+			 * The omnibox API allows you to register a keyword with Firefox's address bar.
+			 *
+			 * Permissions: "manifest:omnibox"
+			 */
+			omnibox: Omnibox.Static;
+			/**
+			 * Use the <code>browser.pageAction</code> 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.
+			 *
+			 * Permissions: "manifest:page_action"
+			 */
+			pageAction: PageAction.Static;
+			permissions: Permissions.Static;
+			/**
+			 * PKCS#11 module management API
+			 *
+			 * Permissions: "pkcs11"
+			 */
+			pkcs11: Pkcs11.Static;
+			/**
+			 * Permissions: "privacy"
+			 */
+			privacy: Privacy.Static;
+			/**
+			 * Provides access to global proxy settings for Firefox and proxy event listeners to handle dynamic proxy implementations.
+			 *
+			 * Permissions: "proxy"
+			 */
+			proxy: Proxy.Static;
+			/**
+			 * Use the <code>browser.runtime</code> 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.
+			 */
+			runtime: Runtime.Static;
+			/**
+			 * Use the scripting API to execute script in different contexts.
+			 *
+			 * Permissions: "scripting"
+			 */
+			scripting: Scripting.Static;
+			/**
+			 * Use browser.search to interact with search engines.
+			 *
+			 * Permissions: "search"
+			 */
+			search: Search.Static;
+			/**
+			 * Use the <code>chrome.sessions</code> API to query and restore tabs and windows from a browsing session.
+			 *
+			 * Permissions: "sessions"
+			 */
+			sessions: Sessions.Static;
+			/**
+			 * Use sidebar actions to add a sidebar to Firefox.
+			 *
+			 * Permissions: "manifest:sidebar_action"
+			 */
+			sidebarAction: SidebarAction.Static;
+			/**
+			 * Use the <code>browser.storage</code> API to store, retrieve, and track changes to user data.
+			 *
+			 * Permissions: "storage"
+			 */
+			storage: Storage.Static;
+			/**
+			 * Use the browser.tabGroups API to interact with the browser's tab grouping system. You can use this API to modify,
+			 * and rearrange tab groups.
+			 *
+			 * Permissions: "tabGroups"
+			 */
+			tabGroups: TabGroups.Static;
+			/**
+			 * Use the <code>browser.tabs</code> API to interact with the browser's tab system. You can use this API to create, modify,
+			 * and rearrange tabs in the browser.
+			 */
+			tabs: Tabs.Static;
+			/**
+			 * The theme API allows customizing of visual elements of the browser.
+			 */
+			theme: Theme.Static;
+			/**
+			 * Use the chrome.topSites API to access the top sites that are displayed on the new tab page.
+			 *
+			 * Permissions: "topSites"
+			 */
+			topSites: TopSites.Static;
+			/**
+			 * Permissions: "trialML"
+			 */
+			trial: Trial.Static;
+			/**
+			 * Contains types used by other schemas.
+			 */
+			types: Types.Static;
+			/**
+			 * Permissions: "manifest:user_scripts", "userScripts"
+			 */
+			userScripts: UserScripts.Static;
+			/**
+			 * Use the <code>browser.webNavigation</code> API to receive notifications about the status of navigation requests
+			 * in-flight.
+			 *
+			 * Permissions: "webNavigation"
+			 */
+			webNavigation: WebNavigation.Static;
+			/**
+			 * Use the <code>browser.webRequest</code> API to observe and analyze traffic and to intercept, block,
+			 * or modify requests in-flight.
+			 *
+			 * Permissions: "webRequest"
+			 */
+			webRequest: WebRequest.Static;
+			/**
+			 * Use the <code>browser.windows</code> API to interact with browser windows. You can use this API to create, modify,
+			 * and rearrange windows in the browser.
+			 */
+			windows: Windows.Static;
+		}
+	}
+}
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+declare global {
+	interface GlideModes {
+		hint: "hint";
+	}
+}
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+declare global {
+	interface ExcmdRegistry {
+		jumplist_back: {};
+		jumplist_forward: {};
+	}
+}
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+declare global {
+	interface ExcmdRegistry {
+		whichkey: {};
+	}
+}
+
+export {};